@sixtyninecommerce/admin 0.10.0 → 0.12.0

package/dist/pos/index.js

@@ -1,26 +1,170 @@
-import { createPage } from '@sixtyninecommerce/core';
+import { createPage, pageFromVendureList, readOffsetCursor, ValidationError, } from '@sixtyninecommerce/core';
+import { redactionWatcher } from '../customer-data-redaction.js';
+import { createPosAnomaliesModule } from './anomalies.js';
+import { createPosAssistedSellingModule, } from './assisted-selling.js';
+import { createPosExchangesModule } from './exchanges.js';
+import { createPosGiftCardsModule } from './gift-cards.js';
+import { createPosNoReceiptModule } from './no-receipt.js';
+import { createPosOfflineSalesModule, readOfflineCashSales, readOfflineSalesToReview, writeOfflineCashSales, } from './offline-sales.js';
+import { createPosPayByLinkModule } from './pay-by-link.js';
+import { createPosQuickKeysModule } from './quick-keys.js';
+import { createPosReportsModule } from './reports.js';
+import { createPosReturnsModule } from './returns.js';
+/** The kinds a device is created as (engine sprint 39), in the engine's order. */
+export const POS_DEVICE_KINDS = ['till', 'display'];
+/** The validities a pairing code is issued with, in the engine's order. */
+export const POS_PAIRING_CODE_VALIDITIES = [
+    'STANDARD',
+    'APP_REVIEW',
+];
+/** The fields `settings.update` sends; anything else is refused before a request is made. */
+export const POS_SETTINGS_INPUT_FIELDS = [
+    'enabled',
+    'cashPaymentMethodCode',
+    'cardPaymentMethodCode',
+    'inStoreShippingMethodId',
+    'fulfillmentProfileId',
+    'defaultStockLocationId',
+];
+/** The bounds the engine holds a store's idle lock to, and the tills' default. */
+export const POS_IDLE_LOCK_LIMITS = { minMinutes: 1, maxMinutes: 60, defaultMinutes: 5 };
+/**
+ * The languages a staff member's own till language may be (`en`, `nl`, `de`, `fr`); the engine's
+ * list, which a value outside it is refused against. The till speaks a language only once its
+ * catalogue is released; until then it falls back to the store's language.
+ */
+export const POS_STAFF_LOCALES = ['en', 'nl', 'de', 'fr'];
+/**
+ * The till actions a store may let a cashier do without a manager's approval (engine sprint 18). A
+ * manager may do all of them, whatever is stored. Closing a drawer above the store's variance
+ * threshold is not one: it stays a manager's.
+ */
+export const POS_STAFF_GRANTS = [
+    'manual_price',
+    'discount',
+    'custom_item_over_limit',
+    'refund',
+    'discard_held_sale',
+    'paid_out',
+    'no_sale',
+    'safe_drop',
+    'float_adjust',
+    // Engine sprint 20: returning a sale items, and voiding a sale.
+    'return_items',
+    'void_sale',
+    // Engine sprint 21: a return without a receipt paid to store credit (cash needs a manager).
+    'no_receipt_return',
+    // Engine C3/34: a webshop order returned at the till, refunded to its online payment.
+    'online_return',
+    // Engine pos-mollie-terminal-pairing: the till's own card terminal (assign, clear, pair a new
+    // Mollie Tap terminal from the till).
+    'manage_card_terminal',
+    // Engine pos-cart-integrity: a till discount past the store limit. EXPLICIT: a manager holds it
+    // only when stored, like a cashier (see POS_EXPLICIT_STAFF_GRANTS).
+    'discount_over_limit',
+    // Engine POS programme PR 15: the money figures of the till day report (its Reports tab);
+    // without it a cashier sees the counts of the day only. A manager holds it by role.
+    'view_reports',
+];
+/**
+ * The grants a staff member holds only when stored on their record, whatever their role: a manager
+ * does not hold these by being one. `discount_over_limit` lets a till discount they authorise
+ * (their own, or one they approve as a manager) go past the store's discount limit.
+ */
+export const POS_EXPLICIT_STAFF_GRANTS = [
+    'discount_over_limit',
+];
 const REGISTER_FIELDS = 'id stockLocationId name status createdAt updatedAt';
+// The X report selects only fields every engine answers; per-tender refunds come with the stored Z.
+// So does the cash rounding: the X report does not select it; it arrives with the stored Z.
 const TOTALS = 'cash card other refunds net saleCount';
 const SESSION_FIELDS = `id registerId deviceId openedByStaffId openingFloat status expectedCash countedCash cashOverShort totals openedAt closedAt`;
+// Engine sprint 25b: the close's details.
+const SESSION_CLOSE_FIELDS = 'closedByStaffId blindCount varianceThreshold varianceApproval varianceApprovedByStaffId varianceApprovedAt';
+const DEFAULT_SESSION_PAGE = 50;
+const MAX_SESSION_PAGE = 100;
 const CART_FIELDS = `id code state currencyCode total totalWithTax couponCodes
   lines { id quantity productVariant { id } linePriceWithTax }
   surcharges { description sku price priceWithTax taxRate }`;
 const TENDER_FIELDS = 'orderId paymentId covered outstanding change';
-const DEVICE_FIELDS = 'id stockLocationId registerId label status paired lastSeenAt';
+const DEVICE_FIELDS = 'id stockLocationId registerId label status paired lastSeenAt mollieTerminalId createdAt updatedAt';
 export const POS_REGISTERS_QUERY = `query PosRegisters { posRegisters { ${REGISTER_FIELDS} } }`;
 export const POS_REGISTER_QUERY = `query PosRegister($id: ID!) { posRegister(id: $id) { ${REGISTER_FIELDS} } }`;
 export const CREATE_POS_REGISTER_MUTATION = `mutation CreatePosRegister($input: CreatePosRegisterInput!) { createPosRegister(input: $input) { ${REGISTER_FIELDS} } }`;
 export const UPDATE_POS_REGISTER_MUTATION = `mutation UpdatePosRegister($id: ID!, $input: UpdatePosRegisterInput!) { updatePosRegister(id: $id, input: $input) { ${REGISTER_FIELDS} } }`;
 export const OPEN_POS_SESSION_MUTATION = `mutation OpenPosRegisterSession($input: OpenPosRegisterSessionInput!, $staffToken: String) { openPosRegisterSession(input: $input, staffToken: $staffToken) { ${SESSION_FIELDS} } }`;
 export const CLOSE_POS_SESSION_MUTATION = `mutation ClosePosRegisterSession($input: ClosePosRegisterSessionInput!, $staffToken: String) { closePosRegisterSession(input: $input, staffToken: $staffToken) { ${SESSION_FIELDS} } }`;
-export const POS_X_REPORT_QUERY = `query PosXReport($sessionId: ID!) { posXReport(sessionId: $sessionId) { sessionId openingFloat expectedCash movementCount totals { ${TOTALS} } } }`;
+export const POS_X_REPORT_QUERY = `query PosXReport($sessionId: ID!) { posXReport(sessionId: $sessionId) { sessionId openingFloat expectedCash movementCount totals { ${TOTALS} giftCardsSold giftCardsSoldCount } } }`;
+/** {@link POS_X_REPORT_QUERY} for an engine before C6 (no gift-card memo), which refuses it. */
+export const POS_X_REPORT_QUERY_BEFORE_GIFT_CARDS = `query PosXReport($sessionId: ID!) { posXReport(sessionId: $sessionId) { sessionId openingFloat expectedCash movementCount totals { ${TOTALS} } } }`;
 export const POS_SESSION_QUERY = `query PosRegisterSession($id: ID!) { posRegisterSession(id: $id) { ${SESSION_FIELDS} } }`;
+// Engine sprint 25b; an older engine refuses the document at validation.
+export const POS_SESSION_DETAIL_QUERY = `query PosRegisterSessionDetail($id: ID!) { posRegisterSession(id: $id) { ${SESSION_FIELDS} ${SESSION_CLOSE_FIELDS} } }`;
+// Engine sprint 27: who approved a pending close afterwards. Only these two documents select the
+// approval fields, so an older engine refuses them alone (the rest of `sessions` keeps working).
+const SESSION_APPROVAL_FIELDS = 'varianceApprovedByUserId varianceApprovedByUserName varianceApprovedByCredential varianceApprovalNote';
+export const POS_SESSION_APPROVAL_QUERY = `query PosRegisterSessionApproval($id: ID!) { posRegisterSession(id: $id) { id varianceApproval varianceThreshold varianceApprovedByStaffId varianceApprovedAt ${SESSION_APPROVAL_FIELDS} } }`;
+export const APPROVE_POS_SESSION_CLOSE_MUTATION = `mutation ApprovePosRegisterSessionClose($input: ApprovePosRegisterSessionCloseInput!) { approvePosRegisterSessionClose(input: $input) { ${SESSION_FIELDS} ${SESSION_CLOSE_FIELDS} ${SESSION_APPROVAL_FIELDS} } }`;
+// Engine sprint 26: a session's Z record. Only `sessions.record` / `sessions.records` select these,
+// each its own document, so an older engine refuses them alone (`get` and `list` are unchanged).
+// Sprint 26b adds the close without a count and its count afterwards; 26e reads none of them.
+export const SESSION_RECORD_FIELDS = 'businessDay stockLocationId timeZone zNumber closeSource closedByUserId autoCloseReason closeNote countedAt countedByUserId countNote';
+// The names are read per session (an administrator read each): the single record only.
+export const SESSION_RECORD_NAME_FIELDS = 'varianceApprovedByUserName closedByUserName countedByUserName';
+const SESSION_RECORD_APPROVAL_FIELDS = 'varianceApprovedByUserId varianceApprovedByCredential varianceApprovalNote';
+export const POS_SESSION_RECORD_QUERY = `query PosRegisterSessionRecord($id: ID!) { posRegisterSession(id: $id) { ${SESSION_FIELDS} ${SESSION_CLOSE_FIELDS} ${SESSION_RECORD_APPROVAL_FIELDS} ${SESSION_RECORD_FIELDS} ${SESSION_RECORD_NAME_FIELDS} } }`;
+export const POS_SESSION_RECORDS_QUERY = `query PosRegisterSessionRecords($options: PosRegisterSessionListOptions) { posRegisterSessions(options: $options) { totalItems items { ${SESSION_FIELDS} ${SESSION_CLOSE_FIELDS} ${SESSION_RECORD_APPROVAL_FIELDS} ${SESSION_RECORD_FIELDS} } } }`;
+// Engine sprint 26b: the back office closes a drawer without a count, and counts it later. Each
+// answers the session as `record` reads it; each its own document.
+const SESSION_RECORD_SELECTION = `${SESSION_FIELDS} ${SESSION_CLOSE_FIELDS} ${SESSION_RECORD_APPROVAL_FIELDS} ${SESSION_RECORD_FIELDS} ${SESSION_RECORD_NAME_FIELDS}`;
+export const CLOSE_POS_SESSION_UNCOUNTED_MUTATION = `mutation ClosePosRegisterSessionUncounted($input: ClosePosRegisterSessionUncountedInput!) { closePosRegisterSessionUncounted(input: $input) { ${SESSION_RECORD_SELECTION} } }`;
+export const COUNT_POS_SESSION_MUTATION = `mutation CountPosRegisterSession($input: CountPosRegisterSessionInput!) { countPosRegisterSession(input: $input) { ${SESSION_RECORD_SELECTION} } }`;
+// Engine sprint 27: the back office's sales, its till sale card and the store-wide movements.
+// Each its own document, so an older engine refuses only it.
+const POS_ORDER_SUMMARY_FIELDS = 'orderId orderCode receiptNumber placedAt state currencyCode totalWithTax totalQuantity refundedTotal tenderKinds customerKind customerName registerId registerName sessionId deviceId deviceLabel staffId staffName';
+export const POS_ORDERS_QUERY = `query PosOrders($input: PosOrderListInput) { posOrders(input: $input) { totalItems items { ${POS_ORDER_SUMMARY_FIELDS} } } }`;
+const POS_TILL_SALE_FIELDS = 'order { id code state } receiptNumber placedAt customerKind deviceId deviceLabel registerId registerName sessionId staffId staffName payments { paymentId kind method state amount refunded refundUnknown refundable }';
+export const POS_TILL_SALE_QUERY = `query PosTillSale($orderId: ID!) { posTillOrder(orderId: $orderId) { ${POS_TILL_SALE_FIELDS} idCheck { id checkedAt staffId staffName deviceId deviceLabel stockLocationId minimumAge } } }`;
+/**
+ * {@link POS_TILL_SALE_QUERY} for an engine older than the till's ID check (user decision L1),
+ * which refuses the whole document at validation: the sale is still read, with no ID check.
+ */
+export const POS_TILL_SALE_QUERY_LEGACY = `query PosTillSale($orderId: ID!) { posTillOrder(orderId: $orderId) { ${POS_TILL_SALE_FIELDS} } }`;
+export const POS_CASH_MOVEMENTS_QUERY = `query PosCashMovements($input: PosCashMovementListInput) { posCashMovements(input: $input) { totalItems items { id sessionId registerId registerName deviceId deviceLabel type amount reason staffId staffName approvedByStaffId approvedByStaffName orderId orderCode receiptNumber idempotencyKey createdAt } } }`;
+const DEFAULT_BACK_OFFICE_PAGE = 50;
+const MAX_BACK_OFFICE_PAGE = 100;
+// Engine sprint 25b (the close's details); an older engine refuses the document at validation.
+// Engine sprint 26e: a location's business days.
+export const STORE_DAY_TOTALS_FIELDS = 'currencyCode sessionCount uncountedCount openingFloat expectedCash countedCash cashOverShort cash card other refunds net saleCount cashRefunds cardRefunds otherRefunds cashRounding';
+export const STORE_DAY_SESSION_FIELDS = 'sessionId registerId registerName zNumber status closeSource openedAt closedAt openingFloat expectedCash countedCash cashOverShort varianceApproval totals { cash card other refunds net saleCount cashRefunds cardRefunds otherRefunds cashRounding }';
+export const STORE_DAY_FIELDS = `id stockLocationId businessDay timeZone startsAt endsAt status totalsFinal totals { ${STORE_DAY_TOTALS_FIELDS} } openSessionCount pendingCount uncountedCount closedAt closedByUserId closedByCredential closeNote closeCount reopenedAt reopenedByUserId reopenNote`;
+/** What a single day's read adds to a list item: its drawers and the two names. */
+export const STORE_DAY_DETAIL_FIELDS = `sessions { ${STORE_DAY_SESSION_FIELDS} } closedByUserName reopenedByUserName`;
+export const POS_STORE_DAY_QUERY = `query PosStoreDay($stockLocationId: ID!, $businessDay: String!) { posStoreDay(stockLocationId: $stockLocationId, businessDay: $businessDay) { ${STORE_DAY_FIELDS} ${STORE_DAY_DETAIL_FIELDS} } }`;
+export const POS_STORE_DAYS_QUERY = `query PosStoreDays($input: PosStoreDayListInput!) { posStoreDays(input: $input) { totalItems items { ${STORE_DAY_FIELDS} } } }`;
+export const CLOSE_POS_STORE_DAY_MUTATION = `mutation ClosePosStoreDay($input: ClosePosStoreDayInput!) { closePosStoreDay(input: $input) { ${STORE_DAY_FIELDS} ${STORE_DAY_DETAIL_FIELDS} } }`;
+export const REOPEN_POS_STORE_DAY_MUTATION = `mutation ReopenPosStoreDay($input: ReopenPosStoreDayInput!) { reopenPosStoreDay(input: $input) { ${STORE_DAY_FIELDS} ${STORE_DAY_DETAIL_FIELDS} } }`;
+export const POS_SESSION_LIST_QUERY = `query PosRegisterSessionList($options: PosRegisterSessionListOptions) { posRegisterSessions(options: $options) { totalItems items { ${SESSION_FIELDS} ${SESSION_CLOSE_FIELDS} } } }`;
 export const RECORD_POS_CASH_MOVEMENT_MUTATION = `mutation RecordPosCashMovement($input: RecordPosCashMovementInput!, $staffToken: String) { recordPosCashMovement(input: $input, staffToken: $staffToken) { id sessionId type amount reason orderId createdAt } }`;
+// Engine sprint 25a; an older engine refuses the document at validation.
+export const POS_DRAWER_MOVEMENTS_QUERY = `query PosDrawerMovements($sessionId: ID!, $skip: Int, $take: Int) { posDrawerMovements(sessionId: $sessionId, skip: $skip, take: $take) { totalItems items { id type amount balanceAfter reason staffId staffName approvedByStaffId approvedByStaffName orderId orderCode receiptNumber createdAt } summary { openingFloat cashSales cashRefunds cashRounding paidIn paidOut safeDrops floatAdjustments noSaleCount expectedCash movementCount } } }`;
 export const POS_CREATE_CART_MUTATION = `mutation PosCreateCart($registerId: ID) { posCreateCart(registerId: $registerId) { ${CART_FIELDS} } }`;
 export const POS_ADD_ITEM_MUTATION = `mutation PosAddItem($input: PosAddItemInput!) { posAddItem(input: $input) { ${CART_FIELDS} } }`;
 export const POS_APPLY_DISCOUNT_MUTATION = `mutation PosApplyDiscount($input: PosApplyDiscountInput!, $staffToken: String) { posApplyDiscount(input: $input, staffToken: $staffToken) { ${CART_FIELDS} } }`;
 export const POS_APPLY_COUPON_CODE_MUTATION = `mutation PosApplyCouponCode($input: PosCouponCodeInput!) { posApplyCouponCode(input: $input) { ${CART_FIELDS} } }`;
 export const POS_REMOVE_COUPON_CODE_MUTATION = `mutation PosRemoveCouponCode($input: PosCouponCodeInput!) { posRemoveCouponCode(input: $input) { ${CART_FIELDS} } }`;
+// A custom item's cart also selects each line's name (merged into CART_FIELDS' `lines`), which
+// an engine before sprint 16b cannot answer: only this document asks for it.
+export const POS_ADD_CUSTOM_ITEM_MUTATION = `mutation PosAddCustomItem($input: PosAddCustomItemInput!, $staffToken: String, $approvalToken: String) { posAddCustomItem(input: $input, staffToken: $staffToken, approvalToken: $approvalToken) { ${CART_FIELDS} lines { id customFields { posCustomItemName } } } }`;
+// The note documents (16c) also select the sale's note and each line's note and name (merged into
+// CART_FIELDS), which an engine before sprint 16c cannot answer: only these documents ask for them.
+const NOTE_CART_FIELDS = `${CART_FIELDS} customFields { posOrderNote } lines { id customFields { posCustomItemName posLineNote } }`;
+export const POS_SET_ORDER_NOTE_MUTATION = `mutation PosSetOrderNote($input: PosSetOrderNoteInput!, $staffToken: String) { posSetOrderNote(input: $input, staffToken: $staffToken) { ${NOTE_CART_FIELDS} } }`;
+export const POS_SET_LINE_NOTE_MUTATION = `mutation PosSetLineNote($input: PosSetLineNoteInput!, $staffToken: String) { posSetLineNote(input: $input, staffToken: $staffToken) { ${NOTE_CART_FIELDS} } }`;
+// A back office's read of what a till wrote on an order (16d): only this document names the POS
+// note and custom item fields on `order`, so `orders.get` keeps working against an older engine.
+export const POS_TILL_SALE_DETAILS_QUERY = `query PosTillSaleDetails($id: ID!) { order(id: $id) { id customFields { isPosOrder posOrderNote } lines { id customFields { posCustomItemName posLineNote } } } }`;
+export const POS_CLEAR_CART_MUTATION = `mutation PosClearCart($input: PosClearCartInput!, $staffToken: String) { posClearCart(input: $input, staffToken: $staffToken) { orderId orderCode } }`;
 export const POS_COMPLETE_SALE_MUTATION = `mutation PosCompleteSale($input: PosCompleteSaleInput!, $staffToken: String) { posCompleteSale(input: $input, staffToken: $staffToken) { orderId orderCode receiptNumber state } }`;
 export const POS_TENDER_CASH_MUTATION = `mutation PosTenderCash($input: PosTenderCashInput!, $staffToken: String) { posTenderCash(input: $input, staffToken: $staffToken) { ${TENDER_FIELDS} } }`;
 export const POS_TENDER_CARD_MUTATION = `mutation PosTenderCard($input: PosTenderCardInput!, $staffToken: String) { posTenderCard(input: $input, staffToken: $staffToken) { ${TENDER_FIELDS} } }`;
@@ -30,17 +174,200 @@ export const POS_REFUND_MUTATION = `mutation PosRefund($input: PosRefundInput!,
 export const POS_DEVICES_QUERY = `query PosDevices { posDevices { ${DEVICE_FIELDS} } }`;
 export const POS_DEVICE_QUERY = `query PosDevice($id: ID!) { posDevice(id: $id) { lastSeenAt } }`;
 export const POS_PAIRING_CODE_MUTATION = `mutation GeneratePosPairingCode($deviceId: ID!) { generatePosPairingCode(deviceId: $deviceId) { code expiresAt } }`;
+// Engine `emre/pos-reviewer-pairing`: a code that names its validity. Only this document names the
+// argument, so an older engine refuses it alone and `pair` without a validity keeps working there.
+export const POS_PAIRING_CODE_WITH_VALIDITY_MUTATION = `mutation GeneratePosPairingCodeWithValidity($deviceId: ID!, $validity: PosPairingCodeValidity!) { generatePosPairingCode(deviceId: $deviceId, validity: $validity) { code expiresAt } }`;
 export const REVOKE_POS_DEVICE_MUTATION = `mutation RevokePosDevice($deviceId: ID!) { revokePosDevice(deviceId: $deviceId) { ${DEVICE_FIELDS} } }`;
+// The device's own read and its three assignments: Admin API doors every deployed engine serves.
+// Like `list` and `revoke`, they select no kind or health column (`fleet` reads those).
+export const POS_DEVICE_DETAIL_QUERY = `query PosDeviceDetail($id: ID!) { posDevice(id: $id) { ${DEVICE_FIELDS} } }`;
+export const ASSIGN_POS_DEVICE_LOCATION_MUTATION = `mutation AssignPosDeviceLocation($deviceId: ID!, $stockLocationId: ID!) { assignPosDeviceLocation(deviceId: $deviceId, stockLocationId: $stockLocationId) { ${DEVICE_FIELDS} } }`;
+export const ASSIGN_POS_DEVICE_REGISTER_MUTATION = `mutation AssignPosDeviceRegister($deviceId: ID!, $registerId: ID!) { assignPosDeviceRegister(deviceId: $deviceId, registerId: $registerId) { ${DEVICE_FIELDS} } }`;
+export const ASSIGN_POS_DEVICE_TERMINAL_MUTATION = `mutation AssignPosDeviceMollieTerminal($deviceId: ID!, $terminalId: String!) { assignPosDeviceMollieTerminal(deviceId: $deviceId, terminalId: $terminalId) { ${DEVICE_FIELDS} } }`;
+// Engine `pos-device-writes-validate`: a move that names the register at the new location, and
+// taking a terminal off. Only these documents name the new argument and field, so an older engine
+// refuses them alone.
+export const ASSIGN_POS_DEVICE_LOCATION_WITH_REGISTER_MUTATION = `mutation AssignPosDeviceLocationWithRegister($deviceId: ID!, $stockLocationId: ID!, $registerId: ID!) { assignPosDeviceLocation(deviceId: $deviceId, stockLocationId: $stockLocationId, registerId: $registerId) { ${DEVICE_FIELDS} } }`;
+export const CLEAR_POS_DEVICE_TERMINAL_MUTATION = `mutation ClearPosDeviceMollieTerminal($deviceId: ID!) { clearPosDeviceMollieTerminal(deviceId: $deviceId) { ${DEVICE_FIELDS} } }`;
+export const POS_OPEN_SESSION_FOR_DEVICE_QUERY = `query PosOpenSessionForDevice($deviceId: ID!) { posOpenSessionForDevice(deviceId: $deviceId) { ${SESSION_FIELDS} } }`;
+// Engine sprint 35: the fleet read and the lock. Only these documents select the health columns,
+// so an older engine refuses them alone (`list`, `revoke` and the rest are unchanged). They select
+// the device's kind (39) too: the engine ships both in one release.
+const DEVICE_HEALTH_FIELDS = 'heartbeatAt lockedAt silentSince kind';
+// A device created without a kind is a till on every engine; only a create that names one sends
+// (and selects) the kind, so a till is still created on an engine before 39.
+export const CREATE_POS_DEVICE_MUTATION = `mutation CreatePosDevice($input: CreatePosDeviceInput!) { createPosDevice(input: $input) { ${DEVICE_FIELDS} } }`;
+export const CREATE_POS_DEVICE_KIND_MUTATION = `mutation CreatePosDeviceOfKind($input: CreatePosDeviceInput!) { createPosDevice(input: $input) { ${DEVICE_FIELDS} kind } }`;
+const HEARTBEAT_REPORT_FIELDS = 'appVersion buildNumber runtimeVersion updateId updateChannel platform connection outboxPending offlineSalesPending offlineSalesRefused printer reportedAt';
+export const POS_DEVICE_FLEET_QUERY = `query PosDeviceFleet($stockLocationId: ID) { posDeviceFleet(stockLocationId: $stockLocationId) { device { ${DEVICE_FIELDS} ${DEVICE_HEALTH_FIELDS} } health { status lastHeardAt silentSince } report { ${HEARTBEAT_REPORT_FIELDS} } openDrawer { sessionId registerId openedAt openedByStaffName } lockedByUserName } }`;
+export const LOCK_POS_DEVICE_MUTATION = `mutation LockPosDevice($deviceId: ID!) { lockPosDevice(deviceId: $deviceId) { ${DEVICE_FIELDS} ${DEVICE_HEALTH_FIELDS} } }`;
+export const UNLOCK_POS_DEVICE_MUTATION = `mutation UnlockPosDevice($deviceId: ID!) { unlockPosDevice(deviceId: $deviceId) { ${DEVICE_FIELDS} ${DEVICE_HEALTH_FIELDS} } }`;
 export const POS_RECEIPT_NUMBERING_QUERY = `query PosReceiptNumberingConfig { posReceiptNumberingConfig { prefix suffix digits } }`;
 export const UPDATE_POS_RECEIPT_NUMBERING_MUTATION = `mutation UpdatePosReceiptNumberingConfig($input: UpdatePosReceiptNumberingConfigInput!) { updatePosReceiptNumberingConfig(input: $input) { prefix suffix digits } }`;
+const SETTINGS_FIELDS = 'enabled cashPaymentMethodCode cardPaymentMethodCode inStoreShippingMethodId fulfillmentProfileId defaultStockLocationId cashRoundingMode hasMollieKey maskedMollieApiKey';
+export const POS_SETTINGS_QUERY = `query PosSettings { getPosConfig { ${SETTINGS_FIELDS} } }`;
+export const UPDATE_POS_SETTINGS_MUTATION = `mutation UpdatePosSettings($input: UpdatePosConfigInput!) { updatePosConfig(input: $input) { ${SETTINGS_FIELDS} } }`;
+export const POS_MOLLIE_TERMINALS_QUERY = `query PosMollieTerminals { posMollieTerminals { terminalId description status brand model serialNumber currency } }`;
+// Engine `pos-mollie-terminal-pairing`; an older engine refuses both documents at validation.
+export const CREATE_POS_MOLLIE_PAIRING_CODE_MUTATION = `mutation CreatePosMollieTerminalPairingCode { createPosMollieTerminalPairingCode { pairingCodeId code qrCodeSvg expiresAt } }`;
+export const REVOKE_POS_MOLLIE_PAIRING_CODE_MUTATION = `mutation RevokePosMollieTerminalPairingCode($pairingCodeId: String!) { revokePosMollieTerminalPairingCode(pairingCodeId: $pairingCodeId) }`;
+// Engine sprint 25b; an older engine refuses both documents at validation.
+export const POS_CASH_CONTROLS_QUERY = `query PosCashControls { getPosConfig { cashControls { blindCount varianceThreshold } } }`;
+export const SET_POS_CASH_CONTROLS_MUTATION = `mutation SetPosCashControls($input: PosCashControlsInput!) { setPosCashControls(input: $input) { blindCount varianceThreshold } }`;
+// The store's idle lock (POS polish programme PR 2); an older engine refuses both at validation.
+export const POS_IDLE_LOCK_QUERY = `query PosIdleLock { getPosConfig { idleLockMinutes } }`;
+export const SET_POS_IDLE_LOCK_MUTATION = `mutation SetPosIdleLock($input: UpdatePosConfigInput!) { updatePosConfig(input: $input) { idleLockMinutes } }`;
+// Engine sprint 22 (the receipt's tender and refund `exchange`, its lines' `ships` and its `delivery`:
+// engine C3); an older engine refuses each document at validation.
+const RECEIPT_SETTINGS_FIELDS = 'configured showStoreName showAddress showPhone showVatNumber headerLines footerLines taxDisplay identity { storeName addressLines phone vatNumber registrationNumber }';
+const RECEIPT_FIELDS = 'kind orderId orderCode receiptNumber issuedAt language locale timeZone currencyCode taxDisplay header { storeName addressLines phone vatNumber registrationNumber extraLines } cashierName registerName lines { orderLineId name sku quantity unitPrice amount taxRate discounts { kind description amount } note ships } subtotal adjustments { kind description amount } taxes { description rate base amount } total tenders { kind exchange methodName amount tendered cashRounding change } changeDue refunds { kind exchange methodName amount refundedAt } orderNote delivery { name addressLines methodName } footerLines thankYou scanCode';
+export const POS_RECEIPT_SETTINGS_QUERY = `query PosReceiptSettings { getPosConfig { receipt { ${RECEIPT_SETTINGS_FIELDS} } } }`;
+export const SET_POS_RECEIPT_SETTINGS_MUTATION = `mutation SetPosReceiptSettings($input: PosReceiptSettingsInput!) { setPosReceiptSettings(input: $input) { ${RECEIPT_SETTINGS_FIELDS} } }`;
+export const POS_RECEIPT_PREVIEW_QUERY = `query PosReceiptPreview($input: PosReceiptSettingsInput) { posReceiptPreview(input: $input) { ${RECEIPT_FIELDS} } }`;
+export const POS_RECEIPT_QUERY = `query PosReceipt($orderId: ID!) { posReceipt(orderId: $orderId) { ${RECEIPT_FIELDS} } }`;
+// Engine sprint 23: each its own document, so a call to an engine before 23 fails alone.
+const RECEIPT_LINK_FIELDS = 'variant url issuedAt expiresAt';
+const RECEIPT_LINK_STATUS_FIELDS = 'variant state url issuedAt expiresAt revokedAt revokeReason';
+const GIFT_RECEIPT_FIELDS = `orderId orderCode receiptNumber issuedAt language locale timeZone header { storeName addressLines phone vatNumber registrationNumber extraLines } registerName lines { orderLineId name sku quantity } footerLines thankYou scanCode link { ${RECEIPT_LINK_FIELDS} } copy { number printedAt }`;
+export const POS_RECEIPT_SHARING_QUERY = `query PosReceiptSharing($orderId: ID!) { posReceiptSharing(orderId: $orderId) { available enabled ttlDays links { ${RECEIPT_LINK_STATUS_FIELDS} } receiptCopies giftPrints } }`;
+export const POS_ISSUE_RECEIPT_LINK_MUTATION = `mutation PosIssueReceiptLink($orderId: ID!, $variant: PosReceiptVariant!) { posIssueReceiptLink(orderId: $orderId, variant: $variant) { ${RECEIPT_LINK_STATUS_FIELDS} } }`;
+export const REVOKE_POS_RECEIPT_LINK_MUTATION = `mutation RevokePosReceiptLink($orderId: ID!, $variant: PosReceiptVariant!) { revokePosReceiptLink(orderId: $orderId, variant: $variant) { ${RECEIPT_LINK_STATUS_FIELDS} } }`;
+export const POS_PRINT_RECEIPT_MUTATION = `mutation PosPrintReceipt($input: PosPrintReceiptInput!, $staffToken: String) { posPrintReceipt(input: $input, staffToken: $staffToken) { orderId variant printNumber copy receipt { ${RECEIPT_FIELDS} link { ${RECEIPT_LINK_FIELDS} } copy { number printedAt } } giftReceipt { ${GIFT_RECEIPT_FIELDS} } } }`;
+export const POS_GIFT_RECEIPT_QUERY = `query PosGiftReceipt($orderId: ID!) { posReceipt(orderId: $orderId) { gift { ${GIFT_RECEIPT_FIELDS} } } }`;
+export const POS_DIGITAL_RECEIPTS_QUERY = `query PosDigitalReceipts { getPosConfig { receipt { publicLink publicLinkAvailable } } }`;
+// Engine C3/32: its own document, so `digitalReceipts()` keeps working on an engine before C3.
+export const POS_RECEIPT_ACCOUNT_CLAIM_QUERY = `query PosReceiptAccountClaim { getPosConfig { receipt { accountClaim accountClaimAvailable } } }`;
+// Engine sprint 22c.
+export const POS_EMAIL_RECEIPT_MUTATION = `mutation PosEmailReceipt($input: PosEmailReceiptInput!, $staffToken: String) { posEmailReceipt(input: $input, staffToken: $staffToken) { orderId source sentForSale } }`;
+// Engine sprint 26: the store's day controls, each its own document.
+const DAY_CONTROLS_FIELDS = 'businessDayStartsAt closingTime autoCloseAfterClosingMinutes autoCloseIdleMinutes';
+export const POS_DAY_CONTROLS_QUERY = `query PosDayControls { getPosConfig { id dayControls { ${DAY_CONTROLS_FIELDS} } } }`;
+export const SET_POS_DAY_CONTROLS_MUTATION = `mutation SetPosDayControls($input: PosDayControlsInput!) { setPosDayControls(input: $input) { ${DAY_CONTROLS_FIELDS} } }`;
+export const POS_SETUP_READINESS_QUERY = `query PosSetupReadiness { posSetupReadiness { ready checks { check ok required reason } } }`;
+const CUSTOM_ITEM_POLICY_FIELDS = 'enabled available maxUnitPrice cashierLimit amountsIncludeTax currencyCode taxCategories { id name taxRate } taxCategoryChoices { id name taxRate }';
+export const POS_CUSTOM_ITEM_POLICY_QUERY = `query PosCustomItemPolicy { posCustomItemPolicy { ${CUSTOM_ITEM_POLICY_FIELDS} } }`;
+export const SET_POS_CUSTOM_ITEM_POLICY_MUTATION = `mutation SetPosCustomItemPolicy($input: PosCustomItemPolicyInput!) { setPosCustomItemPolicy(input: $input) { ${CUSTOM_ITEM_POLICY_FIELDS} } }`;
+const STAFF_FIELDS = 'id name role active administratorId locale createdAt updatedAt';
+export const POS_STAFF_LIST_QUERY = `query PosStaffList { posStaffList { ${STAFF_FIELDS} } }`;
+export const POS_STAFF_QUERY = `query PosStaff($id: ID!) { posStaff(id: $id) { ${STAFF_FIELDS} } }`;
+export const CREATE_POS_STAFF_MUTATION = `mutation CreatePosStaff($input: CreatePosStaffInput!) { createPosStaff(input: $input) { ${STAFF_FIELDS} } }`;
+export const UPDATE_POS_STAFF_MUTATION = `mutation UpdatePosStaff($id: ID!, $input: UpdatePosStaffInput!) { updatePosStaff(id: $id, input: $input) { ${STAFF_FIELDS} } }`;
+// Names no `locale`, unlike the four above: a PIN can be set on an engine older than the staff
+// language too.
+export const SET_POS_STAFF_PIN_MUTATION = `mutation SetPosStaffPin($id: ID!, $pin: String!) { setPosStaffPin(id: $id, pin: $pin) }`;
+// Engine sprint 18: only these three documents name `grants`, so the four above keep working on an
+// older engine.
+const STAFF_GRANTS_FIELDS = 'id role grants';
+export const POS_STAFF_GRANTS_QUERY = `query PosStaffGrants($id: ID!) { posStaff(id: $id) { ${STAFF_GRANTS_FIELDS} } }`;
+export const POS_STAFF_GRANTS_LIST_QUERY = `query PosStaffGrantsList { posStaffList { ${STAFF_GRANTS_FIELDS} } }`;
+export const SET_POS_STAFF_GRANTS_MUTATION = `mutation SetPosStaffGrants($id: ID!, $grants: [PosStaffGrant!]!) { setPosStaffGrants(id: $id, grants: $grants) { ${STAFF_GRANTS_FIELDS} } }`;
+// The engine's own list of grants, read by introspection: any engine answers it (null type, none).
+export const POS_STAFF_GRANT_VALUES_QUERY = `query PosStaffGrantValues { __type(name: "PosStaffGrant") { enumValues { name } } }`;
+const DEVICE_KIND_INVALID = 'POS_DEVICE_KIND_INVALID';
+/** A kind outside {@link POS_DEVICE_KINDS}, refused before sending, as the engine refuses it. */
+function deviceKindRefusal(kind) {
+    const message = `A POS device is a ${POS_DEVICE_KINDS.join(' or a ')}, not "${String(kind).slice(0, 40)}".`;
+    return new ValidationError({
+        code: DEVICE_KIND_INVALID,
+        message,
+        status: 400,
+        service: 'vendure',
+        details: [{ field: 'kind', code: DEVICE_KIND_INVALID, message }],
+    });
+}
+const PAIRING_CODE_VALIDITY_INVALID = 'POS_PAIRING_CODE_VALIDITY_INVALID';
+/** A validity outside {@link POS_PAIRING_CODE_VALIDITIES}, refused before sending. */
+function pairingValidityRefusal(validity) {
+    const message = `A pairing code is ${POS_PAIRING_CODE_VALIDITIES.join(' or ')}, not "${String(validity).slice(0, 40)}".`;
+    return new ValidationError({
+        code: PAIRING_CODE_VALIDITY_INVALID,
+        message,
+        status: 400,
+        service: 'vendure',
+        details: [{ field: 'validity', code: PAIRING_CODE_VALIDITY_INVALID, message }],
+    });
+}
+const LOCALE_UNSUPPORTED = 'POS_LOCALE_UNSUPPORTED';
+const LOCALE_UNSUPPORTED_MESSAGE = `A staff language must be one of ${POS_STAFF_LOCALES.join(', ')}, or null to follow the store.`;
+function localeRefusal(message) {
+    return new ValidationError({
+        code: LOCALE_UNSUPPORTED,
+        message,
+        status: 400,
+        service: 'vendure',
+        details: [{ field: 'locale', code: LOCALE_UNSUPPORTED, message }],
+    });
+}
+/**
+ * A staff language as the engine stores it, refused here before anything is sent when it is not
+ * one: `undefined` stays absent (leave it), null and a blank string follow the store, a listed
+ * language in any case with spaces around it is that language. Never quotes the value.
+ */
+function staffLocale(value) {
+    if (value === undefined)
+        return undefined;
+    if (value === null)
+        return null;
+    if (typeof value !== 'string')
+        throw localeRefusal(LOCALE_UNSUPPORTED_MESSAGE);
+    const locale = value.trim().toLowerCase();
+    if (locale === '')
+        return null;
+    const listed = POS_STAFF_LOCALES.find((known) => known === locale);
+    if (!listed)
+        throw localeRefusal(LOCALE_UNSUPPORTED_MESSAGE);
+    return listed;
+}
+/** The input with its `locale` checked; an absent one stays absent, so the engine leaves it. */
+function withStaffLocale(input) {
+    const { locale, ...rest } = input;
+    const checked = staffLocale(locale);
+    return (checked === undefined ? rest : { ...rest, locale: checked });
+}
+/**
+ * Whether a failure is "this engine does not know that field yet": the document refused before it
+ * ran, never an execution-time refusal or a transient failure (the rule `customers.credit` and the
+ * purchasing settings read with).
+ */
+function isUnknownFieldRejection(error) {
+    if (!(error instanceof ValidationError) || error.service !== 'vendure')
+        return false;
+    return (error.code === 'BAD_REQUEST' ||
+        error.code === 'GRAPHQL_VALIDATION_FAILED' ||
+        /Cannot query field/i.test(error.message));
+}
+function toTillSale(raw) {
+    const { order, ...rest } = raw;
+    return { orderId: order.id, orderCode: order.code, orderState: order.state, ...rest };
+}
+function toTillSaleDetails(raw) {
+    return {
+        orderId: raw.id,
+        isPosOrder: raw.customFields?.isPosOrder === true,
+        note: raw.customFields?.posOrderNote ?? null,
+        lines: raw.lines.map((line) => ({
+            id: line.id,
+            customItemName: line.customFields?.posCustomItemName ?? null,
+            note: line.customFields?.posLineNote ?? null,
+        })),
+    };
+}
 function toCart(raw) {
+    const { customFields, ...cart } = raw;
     return {
-        ...raw,
+        ...cart,
+        ...(customFields === undefined ? {} : { note: customFields?.posOrderNote ?? null }),
         lines: raw.lines.map((line) => ({
             id: line.id,
             quantity: line.quantity,
             productVariantId: line.productVariant.id,
             linePriceWithTax: line.linePriceWithTax,
+            ...(line.customFields === undefined
+                ? {}
+                : { customItemName: line.customFields?.posCustomItemName ?? null }),
+            ...(line.customFields === undefined || !('posLineNote' in (line.customFields ?? {}))
+                ? {}
+                : { note: line.customFields?.posLineNote ?? null }),
         })),
     };
 }
@@ -71,6 +398,61 @@ function requireKey(options) {
 }
 export function createPosModule(transport) {
     const gql = async (query, variables, options) => transport.graphql({ api: 'admin', query, variables }, options);
+    async function sessionPage(skip, take, options, query = POS_SESSION_LIST_QUERY) {
+        const filters = {};
+        for (const key of [
+            'status',
+            'registerId',
+            'deviceId',
+            'staffId',
+            'openedAfter',
+            'openedBefore',
+        ]) {
+            const value = options?.[key];
+            if (value !== undefined)
+                filters[key] = value;
+        }
+        const data = await gql(query, { options: { ...filters, skip, take } }, options);
+        const list = data.posRegisterSessions;
+        return pageFromVendureList({ items: list.items.map(toSession), totalItems: list.totalItems }, skip, take, (cursor) => sessionPage(readOffsetCursor(cursor), take, options, query));
+    }
+    /** The take of a back-office list (1 to 100, 50 when omitted) and its offset from `after`. */
+    function backOfficePaging(options) {
+        const take = Math.min(Math.max(Math.trunc(options?.limit ?? DEFAULT_BACK_OFFICE_PAGE), 1), MAX_BACK_OFFICE_PAGE);
+        const skip = options?.after === undefined ? 0 : readOffsetCursor(options.after);
+        return { skip, take };
+    }
+    async function orderPage(skip, take, options) {
+        const input = { skip, take };
+        for (const key of [
+            'fromDay',
+            'toDay',
+            'registerId',
+            'sessionId',
+            'deviceId',
+            'staffId',
+            'tender',
+            'term',
+        ]) {
+            const value = options?.[key];
+            if (value !== undefined)
+                input[key] = value;
+        }
+        const data = await gql(POS_ORDERS_QUERY, { input }, options);
+        return pageFromVendureList(data.posOrders, skip, take, (cursor) => orderPage(readOffsetCursor(cursor), take, options));
+    }
+    async function movementPage(skip, take, options) {
+        const input = { skip, take };
+        for (const key of ['fromDay', 'toDay', 'registerId', 'sessionId', 'staffId']) {
+            const value = options?.[key];
+            if (value !== undefined)
+                input[key] = value;
+        }
+        if (options?.types !== undefined)
+            input.types = [...options.types];
+        const data = await gql(POS_CASH_MOVEMENTS_QUERY, { input }, options);
+        return pageFromVendureList(data.posCashMovements, skip, take, (cursor) => movementPage(readOffsetCursor(cursor), take, options));
+    }
     return {
         registers: {
             async list(options) {
@@ -100,19 +482,149 @@ export function createPosModule(transport) {
                 return toSession(data.closePosRegisterSession);
             },
             async xReport(sessionId, options) {
-                const data = await gql(POS_X_REPORT_QUERY, { sessionId }, options);
+                try {
+                    const data = await gql(POS_X_REPORT_QUERY, { sessionId }, options);
+                    return data.posXReport;
+                }
+                catch (error) {
+                    // An engine before C6 knows no gift-card memo: the report without it. Anything else
+                    // (a missing session, a refusal, a transient failure) is the read's own.
+                    if (!isUnknownFieldRejection(error))
+                        throw error;
+                }
+                const data = await gql(POS_X_REPORT_QUERY_BEFORE_GIFT_CARDS, { sessionId }, options);
                 return data.posXReport;
             },
+            async get(sessionId, options) {
+                const data = await gql(POS_SESSION_DETAIL_QUERY, { id: sessionId }, options);
+                return data.posRegisterSession && toSession(data.posRegisterSession);
+            },
+            async openForDevice(deviceId, options) {
+                const data = await gql(POS_OPEN_SESSION_FOR_DEVICE_QUERY, { deviceId }, options);
+                return data.posOpenSessionForDevice && toSession(data.posOpenSessionForDevice);
+            },
+            async list(options) {
+                const take = Math.min(Math.max(Math.trunc(options?.limit ?? DEFAULT_SESSION_PAGE), 1), MAX_SESSION_PAGE);
+                const skip = options?.after === undefined ? 0 : readOffsetCursor(options.after);
+                return sessionPage(skip, take, options);
+            },
             async zReport(sessionId, options) {
                 const data = await gql(POS_SESSION_QUERY, { id: sessionId }, options);
                 return data.posRegisterSession && toSession(data.posRegisterSession);
             },
+            async movements(sessionId, options) {
+                const data = await gql(POS_DRAWER_MOVEMENTS_QUERY, { sessionId, skip: options?.skip, take: options?.take }, options);
+                return data.posDrawerMovements;
+            },
+            async approval(sessionId, options) {
+                const data = await gql(POS_SESSION_APPROVAL_QUERY, { id: sessionId }, options);
+                const raw = data.posRegisterSession;
+                if (!raw)
+                    return null;
+                const { id, ...rest } = raw;
+                return { sessionId: id, ...rest };
+            },
+            async approveClose(sessionId, input, options) {
+                const data = await gql(APPROVE_POS_SESSION_CLOSE_MUTATION, { input: { sessionId, note: input.note } }, options);
+                return toSession(data.approvePosRegisterSessionClose);
+            },
+            async record(sessionId, options) {
+                const data = await gql(POS_SESSION_RECORD_QUERY, { id: sessionId }, options);
+                return data.posRegisterSession && toSession(data.posRegisterSession);
+            },
+            async records(options) {
+                const take = Math.min(Math.max(Math.trunc(options?.limit ?? DEFAULT_SESSION_PAGE), 1), MAX_SESSION_PAGE);
+                const skip = options?.after === undefined ? 0 : readOffsetCursor(options.after);
+                return sessionPage(skip, take, options, POS_SESSION_RECORDS_QUERY);
+            },
+            async closeUncounted(sessionId, input, options) {
+                const data = await gql(CLOSE_POS_SESSION_UNCOUNTED_MUTATION, { input: { sessionId, note: input.note } }, options);
+                return toSession(data.closePosRegisterSessionUncounted);
+            },
+            async count(sessionId, input, options) {
+                const data = await gql(COUNT_POS_SESSION_MUTATION, {
+                    input: {
+                        sessionId,
+                        countedCash: input.countedCash,
+                        // Only what was given: an absent count or note is none.
+                        ...(input.closingCounts === undefined ? {} : { closingCounts: input.closingCounts }),
+                        ...(input.note === undefined ? {} : { note: input.note }),
+                    },
+                }, options);
+                return toSession(data.countPosRegisterSession);
+            },
         },
         cash: {
             async record(input, options) {
-                const data = await gql(RECORD_POS_CASH_MOVEMENT_MUTATION, { input, staffToken: options?.staffToken }, options);
+                const data = await gql(RECORD_POS_CASH_MOVEMENT_MUTATION, {
+                    // The key only when given: an engine before 25a refuses the input field.
+                    input: options?.idempotencyKey === undefined
+                        ? input
+                        : { ...input, idempotencyKey: options.idempotencyKey },
+                    staffToken: options?.staffToken,
+                }, options);
                 return data.recordPosCashMovement;
             },
+            async list(options) {
+                const { skip, take } = backOfficePaging(options);
+                return movementPage(skip, take, options);
+            },
+        },
+        orders: {
+            async list(options) {
+                const { skip, take } = backOfficePaging(options);
+                return orderPage(skip, take, options);
+            },
+            async get(orderId, options) {
+                try {
+                    const data = await gql(POS_TILL_SALE_QUERY, { orderId }, options);
+                    return toTillSale(data.posTillOrder);
+                }
+                catch (error) {
+                    // An engine older than the ID check refuses the whole document; the sale is still
+                    // readable, with no ID check. Any other failure is the read's own.
+                    if (!isUnknownFieldRejection(error))
+                        throw error;
+                    const data = await gql(POS_TILL_SALE_QUERY_LEGACY, { orderId }, options);
+                    return toTillSale({ ...data.posTillOrder, idCheck: null });
+                }
+            },
+        },
+        days: {
+            async get(input, options) {
+                const data = await gql(POS_STORE_DAY_QUERY, { stockLocationId: input.stockLocationId, businessDay: input.businessDay }, options);
+                return data.posStoreDay;
+            },
+            async list(input, options) {
+                const data = await gql(POS_STORE_DAYS_QUERY, {
+                    input: {
+                        stockLocationId: input.stockLocationId,
+                        ...(input.fromDay === undefined ? {} : { fromDay: input.fromDay }),
+                        ...(input.toDay === undefined ? {} : { toDay: input.toDay }),
+                    },
+                }, options);
+                return wholeList(data.posStoreDays.items);
+            },
+            async close(input, options) {
+                const data = await gql(CLOSE_POS_STORE_DAY_MUTATION, {
+                    input: {
+                        stockLocationId: input.stockLocationId,
+                        businessDay: input.businessDay,
+                        ...(input.note === undefined ? {} : { note: input.note }),
+                    },
+                }, options);
+                return data.closePosStoreDay;
+            },
+            async reopen(input, options) {
+                const data = await gql(REOPEN_POS_STORE_DAY_MUTATION, {
+                    input: {
+                        stockLocationId: input.stockLocationId,
+                        businessDay: input.businessDay,
+                        note: input.note,
+                    },
+                }, options);
+                return data.reopenPosStoreDay;
+            },
         },
         sale: {
             async createCart(input, options) {
@@ -138,11 +650,96 @@ export function createPosModule(transport) {
                 const data = await gql(POS_REMOVE_COUPON_CODE_MUTATION, { input: { ...input, idempotencyKey: options?.idempotencyKey } }, options);
                 return toCart(data.posRemoveCouponCode);
             },
+            async addCustomItem(input, options) {
+                const idempotencyKey = requireKey(options);
+                const data = await gql(POS_ADD_CUSTOM_ITEM_MUTATION, {
+                    input: { ...input, idempotencyKey },
+                    staffToken: options.staffToken,
+                    ...(options.approvalToken === undefined
+                        ? {}
+                        : { approvalToken: options.approvalToken }),
+                }, options);
+                return toCart(data.posAddCustomItem);
+            },
+            async setOrderNote(input, options) {
+                const idempotencyKey = requireKey(options);
+                const data = await gql(POS_SET_ORDER_NOTE_MUTATION, { input: { ...input, idempotencyKey }, staffToken: options.staffToken }, options);
+                return toCart(data.posSetOrderNote);
+            },
+            async setLineNote(input, options) {
+                const idempotencyKey = requireKey(options);
+                const data = await gql(POS_SET_LINE_NOTE_MUTATION, { input: { ...input, idempotencyKey }, staffToken: options.staffToken }, options);
+                return toCart(data.posSetLineNote);
+            },
+            async clearCart(orderId, options) {
+                const idempotencyKey = requireKey(options);
+                const data = await gql(POS_CLEAR_CART_MUTATION, { input: { orderId, idempotencyKey }, staffToken: options.staffToken }, options);
+                return data.posClearCart;
+            },
             async complete(orderId, options) {
                 const idempotencyKey = requireKey(options);
                 const data = await gql(POS_COMPLETE_SALE_MUTATION, { input: { orderId, idempotencyKey }, staffToken: options.staffToken }, options);
                 return data.posCompleteSale;
             },
+            async tillDetails(orderId, options) {
+                const redaction = redactionWatcher();
+                const data = await transport.graphql({
+                    api: 'admin',
+                    query: POS_TILL_SALE_DETAILS_QUERY,
+                    variables: { id: orderId },
+                    onExtensions: redaction.onExtensions,
+                }, options);
+                return redaction.mark(data.order === null ? null : toTillSaleDetails(data.order));
+            },
+            async receipt(orderId, options) {
+                const redaction = redactionWatcher();
+                const data = await transport.graphql({
+                    api: 'admin',
+                    query: POS_RECEIPT_QUERY,
+                    variables: { orderId },
+                    onExtensions: redaction.onExtensions,
+                }, options);
+                return redaction.mark(data.posReceipt);
+            },
+            async emailReceipt(input, options) {
+                const idempotencyKey = requireKey(options);
+                const data = await gql(POS_EMAIL_RECEIPT_MUTATION, {
+                    input: {
+                        orderId: input.orderId,
+                        ...(input.emailAddress === undefined ? {} : { emailAddress: input.emailAddress }),
+                        idempotencyKey,
+                    },
+                    staffToken: options.staffToken,
+                }, options);
+                return data.posEmailReceipt;
+            },
+            async receiptSharing(orderId, options) {
+                const data = await gql(POS_RECEIPT_SHARING_QUERY, { orderId }, options);
+                return data.posReceiptSharing;
+            },
+            async issueReceiptLink(orderId, variant, options) {
+                const data = await gql(POS_ISSUE_RECEIPT_LINK_MUTATION, { orderId, variant }, options);
+                return data.posIssueReceiptLink;
+            },
+            async revokeReceiptLink(orderId, variant, options) {
+                const data = await gql(REVOKE_POS_RECEIPT_LINK_MUTATION, { orderId, variant }, options);
+                return data.revokePosReceiptLink;
+            },
+            async printReceipt(input, options) {
+                const supplied = options?.idempotencyKey;
+                const idempotencyKey = typeof supplied === 'string' && supplied.trim() !== ''
+                    ? supplied
+                    : globalThis.crypto.randomUUID();
+                const data = await gql(POS_PRINT_RECEIPT_MUTATION, {
+                    input: { orderId: input.orderId, variant: input.variant, idempotencyKey },
+                    staffToken: options?.staffToken,
+                }, options);
+                return data.posPrintReceipt;
+            },
+            async giftReceipt(orderId, options) {
+                const data = await gql(POS_GIFT_RECEIPT_QUERY, { orderId }, options);
+                return data.posReceipt.gift;
+            },
         },
         tenders: {
             async cash(input, options) {
@@ -178,14 +775,77 @@ export function createPosModule(transport) {
                 const data = await gql(POS_DEVICES_QUERY, {}, options);
                 return wholeList(data.posDevices);
             },
+            async get(deviceId, options) {
+                const data = await gql(POS_DEVICE_DETAIL_QUERY, { id: deviceId }, options);
+                return data.posDevice;
+            },
+            async assignLocation(deviceId, stockLocationId, options) {
+                const registerId = options?.registerId;
+                const data = await gql(registerId === undefined
+                    ? ASSIGN_POS_DEVICE_LOCATION_MUTATION
+                    : ASSIGN_POS_DEVICE_LOCATION_WITH_REGISTER_MUTATION, registerId === undefined
+                    ? { deviceId, stockLocationId }
+                    : { deviceId, stockLocationId, registerId }, options);
+                return data.assignPosDeviceLocation;
+            },
+            async assignRegister(deviceId, registerId, options) {
+                const data = await gql(ASSIGN_POS_DEVICE_REGISTER_MUTATION, { deviceId, registerId }, options);
+                return data.assignPosDeviceRegister;
+            },
+            async assignTerminal(deviceId, terminalId, options) {
+                const data = await gql(ASSIGN_POS_DEVICE_TERMINAL_MUTATION, { deviceId, terminalId }, options);
+                return data.assignPosDeviceMollieTerminal;
+            },
+            async clearTerminal(deviceId, options) {
+                const data = await gql(CLEAR_POS_DEVICE_TERMINAL_MUTATION, { deviceId }, options);
+                return data.clearPosDeviceMollieTerminal;
+            },
+            async create(input, options) {
+                const base = {
+                    label: input.label,
+                    stockLocationId: input.stockLocationId,
+                    registerId: input.registerId ?? null,
+                };
+                if (input.kind === undefined) {
+                    const data = await gql(CREATE_POS_DEVICE_MUTATION, { input: base }, options);
+                    return data.createPosDevice;
+                }
+                if (!POS_DEVICE_KINDS.includes(input.kind))
+                    throw deviceKindRefusal(input.kind);
+                const data = await gql(CREATE_POS_DEVICE_KIND_MUTATION, { input: { ...base, kind: input.kind } }, options);
+                return data.createPosDevice;
+            },
             async pair(deviceId, options) {
-                const data = await gql(POS_PAIRING_CODE_MUTATION, { deviceId }, options);
+                const validity = options?.validity;
+                if (validity === undefined || validity === null) {
+                    const data = await gql(POS_PAIRING_CODE_MUTATION, { deviceId }, options);
+                    return data.generatePosPairingCode;
+                }
+                if (!POS_PAIRING_CODE_VALIDITIES.includes(validity)) {
+                    throw pairingValidityRefusal(validity);
+                }
+                const data = await gql(POS_PAIRING_CODE_WITH_VALIDITY_MUTATION, { deviceId, validity }, options);
                 return data.generatePosPairingCode;
             },
             async revoke(deviceId, options) {
                 const data = await gql(REVOKE_POS_DEVICE_MUTATION, { deviceId }, options);
                 return data.revokePosDevice;
             },
+            async fleet(options) {
+                const data = await gql(POS_DEVICE_FLEET_QUERY, { stockLocationId: options?.stockLocationId ?? null }, options);
+                return wholeList(data.posDeviceFleet);
+            },
+            async offlineSalesToReview(options) {
+                return wholeList(await readOfflineSalesToReview(transport, options));
+            },
+            async lock(deviceId, options) {
+                const data = await gql(LOCK_POS_DEVICE_MUTATION, { deviceId }, options);
+                return data.lockPosDevice;
+            },
+            async unlock(deviceId, options) {
+                const data = await gql(UNLOCK_POS_DEVICE_MUTATION, { deviceId }, options);
+                return data.unlockPosDevice;
+            },
             async heartbeat(deviceId, options) {
                 const data = await gql(POS_DEVICE_QUERY, { id: deviceId }, options);
                 return data.posDevice;
@@ -201,5 +861,192 @@ export function createPosModule(transport) {
                 return data.updatePosReceiptNumberingConfig;
             },
         },
+        settings: {
+            async get(options) {
+                const data = await gql(POS_SETTINGS_QUERY, {}, options);
+                return data.getPosConfig;
+            },
+            async update(input, options) {
+                const known = POS_SETTINGS_INPUT_FIELDS;
+                // Names the field, never its value: a Mollie key sent here must not reach a log.
+                const unknown = Object.keys(input).filter((field) => !known.includes(field));
+                if (unknown.length > 0) {
+                    throw new TypeError(`settings.update does not change ${unknown.join(', ')}: use setMollieApiKey, setCashRoundingMode, setReceipt or setIdleLock.`);
+                }
+                const data = await gql(UPDATE_POS_SETTINGS_MUTATION, { input: { ...input } }, options);
+                return data.updatePosConfig;
+            },
+            async setMollieApiKey(apiKey, options) {
+                const key = apiKey.trim();
+                if (key === '') {
+                    // Never quotes the argument: a key mistyped as whitespace around it must not reach a log.
+                    throw new TypeError('setMollieApiKey needs a key; remove the stored one with removeMollieApiKey().');
+                }
+                const data = await gql(UPDATE_POS_SETTINGS_MUTATION, { input: { mollieApiKey: key } }, options);
+                return data.updatePosConfig;
+            },
+            async removeMollieApiKey(options) {
+                // `''` clears (the input documents "Pass empty string to clear").
+                const data = await gql(UPDATE_POS_SETTINGS_MUTATION, { input: { mollieApiKey: '' } }, options);
+                return data.updatePosConfig;
+            },
+            async setCashRoundingMode(mode, options) {
+                const data = await gql(UPDATE_POS_SETTINGS_MUTATION, { input: { cashRoundingMode: mode } }, options);
+                return data.updatePosConfig;
+            },
+            async readiness(options) {
+                const data = await gql(POS_SETUP_READINESS_QUERY, {}, options);
+                return data.posSetupReadiness;
+            },
+            async cashControls(options) {
+                const data = await gql(POS_CASH_CONTROLS_QUERY, {}, options);
+                return data.getPosConfig?.cashControls ?? null;
+            },
+            async setCashControls(input, options) {
+                // Only the fields given: an omitted threshold keeps the stored one.
+                const data = await gql(SET_POS_CASH_CONTROLS_MUTATION, {
+                    input: input.varianceThreshold === undefined
+                        ? { blindCount: input.blindCount }
+                        : { blindCount: input.blindCount, varianceThreshold: input.varianceThreshold },
+                }, options);
+                return data.setPosCashControls;
+            },
+            async dayControls(options) {
+                const data = await gql(POS_DAY_CONTROLS_QUERY, {}, options);
+                return data.getPosConfig?.dayControls ?? null;
+            },
+            async setDayControls(input, options) {
+                // The fields given, as given: an omitted idle time keeps the stored one on the engine.
+                const sent = {
+                    businessDayStartsAt: input.businessDayStartsAt,
+                    autoCloseAfterClosingMinutes: input.autoCloseAfterClosingMinutes,
+                };
+                if (input.closingTime !== undefined)
+                    sent.closingTime = input.closingTime;
+                if (input.autoCloseIdleMinutes !== undefined) {
+                    sent.autoCloseIdleMinutes = input.autoCloseIdleMinutes;
+                }
+                const data = await gql(SET_POS_DAY_CONTROLS_MUTATION, { input: sent }, options);
+                return data.setPosDayControls;
+            },
+            async customItemPolicy(options) {
+                const data = await gql(POS_CUSTOM_ITEM_POLICY_QUERY, {}, options);
+                return data.posCustomItemPolicy;
+            },
+            async setCustomItemPolicy(input, options) {
+                const data = await gql(SET_POS_CUSTOM_ITEM_POLICY_MUTATION, { input }, options);
+                return data.setPosCustomItemPolicy;
+            },
+            async receipt(options) {
+                const data = await gql(POS_RECEIPT_SETTINGS_QUERY, {}, options);
+                return data.getPosConfig?.receipt ?? null;
+            },
+            async setReceipt(input, options) {
+                const data = await gql(SET_POS_RECEIPT_SETTINGS_MUTATION, { input }, options);
+                return data.setPosReceiptSettings;
+            },
+            async previewReceipt(input, options) {
+                const data = await gql(POS_RECEIPT_PREVIEW_QUERY, { input: input ?? null }, options);
+                return data.posReceiptPreview;
+            },
+            async digitalReceipts(options) {
+                const data = await gql(POS_DIGITAL_RECEIPTS_QUERY, {}, options);
+                return data.getPosConfig?.receipt ?? null;
+            },
+            async receiptAccountClaim(options) {
+                const data = await gql(POS_RECEIPT_ACCOUNT_CLAIM_QUERY, {}, options);
+                return data.getPosConfig?.receipt ?? null;
+            },
+            async offlineCashSales(options) {
+                return readOfflineCashSales(transport, options);
+            },
+            async setOfflineCashSales(input, options) {
+                return writeOfflineCashSales(transport, input, options);
+            },
+            async idleLock(options) {
+                const data = await gql(POS_IDLE_LOCK_QUERY, {}, options);
+                return data.getPosConfig ? { minutes: data.getPosConfig.idleLockMinutes ?? null } : null;
+            },
+            async setIdleLock(minutes, options) {
+                if (minutes !== null && !Number.isInteger(minutes)) {
+                    throw new TypeError('setIdleLock needs a whole number of minutes, or null.');
+                }
+                const data = await gql(SET_POS_IDLE_LOCK_MUTATION, { input: { idleLockMinutes: minutes } }, options);
+                return { minutes: data.updatePosConfig.idleLockMinutes ?? null };
+            },
+        },
+        terminals: {
+            async list(options) {
+                const data = await gql(POS_MOLLIE_TERMINALS_QUERY, {}, options);
+                return wholeList(data.posMollieTerminals);
+            },
+            async createPairingCode(options) {
+                const data = await gql(CREATE_POS_MOLLIE_PAIRING_CODE_MUTATION, {}, options);
+                return data.createPosMollieTerminalPairingCode;
+            },
+            async revokePairingCode(pairingCodeId, options) {
+                const data = await gql(REVOKE_POS_MOLLIE_PAIRING_CODE_MUTATION, { pairingCodeId }, options);
+                return data.revokePosMollieTerminalPairingCode;
+            },
+        },
+        staff: {
+            async list(options) {
+                const data = await gql(POS_STAFF_LIST_QUERY, {}, options);
+                return wholeList(data.posStaffList);
+            },
+            async get(id, options) {
+                const data = await gql(POS_STAFF_QUERY, { id }, options);
+                return data.posStaff;
+            },
+            async create(input, options) {
+                // Only the fields this module publishes are sent: the engine stores an `administratorId`
+                // link without checking it belongs to the store, so it is not offered here.
+                const { name, pin, role, locale } = input;
+                const checked = withStaffLocale({
+                    name,
+                    pin,
+                    ...(role === undefined ? {} : { role }),
+                    ...(locale === undefined ? {} : { locale }),
+                });
+                const data = await gql(CREATE_POS_STAFF_MUTATION, { input: checked }, options);
+                return data.createPosStaff;
+            },
+            async update(id, input, options) {
+                const checked = withStaffLocale(input);
+                const data = await gql(UPDATE_POS_STAFF_MUTATION, { id, input: checked }, options);
+                return data.updatePosStaff;
+            },
+            async setPin(id, pin, options) {
+                // The engine answers true or throws: there is no "not set" answer to read.
+                await gql(SET_POS_STAFF_PIN_MUTATION, { id, pin }, options);
+            },
+            async grants(id, options) {
+                const data = await gql(POS_STAFF_GRANTS_QUERY, { id }, options);
+                return data.posStaff;
+            },
+            async listGrants(options) {
+                const data = await gql(POS_STAFF_GRANTS_LIST_QUERY, {}, options);
+                return wholeList(data.posStaffList);
+            },
+            async setGrants(id, grants, options) {
+                // Sent as given: the engine's enum refuses a value it does not know, and it dedupes.
+                const data = await gql(SET_POS_STAFF_GRANTS_MUTATION, { id, grants: [...grants] }, options);
+                return data.setPosStaffGrants;
+            },
+            async knownGrants(options) {
+                const data = await gql(POS_STAFF_GRANT_VALUES_QUERY, {}, options);
+                return (data.__type?.enumValues ?? []).map((value) => value.name);
+            },
+        },
+        quickKeys: createPosQuickKeysModule(transport),
+        returns: createPosReturnsModule(transport),
+        exchanges: createPosExchangesModule(transport),
+        reports: createPosReportsModule(transport),
+        anomalies: createPosAnomaliesModule(transport),
+        noReceipt: createPosNoReceiptModule(transport),
+        assistedSelling: createPosAssistedSellingModule(transport),
+        payByLink: createPosPayByLinkModule(transport),
+        offlineSales: createPosOfflineSalesModule(transport),
+        giftCards: createPosGiftCardsModule(transport),
     };
 }