@sixtyninecommerce/admin 0.11.0 → 0.12.0

package/dist/pos/offline-sales.d.ts

@@ -47,11 +47,17 @@ export declare const POS_OFFLINE_NOT_READY_REASONS: readonly ["prices_exclude_ta
 export type PosOfflineNotReadyReason = (typeof POS_OFFLINE_NOT_READY_REASONS)[number];
 /**
  * Why the engine refused or flagged an offline sale, in the order an answer lists them: the
- * refusals first (`item_gone` to `rounding_mismatch`: nothing was recorded but the row), then the
+ * refusals first (`item_gone` to `price_over_limit`: nothing was recorded but the row), then the
  * reviews (`price_changed` to `sold_at_suspect`: the sale is recorded). More may come.
  */
-export declare const POS_OFFLINE_SALE_REASONS: readonly ["item_gone", "drawer_closed", "currency_changed", "prices_exclude_tax", "out_of_stock", "gift_card", "total_mismatch", "rounding_mismatch", "price_changed", "not_fulfilled", "cashier_changed", "policy_off", "over_cap", "sold_at_suspect"];
+export declare const POS_OFFLINE_SALE_REASONS: readonly ["item_gone", "drawer_closed", "currency_changed", "prices_exclude_tax", "out_of_stock", "gift_card", "total_mismatch", "rounding_mismatch", "price_over_limit", "price_changed", "not_fulfilled", "cashier_changed", "policy_off", "over_cap", "sold_at_suspect", "cashier_unverified", "item_gone_stand_in", "stock_short_stand_in", "total_corrected", "rounding_as_rung"];
 export type PosOfflineSaleReason = (typeof POS_OFFLINE_SALE_REASONS)[number];
+/**
+ * The reasons the engine REFUSES a sale for (nothing recorded but its row): `item_gone` to
+ * `price_over_limit`. Every other reason is a review of a recorded sale. A reason this release does
+ * not know is neither: show it as it is.
+ */
+export declare const POS_OFFLINE_SALE_REFUSAL_REASONS: readonly PosOfflineSaleReason[];
 /**
  * `recorded` (the order, the cash and the receipt number exist, as the till rang it),
  * `needs_review` (recorded, with a reason to look at) or `refused` (nothing but this row). More
@@ -132,6 +138,19 @@ export interface PosOfflineSale {
     resolvedByUserName: string | null;
     /** What the manager wrote they did about it. Staff text. */
     resolutionNote: string | null;
+    /**
+     * When a manager recorded it again (engine with POS polish PR 6), and their name now. Answered
+     * by `recordAgain` and `list` (an engine before PR 6 answers its list without them: absent);
+     * absent from `resolve`.
+     */
+    recordedAgainAt?: string | null;
+    recordedAgainByUserName?: string | null;
+    /**
+     * The drawer the sale's cash went into once recorded (its order's): the one it was rung in, or
+     * the one a manager recorded it again into (engine with POS polish PR 6); null while nothing is
+     * recorded, absent from an older engine (link `registerSessionId` then).
+     */
+    cashRegisterSessionId?: string | null;
 }
 /** `open` (the default): the sales a manager must still handle; `all`: every offline sale. */
 export type PosOfflineSaleFilter = 'open' | 'all';
@@ -170,11 +189,33 @@ export interface PosOfflineSalesModule {
         id: string;
         note: string;
     }, options?: Call): Promise<PosOfflineSale>;
+    /**
+     * Record a REFUSED offline sale again (engine with POS polish PR 6): the engine builds it the
+     * way the till's replay does, into the sale's own drawer while that is open, else the open drawer
+     * `registerSessionId` names (ignored while the own one is open); it is attributed to the caller
+     * (`recordedAgainAt`, `recordedAgainByUserName`). A sale refused again stays `refused` with its new
+     * reasons; one recorded again already answers as it is. Refused `POS_OFFLINE_SALE_NOT_FOUND`
+     * (`NotFoundError`: another store's, a till the caller may not see, an unknown id, or a sale that
+     * is not refused) and `POS_OFFLINE_SALE_DRAWER_INVALID` (`ValidationError`,
+     * `extensions.registerSessionId`: the own drawer is closed and none, or no open drawer of the
+     * store, was named) and `LOCATION_NOT_ALLOWED` (`PermissionDeniedError`: the drawer, the sale's
+     * own or the one named, stands at a location a location-restricted caller may not act at).
+     * Needs `UpdateSettings` or `ManagePosDevices`, and `CreateOrder` (it records an order and its
+     * cash). An engine before PR 6 refuses the document.
+     */
+    recordAgain(input: {
+        id: string;
+        registerSessionId?: string;
+    }, options?: Call): Promise<PosOfflineSale>;
 }
 export declare const POS_OFFLINE_CASH_SALES_QUERY = "query PosOfflineCashSales { getPosConfig { offlineCashSales { enabled maxSaleAmount maxSalesPerOutage maxOfflineMinutes ready notReadyReasons } } }";
 export declare const SET_POS_OFFLINE_CASH_SALES_MUTATION = "mutation SetPosOfflineCashSales($input: PosOfflineCashSalesInput!) { setPosOfflineCashSales(input: $input) { enabled maxSaleAmount maxSalesPerOutage maxOfflineMinutes ready notReadyReasons } }";
-export declare const POS_OFFLINE_SALES_QUERY = "query PosOfflineSales($input: PosOfflineSaleListInput) { posOfflineSales(input: $input) { items { id deviceId deviceLabel registerSessionId offlineSaleId provisionalReceiptNumber soldAt recordedAt status reasons orderId orderCode receiptNumber currencyCode totalWithTax cashTendered changeGiven cashRounding lines { variantId quantity unitPriceWithTax serverUnitPriceWithTax } staffName claimedStaffName resolvedAt resolvedByUserName resolutionNote } totalItems } }";
+/** The list, naming who recorded a sale again (engine POS polish PR 6). */
+export declare const POS_OFFLINE_SALES_QUERY = "query PosOfflineSales($input: PosOfflineSaleListInput) { posOfflineSales(input: $input) { items { id deviceId deviceLabel registerSessionId offlineSaleId provisionalReceiptNumber soldAt recordedAt status reasons orderId orderCode receiptNumber currencyCode totalWithTax cashTendered changeGiven cashRounding lines { variantId quantity unitPriceWithTax serverUnitPriceWithTax } staffName claimedStaffName resolvedAt resolvedByUserName resolutionNote recordedAgainAt recordedAgainByUserName cashRegisterSessionId } totalItems } }";
+/** The list as an engine before PR 6 reads it: sent once that engine refused the fields. */
+export declare const POS_OFFLINE_SALES_QUERY_BEFORE_RECORD_AGAIN = "query PosOfflineSales($input: PosOfflineSaleListInput) { posOfflineSales(input: $input) { items { id deviceId deviceLabel registerSessionId offlineSaleId provisionalReceiptNumber soldAt recordedAt status reasons orderId orderCode receiptNumber currencyCode totalWithTax cashTendered changeGiven cashRounding lines { variantId quantity unitPriceWithTax serverUnitPriceWithTax } staffName claimedStaffName resolvedAt resolvedByUserName resolutionNote } totalItems } }";
 export declare const RESOLVE_POS_OFFLINE_SALE_MUTATION = "mutation ResolvePosOfflineSale($input: ResolvePosOfflineSaleInput!) { resolvePosOfflineSale(input: $input) { id deviceId deviceLabel registerSessionId offlineSaleId provisionalReceiptNumber soldAt recordedAt status reasons orderId orderCode receiptNumber currencyCode totalWithTax cashTendered changeGiven cashRounding lines { variantId quantity unitPriceWithTax serverUnitPriceWithTax } staffName claimedStaffName resolvedAt resolvedByUserName resolutionNote } }";
+export declare const RECORD_POS_OFFLINE_SALE_AGAIN_MUTATION = "mutation RecordPosOfflineSaleAgain($input: RecordPosOfflineSaleAgainInput!) { recordPosOfflineSaleAgain(input: $input) { id deviceId deviceLabel registerSessionId offlineSaleId provisionalReceiptNumber soldAt recordedAt status reasons orderId orderCode receiptNumber currencyCode totalWithTax cashTendered changeGiven cashRounding lines { variantId quantity unitPriceWithTax serverUnitPriceWithTax } staffName claimedStaffName resolvedAt resolvedByUserName resolutionNote recordedAgainAt recordedAgainByUserName cashRegisterSessionId } }";
 export declare const POS_DEVICE_OFFLINE_SALES_TO_REVIEW_QUERY = "query PosDeviceOfflineSalesToReview($stockLocationId: ID) { posDeviceFleet(stockLocationId: $stockLocationId) { device { id } offlineSalesToReview } }";
 /** `admin.pos.settings.offlineCashSales()`: null when POS was never set up. */
 export declare function readOfflineCashSales(transport: Transport, options?: Call): Promise<PosOfflineCashSales | null>;

package/dist/pos/offline-sales.js

@@ -1,4 +1,5 @@
 import { pageFromVendureList, readOffsetCursor, } from '@sixtyninecommerce/core';
+import { isUnknownFieldRejection } from '../payments/store-credit-fields.js';
 /**
  * Offline cash sales (engine sprint 45, shipped dark): a till that loses its connection may keep
  * selling for cash, within the store's limits, and sends each sale when it is back. The engine
@@ -38,7 +39,7 @@ export const POS_OFFLINE_NOT_READY_REASONS = [
 ];
 /**
  * Why the engine refused or flagged an offline sale, in the order an answer lists them: the
- * refusals first (`item_gone` to `rounding_mismatch`: nothing was recorded but the row), then the
+ * refusals first (`item_gone` to `price_over_limit`: nothing was recorded but the row), then the
  * reviews (`price_changed` to `sold_at_suspect`: the sale is recorded). More may come.
  */
 export const POS_OFFLINE_SALE_REASONS = [
@@ -50,12 +51,34 @@ export const POS_OFFLINE_SALE_REASONS = [
     'gift_card',
     'total_mismatch',
     'rounding_mismatch',
+    'price_over_limit',
     'price_changed',
     'not_fulfilled',
     'cashier_changed',
     'policy_off',
     'over_cap',
     'sold_at_suspect',
+    'cashier_unverified',
+    'item_gone_stand_in',
+    'stock_short_stand_in',
+    'total_corrected',
+    'rounding_as_rung',
+];
+/**
+ * The reasons the engine REFUSES a sale for (nothing recorded but its row): `item_gone` to
+ * `price_over_limit`. Every other reason is a review of a recorded sale. A reason this release does
+ * not know is neither: show it as it is.
+ */
+export const POS_OFFLINE_SALE_REFUSAL_REASONS = [
+    'item_gone',
+    'drawer_closed',
+    'currency_changed',
+    'prices_exclude_tax',
+    'out_of_stock',
+    'gift_card',
+    'total_mismatch',
+    'rounding_mismatch',
+    'price_over_limit',
 ];
 const DEFAULT_PAGE = 50;
 const MAX_PAGE = 100;
@@ -63,8 +86,13 @@ const POLICY_FIELDS = 'enabled maxSaleAmount maxSalesPerOutage maxOfflineMinutes
 const SALE_FIELDS = 'id deviceId deviceLabel registerSessionId offlineSaleId provisionalReceiptNumber soldAt recordedAt status reasons orderId orderCode receiptNumber currencyCode totalWithTax cashTendered changeGiven cashRounding lines { variantId quantity unitPriceWithTax serverUnitPriceWithTax } staffName claimedStaffName resolvedAt resolvedByUserName resolutionNote';
 export const POS_OFFLINE_CASH_SALES_QUERY = `query PosOfflineCashSales { getPosConfig { offlineCashSales { ${POLICY_FIELDS} } } }`;
 export const SET_POS_OFFLINE_CASH_SALES_MUTATION = `mutation SetPosOfflineCashSales($input: PosOfflineCashSalesInput!) { setPosOfflineCashSales(input: $input) { ${POLICY_FIELDS} } }`;
-export const POS_OFFLINE_SALES_QUERY = `query PosOfflineSales($input: PosOfflineSaleListInput) { posOfflineSales(input: $input) { items { ${SALE_FIELDS} } totalItems } }`;
+/** The list, naming who recorded a sale again (engine POS polish PR 6). */
+export const POS_OFFLINE_SALES_QUERY = `query PosOfflineSales($input: PosOfflineSaleListInput) { posOfflineSales(input: $input) { items { ${SALE_FIELDS} recordedAgainAt recordedAgainByUserName cashRegisterSessionId } totalItems } }`;
+/** The list as an engine before PR 6 reads it: sent once that engine refused the fields. */
+export const POS_OFFLINE_SALES_QUERY_BEFORE_RECORD_AGAIN = `query PosOfflineSales($input: PosOfflineSaleListInput) { posOfflineSales(input: $input) { items { ${SALE_FIELDS} } totalItems } }`;
 export const RESOLVE_POS_OFFLINE_SALE_MUTATION = `mutation ResolvePosOfflineSale($input: ResolvePosOfflineSaleInput!) { resolvePosOfflineSale(input: $input) { ${SALE_FIELDS} } }`;
+// Engine POS polish PR 6: only this document selects who recorded it again.
+export const RECORD_POS_OFFLINE_SALE_AGAIN_MUTATION = `mutation RecordPosOfflineSaleAgain($input: RecordPosOfflineSaleAgainInput!) { recordPosOfflineSaleAgain(input: $input) { ${SALE_FIELDS} recordedAgainAt recordedAgainByUserName cashRegisterSessionId } }`;
 // The fleet's count beside the device's id alone, its own document: the fleet read
 // (`POS_DEVICE_FLEET_QUERY`) never names it, so an engine before 45 keeps answering the fleet.
 export const POS_DEVICE_OFFLINE_SALES_TO_REVIEW_QUERY = 'query PosDeviceOfflineSalesToReview($stockLocationId: ID) { posDeviceFleet(stockLocationId: $stockLocationId) { device { id } offlineSalesToReview } }';
@@ -92,13 +120,30 @@ export async function readOfflineSalesToReview(transport, options) {
 }
 export function createPosOfflineSalesModule(transport) {
     const gql = gqlOf(transport);
+    // An engine before PR 6 refused the list's record-again fields once: every later page asks
+    // without them (one refused request per module, not per page).
+    let listBeforeRecordAgain = false;
+    async function listDocument(variables, options) {
+        if (!listBeforeRecordAgain) {
+            try {
+                return await gql(POS_OFFLINE_SALES_QUERY, variables, options);
+            }
+            catch (error) {
+                // Refused before it ran: the same read without the fields. Any other failure is the read's.
+                if (!isUnknownFieldRejection(error))
+                    throw error;
+                listBeforeRecordAgain = true;
+            }
+        }
+        return gql(POS_OFFLINE_SALES_QUERY_BEFORE_RECORD_AGAIN, variables, options);
+    }
     async function salePage(skip, take, options) {
         const input = { skip, take };
         if (options?.filter !== undefined)
             input.filter = options.filter;
         if (options?.deviceId !== undefined)
             input.deviceId = options.deviceId;
-        const data = await gql(POS_OFFLINE_SALES_QUERY, { input }, options);
+        const data = await listDocument({ input }, options);
         return pageFromVendureList(data.posOfflineSales, skip, take, (cursor) => salePage(readOffsetCursor(cursor), take, options));
     }
     return {
@@ -112,5 +157,14 @@ export function createPosOfflineSalesModule(transport) {
             const data = await gql(RESOLVE_POS_OFFLINE_SALE_MUTATION, { input: { id: input.id, note: input.note } }, options);
             return data.resolvePosOfflineSale;
         },
+        async recordAgain(input, options) {
+            const data = await gql(RECORD_POS_OFFLINE_SALE_AGAIN_MUTATION, {
+                input: {
+                    id: input.id,
+                    ...(input.registerSessionId ? { registerSessionId: input.registerSessionId } : {}),
+                },
+            }, options);
+            return data.recordPosOfflineSaleAgain;
+        },
     };
 }

package/dist/pos/returns.d.ts

@@ -26,6 +26,13 @@ import type { Call } from '../types.js';
  * refuses `POS_RETURN_STORE_CREDIT_UNAVAILABLE` (`extensions.reason`) when it cannot, nothing moved.
  * `quote` and `create` need an engine with C6b (an older one refuses their documents); `void`
  * keeps its sprint-20 selection and reads on any engine.
+ *
+ * The customer's consent to store credit (owner ruling Q4, EU consumer law CRD art. 13(1)): a
+ * store-credit payout asks whether the customer expressly agreed to store credit instead of a
+ * refund to their payment when `quote(...).storedValuePayout.asksConsent` says so, and `create`
+ * sends the answer as `customerAgreed`. The engine records it on the store credit; never a
+ * condition. `quote` reads `asksConsent` on an engine before it too (the document without it,
+ * `false`: such an engine takes no answer).
  */
 export type PosReturnKind = 'RETURN' | 'VOID';
 /** Where a return's value goes (C6b): REFUND (the default) or the customer's store credit. */
@@ -47,6 +54,13 @@ export interface PosReturnStoredValuePayout {
     available: boolean;
     /** no_customer, no_method or not_entitled when it cannot. More may come. */
     reason: string | null;
+    /**
+     * Ask the customer whether they expressly agreed to store credit before this payout, and send
+     * the answer as `PosReturnCreateInput.customerAgreed` (owner ruling Q4): true exactly when the
+     * payout is available. `false` from an engine before the field, which takes no answer, and on a
+     * webshop order's quote, which never pays out to store credit.
+     */
+    asksConsent: boolean;
 }
 /** The store credit a return was paid out to (C6b). */
 export interface PosReturnStoredValueCredit {
@@ -108,6 +122,17 @@ export interface PosReturnCreateInput {
     cashFirst?: boolean;
     /** REFUND when omitted (C6b). STORED_VALUE: the whole return to the sale's customer's store credit. */
     payout?: PosReturnPayout;
+    /**
+     * A STORED_VALUE payout whose quote said `asksConsent`: whether the customer expressly agreed to
+     * store credit instead of a refund to their payment (EU consumer law, CRD art. 13(1)), as staff
+     * asked them. The engine records it on the store credit with who stated it
+     * (`StoredValueEntry.customerAgreed`); never a condition, nothing is refused for it. Part of the
+     * request: a repeat under the same key sends the same answer, another answer is
+     * `IDEMPOTENCY_CONFLICT`. Sent only when given (true or false): left out or null, the request is
+     * what it always was. An engine before the field refuses a call that gives it, and that refusal
+     * is surfaced, never retried without the answer.
+     */
+    customerAgreed?: boolean | null;
 }
 export interface PosVoidInput {
     orderId: string;
@@ -208,7 +233,9 @@ export interface PosReturnsModule {
         idempotencyKey: string;
     }): Promise<PosReturnResult>;
 }
-export declare const POS_RETURN_QUOTE_QUERY = "query PosReturnQuote($input: PosReturnQuoteInput!) { posReturnQuote(input: $input) { orderId kind currencyCode receiptNumber lines { orderLineId name sku customItem restockable soldQuantity returnedQuantity returnableQuantity quantity refundAmount } total legs { paymentId kind method amount } cashPaidOut returnWindowEndsAt outsideWindow refundedOutsideReturns restockLocationName blockedBy blockedReason storedValuePayout { available reason } } }";
+export declare const POS_RETURN_QUOTE_QUERY = "query PosReturnQuote($input: PosReturnQuoteInput!) { posReturnQuote(input: $input) { orderId kind currencyCode receiptNumber lines { orderLineId name sku customItem restockable soldQuantity returnedQuantity returnableQuantity quantity refundAmount } total legs { paymentId kind method amount } cashPaidOut returnWindowEndsAt outsideWindow refundedOutsideReturns restockLocationName blockedBy blockedReason storedValuePayout { available reason asksConsent } } }";
+/** The quote for an engine before the till's consent (owner ruling Q4): no `asksConsent`. */
+export declare const POS_RETURN_QUOTE_QUERY_BEFORE_CONSENT = "query PosReturnQuote($input: PosReturnQuoteInput!) { posReturnQuote(input: $input) { orderId kind currencyCode receiptNumber lines { orderLineId name sku customItem restockable soldQuantity returnedQuantity returnableQuantity quantity refundAmount } total legs { paymentId kind method amount } cashPaidOut returnWindowEndsAt outsideWindow refundedOutsideReturns restockLocationName blockedBy blockedReason storedValuePayout { available reason } } }";
 export declare const POS_RETURN_MUTATION = "mutation PosReturn($input: PosReturnInput!) { posReturn(input: $input) { orderId returnId returnCode kind total refunds { paymentId kind method amount refundId outcome } cashPaidOut complete storedValueCredit { accountId entryId amount } } }";
 export declare const POS_VOID_SALE_MUTATION = "mutation PosVoidSale($input: PosVoidSaleInput!) { posVoidSale(input: $input) { orderId returnId returnCode kind total refunds { paymentId kind method amount refundId outcome } cashPaidOut complete } }";
 export declare const POS_ONLINE_ORDER_QUERY = "query PosOnlineOrder($input: PosOnlineOrderRefInput!) { posOnlineOrder(input: $input) { orderId orderCode placedAt state currencyCode totalWithTax customerName refundMethodName returnableUnits blockedBy blockedReason } }";

package/dist/pos/returns.js

@@ -1,17 +1,35 @@
-const QUOTE_FIELDS = 'orderId kind currencyCode receiptNumber lines { orderLineId name sku customItem restockable soldQuantity returnedQuantity returnableQuantity quantity refundAmount } total legs { paymentId kind method amount } cashPaidOut returnWindowEndsAt outsideWindow refundedOutsideReturns restockLocationName blockedBy blockedReason storedValuePayout { available reason }';
+import { statedCustomerAgreed } from '../payments/customer-consent.js';
+import { isUnknownFieldRejection } from '../payments/store-credit-fields.js';
+/** A quote's fields up to its store-credit payout, which every engine with C6b reads. */
+const QUOTE_BASE_FIELDS = 'orderId kind currencyCode receiptNumber lines { orderLineId name sku customItem restockable soldQuantity returnedQuantity returnableQuantity quantity refundAmount } total legs { paymentId kind method amount } cashPaidOut returnWindowEndsAt outsideWindow refundedOutsideReturns restockLocationName blockedBy blockedReason';
+// Spliced as template constants, never built by a call: the repo's GraphQL cost scan
+// (`graphql-cost-fits-repo.spec.ts`) resolves `${CONSTANT}` statically and nothing computed.
+/** A quote's fields before the till's consent (owner ruling Q4): what every engine with C6b reads. */
+const QUOTE_FIELDS_BEFORE_CONSENT = `${QUOTE_BASE_FIELDS} storedValuePayout { available reason }`;
+const QUOTE_FIELDS = `${QUOTE_BASE_FIELDS} storedValuePayout { available reason asksConsent }`;
 /** The sprint-20 result: what a void answers (it never pays out to store credit). */
 const VOID_RESULT_FIELDS = 'orderId returnId returnCode kind total refunds { paymentId kind method amount refundId outcome } cashPaidOut complete';
 /** A return's result: the void's, and the store credit a STORED_VALUE payout made (C6b). */
 const RESULT_FIELDS = `${VOID_RESULT_FIELDS} storedValueCredit { accountId entryId amount }`;
 export const POS_RETURN_QUOTE_QUERY = `query PosReturnQuote($input: PosReturnQuoteInput!) { posReturnQuote(input: $input) { ${QUOTE_FIELDS} } }`;
+/** The quote for an engine before the till's consent (owner ruling Q4): no `asksConsent`. */
+export const POS_RETURN_QUOTE_QUERY_BEFORE_CONSENT = `query PosReturnQuote($input: PosReturnQuoteInput!) { posReturnQuote(input: $input) { ${QUOTE_FIELDS_BEFORE_CONSENT} } }`;
 export const POS_RETURN_MUTATION = `mutation PosReturn($input: PosReturnInput!) { posReturn(input: $input) { ${RESULT_FIELDS} } }`;
 export const POS_VOID_SALE_MUTATION = `mutation PosVoidSale($input: PosVoidSaleInput!) { posVoidSale(input: $input) { ${VOID_RESULT_FIELDS} } }`;
 // Engine C3/34: their own documents, so a call to an older engine fails alone.
 const ONLINE_ORDER_FIELDS = 'orderId orderCode placedAt state currencyCode totalWithTax customerName refundMethodName returnableUnits blockedBy blockedReason';
 export const POS_ONLINE_ORDER_QUERY = `query PosOnlineOrder($input: PosOnlineOrderRefInput!) { posOnlineOrder(input: $input) { ${ONLINE_ORDER_FIELDS} } }`;
-export const POS_ONLINE_RETURN_QUOTE_QUERY = `query PosOnlineReturnQuote($input: PosOnlineReturnQuoteInput!) { posOnlineReturnQuote(input: $input) { ${QUOTE_FIELDS} shippingRefund source } }`;
+// Never store credit (D22), so it never asks consent: the selection before Q4, `asksConsent` false.
+export const POS_ONLINE_RETURN_QUOTE_QUERY = `query PosOnlineReturnQuote($input: PosOnlineReturnQuoteInput!) { posOnlineReturnQuote(input: $input) { ${QUOTE_FIELDS_BEFORE_CONSENT} shippingRefund source } }`;
 // A webshop order's return never pays out to store credit (C3 D22): the void's result fields.
 export const POS_ONLINE_RETURN_MUTATION = `mutation PosOnlineReturn($input: PosOnlineReturnInput!) { posOnlineReturn(input: $input) { ${VOID_RESULT_FIELDS} } }`;
+/** Such a quote as this SDK answers it: `asksConsent` false (that engine takes no answer). */
+function withoutConsent(quote) {
+    return {
+        ...quote,
+        storedValuePayout: { ...quote.storedValuePayout, asksConsent: false },
+    };
+}
 function keyOf(options, call) {
     const key = options?.idempotencyKey;
     if (typeof key !== 'string' || key.trim() === '') {
@@ -23,12 +41,24 @@ export function createPosReturnsModule(transport) {
     const gql = async (query, variables, options) => transport.graphql({ api: 'admin', query, variables }, options);
     return {
         async quote(input, options) {
-            const data = await gql(POS_RETURN_QUOTE_QUERY, { input }, options);
-            return data.posReturnQuote;
+            try {
+                const data = await gql(POS_RETURN_QUOTE_QUERY, { input }, options);
+                return data.posReturnQuote;
+            }
+            catch (error) {
+                // An engine before the till's consent (Q4) refuses the whole document; the quote is still
+                // readable without it, and that engine takes no answer. Any other failure is the read's.
+                if (!isUnknownFieldRejection(error))
+                    throw error;
+                const data = await gql(POS_RETURN_QUOTE_QUERY_BEFORE_CONSENT, { input }, options);
+                return withoutConsent(data.posReturnQuote);
+            }
         },
         async create(input, options) {
             const idempotencyKey = keyOf(options, 'create');
-            const data = await gql(POS_RETURN_MUTATION, { input: { ...input, idempotencyKey } }, options);
+            // The answer only when stated: left out or null, the request is what it always was.
+            const { customerAgreed, ...rest } = input;
+            const data = await gql(POS_RETURN_MUTATION, { input: { ...rest, ...statedCustomerAgreed(customerAgreed), idempotencyKey } }, options);
             return data.posReturn;
         },
         async void(input, options) {
@@ -42,7 +72,7 @@ export function createPosReturnsModule(transport) {
         },
         async onlineQuote(input, options) {
             const data = await gql(POS_ONLINE_RETURN_QUOTE_QUERY, { input }, options);
-            return data.posOnlineReturnQuote;
+            return withoutConsent(data.posOnlineReturnQuote);
         },
         async onlineReturn(input, options) {
             const idempotencyKey = keyOf(options, 'onlineReturn');

package/dist/pricing/price-lists.d.ts

@@ -500,7 +500,9 @@ export interface PricingPriceListsModule {
     /**
      * The lists that apply to a customer of the store NOW, IN THE ORDER the price-list pricing
      * tries them for each line: contracts first, then assigned to the customer, through one of
-     * their groups, to every customer; then higher priority first. Only enabled lists inside their
+     * their groups, to every customer; then higher priority first. Lists of one standing (same
+     * contract flag, assignment and priority) are tried together and the lower price wins per line,
+     * an equal price going to the lower list id; they are listed by id. Only enabled lists inside their
      * date window, every list of the store considered; never an order's one-time discount (read
      * that as `Order.priceList`). Each comes with its first entries and its order rules. The
      * engine ranks them with the function its pricing uses, so a client never re-derives it.

package/dist/purchasing/alerts.d.ts

@@ -30,13 +30,22 @@ export interface PurchasingAlertSummary {
     reorderSuggestions: number;
     /** Of those, the ones the last compute found new (not suggested before, or grown). */
     newReorderSuggestions: number;
+    /**
+     * The ACTIVE store's backordered order lines that stock on hand can ship now (its own orders,
+     * never another store's of the legal entity): `backorders.ready()`'s total. Purchase-orders
+     * step 3.6; `null` from an engine before it (the SDK asks again without the two counts).
+     */
+    backordersReadyLines: number | null;
+    /** The orders holding those lines, each counted once; `null` as `backordersReadyLines`. */
+    backordersReadyOrders: number | null;
 }
 /** Who one purchasing alert email goes to. */
 export interface PurchasingAlertRecipients {
     alert: PurchasingAlert;
     /**
      * The permission whose holders get the alert when no addresses are set:
-     * `ApprovePurchaseOrder`, `UpdatePurchaseOrder` or `CreatePurchaseOrder`.
+     * `ApprovePurchaseOrder`, `ReceivePurchaseOrder` (`UpdatePurchaseOrder` on an engine before
+     * purchase-orders step 3.6) or `CreatePurchaseOrder`.
      */
     permission: string;
     /** The addresses set for this alert; empty when it goes to the permission's holders. */
@@ -52,9 +61,14 @@ export interface PurchasingAlertRecipientsInput {
     alert: PurchasingAlert;
     emails: string[];
 }
-export declare const PURCHASING_ALERT_SUMMARY_FIELDS = "\n  localDay\n  awaitingApproval\n  overdueLines\n  overdueOrders\n  attentionOrders\n  reorderSuggestions\n  newReorderSuggestions\n";
+export declare const PURCHASING_ALERT_SUMMARY_FIELDS = "\n  \n  localDay\n  awaitingApproval\n  overdueLines\n  overdueOrders\n  attentionOrders\n  reorderSuggestions\n  newReorderSuggestions\n\n  backordersReadyLines\n  backordersReadyOrders\n";
 export declare const PURCHASING_ALERT_RECIPIENTS_FIELDS = "\n  alert\n  permission\n  emails\n  recipients\n";
-export declare const PURCHASING_ALERTS_QUERY = "\n  query PurchasingAlerts {\n    purchasingAlerts { \n  localDay\n  awaitingApproval\n  overdueLines\n  overdueOrders\n  attentionOrders\n  reorderSuggestions\n  newReorderSuggestions\n }\n  }\n";
+export declare const PURCHASING_ALERTS_QUERY = "\n  query PurchasingAlerts {\n    purchasingAlerts { \n  \n  localDay\n  awaitingApproval\n  overdueLines\n  overdueOrders\n  attentionOrders\n  reorderSuggestions\n  newReorderSuggestions\n\n  backordersReadyLines\n  backordersReadyOrders\n }\n  }\n";
+/**
+ * The summary without the backorder counts, for an engine before purchase-orders step 3.6: the SDK
+ * retries once with it when the engine refuses the fields, and answers the two counts null.
+ */
+export declare const LEGACY_PURCHASING_ALERTS_QUERY = "\n  query PurchasingAlertsLegacy {\n    purchasingAlerts { \n  localDay\n  awaitingApproval\n  overdueLines\n  overdueOrders\n  attentionOrders\n  reorderSuggestions\n  newReorderSuggestions\n }\n  }\n";
 export declare const PURCHASING_ALERT_RECIPIENTS_QUERY = "\n  query PurchasingAlertRecipients {\n    purchasingAlertRecipients { \n  alert\n  permission\n  emails\n  recipients\n }\n  }\n";
 export declare const UPDATE_PURCHASING_ALERT_RECIPIENTS_MUTATION = "\n  mutation UpdatePurchasingAlertRecipients(\n    $input: [PurchasingAlertRecipientsInput!]!\n    $idempotencyKey: String\n  ) {\n    updatePurchasingAlertRecipients(input: $input, idempotencyKey: $idempotencyKey) {\n      \n  alert\n  permission\n  emails\n  recipients\n\n    }\n  }\n";
 export interface PurchasingAlertRecipientsModule {
@@ -81,7 +95,8 @@ export interface PurchasingAlertRecipientsModule {
 export interface PurchasingAlertsModule {
     /**
      * The counts behind the nav badges and the Overview cards. Needs `ReadPurchaseOrder`. `null`
-     * while purchasing is not switched on for the store's legal entity.
+     * while purchasing is not switched on for the store's legal entity. Against an engine before
+     * purchase-orders step 3.6 the backorder counts answer `null` and the rest as ever.
      */
     summary(call?: Call): Promise<PurchasingAlertSummary | null>;
     recipients: PurchasingAlertRecipientsModule;

package/dist/purchasing/alerts.js

@@ -1,4 +1,6 @@
-export const PURCHASING_ALERT_SUMMARY_FIELDS = /* GraphQL */ `
+import { isUnknownFieldRejection } from '../payments/store-credit-fields.js';
+/** The summary's counts an engine before purchase-orders step 3.6 answers. */
+const STEP_4_3_SUMMARY_FIELDS = /* GraphQL */ `
   localDay
   awaitingApproval
   overdueLines
@@ -7,6 +9,11 @@ export const PURCHASING_ALERT_SUMMARY_FIELDS = /* GraphQL */ `
   reorderSuggestions
   newReorderSuggestions
 `;
+export const PURCHASING_ALERT_SUMMARY_FIELDS = /* GraphQL */ `
+  ${STEP_4_3_SUMMARY_FIELDS}
+  backordersReadyLines
+  backordersReadyOrders
+`;
 export const PURCHASING_ALERT_RECIPIENTS_FIELDS = /* GraphQL */ `
   alert
   permission
@@ -18,6 +25,15 @@ export const PURCHASING_ALERTS_QUERY = /* GraphQL */ `
     purchasingAlerts { ${PURCHASING_ALERT_SUMMARY_FIELDS} }
   }
 `;
+/**
+ * The summary without the backorder counts, for an engine before purchase-orders step 3.6: the SDK
+ * retries once with it when the engine refuses the fields, and answers the two counts null.
+ */
+export const LEGACY_PURCHASING_ALERTS_QUERY = /* GraphQL */ `
+  query PurchasingAlertsLegacy {
+    purchasingAlerts { ${STEP_4_3_SUMMARY_FIELDS} }
+  }
+`;
 export const PURCHASING_ALERT_RECIPIENTS_QUERY = /* GraphQL */ `
   query PurchasingAlertRecipients {
     purchasingAlertRecipients { ${PURCHASING_ALERT_RECIPIENTS_FIELDS} }
@@ -36,8 +52,18 @@ export const UPDATE_PURCHASING_ALERT_RECIPIENTS_MUTATION = /* GraphQL */ `
 export function createPurchasingAlertsModule(transport) {
     return {
         async summary(call) {
-            const data = await transport.graphql({ api: 'admin', query: PURCHASING_ALERTS_QUERY }, call);
-            return data.purchasingAlerts ?? null;
+            try {
+                const data = await transport.graphql({ api: 'admin', query: PURCHASING_ALERTS_QUERY }, call);
+                return data.purchasingAlerts ?? null;
+            }
+            catch (error) {
+                if (!isUnknownFieldRejection(error))
+                    throw error;
+                const data = await transport.graphql({ api: 'admin', query: LEGACY_PURCHASING_ALERTS_QUERY }, call);
+                return data.purchasingAlerts === null
+                    ? null
+                    : { ...data.purchasingAlerts, backordersReadyLines: null, backordersReadyOrders: null };
+            }
         },
         recipients: {
             async list(call) {

package/dist/purchasing/backorders.d.ts

@@ -0,0 +1,61 @@
+import { type Page, type Transport } from '@sixtyninecommerce/core';
+import type { ListOptions } from '../types.js';
+/**
+ * An open backordered order line of the active store that stock on hand can ship now
+ * (purchase-orders spec §8.11): the store's free on-hand of the variant shared out over its open
+ * backorders, oldest order first.
+ */
+export interface BackorderReadyLine {
+    orderId: string;
+    orderCode: string;
+    /** The order's state; a parked or approval-waiting order keeps its turn too. */
+    orderState: string;
+    /** ISO-8601 UTC; null for an order never placed. */
+    orderPlacedAt: string | null;
+    orderLineId: string;
+    productVariantId: string;
+    sku: string;
+    /** The variant's name in the request's language. */
+    name: string;
+    /** The line's quantity. */
+    quantity: number;
+    /** Its backordered units not yet in a fulfilment. */
+    backorderedQuantity: number;
+    /** Of those, what stock on hand covers now (at least 1). */
+    readyQuantity: number;
+    /** The variant's on-hand, summed over the store's stock locations. */
+    stockOnHand: number;
+    /**
+     * True when the line was ordered from a supplier for this customer (a back-to-back link) and
+     * the supplier side cancelled it: it is an ordinary backorder again ("Supplier cancelled").
+     */
+    supplierCancelled: boolean;
+}
+export interface BackordersReadyOptions extends ListOptions {
+    /** Only the variants this goods receipt (of the store's legal entity) brought in. */
+    goodsReceiptId?: string;
+}
+export declare const BACKORDER_READY_LINE_FIELDS = "\n  orderId\n  orderCode\n  orderState\n  orderPlacedAt\n  orderLineId\n  productVariantId\n  sku\n  name\n  quantity\n  backorderedQuantity\n  readyQuantity\n  stockOnHand\n  supplierCancelled\n";
+export declare const BACKORDERS_READY_QUERY = "\n  query BackordersReadyToShip($options: BackordersReadyOptions) {\n    backordersReadyToShip(options: $options) {\n      items { \n  orderId\n  orderCode\n  orderState\n  orderPlacedAt\n  orderLineId\n  productVariantId\n  sku\n  name\n  quantity\n  backorderedQuantity\n  readyQuantity\n  stockOnHand\n  supplierCancelled\n }\n      totalItems\n    }\n  }\n";
+/**
+ * The list without `supplierCancelled`, for an engine before purchase-orders step 5.1: the SDK
+ * retries once with it when the engine refuses the field, and answers it `false` (that engine has
+ * no order links, so no supplier cancelled one).
+ */
+export declare const LEGACY_BACKORDERS_READY_QUERY = "\n  query BackordersReadyToShipLegacy($options: BackordersReadyOptions) {\n    backordersReadyToShip(options: $options) {\n      items { \n  orderId\n  orderCode\n  orderState\n  orderPlacedAt\n  orderLineId\n  productVariantId\n  sku\n  name\n  quantity\n  backorderedQuantity\n  readyQuantity\n  stockOnHand\n }\n      totalItems\n    }\n  }\n";
+/**
+ * `admin.purchasing.backorders` (purchase-orders spec §8.11, §8.14): what a goods receipt let the
+ * store ship. A read only: nothing is allocated. Needs the Purchasing plugin on the store and
+ * purchasing switched on for its legal entity (`PURCHASING_NOT_ENABLED`, 422), a store that
+ * purchases (`HUB_HAS_NO_PURCHASING`, `LEGAL_ENTITY_REQUIRED`), and `ReadOrder`.
+ */
+export interface PurchasingBackordersModule {
+    /**
+     * The active store's open backordered order lines that stock on hand can ship now, oldest order
+     * first (pages of at most 100). `goodsReceiptId` narrows them to the variants that receipt
+     * brought in. Refusals: `GOODS_RECEIPT_NOT_FOUND` (404, a receipt of another legal entity too),
+     * `GOODS_RECEIPT_INVALID` (400, a page out of range).
+     */
+    ready(options?: BackordersReadyOptions): Promise<Page<BackorderReadyLine>>;
+}
+export declare function createPurchasingBackordersModule(transport: Transport): PurchasingBackordersModule;

package/dist/purchasing/backorders.js

@@ -0,0 +1,92 @@
+import { pageFromVendureList, readOffsetCursor, } from '@sixtyninecommerce/core';
+import { isUnknownFieldRejection } from '../payments/store-credit-fields.js';
+/** The line's fields an engine before purchase-orders step 5.1 serves. */
+const STEP_3_6_LINE_FIELDS = /* GraphQL */ `
+  orderId
+  orderCode
+  orderState
+  orderPlacedAt
+  orderLineId
+  productVariantId
+  sku
+  name
+  quantity
+  backorderedQuantity
+  readyQuantity
+  stockOnHand
+`;
+export const BACKORDER_READY_LINE_FIELDS = /* GraphQL */ `
+  orderId
+  orderCode
+  orderState
+  orderPlacedAt
+  orderLineId
+  productVariantId
+  sku
+  name
+  quantity
+  backorderedQuantity
+  readyQuantity
+  stockOnHand
+  supplierCancelled
+`;
+export const BACKORDERS_READY_QUERY = /* GraphQL */ `
+  query BackordersReadyToShip($options: BackordersReadyOptions) {
+    backordersReadyToShip(options: $options) {
+      items { ${BACKORDER_READY_LINE_FIELDS} }
+      totalItems
+    }
+  }
+`;
+/**
+ * The list without `supplierCancelled`, for an engine before purchase-orders step 5.1: the SDK
+ * retries once with it when the engine refuses the field, and answers it `false` (that engine has
+ * no order links, so no supplier cancelled one).
+ */
+export const LEGACY_BACKORDERS_READY_QUERY = /* GraphQL */ `
+  query BackordersReadyToShipLegacy($options: BackordersReadyOptions) {
+    backordersReadyToShip(options: $options) {
+      items { ${STEP_3_6_LINE_FIELDS} }
+      totalItems
+    }
+  }
+`;
+const DEFAULT_PAGE_SIZE = 25;
+export function createPurchasingBackordersModule(transport) {
+    const readyPage = async (skip, take, options) => {
+        const variables = {
+            options: {
+                skip,
+                take,
+                ...(options?.goodsReceiptId === undefined
+                    ? {}
+                    : { goodsReceiptId: options.goodsReceiptId }),
+            },
+        };
+        let list;
+        try {
+            const data = await transport.graphql({ api: 'admin', query: BACKORDERS_READY_QUERY, variables }, options);
+            list = data.backordersReadyToShip;
+        }
+        catch (error) {
+            if (!isUnknownFieldRejection(error))
+                throw error;
+            const data = await transport.graphql({ api: 'admin', query: LEGACY_BACKORDERS_READY_QUERY, variables }, options);
+            list = {
+                items: data.backordersReadyToShip.items.map((line) => ({
+                    ...line,
+                    supplierCancelled: false,
+                })),
+                totalItems: data.backordersReadyToShip.totalItems,
+            };
+        }
+        return pageFromVendureList(list, skip, take, (cursor) => readyPage(readOffsetCursor(cursor), take, options));
+    };
+    return {
+        async ready(options) {
+            const take = options?.limit ?? DEFAULT_PAGE_SIZE;
+            const skip = options?.after === undefined ? 0 : readOffsetCursor(options.after);
+            return readyPage(skip, take, options);
+        },
+    };
+}