@sixtyninecommerce/admin 0.9.0 → 0.11.0

package/dist/pos/index.d.ts

@@ -1,5 +1,15 @@
 import { type Page, type Transport } from '@sixtyninecommerce/core';
-import type { Call } from '../types.js';
+import type { Call, ListOptions } from '../types.js';
+import { type PosAnomaliesModule } from './anomalies.js';
+import { type PosAssistedSellingModule } from './assisted-selling.js';
+import { type PosExchangesModule } from './exchanges.js';
+import { type PosGiftCardsModule } from './gift-cards.js';
+import { type PosNoReceiptModule } from './no-receipt.js';
+import { type PosDeviceOfflineSalesToReview, type PosOfflineCashSales, type PosOfflineCashSalesInput, type PosOfflineSalesModule } from './offline-sales.js';
+import { type PosPayByLinkModule } from './pay-by-link.js';
+import { type PosQuickKeysModule } from './quick-keys.js';
+import { type PosReportsModule } from './reports.js';
+import { type PosReturnsModule } from './returns.js';
 /**
  * Point of sale on a machine principal (spec §8.8): a vertical's own backend
  * runs the till — register sessions, cash, tenders, the sale, refunds, X and Z —
@@ -29,7 +39,8 @@ import type { Call } from '../types.js';
  * / `registerRef`)
  * — the platform records those refs on each payment only when it vouches for
  * the credential; they are attribution, never authorization. For a principal
- * the CREDENTIAL is the manager gate for discounts and refunds.
+ * the CREDENTIAL is the manager gate for discounts and refunds, and for a
+ * drawer's paid-out, no-sale and float adjustment.
  *
  * ## Money
  *
@@ -55,17 +66,92 @@ import type { Call } from '../types.js';
  * - the tenders take money on such a cart (once it is placed, more money is
  *   `POS_ORDER_NOT_PAYABLE`) or on an order the till did not open while it can
  *   still take payment (see {@link PosTendersModule.card});
- * - `refunds.create` refunds a payment of a till's sale.
+ * - `refunds.create` refunds a payment of a till's sale (money only);
+ * - `returns.quote` / `returns.create` / `returns.void` take a sale's items back (or void it) and
+ *   refund them to the sale's own payments (engine sprint 20);
+ * - `exchanges.quote` / `exchanges.create` take a sale's items back and carry their value to an
+ *   open till cart as its last tender (engine sprint 21).
+ *
+ * ## Setting the till up
+ *
+ * `settings` and `terminals` are the store's own setup, for a back-office user
+ * or its tooling, not for a till: `settings.get` reads the POS settings, with the
+ * till's Mollie API key only ever as `hasMollieKey` and its mask;
+ * `settings.setMollieApiKey` / `removeMollieApiKey` write the key (it is never
+ * readable again, and a store that is not live takes only a `test_` key);
+ * `terminals.list` asks Mollie, server-side with the stored key, which card
+ * terminals that key reaches (the id a device is assigned);
+ * `settings.setCashRoundingMode` chooses how the cash that settles a sale is
+ * rounded, between shifts only; and `settings.readiness` says what the tills
+ * still need before they take cash and card payments, judged by the engine from
+ * the store's own records. `quickKeys.get` / `quickKeys.set` read and replace the
+ * store's quick keys, the favourite-product buttons on every till's sell screen.
+ *
+ * ## A store's days
+ *
+ * `days` is a location's business days for a back office: `days.get` one day with its drawers
+ * and totals, `days.list` a window of days, `days.close` once every drawer of the day is closed
+ * (no drawer opens on it after), `days.reopen` with a reason (engine sprint 26e).
+ *
+ * ## Reports
+ *
+ * `reports` is the back office's figures, computed by the engine: `reports.summary` by business
+ * day (reconciled to the Z reports), `tenders`, `locations`, `hours` and `cashiers`, each its own
+ * document over `posReport` (engine sprint 28). `anomalies` is the store's anomaly flags: the
+ * rules (off until the store turns them on), the flags each location's ended business day raised,
+ * their acknowledgement with a note, and a day scanned on demand (engine row 43).
+ *
+ * ## The staff
+ *
+ * `staff` is the store's cashiers and managers as the back office manages them:
+ * name, role, active, and each one's own till language (`locale`). Creating one
+ * sets its first PIN; the PIN is never read back.
+ *
+ * ## Offline cash sales
+ *
+ * `settings.offlineCashSales` / `setOfflineCashSales` are the store's switch for cash sales a
+ * till makes while offline (off by default) and its limits; `offlineSales` is the manager's queue
+ * of the ones the engine could not record as rung (engine sprint 45). The till's replay is its
+ * own door: no method here sends one.
  */
 export interface PosModule {
     registers: PosRegistersModule;
     sessions: PosSessionsModule;
     cash: PosCashModule;
+    /** The store's till sales for a back office (engine sprint 27). */
+    orders: PosOrdersModule;
+    /** A location's business days: read, list, close and reopen (engine sprint 26). */
+    days: PosDaysModule;
+    /** The back office's reports, every figure computed by the engine (engine sprint 28). */
+    reports: PosReportsModule;
+    /** The store's anomaly flags and their rules (engine row 43). Off until the store turns them on. */
+    anomalies: PosAnomaliesModule;
     sale: PosSaleModule;
     tenders: PosTendersModule;
     refunds: PosRefundsModule;
+    /** Till returns and voids: goods back to the till, money to the sale's tenders (engine sprint 20). */
+    returns: PosReturnsModule;
+    /** Till exchanges: a sale's items back, their value to an open cart (engine sprint 21). */
+    exchanges: PosExchangesModule;
+    /** Returns without a receipt: the store's rules and the quote (engine sprint 21). */
+    noReceipt: PosNoReceiptModule;
     devices: PosDevicesModule;
     receiptNumbering: PosReceiptNumberingModule;
+    settings: PosSettingsModule;
+    terminals: PosTerminalsModule;
+    staff: PosStaffModule;
+    quickKeys: PosQuickKeysModule;
+    /** Upsell prompts and assisted search at the till (engine sprint C4/44). */
+    assistedSelling: PosAssistedSellingModule;
+    /** Pay by link at the till: a link and QR code for part or all of a sale (engine C5). */
+    payByLink: PosPayByLinkModule;
+    /** The offline sales a manager must look at, and marking them handled (engine sprint 45). */
+    offlineSales: PosOfflineSalesModule;
+    /**
+     * Gift cards at the till (engine C6): a card's balance by its code, paying by code, and a
+     * sale whose codes the till hands over (their codes in the completion's first answer only).
+     */
+    giftCards: PosGiftCardsModule;
 }
 /**
  * A money call: the key is REQUIRED, not optional. The server claims it before
@@ -92,35 +178,102 @@ export interface PosRegister {
     createdAt: string;
     updatedAt: string;
 }
+/**
+ * The store's registers: the logical tills a drawer session, its Z numbers and a device's cash
+ * belong to, each standing at one stock location for good.
+ */
 export interface PosRegistersModule {
     /**
-     * The store's registers. A machine principal sees only the registers at its
-     * own verified location — the ids it may open a session on.
+     * The store's registers, newest first, whole (one page). A machine principal sees only the
+     * registers at its own verified location — the ids it may open a session on — and a
+     * location-restricted credential only those at its locations.
+     *
+     * @effect read
      */
     list(options?: Call): Promise<Page<PosRegister>>;
-    /** One register, or null (also for another location's register, to a principal). */
+    /**
+     * One register, or null when the store has none by that id (another store's reads the same;
+     * to a principal, also another location's, and to a location-restricted credential one
+     * outside its locations).
+     *
+     * @effect read
+     */
     get(id: string, options?: Call): Promise<PosRegister | null>;
-    /** Needs `ManagePosDevices` (or `UpdateSettings`). */
+    /**
+     * Add an active register at one of the store's stock locations; its location never changes.
+     * Needs `ManagePosDevices` (or `UpdateSettings`). A location outside a restricted credential's
+     * is refused `LOCATION_NOT_ALLOWED` (`PermissionDeniedError`), one the store does not have
+     * `POS_LOCATION_NOT_FOUND` (`NotFoundError`; an engine before W10-62 answers it uncoded), and an
+     * organization workspace `ORGANIZATION_WORKSPACE_NOT_A_STORE`. All before anything is written.
+     *
+     * @effect write
+     */
     create(input: {
         name: string;
         stockLocationId: string;
     }, options?: Call): Promise<PosRegister>;
-    /** Needs `ManagePosDevices` (or `UpdateSettings`). */
+    /**
+     * Rename a register, or retire it with `status: 'inactive'` (and bring it back with
+     * `'active'`). Only an active register opens a drawer (`POS_REGISTER_INACTIVE` to a new one, and
+     * from W10-62 to a device being given it); a drawer already open on it can still be counted and
+     * closed. Its sessions and Z numbers stay. Needs `ManagePosDevices` (or `UpdateSettings`).
+     * Refused `POS_REGISTER_NOT_FOUND` (`NotFoundError`) for a register the store does not have, and
+     * `LOCATION_NOT_ALLOWED` (`PermissionDeniedError`) for one standing outside a restricted
+     * credential's locations (both coded from W10-62; an older engine answers the first uncoded and
+     * does not check the second).
+     *
+     * @effect write
+     */
     update(id: string, input: {
         name?: string;
         status?: string;
     }, options?: Call): Promise<PosRegister>;
 }
+/**
+ * A register session's tender totals, integer minor units of the drawer's
+ * currency (the store's default), from the SETTLED payments and refunds of the
+ * session's orders: a card payment still waiting on the terminal is not counted.
+ * Orders in a currency other than the store's default are left out.
+ */
 export interface PosSessionTotals {
-    /** Cash taken in sales, minor units. */
+    /** Settled payments on the till's cash method. */
     cash: number;
-    /** Card and other tenders are reconciled from payments, not the drawer: always 0 here. */
+    /** Settled payments on the till's card terminal method. */
     card: number;
+    /** Settled payments on any other method (manual tenders). */
     other: number;
+    /**
+     * All settled refunds, on every tender (`cashRefunds + cardRefunds +
+     * otherRefunds` of {@link PosStoredSessionTotals}).
+     */
     refunds: number;
+    /** `cash + card + other - refunds`. */
     net: number;
+    /** Completed sales: the session's orders given a receipt number. */
     saleCount: number;
 }
+/** A session's stored totals (the Z): the X-report figures plus the refunds split by tender. */
+export interface PosStoredSessionTotals extends PosSessionTotals {
+    /** Settled refunds on cash payments. Absent on older engines. */
+    cashRefunds?: number;
+    /** Settled refunds on card terminal payments. Absent on older engines. */
+    cardRefunds?: number;
+    /** Settled refunds on payments of any other method. Absent on older engines. */
+    otherRefunds?: number;
+    /**
+     * Signed cash rounding the drawer kept (+) or gave up (−), from its ledger; not in `net`. On a
+     * store that rounds cash (`cashRoundingMode`), cash into the drawer from sales is
+     * `cash - cashRefunds + cashRounding`. Absent on older engines.
+     */
+    cashRounding?: number;
+    /**
+     * Of which gift cards sold (engine C6): the face value and count of the cards the session's
+     * completed sales issued, a memo already inside the tenders (a liability, not sales). Absent on
+     * a Z closed before C6 and on older engines: read it as 0.
+     */
+    giftCardsSold?: number;
+    giftCardsSoldCount?: number;
+}
 /** A register session: one drawer, from its opening float to its Z. */
 export interface PosRegisterSession {
     id: string;
@@ -136,10 +289,105 @@ export interface PosRegisterSession {
     countedCash: number | null;
     /** `countedCash - expectedCash`; negative is short. Null while open. */
     cashOverShort: number | null;
-    totals: PosSessionTotals | null;
+    totals: PosStoredSessionTotals | null;
     openedAt: string;
     closedAt: string | null;
+    /**
+     * The close's details (engine sprint 25b), read by `sessions.get` and `sessions.list`; absent
+     * from the other session calls, and null while open and for sessions closed before 25b. Who
+     * closed it (null for a machine principal without a staff token).
+     */
+    closedByStaffId?: string | null;
+    /** Whether the store counted blind when it closed. */
+    blindCount?: boolean | null;
+    /** The store's variance threshold when it closed (minor units); null for none. */
+    varianceThreshold?: number | null;
+    /**
+     * What became of the variance: `not_required` (within the threshold), `approved` (a manager, or
+     * a machine credential, approved it at the close) or `pending` (a manager still has to). More may
+     * come: show an unknown value as it is.
+     */
+    varianceApproval?: PosVarianceApproval | (string & {}) | null;
+    /** The manager who approved it; null when none needed to, a machine credential did, or pending. */
+    varianceApprovedByStaffId?: string | null;
+    varianceApprovedAt?: string | null;
+    /**
+     * A `pending` close approved afterwards in the back office (engine sprint 27): the person's
+     * user id. Read by `sessions.approval` and `sessions.approveClose`; absent elsewhere.
+     */
+    varianceApprovedByUserId?: string | null;
+    /** That person's name as the store's administrators hold it now. Same documents as above. */
+    varianceApprovedByUserName?: string | null;
+    /** The machine credential that approved it afterwards (`api_token:<id>` / `app_installation:<id>`). */
+    varianceApprovedByCredential?: string | null;
+    /** Why the variance was accepted afterwards. Same documents as above. */
+    varianceApprovalNote?: string | null;
+    /**
+     * The Z's identity (engine sprint 26), read by `sessions.record` and `sessions.records`; absent
+     * from the other session calls. The store's business day it opened in (`YYYY-MM-DD`, its own
+     * day start in its location's zone; null for a drawer opened before 26 and not closed since).
+     */
+    businessDay?: string | null;
+    /** The stock location it was opened at, and that location's zone then (null before 26). */
+    stockLocationId?: string | null;
+    timeZone?: string | null;
+    /** The register's Z number, 1, 2, 3… in close order; null while open and for drawers closed before 26. */
+    zNumber?: number | null;
+    /**
+     * How it closed: `till` (its tablet, or a machine credential), `back_office` (a person, named
+     * in `closedByUserId`) or `auto` (closed without a count, left open). More may come: show an
+     * unknown value as it is. Null while open and before 26.
+     */
+    closeSource?: PosCloseSource | (string & {}) | null;
+    /** The person who closed it in the back office (their user id); null otherwise. */
+    closedByUserId?: string | null;
+    /** That person's name as the store's administrators hold it now. Read by `sessions.record` only. */
+    closedByUserName?: string | null;
+    /**
+     * A drawer closed WITHOUT a count, and counted later (engine sprint 26b), read by
+     * `sessions.record`, `sessions.records`, `sessions.closeUncounted` and `sessions.count`; absent
+     * elsewhere. Why it closed automatically (`after_closing_time` or `idle`; null for every other
+     * close). More may come: show an unknown value as it is.
+     */
+    autoCloseReason?: PosAutoCloseReason | (string & {}) | null;
+    /** Why a person closed it without a count (`sessions.closeUncounted`'s note); null otherwise. */
+    closeNote?: string | null;
+    /** When its cash was counted after a close without a count (`sessions.count`); null otherwise. */
+    countedAt?: string | null;
+    /** The person who counted it afterwards (their user id); null for a machine credential. */
+    countedByUserId?: string | null;
+    /** That person's name as the store's administrators hold it now. Not read by `records`. */
+    countedByUserName?: string | null;
+    /** The counter's note; null when none was given. */
+    countNote?: string | null;
 }
+/** Why a drawer was closed automatically, without a count (engine sprint 26b). More may come. */
+export type PosAutoCloseReason = 'after_closing_time' | 'idle';
+/** How a drawer closed (engine sprint 26). More may come. */
+export type PosCloseSource = 'till' | 'back_office' | 'auto';
+/**
+ * What became of a closed drawer's variance, with who approved it after the close (engine sprint
+ * 27, `sessions.approval`). Approved at the close: `varianceApprovedByStaffId` (a manager) or
+ * nobody named (a machine credential); approved afterwards: `varianceApprovedByUserId` (a person)
+ * or `varianceApprovedByCredential`, with the note.
+ */
+export interface PosSessionApproval {
+    sessionId: string;
+    varianceApproval: PosVarianceApproval | (string & {}) | null;
+    varianceThreshold: number | null;
+    varianceApprovedByStaffId: string | null;
+    varianceApprovedAt: string | null;
+    varianceApprovedByUserId: string | null;
+    varianceApprovedByUserName: string | null;
+    varianceApprovedByCredential: string | null;
+    varianceApprovalNote: string | null;
+}
+/**
+ * What became of a closed drawer's variance (engine sprint 25b): within the threshold, approved,
+ * or waiting for a manager; or (engine sprint 26b) `uncounted`, closed without a count, so there
+ * is no variance yet: count it with `sessions.count` (never approved as it is).
+ */
+export type PosVarianceApproval = 'not_required' | 'approved' | 'pending' | 'uncounted';
 /** A mid-shift snapshot. Reading it changes nothing. */
 export interface PosXReport {
     sessionId: string;
@@ -164,12 +412,16 @@ export interface PosSessionsModule {
     /**
      * Open a drawer. Refusals: `POS_REGISTER_REQUIRED`, `POS_REGISTER_NOT_FOUND`,
      * `POS_REGISTER_INACTIVE`, `POS_LOCATION_MISMATCH`, `POS_DEVICE_NOT_ALLOWED`,
-     * and an already-open session on that register.
+     * `POS_DEVICE_NOT_FOUND`, `POS_DEVICE_NO_REGISTER`, and `POS_SESSION_ALREADY_OPEN` for a
+     * session already open on that register (`extensions.sessionId` names it; engine 25a, an
+     * uncoded error before).
      */
     open(input: OpenPosSessionInput, options?: PosCall): Promise<PosRegisterSession>;
     /**
      * Close it — this IS the Z report: expected cash from the ledger, your count,
-     * the variance and the totals are stored on the session and returned.
+     * the variance and the totals are stored on the session and returned. A session already
+     * closed is `POS_SESSION_CLOSED`, an id that is no session of the store
+     * `POS_SESSION_NOT_FOUND` (engine 25a; uncoded errors before).
      */
     close(input: {
         sessionId: string;
@@ -178,13 +430,213 @@ export interface PosSessionsModule {
     }, options?: PosCall): Promise<PosRegisterSession>;
     /** The X report: the drawer so far, read-only. */
     xReport(sessionId: string, options?: Call): Promise<PosXReport>;
+    /**
+     * One session with its close's details (engine sprint 25b): who closed it, whether the store
+     * counted blind, its variance threshold then and what became of the variance (`pending`: a
+     * manager still has to approve it). Null for no session of the store. A till read, like
+     * `zReport`: any staff member of the store (or a `pos` token) may call it, and a machine
+     * principal reads a session at its verified location. An engine before 25b refuses the
+     * document at validation; `zReport` reads the session without these fields on every engine.
+     */
+    get(sessionId: string, options?: Call): Promise<PosRegisterSession | null>;
+    /**
+     * The drawer session open on a device now, or null when none is (an id that is no device of the
+     * store reads the same). Any staff member of the store may read it; a paired till reads its own
+     * device only (`POS_DEVICE_MISMATCH`), and a machine credential, which has no device, is refused
+     * `POS_DEVICE_NOT_ALLOWED`: read its session with `get`.
+     *
+     * @effect read
+     */
+    openForDevice(deviceId: string, options?: Call): Promise<PosRegisterSession | null>;
+    /**
+     * The store's register sessions, newest opened first, each with its close's details (as
+     * {@link PosSessionsModule.get}: who closed it, blind or not, the threshold then and what became
+     * of its variance, so a close still `pending` a manager can be found). `limit` is at most 100
+     * (50 when omitted); `after` is the previous page's cursor. Filters narrow it on the server.
+     * Needs `UpdateSettings` or `ManagePosDevices`; a paired till lists only the sessions its own
+     * device opened, a location-restricted credential only the drawers of registers at its
+     * locations, and a machine principal is `FORBIDDEN`. An engine before 25b refuses the document
+     * at validation.
+     *
+     * @effect read
+     */
+    list(options?: PosSessionListOptions): Promise<Page<PosRegisterSession>>;
     /**
      * The stored Z of a CLOSED session (the session as `close` left it). On a
      * session that is still open the Z fields are null — close it first.
      */
     zReport(sessionId: string, options?: Call): Promise<PosRegisterSession | null>;
+    /**
+     * A drawer session's cash ledger, newest first, with the WHOLE session's
+     * summary by kind (engine sprint 25a). Each row is its effect on the drawer
+     * (positive in, negative out) and the expected cash right after it; the
+     * summary's `expectedCash` is the X report's. `take` is at most 100 (50 when
+     * omitted); `skip` pages back in time. Read-only.
+     *
+     * A machine principal reads a session at its verified location; staff need
+     * `UpdateSettings` or `ManagePosDevices` (else `FORBIDDEN`). Another store's
+     * session, or none, is `POS_SESSION_NOT_FOUND`. An engine before 25a refuses
+     * the document at validation.
+     */
+    movements(sessionId: string, options?: Call & {
+        skip?: number;
+        take?: number;
+    }): Promise<PosDrawerMovementList>;
+    /**
+     * A session's variance approval with who approved it after the close (engine sprint 27): see
+     * {@link PosSessionApproval}. Null for no session of the store. Its own document, so `get`,
+     * `list` and `movements` keep working on an engine before 27, which refuses only this one at
+     * validation (`GRAPHQL_VALIDATION_FAILED`).
+     */
+    approval(sessionId: string, options?: Call): Promise<PosSessionApproval | null>;
+    /**
+     * Approve, after the close, a variance still waiting for a manager (`varianceApproval`
+     * `pending`, engine sprint 27): it becomes `approved` with who approved it, when and the note.
+     * The close's figures (expected, counted, variance, totals, the threshold then) never change.
+     * Idempotent by state: approving a session already approved answers it unchanged and writes
+     * nothing, so a lost answer is safe to retry and a second manager sees the first's approval.
+     * Refusals: `POS_SESSION_APPROVAL_NOTE_INVALID` (the note: 1 to 500 characters once trimmed,
+     * line breaks allowed; the refusal names the field `note`, `error.details[0].field`, and its
+     * `extensions.reason` is `required`, `too_long` or `control_character`), `POS_SESSION_CLOSE_NOT_PENDING` (open, within
+     * the threshold, closed before the store had cash controls; `extensions.varianceApproval`),
+     * `POS_SESSION_NOT_FOUND`. Needs `UpdateSettings` or `ManagePosDevices`; a `pos` token holding
+     * only `OperatePos` is `FORBIDDEN`. An engine before 27 refuses the document at validation.
+     */
+    approveClose(sessionId: string, input: {
+        note: string;
+    }, options?: Call): Promise<PosRegisterSession>;
+    /**
+     * One session's Z RECORD (engine sprint 26): everything `get` and `approval` read, plus the
+     * business day it opened in, its location and zone, the register's Z number, how it closed
+     * (`closeSource`) and who closed it in the back office, by name. Null for no session of the
+     * store. Its own document, so `get`, `list` and every other session call keep working on an
+     * engine before 26, which refuses only this one at validation (`GRAPHQL_VALIDATION_FAILED`).
+     */
+    record(sessionId: string, options?: Call): Promise<PosRegisterSession | null>;
+    /**
+     * The store's register sessions with their Z record (engine sprint 26), paged and filtered as
+     * {@link PosSessionsModule.list}, so a sessions list stays one read: the close's details, who
+     * approved it afterwards (by id and credential; the names are per session, read them with
+     * `record`), the business day, Z number and close source. Needs `UpdateSettings` or
+     * `ManagePosDevices`. An engine before 26 refuses the document at validation: fall back to
+     * `list`.
+     */
+    records(options?: PosSessionListOptions): Promise<Page<PosRegisterSession>>;
+    /**
+     * Close an OPEN drawer without a count, from the back office (engine sprint 26b): a till left
+     * open. Its Z is written as at any close (expected cash from the ledger, tender totals, the
+     * register's Z number, the business day, the store's threshold then) with no counted cash and
+     * `varianceApproval` `uncounted`; `closeSource` is `back_office`, `closeNote` the note, and the
+     * till finds the drawer closed at its next drawer call. Answers the session as `record` reads
+     * it. Idempotent by state: closing a drawer this way again answers it unchanged and writes
+     * nothing, so a lost answer is safe to retry. Refusals: `POS_CLOSE_NOTE_INVALID` (the note: 1 to
+     * 500 characters once trimmed; `extensions.reason` `required`, `too_long` or
+     * `control_character`), `POS_SESSION_NOT_FOUND`, `POS_SESSION_CLOSED` (closed another way: at
+     * the till, counted, or automatically), `POS_SESSION_SALE_IN_PROGRESS` (a payment is in flight
+     * on one of its carts; `extensions.orderCodes`, at most 10: finish or cancel it at the till
+     * first), `LOCATION_NOT_ALLOWED` (a credential restricted to other locations). Needs
+     * `UpdateSettings` or `ManagePosDevices`; a `pos` token holding only `OperatePos` is
+     * `FORBIDDEN`. An engine before 26 refuses the document at validation
+     * (`GRAPHQL_VALIDATION_FAILED`).
+     */
+    closeUncounted(sessionId: string, input: {
+        note: string;
+    }, options?: Call): Promise<PosRegisterSession>;
+    /**
+     * Record the count of a drawer closed without one (engine sprint 26b), in minor units of the
+     * drawer's currency. Fills `countedCash`, `closingCounts` and `cashOverShort` against the
+     * expected cash STORED at its close; `varianceApproval` becomes `not_required` within the
+     * threshold stored at its close, or `pending` above it (approve it with `approveClose`): the
+     * count never approves. The ledger, expected cash, totals and Z number never change. Idempotent
+     * by state: the same count again answers the session unchanged and writes nothing; other
+     * figures are refused. Refusals: `POS_SESSION_COUNT_INVALID` (`countedCash` a whole number from
+     * 0 to 100000000; `closingCounts` at most 50 denominations, each a whole count of 0 or more;
+     * `extensions.field` and `reason`), `POS_CLOSE_NOTE_INVALID` (the optional note: at most 500
+     * characters once trimmed), `POS_SESSION_NOT_FOUND`, `POS_SESSION_NOT_UNCOUNTED` (open, counted
+     * already with other figures, or not closed without a count; `extensions.status` and
+     * `varianceApproval`), `LOCATION_NOT_ALLOWED`. Needs `UpdateSettings` or `ManagePosDevices`. An
+     * engine before 26 refuses the document at validation (`GRAPHQL_VALIDATION_FAILED`).
+     */
+    count(sessionId: string, input: {
+        countedCash: number;
+        closingCounts?: Record<string, number>;
+        note?: string;
+    }, options?: Call): Promise<PosRegisterSession>;
+}
+/** `sessions.list`'s page and filters; every filter is optional and narrows on the server. */
+export interface PosSessionListOptions extends ListOptions {
+    status?: 'open' | 'closed';
+    registerId?: string;
+    deviceId?: string;
+    /** The staff member who OPENED it. */
+    staffId?: string;
+    /** ISO instants bounding `openedAt`, both inclusive. */
+    openedAfter?: string;
+    openedBefore?: string;
 }
-export type PosCashMovementType = 'sale' | 'refund' | 'paid_in' | 'paid_out' | 'no_sale' | 'float_adjust';
+/**
+ * One row of a drawer session's ledger as the drawer felt it. `type` is a
+ * string: besides the {@link PosCashMovementType}s it may be `cash_rounding`
+ * (the engine's rounding row), and a newer engine may add one; show an unknown
+ * type by its amount.
+ */
+export interface PosDrawerMovement {
+    id: string;
+    type: string;
+    /** Its effect on the drawer, minor units: positive in, negative out, 0 for a no-sale. */
+    amount: number;
+    /** The expected cash right after this row: the opening float plus every row up to it. */
+    balanceAfter: number;
+    reason: string | null;
+    /** Who recorded it; null for a machine credential's row. */
+    staffId: string | null;
+    staffName: string | null;
+    /** The manager who approved it (a paid-out, no-sale, float adjustment or safe drop). */
+    approvedByStaffId: string | null;
+    approvedByStaffName: string | null;
+    /** The sale or refunded sale it belongs to. */
+    orderId: string | null;
+    orderCode: string | null;
+    receiptNumber: string | null;
+    createdAt: string;
+}
+/** A drawer session's ledger by kind: what makes up its expected cash (minor units). */
+export interface PosDrawerSummary {
+    openingFloat: number;
+    /** Cash taken for sales in this drawer. */
+    cashSales: number;
+    /** Cash paid out of this drawer for refunds, whichever session sold them (negative). */
+    cashRefunds: number;
+    /** Signed cash rounding the drawer kept (+) or gave up (−). */
+    cashRounding: number;
+    paidIn: number;
+    /** Negative. */
+    paidOut: number;
+    /** Cash moved to the safe (negative). */
+    safeDrops: number;
+    /** Signed. */
+    floatAdjustments: number;
+    noSaleCount: number;
+    /** The opening float plus every row: the X report's expected cash. */
+    expectedCash: number;
+    movementCount: number;
+}
+/** A page of a drawer session's ledger, newest first, and the whole session's summary. */
+export interface PosDrawerMovementList {
+    items: PosDrawerMovement[];
+    totalItems: number;
+    summary: PosDrawerSummary;
+}
+export type PosCashMovementType = 'sale' | 'refund' | 'paid_in' | 'paid_out' | 'no_sale' | 'float_adjust'
+/** Cash taken from the drawer to the safe mid-shift (engine sprint 25a). */
+ | 'safe_drop';
+/**
+ * The movement types `cash.record` takes: the five a person records (a safe
+ * drop since engine sprint 25a). A `sale` or `refund` movement is the engine's
+ * own, written when a sale or a refund settles in cash, so it is a
+ * {@link PosCashMovementType} you read back, never one you send.
+ */
+export type PosRecordableCashMovementType = 'paid_in' | 'paid_out' | 'no_sale' | 'float_adjust' | 'safe_drop';
 export interface PosCashMovement {
     id: string;
     sessionId: string;
@@ -198,21 +650,401 @@ export interface PosCashMovement {
 export interface PosCashModule {
     /**
      * Record a drawer movement that is not a sale — paid in, paid out, a no-sale
-     * open. Sales and refunds record their own.
+     * open. Sales and refunds record their own, so `type` takes only the four
+     * movement types a person records ({@link PosRecordableCashMovementType}); a
+     * caller that sends `sale` or `refund` anyway (from JavaScript, past the
+     * type) is refused `POS_CASH_MOVEMENT_TYPE_NOT_ALLOWED` (a permission
+     * refusal, whoever calls) and nothing is recorded. A `paid_out`, `no_sale`
+     * or `float_adjust` needs a manager: on a paired till a manager's PIN
+     * session, else `POS_MANAGER_REQUIRED`; for this principal the credential is
+     * that authority.
+     *
+     * For `paid_in` and `paid_out`, `amount` is the MAGNITUDE in minor units, 0
+     * or more: a paid-out of 10.00 is `1000`. The engine applies the sign: it
+     * records a paid-in as cash in and a paid-out as cash out (the movement it
+     * answers carries `-1000`). A `no_sale` carries no amount: send `0`. A
+     * negative amount, or a no-sale with any amount but `0`, is refused
+     * `POS_CASH_MOVEMENT_AMOUNT_INVALID` and nothing is recorded. `amount` is a
+     * GraphQL `Int`, so a fractional one never reaches the engine: the API
+     * refuses it as invalid input before anything runs. A `float_adjust` amount
+     * stays signed.
      *
      * The drawer holds the store's default currency. A movement naming the
      * `orderId` of an order in another currency is refused
      * `CASH_TENDER_CURRENCY_NOT_SUPPORTED` and nothing is recorded. An `orderId`
      * that is not an order of this store (another store's, or none at all) is
      * refused `ENTITY_NOT_FOUND`, and nothing is recorded.
+     *
+     * Engine sprint 25a: a `safe_drop` (cash to the safe) is a magnitude like a
+     * paid-out and needs a manager. A `float_adjust` needs an amount other than
+     * `0` (`POS_CASH_MOVEMENT_AMOUNT_INVALID`) and a reason
+     * (`POS_CASH_MOVEMENT_REASON_REQUIRED`). A movement on a closed session is
+     * `POS_SESSION_CLOSED`. With `options.idempotencyKey` (1 to 200
+     * characters, minted per movement) the movement is recorded at most once: a
+     * retry under the same key answers the movement already recorded, the same
+     * key for a different movement is `IDEMPOTENCY_CONFLICT`. The key is sent
+     * only when given, so a call without one works on an engine before 25a,
+     * which refuses the field.
      */
     record(input: {
         sessionId: string;
-        type: PosCashMovementType;
+        type: PosRecordableCashMovementType;
         amount: number;
         reason?: string;
         orderId?: string;
     }, options?: PosCall): Promise<PosCashMovement>;
+    /**
+     * The store's drawer movements across every session and register, newest first, for a back
+     * office (engine sprint 27): each row's drawer effect (positive in, negative out, 0 for a
+     * no-sale), its session, register and till, who recorded and approved it, its order and the
+     * till's key it was recorded under (`idempotencyKey`, null for a row sent without one and for
+     * rows before 27), so a "may have gone through" on a till can be matched to one row. No
+     * running balance: `sessions.movements` has a session's. `fromDay`/`toDay` are the STORE's
+     * calendar days (`YYYY-MM-DD`, inclusive, both today when omitted, at most 31 days apart);
+     * `types` keeps only those ledger types (an unknown one is refused); `staffId` matches who
+     * recorded OR approved. `limit` is at most 100 (50 when omitted); `after` is the previous page's
+     * cursor. Refused `POS_LIST_RANGE_INVALID` (`extensions.reason`). Needs `UpdateSettings` or
+     * `ManagePosDevices`; a location-restricted credential reads the drawers at its locations
+     * only. An engine before 27 refuses the document at validation.
+     *
+     * @effect read
+     */
+    list(options?: PosCashMovementListOptions): Promise<Page<PosStoreCashMovement>>;
+}
+/** `cash.list`'s page and filters (engine sprint 27). */
+export interface PosCashMovementListOptions extends ListOptions {
+    /** `YYYY-MM-DD` in the store's zone, inclusive. */
+    fromDay?: string;
+    toDay?: string;
+    registerId?: string;
+    sessionId?: string;
+    /** Only these ledger types (`sale`, `refund`, `cash_rounding`, `paid_in`, …); every type when omitted or empty. */
+    types?: readonly string[];
+    /** Recorded or approved by this staff member. */
+    staffId?: string;
+}
+/** One drawer ledger row as the store-wide list answers it (engine sprint 27). */
+export interface PosStoreCashMovement {
+    id: string;
+    sessionId: string;
+    registerId: string;
+    registerName: string | null;
+    /** The till whose drawer it is; null for a machine credential's session. */
+    deviceId: string | null;
+    deviceLabel: string | null;
+    /** A ledger type; a newer engine may add one: show an unknown type by its amount. */
+    type: PosCashMovementType | 'cash_rounding' | (string & {});
+    /** Its effect on the drawer, minor units: positive in, negative out, 0 for a no-sale. */
+    amount: number;
+    reason: string | null;
+    staffId: string | null;
+    staffName: string | null;
+    approvedByStaffId: string | null;
+    approvedByStaffName: string | null;
+    orderId: string | null;
+    orderCode: string | null;
+    receiptNumber: string | null;
+    /** The till's key it was recorded under; null without one and for rows before engine 27. */
+    idempotencyKey: string | null;
+    createdAt: string;
+}
+/** The tender a till sale's settled payments were taken in. */
+export type PosTenderKind = 'cash' | 'card' | 'other';
+/** A completed till sale as the back office's list answers it (engine sprint 27). Money in minor units of `currencyCode`. */
+export interface PosOrderSummary {
+    orderId: string;
+    orderCode: string;
+    receiptNumber: string;
+    placedAt: string | null;
+    state: string;
+    currencyCode: string;
+    totalWithTax: number;
+    totalQuantity: number;
+    /** Refunds that returned money or are on their way (Settled or Pending), over every payment. */
+    refundedTotal: number;
+    /** The tenders its settled payments were taken in, each once: cash, then card, then other. */
+    tenderKinds: PosTenderKind[];
+    /** `walk_in`, `customer` or `none`; more may come. */
+    customerKind: string;
+    /** The named customer's name; null for the walk-in and when none is attached. Customer data. */
+    customerName: string | null;
+    registerId: string | null;
+    registerName: string | null;
+    /** The drawer session it was rung up under; null when none. */
+    sessionId: string | null;
+    /** The paired till that sold it; null for a machine credential's sale. */
+    deviceId: string | null;
+    deviceLabel: string | null;
+    /** The cashier who completed it; null for a machine credential's sale. */
+    staffId: string | null;
+    staffName: string | null;
+}
+/** `orders.list`'s page and filters (engine sprint 27). */
+export interface PosOrderListOptions extends ListOptions {
+    /** `YYYY-MM-DD` in the store's zone, inclusive. */
+    fromDay?: string;
+    toDay?: string;
+    registerId?: string;
+    sessionId?: string;
+    deviceId?: string;
+    /** The cashier who completed the sale. */
+    staffId?: string;
+    /** Sales with a settled payment in this tender; a split sale is listed under each. */
+    tender?: PosTenderKind;
+    /** 2 to 100 characters: an order code prefix, a receipt number suffix, or a named customer's name or email. */
+    term?: string;
+}
+/** One payment of a till sale, with its refund position (engine sprint 19). */
+export interface PosTillSalePayment {
+    paymentId: string;
+    kind: PosTenderKind;
+    method: string;
+    state: string;
+    amount: number;
+    /** Refunds that returned money or are on their way (Settled or Pending). */
+    refunded: number;
+    /** Refunds with no confirmed outcome, held back until reconciled. */
+    refundUnknown: number;
+    /**
+     * What the till may still refund; 0 unless the payment is Settled, and 0 on an invoiced sale,
+     * which the till's guard refuses (`REFUND_REQUIRES_CREDIT_NOTE`): refund that through the
+     * invoice's correction.
+     */
+    refundable: number;
+}
+/**
+ * An in-person ID check a till recorded on a sale in a store with a minimum age (engine
+ * user decision L1): the cashier confirmed they saw the buyer's ID. Who and where are the till's
+ * own session and its cashier's PIN sign-in, never something a request named.
+ */
+export interface PosTillSaleIdCheck {
+    id: string;
+    /** When the cashier confirmed it (ISO 8601, the server's clock). */
+    checkedAt: string;
+    staffId: string;
+    /** The cashier's name now; null when the store no longer has the staff row. */
+    staffName: string | null;
+    /** The paired till it was confirmed on, and that till's stock location. */
+    deviceId: string;
+    deviceLabel: string | null;
+    stockLocationId: string;
+    /** The store's minimum age when it was confirmed. */
+    minimumAge: number;
+}
+/** A till sale as the order page's "Till sale" card reads it (`orders.get`, engine sprint 19's read). */
+export interface PosTillSale {
+    orderId: string;
+    orderCode: string;
+    orderState: string;
+    receiptNumber: string | null;
+    placedAt: string | null;
+    customerKind: string;
+    deviceId: string | null;
+    deviceLabel: string | null;
+    registerId: string | null;
+    registerName: string | null;
+    sessionId: string | null;
+    staffId: string | null;
+    staffName: string | null;
+    /** Every payment, oldest first, failed and cancelled ones included. */
+    payments: PosTillSalePayment[];
+    /**
+     * The in-person ID check standing for the sale (engine user decision L1): "ID checked by
+     * `staffName` at `checkedAt`". Null when none was recorded, or the one recorded was voided when
+     * the sale was held and resumed.
+     */
+    idCheck: PosTillSaleIdCheck | null;
+}
+export interface PosOrdersModule {
+    /**
+     * The store's completed till sales for a back office, newest first, every register and every
+     * kind of till (engine sprint 27, `posOrders`). `fromDay`/`toDay` are the STORE's calendar
+     * days (`YYYY-MM-DD`, inclusive, both today when omitted, at most 31 days apart); `registerId`,
+     * `sessionId`, `deviceId`, `staffId`, `tender` and `term` narrow it on the server, each sent
+     * only when given. `limit` is at most 100 (50 when omitted); `after` is the previous page's
+     * cursor. Refused `POS_LIST_RANGE_INVALID` (`extensions.reason`: `day_format`, `day_order`,
+     * `span_too_long`, `term_too_long`). Needs `UpdateSettings` or `ManagePosDevices` AND
+     * `ReadOrder` (else `FORBIDDEN`): the rows name customers. A location-restricted credential
+     * lists the sales of its locations only. An engine before 27 refuses the document at
+     * validation.
+     *
+     * @effect read
+     */
+    list(options?: PosOrderListOptions): Promise<Page<PosOrderSummary>>;
+    /**
+     * One till sale with its receipt number, till, register, drawer session, cashier and per
+     * payment what was refunded and may still be (engine sprint 19's `posTillOrder`). An order no
+     * till sold is refused `POS_ORDER_UNSTAMPED`: call it only when `sale.tillDetails` says
+     * `isPosOrder`. Another store's order, or none, is `ENTITY_NOT_FOUND`. Needs `ReadOrder`.
+     * A sale a machine credential rang up (no paired till on it) answers only that credential at
+     * its own location: any other caller, a back office included, is refused
+     * `POS_PRINCIPAL_REQUIRED`. `idCheck` is the cashier's in-person ID check of the sale
+     * (engine user decision L1); an engine before it is read with the sale's other fields only, and
+     * answers `idCheck: null`.
+     *
+     * @effect read
+     */
+    get(orderId: string, options?: Call): Promise<PosTillSale>;
+}
+/** A store day's state (engine sprint 26). More may come: a reader shows an unknown one as it is. */
+export type PosStoreDayStatus = 'open' | 'closed' | 'reopened';
+/**
+ * A store day's money, rolled up from its drawers' Zs (engine sprint 26): integer minor units of
+ * the store's default currency. Over the day's CLOSED drawers: their floats, expected cash and
+ * tender totals; the counted cash and the variance over the COUNTED ones only.
+ */
+export interface PosStoreDayTotals {
+    currencyCode: string;
+    /** The Zs rolled up: the day's closed drawers. */
+    sessionCount: number;
+    /** Drawers closed without a count and not counted since. */
+    uncountedCount: number;
+    openingFloat: number;
+    expectedCash: number;
+    /** Over the counted drawers only. */
+    countedCash: number;
+    /** Over the counted drawers only: negative short, positive over. */
+    cashOverShort: number;
+    cash: number;
+    card: number;
+    other: number;
+    refunds: number;
+    net: number;
+    saleCount: number;
+    cashRefunds: number;
+    cardRefunds: number;
+    otherRefunds: number;
+    cashRounding: number;
+}
+/** One drawer of a store day, as its Z says (engine sprint 26). */
+export interface PosStoreDaySession {
+    sessionId: string;
+    registerId: string;
+    /** The register's name now; null when it is gone. */
+    registerName: string | null;
+    /** The register's Z number; null while open and for drawers closed before sprint 26. */
+    zNumber: number | null;
+    status: 'open' | 'closed';
+    /** How it closed; null while open. */
+    closeSource: PosCloseSource | null;
+    openedAt: string;
+    closedAt: string | null;
+    openingFloat: number;
+    expectedCash: number | null;
+    /** Null while open and for a drawer closed without a count. */
+    countedCash: number | null;
+    cashOverShort: number | null;
+    varianceApproval: PosVarianceApproval | null;
+    /** The stored Z's tender totals; null while open. */
+    totals: PosStoredSessionTotals | null;
+}
+/**
+ * A store's business day at one stock location, as `days.list` reads it (engine sprint 26):
+ * everything but its drawers and the closer's and reopener's names, which `days.get` reads.
+ */
+export interface PosStoreDaySummary {
+    /** Null for a day no drawer opened on and nobody closed (it has no record yet). */
+    id: string | null;
+    stockLocationId: string;
+    /** `YYYY-MM-DD`: the store's business day (it starts at the store's day start, not midnight). */
+    businessDay: string;
+    /** The IANA zone the day is counted in. */
+    timeZone: string;
+    /** The day's window: from its start to the next day's start (23, 24 or 25 hours). */
+    startsAt: string;
+    endsAt: string;
+    status: PosStoreDayStatus;
+    /** True: `totals` is the roll-up stored at the close (refreshed by a later count); false: computed now. */
+    totalsFinal: boolean;
+    totals: PosStoreDayTotals;
+    /** Drawers of the day still open: the day does not close while there is one. */
+    openSessionCount: number;
+    /** Drawers whose variance waits for a manager (`sessions.approveClose`), read now. */
+    pendingCount: number;
+    /** Drawers closed without a count and not counted since (`sessions.count`), read now. */
+    uncountedCount: number;
+    closedAt: string | null;
+    /** The person who closed it last (a User id); null for a machine credential and before. */
+    closedByUserId: string | null;
+    /** The machine credential that closed it last (`api_token:<id>` / `app_installation:<id>`). */
+    closedByCredential: string | null;
+    closeNote: string | null;
+    /** How many times it was closed: 0 before its first close, 2 after a reopen and a close again. */
+    closeCount: number;
+    reopenedAt: string | null;
+    reopenedByUserId: string | null;
+    reopenNote: string | null;
+}
+/** A store's business day with its drawers and names, as `days.get`, `close` and `reopen` read it. */
+export interface PosStoreDay extends PosStoreDaySummary {
+    /** The day's drawers, by register name, then Z number. */
+    sessions: PosStoreDaySession[];
+    /** The closer's name as the store's administrators hold it now; null when unknown or not a person. */
+    closedByUserName: string | null;
+    reopenedByUserName: string | null;
+}
+/**
+ * A location's business days, closed and reopened in the back office (engine sprint 26e). A day
+ * is the store's business day at ONE stock location (each location's own zone, the store's day
+ * start); its drawers are the ones that opened in it. Every call needs `UpdateSettings` or
+ * `ManagePosDevices` (a `pos` token holding only `OperatePos` is `FORBIDDEN`); a credential
+ * restricted to other locations is refused `LOCATION_NOT_ALLOWED`. Each is its own document: an
+ * engine before 26 refuses only these, at validation (`GRAPHQL_VALIDATION_FAILED`).
+ */
+export interface PosDaysModule {
+    /**
+     * One business day at a location, with its drawers (by register name, then Z number), its
+     * totals (the roll-up stored at its close when `totalsFinal`, else computed now from the
+     * drawers' Zs), its open, pending and uncounted drawers counted now, and who closed or reopened
+     * it, by name. Any valid day answers, one with no record as `open` with `id` null. Refused
+     * `POS_STORE_DAY_INVALID` (`extensions.reason`: `day_format`, or `location_unknown` for a
+     * location where no register, day or drawer of the store stands).
+     */
+    get(input: {
+        stockLocationId: string;
+        businessDay: string;
+    }, options?: Call): Promise<PosStoreDay>;
+    /**
+     * A location's business days from `fromDay` to `toDay` (`YYYY-MM-DD`, inclusive; both the
+     * business day today when omitted; at most 31 days apart), newest first: the days with a drawer
+     * or a record only, each with its totals and counts, never its drawers or names (read them with
+     * `get`). Returned whole. Refused `POS_LIST_RANGE_INVALID` (`extensions.reason`: `day_format`,
+     * `day_order`, `span_too_long`) and `POS_STORE_DAY_INVALID` (`location_unknown`).
+     */
+    list(input: {
+        stockLocationId: string;
+        fromDay?: string;
+        toDay?: string;
+    }, options?: Call): Promise<Page<PosStoreDaySummary>>;
+    /**
+     * Close a business day at a location: every drawer of the day must be closed; drawers closed
+     * without a count or waiting for a manager are not blocking (the day lists them). Stores the
+     * day's totals and who closed it, with the optional note; from then on no drawer opens on that
+     * day (a till is refused `POS_STORE_DAY_CLOSED`). Idempotent by state: closing a closed day
+     * answers it unchanged and writes nothing, so a lost answer is safe to retry. Refusals:
+     * `POS_STORE_DAY_SESSIONS_OPEN` (`extensions.sessionIds`, `registerIds`: close them at the
+     * till or with `sessions.closeUncounted` first), `POS_STORE_DAY_INVALID` (`extensions.reason`:
+     * `day_format`, `future`, `location_unknown`), `POS_CLOSE_NOTE_INVALID` (at most 500
+     * characters once trimmed). A later `sessions.count` of one of its drawers refreshes the stored
+     * totals.
+     */
+    close(input: {
+        stockLocationId: string;
+        businessDay: string;
+        note?: string;
+    }, options?: Call): Promise<PosStoreDay>;
+    /**
+     * Reopen a CLOSED business day, with a reason (1 to 500 characters once trimmed), so drawers
+     * open on it again; its stored totals stay until it is closed again (`closeCount` + 1).
+     * Refusals: `POS_STORE_DAY_NOT_CLOSED` (`extensions.status`: `open`, or `reopened` already),
+     * `POS_CLOSE_NOTE_INVALID`, `POS_STORE_DAY_INVALID` (`day_format`). Needs the store's `pos`
+     * grant (a lapsed store closes its days but never reopens one).
+     */
+    reopen(input: {
+        stockLocationId: string;
+        businessDay: string;
+        note: string;
+    }, options?: Call): Promise<PosStoreDay>;
 }
 /** A till cart — a draft order — as far as this module projects it. */
 export interface PosCart {
@@ -234,7 +1066,23 @@ export interface PosCart {
         quantity: number;
         productVariantId: string;
         linePriceWithTax: number;
+        /**
+         * A custom item's name (sprint 16b), null on a catalogue line. Present on carts answered by
+         * {@link PosSaleModule.addCustomItem}; absent on the others, which do not select it.
+         */
+        customItemName?: string | null;
+        /**
+         * The line's note (sprint 16c), null when it has none. Present on carts answered by
+         * {@link PosSaleModule.setOrderNote} and {@link PosSaleModule.setLineNote}; absent on the
+         * others, which do not select it.
+         */
+        note?: string | null;
     }>;
+    /**
+     * The sale's note (sprint 16c), null when it has none. Present on carts answered by the note
+     * methods only, as the lines' `note`.
+     */
+    note?: string | null;
     surcharges: Array<{
         description: string;
         sku: string;
@@ -243,6 +1091,32 @@ export interface PosCart {
         taxRate: number;
     }>;
 }
+/**
+ * What a till wrote on a sale, for a back office reading the order (sprint 16d): the sale's note
+ * and, per line, its custom item name and its note. Every order answers it; one the till did not
+ * sell has `isPosOrder: false` and nothing else set.
+ */
+export interface PosTillSaleDetails {
+    orderId: string;
+    /** The order was sold at a till. */
+    isPosOrder: boolean;
+    /** The sale's note, null when it has none. May name a customer: customer data. */
+    note: string | null;
+    /** Every line of the order, in the order's own order. */
+    lines: Array<{
+        id: string;
+        /** A custom item's name, null on a catalogue line: the till's name for what it sold. */
+        customItemName: string | null;
+        /** The line's note, null when it has none. Customer data, as the sale's note. */
+        note: string | null;
+    }>;
+    /**
+     * Present (`true`) when the caller's customer-data level blanked a field of this answer: an
+     * app installation below `customerData: full` reads the notes as null, which is then not "no
+     * note".
+     */
+    redacted?: true;
+}
 export interface CompletedPosSale {
     orderId: string;
     orderCode: string;
@@ -315,6 +1189,89 @@ export interface PosSaleModule {
         orderId: string;
         couponCode: string;
     }, options?: Call): Promise<PosCart>;
+    /**
+     * Add a custom item (sprint 16b): a line you name and price, sold on one of the store's custom
+     * item tax categories (`settings.customItemPolicy().taxCategories`). The unit price is in minor
+     * units of the cart's currency on the ORDER's price basis: its first line's, else the store's
+     * (`amountsIncludeTax`: gross on an inclusive store). The two differ only on an inclusive store's
+     * cart taxed in another zone (an attached customer from a tax-exclusive country), whose lines are
+     * net. The engine states it on the line and core taxes it from the category in the order's zone,
+     * so you never compute tax. Only in the store's default currency, at least 1, at
+     * most the store's `maxUnitPrice`; quantity 1 to 999 (1 when omitted); a name of 1 to 80
+     * characters on one line, printed on the receipt and invoice.
+     *
+     * Above the store's `cashierLimit` a manager approves it. A machine principal's credential IS
+     * the manager (a person minted it), so a `pos` token is never asked. A paired till's cashier
+     * passes a manager's single-use `approvalToken` (a `posStaffLogin` with purpose `APPROVAL`),
+     * which the engine spends only when the item is added. The price of a custom line is fixed:
+     * correct it by removing the line and adding the item again.
+     *
+     * Refusals: `POS_CUSTOM_ITEM_INVALID` (`field`), `POS_CUSTOM_ITEMS_DISABLED` (`reason`: `store`,
+     * or `host` for an engine that cannot), `POS_CUSTOM_ITEM_CURRENCY_UNSUPPORTED`,
+     * `POS_CUSTOM_ITEM_TAX_CATEGORY_UNAVAILABLE` (`reason`: `not_listed` or `no_rate`),
+     * `POS_CUSTOM_ITEM_PRICE_ABOVE_MAX` (`maxUnitPrice`), `POS_MANAGER_REQUIRED`
+     * (`customItemLimit`, `unitPrice`), and the cart doors' own (`POS_ORDER_NOT_EDITABLE`, …). Takes
+     * `options.idempotencyKey` (required: a fresh UUIDv7 per item): a retry answers the cart as it is
+     * now, never a second line.
+     */
+    addCustomItem(input: {
+        orderId: string;
+        name: string;
+        unitPrice: number;
+        taxCategoryId: string;
+        quantity?: number;
+    }, options: PosMoneyCall & {
+        staffToken?: string;
+        approvalToken?: string;
+    }): Promise<PosCart>;
+    /**
+     * Set or remove the sale's note (sprint 16c): one line printed on the receipt, at most 280
+     * characters; `null` or a blank string removes it. Any staff member (a paired till's cashier
+     * passes `staffToken`; a `pos` token needs none), on an open till cart opened at your location,
+     * a cart readied for payment included: a note changes no money. A cashier may type a customer's
+     * name into it, so treat it as customer data: the engine never writes the text to its audit
+     * trail. Refused `POS_NOTE_INVALID` (`field`, `maxLength`: too long, or a line break or other
+     * control character), `POS_CART_HELD`, and the cart doors' own (`POS_ORDER_NOT_EDITABLE`, …).
+     * Takes `options.idempotencyKey` (required): a retry answers the cart as it is now. The cart it
+     * answers carries `note` and each line's `note` and `customItemName`.
+     */
+    setOrderNote(input: {
+        orderId: string;
+        note: string | null;
+    }, options: PosMoneyCall & {
+        staffToken?: string;
+    }): Promise<PosCart>;
+    /**
+     * Set or remove one line's note (sprint 16c): printed under the line, at most 140 characters;
+     * the rules of {@link PosSaleModule.setOrderNote}. A line that is not on the cart is
+     * `POS_ORDER_LINE_NOT_FOUND`. A line with a note is never merged with a later add of the same
+     * variant: that add is a line of its own.
+     */
+    setLineNote(input: {
+        orderId: string;
+        lineId: string;
+        note: string | null;
+    }, options: PosMoneyCall & {
+        staffToken?: string;
+    }): Promise<PosCart>;
+    /**
+     * Clear the sale (sprint 16c): the unpaid till draft is DELETED with its lines, discounts,
+     * coupons, notes and the attached customer, so the till is free for the next customer. Never
+     * cancelled (no cancellation email). Any staff member, no manager. Refused
+     * `POS_CART_NOT_CLEARABLE` with `reason` `readied` (it started taking payment), `payment` (it has
+     * a payment record of any state: finish it, or refund it) or `open_key` (a payment on the store
+     * may still be in progress: wait and try again); `POS_CART_HELD` (resume it first); and the cart
+     * doors' own (`POS_ORDER_NOT_EDITABLE` for a placed order, …). Answers the deleted sale's id and
+     * code. Takes `options.idempotencyKey` (required). A retry after the clear succeeded (its answer
+     * lost) finds no order, `ENTITY_NOT_FOUND`: re-read the order (`orders.get(orderId)`), and a
+     * sale that is no longer there was cleared.
+     */
+    clearCart(orderId: string, options: PosMoneyCall & {
+        staffToken?: string;
+    }): Promise<{
+        orderId: string;
+        orderCode: string;
+    }>;
     /**
      * Finalise a fully paid sale: settles the order, debits your location's
      * stock through its fulfillment profile (none at that location is
@@ -323,6 +1280,207 @@ export interface PosSaleModule {
     complete(orderId: string, options: PosMoneyCall & {
         staffToken?: string;
     }): Promise<CompletedPosSale>;
+    /**
+     * What the till wrote on an order (sprint 16d), for a back office showing it: the sale's note,
+     * and each line's custom item name and note. Reads any order of the store, sold at a till or
+     * not (`isPosOrder`); null when the store holds no order with that id. Needs `ReadOrder`, like
+     * `orders.get`. Its own read rather than a block of `orders.get`, because an engine before
+     * sprint 16c has none of these fields: there it is refused `GRAPHQL_VALIDATION_FAILED`, and an
+     * order page that reads it beside `orders.get` keeps working.
+     */
+    tillDetails(orderId: string, options?: Call): Promise<PosTillSaleDetails | null>;
+    /**
+     * A completed till sale's receipt (engine sprint 22): ONE structured document, money in minor
+     * units of `currencyCode`, every row core's own figure, so it adds up in both tax displays
+     * (`subtotal` + `adjustments` [+ `taxes` when `EXCLUSIVE`] = `total`, the billable total). It
+     * carries no words of its own: label the rows and lay them out yourself, by their `kind` (each
+     * row kind, adjustment kind and tender kind is one label in your own vocabulary). `kind` is
+     * `SALE` today; read an unknown one as a sale. Who may read it is the till's
+     * sale read rule: a paired till any till sale of the store, a `pos` API token a sale of its
+     * verified location, staff with `ReadOrder`. Refusals: `POS_RECEIPT_NOT_AVAILABLE` (the sale is
+     * not completed), `POS_ORDER_UNSTAMPED` (no till opened the order), `ENTITY_NOT_FOUND`. Below
+     * the `full` customer-data level the notes are withheld (`redacted: true`). An engine before 22
+     * refuses the document at validation.
+     */
+    receipt(orderId: string, options?: Call): Promise<PosReceipt & {
+        redacted?: true;
+    }>;
+    /**
+     * Email a completed till sale's receipt through the store's own email (engine sprint 22c): the
+     * POS Receipt notification's template, gateway, styles and logo, logged under Settings, Emails,
+     * Deliveries. To `emailAddress` alone (no configured CC/BCC), or, omitted, to the sale's
+     * customer (never the till's walk-in). Once per `options.idempotencyKey` (required; a retry
+     * answers the first answer and sends nothing); a paired till signs with `staffToken`. The engine
+     * keeps no address: the answer says where it came from (`source`: `typed`/`customer`) and how
+     * many receipt emails the sale had in 24 hours. Refusals: `POS_RECEIPT_EMAIL_INVALID`,
+     * `POS_RECEIPT_EMAIL_NO_ADDRESS`, `POS_RECEIPT_EMAIL_LIMIT` (`limit` sale or till,
+     * `retryAfterSeconds`: 5 per sale a day, 30 per till an hour by default),
+     * `POS_RECEIPT_EMAIL_UNAVAILABLE` (`reason` disabled or not_installed),
+     * `POS_RECEIPT_NOT_AVAILABLE`, `IDEMPOTENCY_CONFLICT`. An engine before 22c refuses the document
+     * at validation.
+     */
+    emailReceipt(input: {
+        orderId: string;
+        emailAddress?: string | null;
+    }, options: PosMoneyCall & {
+        staffToken?: string;
+    }): Promise<PosEmailReceiptResult>;
+    /**
+     * A completed till sale's digital receipt and prints, for an order page (engine sprint 23):
+     * whether the platform serves receipt pages (`available`) and the store has them on (`enabled`),
+     * how long a new link lives, the RECEIPT then the GIFT link's state (`url` only while `ACTIVE`)
+     * and how many copies and gift receipts were printed through `printReceipt`. Who may read it:
+     * `receipt`'s rule. Refusals as `receipt`. An engine before 23 refuses the document at
+     * validation.
+     */
+    receiptSharing(orderId: string, options?: Call): Promise<PosReceiptSharing>;
+    /**
+     * The sale's live link of `variant`, created when there is none or it expired (engine sprint
+     * 23); a live one is answered unchanged (state-driven: no key). Anyone holding the URL can open
+     * the page (the receipt without the customer, the cashier or notes; the gift receipt without a
+     * price). Needs `UpdateOrder`. Refused `POS_RECEIPT_LINK_UNAVAILABLE` (`reason`:
+     * `not_configured`, the platform serves no receipt pages; `disabled`, the store has digital
+     * receipts off), `POS_RECEIPT_NOT_AVAILABLE`, `POS_ORDER_UNSTAMPED`.
+     */
+    issueReceiptLink(orderId: string, variant: PosReceiptVariant, options?: Call): Promise<PosReceiptLinkStatus>;
+    /**
+     * Withdraw the sale's live link of `variant` (engine sprint 23): its page stops answering at
+     * once and a printed QR is dead; a new link is a new token. A sale with no live link answers its
+     * status and changes nothing. Needs `UpdateOrder`; allowed without the `pos` entitlement (it only
+     * removes access).
+     */
+    revokeReceiptLink(orderId: string, variant: PosReceiptVariant, options?: Call): Promise<PosReceiptLinkStatus>;
+    /**
+     * Print a receipt or a gift receipt again (engine sprint 23): the engine numbers the print and
+     * answers the document to print. A `RECEIPT` print is always a copy (`receipt.copy`: its number
+     * and when it was printed; lay out "COPY"); a `GIFT` print is the gift original the first time
+     * and a copy from the second on, and its `giftReceipt` has no money at all. Once per
+     * `options.idempotencyKey` (minted here when omitted: send your own to retry the same print and
+     * get the same number back); a paired till signs with `staffToken`, staff in the back office
+     * print as themselves. Refused `POS_RECEIPT_NOT_AVAILABLE`, `POS_ORDER_UNSTAMPED`,
+     * `IDEMPOTENCY_CONFLICT`.
+     */
+    printReceipt(input: {
+        orderId: string;
+        variant: PosReceiptVariant;
+    }, options?: Call & {
+        idempotencyKey?: string;
+        staffToken?: string;
+    }): Promise<PosPrintReceiptResult>;
+    /**
+     * A completed till sale's gift receipt (engine sprint 23): the same sale without a single price,
+     * with its live GIFT link. A read: nothing is printed or counted (print one with `printReceipt`).
+     */
+    giftReceipt(orderId: string, options?: Call): Promise<PosGiftReceipt>;
+}
+/** Which receipt a link or a print is for (engine sprint 23). */
+export type PosReceiptVariant = 'RECEIPT' | 'GIFT';
+/** A live public link to a receipt (engine sprint 23). */
+export interface PosReceiptLink {
+    variant: PosReceiptVariant;
+    url: string;
+    issuedAt: string;
+    expiresAt: string;
+}
+/** This print is a copy (engine sprint 23): lay out "COPY" with its number and instant. */
+export interface PosReceiptCopy {
+    /** 1 for the first copy. */
+    number: number;
+    printedAt: string;
+}
+/** Where a sale's link stands (engine sprint 23). `url` only while `ACTIVE`. */
+export interface PosReceiptLinkStatus {
+    variant: PosReceiptVariant;
+    /** `ACTIVE`, `EXPIRED`, `REVOKED` or `NONE`; read an unknown one as not active. */
+    state: string;
+    url: string | null;
+    issuedAt: string | null;
+    expiresAt: string | null;
+    revokedAt: string | null;
+    /** `staff` or `erasure`; null unless `REVOKED`. */
+    revokeReason: string | null;
+}
+/** A till sale's digital receipt and prints (engine sprint 23). */
+export interface PosReceiptSharing {
+    /** The platform serves receipt pages (a public base URL is configured). */
+    available: boolean;
+    /** The store has digital receipts switched on. */
+    enabled: boolean;
+    /** How long a new link stays valid, in days. */
+    ttlDays: number;
+    /** The RECEIPT link, then the GIFT link. */
+    links: PosReceiptLinkStatus[];
+    /** Copies of the receipt printed through `printReceipt`. */
+    receiptCopies: number;
+    /** Gift receipts printed through `printReceipt` (the first is the gift original). */
+    giftPrints: number;
+}
+/** A gift receipt line (engine sprint 23): what was bought, never its price. */
+export interface PosGiftReceiptLine {
+    orderLineId: string;
+    name: string;
+    sku: string | null;
+    quantity: number;
+}
+/** A gift receipt (engine sprint 23): no money field at all. */
+export interface PosGiftReceipt {
+    orderId: string;
+    orderCode: string;
+    receiptNumber: string;
+    issuedAt: string;
+    language: string;
+    locale: string;
+    timeZone: string;
+    /** The store's name, address, phone and extra lines (no VAT or registration number). */
+    header: PosReceiptIdentity & {
+        extraLines: string[];
+    };
+    registerName: string | null;
+    lines: PosGiftReceiptLine[];
+    footerLines: string[];
+    thankYou: boolean;
+    scanCode: string;
+    link: PosReceiptLink | null;
+    copy: PosReceiptCopy | null;
+}
+/** One print through `printReceipt` (engine sprint 23): exactly one of the two documents. */
+export interface PosPrintReceiptResult {
+    orderId: string;
+    variant: PosReceiptVariant;
+    /** 1, 2, … per order and variant. */
+    printNumber: number;
+    /** True for every RECEIPT print and every GIFT print after the first. */
+    copy: boolean;
+    receipt: (PosReceipt & {
+        link: PosReceiptLink | null;
+        copy: PosReceiptCopy | null;
+    }) | null;
+    giftReceipt: PosGiftReceipt | null;
+}
+/** The store's digital receipts (engine sprint 23). */
+export interface PosDigitalReceiptSettings {
+    /** Digital receipts are on: a link is minted at completion and its QR printed. */
+    publicLink: boolean;
+    /** The platform serves receipt pages; false = `publicLink` cannot be switched on. */
+    publicLinkAvailable: boolean;
+}
+/** The receipt account claim (engine C3/32). */
+export interface PosReceiptAccountClaimSettings {
+    /**
+     * Shoppers may add a receipt to their webshop account from its page: the page links to the
+     * store's storefront at `/account/claim-receipt`. Inert while digital receipts are off.
+     */
+    accountClaim: boolean;
+    /** Digital receipts are on and the store has a storefront address: it can be switched on. */
+    accountClaimAvailable: boolean;
+}
+/** A queued receipt email (engine sprint 22c). Never the address. */
+export interface PosEmailReceiptResult {
+    orderId: string;
+    /** `typed` or `customer`. */
+    source: string;
+    /** Receipt emails accepted for the sale in the last 24 hours, this one included. */
+    sentForSale: number;
 }
 export interface PosTenderResult {
     orderId: string;
@@ -330,7 +1488,13 @@ export interface PosTenderResult {
     /** True once settled payments cover the order total. */
     covered: boolean;
     outstanding: number;
-    /** Cash only: `tendered - amount`, floored at zero. */
+    /**
+     * Cash only. The tender that clears the balance on a store that rounds cash
+     * (`cashRoundingMode`) is due rounded (12.33 → 12.35 on `nearest_05`), and change is
+     * `tendered - rounded due`. Otherwise `tendered - amount`. Floored at zero. The difference
+     * from the exact amount is recorded as the drawer's cash rounding; the payment stays the exact
+     * `amount`.
+     */
     change: number;
 }
 export interface PosTendersModule {
@@ -351,6 +1515,16 @@ export interface PosTendersModule {
      * {@link PosTendersModule.card} or {@link PosTendersModule.manual} instead:
      * neither touches the drawer, so this rule does not apply to them.
      *
+     * On a store that rounds cash (`cashRoundingMode` `nearest_05` / `nearest_10`), only the
+     * tender that clears the balance is rounded: its `amount` is due rounded to the store's
+     * increment, and `change` is measured from that rounded due. Such a tender may hand over the
+     * exact amount or the rounded one (1 and 2 cent coins stay legal tender), and `tendered` is 0
+     * when the rounded due is 0 (a 0.02 balance on `nearest_05`). A partial tender
+     * (one that leaves a balance) is never rounded and must hand over at least its `amount`, or it
+     * is refused (`Only the cash tender that clears the balance is rounded`) and nothing is
+     * taken. The payment is always the exact `amount`; the difference is the drawer's cash
+     * rounding, reported on the session's stored totals.
+     *
      * The first tender of a sale asks the apps the store installed
      * (`order.validate`) before anything is taken: a refusal is `HOOK_REJECTED`
      * (`HookRejectedError`, with the app's `customerMessage`) or
@@ -458,7 +1632,15 @@ export interface PosRefundsModule {
      * Hand money back against one payment of the order, never more than the order
      * took (`REFUND_EXCEEDS_SETTLED`). Refusals that mean NO money moved:
      * `REFUND_METHOD_UNAVAILABLE` (that payment's method is disabled or gone),
-     * `REFUND_REFUSED` (the gateway said no, with its reason) — retry is safe.
+     * `REFUND_REFUSED` (the gateway said no, with its reason) — retry is safe —
+     * and `LIVE_CONNECTION_REFUSED`: a store that is not live holds a till
+     * Mollie key that is not a `test_` key, so no card refund is asked of Mollie
+     * until that key is replaced by a test key (`settings.setMollieApiKey`) or
+     * removed; `settings.readiness()` reads `KEY_LIVE_ON_TEST_STORE` meanwhile.
+     * `REFUND_REQUIRES_CREDIT_NOTE` (409): the sale has a live invoice, so its
+     * refund goes back through the invoice's correction in the back office
+     * (`documents.commitCorrection`, the invoice named by
+     * `payments.refundCreditNoteRequirement`), never at the till.
      *
      * `IDEMPOTENCY_OUTCOME_UNKNOWN` is neither: the card refund reached the
      * payment provider and then failed (no answer, a timeout, a provider error),
@@ -482,6 +1664,12 @@ export interface PosRefundsModule {
      * `CASH_TENDER_CURRENCY_NOT_SUPPORTED` before anything moves. Refund that
      * payment from the order in the back office instead.
      *
+     * On a store that rounds cash (`cashRoundingMode`), a refund of a CASH payment pays out the
+     * `amount` cash-rounded like a sale (12.33 refunded on `nearest_05` pays out 12.35), and the
+     * difference is recorded on the drawer as its cash rounding; the refund itself stays the exact
+     * `amount`. The engine answers the payout as `cashPaidOut`, which this SDK version does not
+     * read, so older engines keep answering: work it out with the same rounding when you need it.
+     *
      * The order must be a till's sale made at your location, and the payment one
      * of ITS payments: an order no till opened is `POS_ORDER_UNSTAMPED`, a payment
      * of another order `USER_INPUT_ERROR`, another store's order `ENTITY_NOT_FOUND`.
@@ -502,26 +1690,288 @@ export interface PosDevice {
     label: string;
     status: 'active' | 'revoked';
     paired: boolean;
-    /** Recorded server-side every time the tablet authenticates. */
+    /** Stamped when the tablet signs in (`authenticate`) and, from engine sprint 35, at each heartbeat. */
     lastSeenAt: string | null;
+    /**
+     * The Mollie card terminal (`term_…`) its card tenders go to (`devices.assignTerminal`); null
+     * while none is assigned. A display holds none.
+     */
+    mollieTerminalId: string | null;
+    createdAt: string;
+    updatedAt: string;
+    /**
+     * The device's health columns (engine sprint 35), read by `devices.fleet`, `devices.lock` and
+     * `devices.unlock`; absent from `list` and `revoke`, which keep answering an older engine. When
+     * the till last sent a heartbeat; null for an app build that sends none.
+     */
+    heartbeatAt?: string | null;
+    /** When a manager locked it (`devices.lock`); null while unlocked. */
+    lockedAt?: string | null;
+    /** Since when the till has been silent with a drawer open; null otherwise. */
+    silentSince?: string | null;
+    /**
+     * What the device is (engine sprint 39): a `till` sells, a `display` shows the shopper the sale
+     * of its register. Chosen at `create`, never changed. Read by `fleet`, `lock`, `unlock` and a
+     * `create` that names a kind; absent elsewhere, where it is a till. More may come: treat an
+     * unknown kind as neither.
+     */
+    kind?: PosDeviceKind | (string & {});
+}
+/** A device's kind (engine sprint 39). */
+export type PosDeviceKind = 'till' | 'display';
+/** The kinds a device is created as (engine sprint 39), in the engine's order. */
+export declare const POS_DEVICE_KINDS: readonly PosDeviceKind[];
+/** A one-time pairing code (`devices.pair`) and when it stops working (ISO-8601). */
+export interface PosPairingCode {
+    code: string;
+    expiresAt: string;
+}
+/** A new device (`devices.create`). */
+export interface PosDeviceCreateInput {
+    label: string;
+    /** The stock location it sells from (a till) or stands at (a display). */
+    stockLocationId: string;
+    /** The register it works at. A display shows the sale of this register's open drawer. */
+    registerId?: string | null;
+    /** `till` when omitted (engine sprint 39); never changes. */
+    kind?: PosDeviceKind;
+}
+/**
+ * A device's health as the engine judges it now (engine sprint 35): `online` (heard within 2
+ * minutes), `quiet` (2 to 15), `silent` (longer, with a drawer open), `idle` (longer, no drawer
+ * open), `unknown` (never sent a heartbeat: an app build before 35), and `locked`, `unpaired` or
+ * `revoked`, which take precedence. More may come: show an unknown status as it is.
+ */
+export type PosDeviceHealthStatus = 'online' | 'quiet' | 'silent' | 'idle' | 'unknown' | 'locked' | 'unpaired' | 'revoked';
+export interface PosDeviceHealth {
+    status: PosDeviceHealthStatus | (string & {});
+    /** The last heartbeat the engine stored; null when it never sent one. */
+    lastHeardAt: string | null;
+    silentSince: string | null;
+}
+/**
+ * What a till said in its last heartbeat (engine sprint 35). Every value is the till's own claim,
+ * null when it did not say. The closed values (`platform`, `connection`, `printer`) may grow: show
+ * an unknown one as it is.
+ */
+export interface PosDeviceHeartbeatReport {
+    appVersion: string | null;
+    buildNumber: string | null;
+    runtimeVersion: string | null;
+    updateId: string | null;
+    updateChannel: string | null;
+    platform: 'ios' | 'android' | 'other' | (string & {}) | null;
+    /** `online` or `degraded`: a till that is offline sends nothing. */
+    connection: 'online' | 'degraded' | (string & {}) | null;
+    outboxPending: number | null;
+    offlineSalesPending: number | null;
+    offlineSalesRefused: number | null;
+    printer: 'none' | 'ready' | 'unreachable' | 'unknown' | (string & {}) | null;
+    reportedAt: string;
+}
+/** The drawer a till has open (engine sprint 35). */
+export interface PosDeviceOpenDrawer {
+    sessionId: string;
+    registerId: string;
+    openedAt: string;
+    /** The cashier who opened it, as the store names them now; null for a machine principal. */
+    openedByStaffName: string | null;
+}
+/**
+ * One device of the store with its health (engine sprint 35, `devices.fleet`). How many of its
+ * offline sales wait for a manager (engine sprint 45) is its own read,
+ * `devices.offlineSalesToReview`, so this row answers an engine before 45.
+ */
+export interface PosDeviceFleetRow {
+    device: PosDevice;
+    health: PosDeviceHealth;
+    /** Null until the till sends its first heartbeat. */
+    report: PosDeviceHeartbeatReport | null;
+    openDrawer: PosDeviceOpenDrawer | null;
+    /** Who locked it, as the store's administrators name them now; null when unknown or not a person. */
+    lockedByUserName: string | null;
 }
-/** Paired tablets. Every method needs `ManagePosDevices` (or `UpdateSettings`). */
+/**
+ * The store's tills and customer displays. Every method needs `ManagePosDevices` or
+ * `UpdateSettings` (either one). A `deviceId` that is not one of this store's devices (missing, or
+ * another store's) is refused `POS_DEVICE_NOT_FOUND` (`NotFoundError`); `get` and `heartbeat`
+ * answer null instead.
+ */
 export interface PosDevicesModule {
+    /**
+     * The store's devices, newest first, whole (one page); a location-restricted credential sees
+     * the devices at its locations only. Their health is `fleet`'s.
+     *
+     * @effect read
+     */
     list(options?: Call): Promise<Page<PosDevice>>;
     /**
-     * A one-time pairing code the tablet redeems; it expires. Needs a human session: an API token
-     * is refused (`PermissionDeniedError` `TOKEN_CREDENTIAL_NOT_ALLOWED`), because the paired
-     * device's session would outlive the token.
+     * One device of the store, or null when the store has none by that id (another store's reads
+     * the same, and so does, to a location-restricted credential, a device at another location).
+     * Its kind and health are `fleet`'s.
+     *
+     * @effect read
+     */
+    get(deviceId: string, options?: Call): Promise<PosDevice | null>;
+    /**
+     * Add a device to the store; pair it afterwards with `pair`. Without `kind` it is a till, and
+     * the call works against any engine. `kind: 'display'` adds a customer display (engine sprint
+     * 39), which shows the shopper the sale of its register's open drawer: give it the register
+     * (or assign one later), since a display without one shows nothing. A display takes no card
+     * terminal (`POS_DEVICE_KIND_NOT_ALLOWED` on assigning one). A kind outside `POS_DEVICE_KINDS`
+     * is refused before anything is sent (`ValidationError`, code `POS_DEVICE_KIND_INVALID`, the
+     * engine's own code for it), and an engine before 39 fails the document's validation. Needs a
+     * human session like `pair`: an API token is refused `TOKEN_CREDENTIAL_NOT_ALLOWED`.
+     *
+     * Adding a device first sets the store's POS up where it is not yet (its payment methods,
+     * in-store shipping method, till role and fulfilment profile; idempotent). A location outside a
+     * restricted credential's is refused `LOCATION_NOT_ALLOWED` (`PermissionDeniedError`) before
+     * anything is written, and so is a caller that does not hold every permission the till will
+     * carry (`POS_DEVICE_CEILING_NOT_ALLOWED`). A `registerId` is judged as
+     * {@link PosDevicesModule.assignRegister} judges it, against the new device's location, before
+     * the device is written.
+     *
+     * @effect write
+     */
+    create(input: PosDeviceCreateInput, options?: Call): Promise<PosDevice>;
+    /**
+     * Move a device to another of the store's stock locations: a till then sells from it and
+     * reserves its stock. Its register moves WITH it (engine `pos-device-writes-validate`): a
+     * device holding a register moves only with `options.registerId`, an active register at the new
+     * location (judged as {@link PosDevicesModule.assignRegister} judges one), unless its register
+     * already stands there; otherwise it is refused `POS_LOCATION_MISMATCH` (`BusinessRuleError`,
+     * `reason` `device_register_elsewhere`) and nothing changes, so its drawer never stays behind at
+     * the old location. A device with no register moves without one.
+     *
+     * Refused before anything changes: `POS_DEVICE_NOT_FOUND` (`NotFoundError`, another store's
+     * reads the same), `LOCATION_NOT_ALLOWED` (`PermissionDeniedError`: the device's own location or
+     * the new one outside a restricted credential's), `POS_DEVICE_REVOKED` (`BusinessRuleError`),
+     * `POS_LOCATION_NOT_FOUND` (`NotFoundError`, a location the store does not have). An older
+     * engine keeps the device's register as it was, answers an unknown location as a server fault,
+     * and refuses a call that names `registerId` at validation (`GRAPHQL_VALIDATION_FAILED`, or a
+     * 400 the transport reports as `BAD_REQUEST`); without it the document is the one every engine
+     * serves.
+     *
+     * @effect write
+     */
+    assignLocation(deviceId: string, stockLocationId: string, options?: {
+        registerId?: string;
+    } & Call): Promise<PosDevice>;
+    /**
+     * The register the device's drawer sessions open on (a display shows that register's sale):
+     * one of `registers.list()` that is active and stands at the device's `stockLocationId`. From
+     * engine W10-62 anything else is refused before the device changes: a register the store does
+     * not have `POS_REGISTER_NOT_FOUND` (`NotFoundError`, another store's reads the same), one at
+     * another location `POS_LOCATION_MISMATCH` (`BusinessRuleError`; move the device there first,
+     * or pick a register at its location), a retired one `POS_REGISTER_INACTIVE`
+     * (`BusinessRuleError`). An older engine stores any id as sent. From engine
+     * `pos-device-writes-validate` the device is judged first, as
+     * {@link PosDevicesModule.assignLocation} judges it (`POS_DEVICE_NOT_FOUND`,
+     * `LOCATION_NOT_ALLOWED` for a device at a location outside a restricted credential's,
+     * `POS_DEVICE_REVOKED`).
+     *
+     * @effect write
+     */
+    assignRegister(deviceId: string, registerId: string, options?: Call): Promise<PosDevice>;
+    /**
+     * The Mollie card terminal (`term_…`, one of `terminals.list()`) the device's card tenders go
+     * to. The engine does not ask Mollie about it, and one terminal may be assigned to several
+     * devices. A display takes none: `POS_DEVICE_KIND_NOT_ALLOWED` (`PermissionDeniedError`).
+     *
+     * From engine `pos-device-writes-validate` the id is stored trimmed, and one that is empty,
+     * longer than 100 characters or not one word is refused `POS_MOLLIE_TERMINAL_ID_INVALID`
+     * (`ValidationError`, `reason` `empty` | `too_long` | `not_one_word`); the device is judged as
+     * {@link PosDevicesModule.assignRegister} judges it. An older engine stores any text as sent.
+     * Take a terminal off a device with {@link PosDevicesModule.clearTerminal}.
+     *
+     * @effect write
+     */
+    assignTerminal(deviceId: string, terminalId: string, options?: Call): Promise<PosDevice>;
+    /**
+     * Take the device's own card terminal off it (engine `pos-device-writes-validate`): its card
+     * tenders then go to the one reader assigned to its stock location (`terminals`, Settings →
+     * Payments), and are refused when the location has none or several. Clearing a device with none
+     * answers it unchanged. Refused `POS_DEVICE_NOT_FOUND` (`NotFoundError`), `LOCATION_NOT_ALLOWED`
+     * (`PermissionDeniedError`, a device at a location outside a restricted credential's) and
+     * `POS_DEVICE_REVOKED` (`BusinessRuleError`). An older engine fails the document's validation
+     * (`GRAPHQL_VALIDATION_FAILED`, or a 400 the transport reports as `BAD_REQUEST`).
+     *
+     * @effect write
+     */
+    clearTerminal(deviceId: string, options?: Call): Promise<PosDevice>;
+    /**
+     * The store's devices with their health, version and open drawer (engine sprint 35), grouped by
+     * health status with the newest heartbeat first, whole (one page). `stockLocationId` keeps one
+     * location's; a location-restricted caller sees its own locations only. The engine judges the
+     * health at the time of the read: ask again for a fresh view. An engine before 35 fails the
+     * document's validation (`GRAPHQL_VALIDATION_FAILED`, or a 400 the transport reports as
+     * `BAD_REQUEST`); `list` keeps working there.
+     *
+     * @effect read
+     */
+    fleet(options?: {
+        stockLocationId?: string;
+    } & Call): Promise<Page<PosDeviceFleetRow>>;
+    /**
+     * How many of each device's offline sales wait for a manager (engine sprint 45, the fleet's
+     * `offlineSalesToReview`: `needs_review` or `refused`, not yet handled), one row per device
+     * `fleet` lists, whole (one page). Its own document, so `fleet` keeps answering an engine
+     * before 45, which fails this one alone at validation (`GRAPHQL_VALIDATION_FAILED`, or a 400
+     * the transport reports as `BAD_REQUEST`). The sales themselves: `offlineSales.list`.
+     *
+     * @effect read
+     */
+    offlineSalesToReview(options?: {
+        stockLocationId?: string;
+    } & Call): Promise<Page<PosDeviceOfflineSalesToReview>>;
+    /**
+     * Lock a device (engine sprint 35): every call of its session is refused `POS_DEVICE_LOCKED`
+     * except its heartbeat, its cashiers' PIN sessions end, and nobody signs in on it until
+     * `unlock`. Its pairing, its open drawer and the sale on its screen stay, and a card already on
+     * the terminal still settles; the sale is completed after the unlock. The lock is never refused
+     * for money in flight. Locking a locked device answers it unchanged. Refused `POS_DEVICE_REVOKED`
+     * (`BusinessRuleError`) and `LOCATION_NOT_ALLOWED`. A store without its `pos` grant can still
+     * lock a lost till.
+     *
+     * @effect write
+     */
+    lock(deviceId: string, options?: Call): Promise<PosDevice>;
+    /**
+     * Unlock a locked device (engine sprint 35); an unlocked one answers unchanged.
+     *
+     * @effect write
+     */
+    unlock(deviceId: string, options?: Call): Promise<PosDevice>;
+    /**
+     * A one-time pairing code the tablet redeems; it expires. A new code replaces any the device
+     * still had. Needs a human session: an API token is refused (`PermissionDeniedError`
+     * `TOKEN_CREDENTIAL_NOT_ALLOWED`), because the paired device's session would outlive the token.
+     * A revoked device is refused `POS_DEVICE_REVOKED` (`BusinessRuleError`): revoke retires a
+     * device for good, so add a new device to use that tablet again. A device its till unpaired is
+     * still `active` and is paired again here. Refused `LOCATION_NOT_ALLOWED` at a location outside
+     * a restricted credential's, and `POS_DEVICE_CEILING_NOT_ALLOWED` to a caller that does not
+     * hold every permission the till will carry.
+     *
+     * @effect write
+     */
+    pair(deviceId: string, options?: Call): Promise<PosPairingCode>;
+    /**
+     * Retire the device for good: its token stops working at once, its tablet's sessions end, and
+     * it can never be paired again (add a new device to use that tablet). There is no undo.
+     * Revoking a revoked device answers it as it is. From engine `pos-device-writes-validate` a
+     * device at a location outside a restricted credential's is refused `LOCATION_NOT_ALLOWED`
+     * (`PermissionDeniedError`).
+     *
+     * @effect destructive
      */
-    pair(deviceId: string, options?: Call): Promise<{
-        code: string;
-        expiresAt: string;
-    }>;
     revoke(deviceId: string, options?: Call): Promise<PosDevice>;
     /**
-     * The device's last sign of life. There is no heartbeat WRITE for an SDK to
-     * send: the server stamps `lastSeenAt` on every authenticated tablet request,
-     * so this reads it.
+     * The device's `lastSeenAt`: when its tablet last signed in (`authenticate`) and, from engine
+     * sprint 35, when it last sent a heartbeat. It is not stamped on every request. A paired till
+     * reports its health every minute through its own session, a door no SDK sends; read that report
+     * with `fleet` (`health`, `report`, `device.heartbeatAt`). Null as `get` answers null.
+     *
+     * @effect read
      */
     heartbeat(deviceId: string, options?: Call): Promise<{
         lastSeenAt: string | null;
@@ -538,6 +1988,574 @@ export interface PosReceiptNumberingModule {
     get(options?: Call): Promise<PosReceiptNumbering>;
     set(input: Partial<PosReceiptNumbering>, options?: Call): Promise<PosReceiptNumbering>;
 }
+/** A store's POS settings as the setup surfaces read them. The Mollie key itself is never returned. */
+export interface PosSettings {
+    /** Whether the store's tills may open sessions and take payments. */
+    enabled: boolean;
+    /** The till's cash payment method; null = the engine's default `pos-cash`. */
+    cashPaymentMethodCode: string | null;
+    /** The till's card (terminal) payment method; null = the engine's default `pos-mollie-terminal`. */
+    cardPaymentMethodCode: string | null;
+    inStoreShippingMethodId: string | null;
+    /** Pre-fills a new device's location; the engine never reads it otherwise. */
+    defaultStockLocationId: string | null;
+    /** `none`, `nearest_05` or `nearest_10`; a till treats any other stored value as `none`. */
+    cashRoundingMode: string;
+    /** A Mollie API key is stored for the till. */
+    hasMollieKey: boolean;
+    /**
+     * The stored key masked (`live_••••k6rW`: its mode and last four), or null: when none is stored,
+     * when the engine can no longer decrypt it, and for a caller without `UpdateSettings` or
+     * `ManagePosDevices` (a `pos` API token included), whatever is stored. Read `hasMollieKey` for
+     * whether a key is stored.
+     */
+    maskedMollieApiKey: string | null;
+}
+/** A Mollie terminal the store's till key reaches, as Mollie reports it now. */
+export interface PosMollieTerminal {
+    /** `term_…`: what a device is assigned. */
+    terminalId: string;
+    /** The name the merchant gave it in Mollie, or its id when it has none. */
+    description: string;
+    /** `pending` (not activated yet), `active` or `inactive`. */
+    status: string;
+    brand: string | null;
+    model: string | null;
+    serialNumber: string | null;
+    currency: string | null;
+}
+/** One thing the store's tills need before they take cash and card payments. */
+export interface PosSetupCheck {
+    /** `pos_enabled`, `cash_method`, `card_method`, `mollie_key`, `card_device`, `in_store_shipping`, `default_location`, `staff`, `fulfillment_profile`; more may come. */
+    check: string;
+    ok: boolean;
+    /** False for a check the tills can trade without. */
+    required: boolean;
+    /** A code saying why it is not ok; null when ok. */
+    reason: string | null;
+}
+/** What the store's tills still need: `ready` when every required check is ok. */
+export interface PosSetupReadiness {
+    ready: boolean;
+    checks: PosSetupCheck[];
+}
+/**
+ * How a store rounds the cash that settles a sale: not at all, or to the nearest 5 or 10 minor units
+ * of its currency (`nearest_05`: 12.33 is paid as 12.35 and 12.32 as 12.30).
+ */
+export type PosCashRoundingMode = 'none' | 'nearest_05' | 'nearest_10';
+/** A tax category a custom item may use, with its rate in the store's own tax zone. */
+export interface PosCustomItemTaxCategory {
+    id: string;
+    name: string;
+    /** Percent in the store's default tax zone; null when that zone has none for it (unusable). */
+    taxRate: number | null;
+}
+/** A store's rules for custom items (sprint 16b). Money in minor units of `currencyCode`. */
+export interface PosCustomItemPolicy {
+    /** The store sells custom items; off until it turns them on. */
+    enabled: boolean;
+    /** False when the engine cannot sell custom items at all. */
+    available: boolean;
+    /** The categories a custom item may use, in the store's order. */
+    taxCategories: PosCustomItemTaxCategory[];
+    /** Every category the store could list, for a settings form. */
+    taxCategoryChoices: PosCustomItemTaxCategory[];
+    /** The highest unit price; 0 until set. */
+    maxUnitPrice: number;
+    /** The highest unit price a cashier sells without a manager; 0: a manager approves each one. */
+    cashierLimit: number;
+    /** The amounts include tax (the store's price basis). */
+    amountsIncludeTax: boolean;
+    /** The store's default currency: custom items are sold only in it. */
+    currencyCode: string;
+}
+/** What `setCustomItemPolicy` changes: an omitted field keeps its value; `taxCategoryIds` replaces the list. */
+export interface PosCustomItemPolicyInput {
+    enabled?: boolean;
+    taxCategoryIds?: string[];
+    maxUnitPrice?: number;
+    cashierLimit?: number;
+}
+/** Needs `UpdateSettings` to write; `get` needs any session of the store. */
+export interface PosSettingsModule {
+    /** The store's POS settings, or null when POS was never set up. */
+    get(options?: Call): Promise<PosSettings | null>;
+    /**
+     * Store the till's Mollie API key (encrypted at rest; never readable again). The key is trimmed;
+     * an empty one is refused here (`TypeError`) — remove it with `removeMollieApiKey`. Sending the
+     * masked value back keeps the stored key. Refusals: `LIVE_CONNECTION_REFUSED` (a store that is not
+     * live takes only a `test_` key), `SECRET_ARG_MASK_INVALID`, `APP_SECRET_ARG_NOT_ALLOWED` (an app
+     * installation), `ORGANIZATION_WORKSPACE_NOT_A_STORE`, `POS_ENCRYPTION_NOT_CONFIGURED` (the engine
+     * cannot store a card key yet: its operator must configure it; a non-retryable 500, nothing
+     * stored, and `settings.readiness()` reports it as the `mollie_key` reason
+     * `ENCRYPTION_NOT_CONFIGURED`). Replacing it does not move payments already
+     * taken: a card payment or refund of a payment made under a key of ANOTHER Mollie account can no
+     * longer be read or refunded through the till.
+     */
+    setMollieApiKey(apiKey: string, options?: Call): Promise<PosSettings>;
+    /** Remove the stored key: card payments and card refunds at the till stop until one is set again. */
+    removeMollieApiKey(options?: Call): Promise<PosSettings>;
+    /**
+     * Set how the cash that settles a sale is rounded (`nearest_05`: 12.33 is paid as 12.35). Only the
+     * cash tender that clears the balance is rounded, and the customer may still pay the exact amount;
+     * card payments and the order total are never rounded, and the difference is recorded on the
+     * drawer as cash rounding. Sends the mode alone. Refusals: `POS_CASH_ROUNDING_MODE_INVALID` (not
+     * one of the three), `POS_CASH_ROUNDING_SESSION_OPEN` (a register session of the store is open:
+     * close it on the till first; the message says how many are open). Setting the stored mode again
+     * is never refused. Needs `UpdateSettings`. An engine older than these checks stores the mode
+     * without them.
+     */
+    setCashRoundingMode(mode: PosCashRoundingMode, options?: Call): Promise<PosSettings>;
+    /**
+     * What the tills still need (no provider is asked). Needs `UpdateSettings` or `ManagePosDevices`.
+     * The tills judged are the POS app's paired devices: `card_device` counts an active, paired
+     * device on a register that reaches a terminal. A till your own backend runs with a `pos` API token (no device)
+     * is not judged, so a store with no paired device reads `NO_ACTIVE_DEVICE` and not `ready`.
+     */
+    readiness(options?: Call): Promise<PosSetupReadiness>;
+    /**
+     * The store's cash controls at the till's close (engine sprint 25b): whether the till counts
+     * blind, and the variance threshold (minor units of the drawer's currency) above which a close
+     * needs a manager's approval, at the close or later. Null when POS was never set up; the engine
+     * then closes with its defaults (blind off, threshold 0: every variance needs a manager). Any
+     * session of the store reads it. An engine before 25b refuses the document at validation.
+     */
+    cashControls(options?: Call): Promise<PosCashControls | null>;
+    /**
+     * Set the store's cash controls; they apply from the next close, open drawers included.
+     * `varianceThreshold`: whole minor units from 0 to 100000000, `null` for never, omitted to keep
+     * the stored one (0 makes every variance need a manager). Refusals: `POS_CASH_CONTROLS_INVALID`
+     * (out of range), `ORGANIZATION_WORKSPACE_NOT_A_STORE`. Needs `UpdateSettings`. An engine
+     * before 25b refuses the document at validation.
+     */
+    setCashControls(input: PosCashControlsInput, options?: Call): Promise<PosCashControls>;
+    /**
+     * The store's business day and the automatic close of forgotten drawers (engine sprint 26): when
+     * its day starts and when it closes (`HH:MM` on each location's wall clock), and after how many
+     * minutes a drawer left open is closed without a count. Null when POS was never set up; the
+     * engine then runs with its defaults (00:00, no closing time, 120 minutes after it, 24 hours
+     * idle). Any session of the store reads it. An engine before 26 refuses the document at
+     * validation.
+     */
+    dayControls(options?: Call): Promise<PosDayControls | null>;
+    /**
+     * Set the store's day controls, all at once (engine sprint 26). A new day start applies to
+     * drawers opened after it: an open drawer keeps the business day it was stamped with. An omitted
+     * or null `closingTime` is no closing time (no closing-time auto-close); an omitted
+     * `autoCloseIdleMinutes` keeps the stored one, `null` switches the idle close off. Refused
+     * `POS_DAY_CONTROLS_INVALID` (a `ValidationError`; `error.details[0].field` names the control,
+     * `extensions.reason` is `time_format`, `day_start_out_of_range`, `after_closing_out_of_range`
+     * or `idle_out_of_range`): times are `HH:MM`, the day starts 00:00 to 12:00, the grace is 30 to
+     * 1440 minutes, the idle time 120 to 10080. Also `ORGANIZATION_WORKSPACE_NOT_A_STORE`. Needs
+     * `UpdateSettings`; setting what is stored writes nothing.
+     */
+    setDayControls(input: PosDayControlsInput, options?: Call): Promise<PosDayControls>;
+    /** The store's custom item rules (sprint 16b), with every category it could list. Any staff session. */
+    customItemPolicy(options?: Call): Promise<PosCustomItemPolicy>;
+    /**
+     * Change the store's custom item rules (sprint 16b); needs `UpdateSettings`. Refused
+     * `POS_CUSTOM_ITEM_POLICY_INVALID` (`field`; `taxCategoryId` for a category that does not exist or
+     * has no rate in the store's tax zone): at most 20 categories, each once; amounts 0 to
+     * 2147483647; turning it on needs a category and a `maxUnitPrice` of at least 1. A change that
+     * changes nothing writes nothing.
+     */
+    setCustomItemPolicy(input: PosCustomItemPolicyInput, options?: Call): Promise<PosCustomItemPolicy>;
+    /**
+     * The store's receipt settings (engine sprint 22): which of the store's details print at the top
+     * (`identity` is what the platform holds, edited under the store's details, never here), its
+     * extra header and footer lines, and how tax shows. `configured: false` for a store that never
+     * saved them: its receipt prints as before. Null when POS was never set up. Any staff session
+     * of the store reads it. An engine before 22 refuses the document at validation.
+     */
+    receipt(options?: Call): Promise<PosReceiptSettings | null>;
+    /**
+     * Change the store's receipt settings; an omitted field keeps its value. `footerLines: null`
+     * prints the receipt's own thank-you line, `[]` no footer. Refusals:
+     * `POS_RECEIPT_SETTINGS_INVALID` with `field` (`headerLines`, `footerLines`, `taxDisplay`: more
+     * than 4 lines, a line over 48 characters or holding a tab or a line break),
+     * `ORGANIZATION_WORKSPACE_NOT_A_STORE`. A change that changes nothing writes nothing. Needs
+     * `UpdateSettings`. An engine before 22 refuses the document at validation.
+     */
+    setReceipt(input: PosReceiptSettingsInput, options?: Call): Promise<PosReceiptSettings>;
+    /**
+     * A sample sale's receipt with these settings over the stored ones (nothing is written), for a
+     * preview, laid out as you lay out `sale.receipt`. Refused `POS_RECEIPT_SETTINGS_INVALID` as the save
+     * would be. Needs `UpdateSettings` or `ManagePosDevices`. An engine before 22 refuses the
+     * document at validation.
+     */
+    previewReceipt(input?: PosReceiptSettingsInput, options?: Call): Promise<PosReceipt>;
+    /**
+     * The store's digital receipts (engine sprint 23): on or off, and whether the platform serves
+     * receipt pages at all. Its own read, so `receipt()` keeps working on an engine before 23 (this
+     * one is refused there at validation). Null when POS was never set up. Switch it with
+     * `setReceipt({ publicLink })`.
+     */
+    digitalReceipts(options?: Call): Promise<PosDigitalReceiptSettings | null>;
+    /**
+     * The receipt account claim (engine C3/32): on or off, and whether it can be switched on (digital
+     * receipts on and a storefront address). Its own read, so `digitalReceipts()` keeps working on
+     * an engine before C3 (this one is refused there at validation). Null when POS was never set
+     * up. Switch it with `setReceipt({ accountClaim })`.
+     */
+    receiptAccountClaim(options?: Call): Promise<PosReceiptAccountClaimSettings | null>;
+    /**
+     * The store's offline cash sales (engine sprint 45): whether its tills may keep selling for cash
+     * while offline (off until a manager turns it on), the three limits, and whether the store can
+     * sell offline now (`ready`; `notReadyReasons` says why not: `prices_exclude_tax`,
+     * `automatic_promotions`, `no_cash_method`, `pos_disabled`, more may come). A till sells offline
+     * only on a store that is switched on AND ready. Null when POS was never set up (the defaults
+     * apply: off). Any staff session of the store reads it. Its own document: an engine before 45
+     * refuses it at validation, and every other settings read keeps working.
+     */
+    offlineCashSales(options?: Call): Promise<PosOfflineCashSales | null>;
+    /**
+     * Set the store's offline cash sales, every field at once, each within
+     * `POS_OFFLINE_CASH_SALES_LIMITS` (the sale amount in minor units of the store's default
+     * currency). Switching on is allowed on a store that is not ready: its tills sell offline once it
+     * is. Refused `POS_OFFLINE_POLICY_INVALID` (`ValidationError`; `details[0].field` names the
+     * limit, `extensions.min`/`max` its bounds) and `ORGANIZATION_WORKSPACE_NOT_A_STORE`. Needs
+     * `UpdateSettings`. An engine before 45 refuses the document at validation.
+     */
+    setOfflineCashSales(input: PosOfflineCashSalesInput, options?: Call): Promise<PosOfflineCashSales>;
+}
+/** How tax shows on a receipt (engine sprint 22). */
+export type PosReceiptTaxDisplay = 'INCLUSIVE' | 'EXCLUSIVE';
+/** The store's details as the platform holds them (what a receipt's header may print). */
+export interface PosReceiptIdentity {
+    storeName: string | null;
+    addressLines: string[];
+    phone: string | null;
+    vatNumber: string | null;
+    registrationNumber: string | null;
+}
+/** The store's receipt settings (engine sprint 22). */
+export interface PosReceiptSettings {
+    /** False for a store that never saved them: its receipt prints as before. */
+    configured: boolean;
+    showStoreName: boolean;
+    showAddress: boolean;
+    showPhone: boolean;
+    /** The VAT number and the registration number. */
+    showVatNumber: boolean;
+    /** At most 4 lines of at most 48 characters under the store's details. */
+    headerLines: string[];
+    /** At most 4 lines of at most 48 characters; null = the receipt's own thank-you line. */
+    footerLines: string[] | null;
+    /** The stored choice, else the store's price basis. */
+    taxDisplay: PosReceiptTaxDisplay;
+    identity: PosReceiptIdentity;
+}
+/** What `setReceipt` / `previewReceipt` change: an omitted field keeps its value. */
+export interface PosReceiptSettingsInput {
+    showStoreName?: boolean;
+    showAddress?: boolean;
+    showPhone?: boolean;
+    showVatNumber?: boolean;
+    headerLines?: string[];
+    /** null = the receipt's own thank-you line; [] = no footer. */
+    footerLines?: string[] | null;
+    taxDisplay?: PosReceiptTaxDisplay;
+    /**
+     * Digital receipts on or off (engine sprint 23; send it only to change it: an engine before 23
+     * refuses the field). Switching on where the platform serves no receipt pages is refused
+     * `POS_RECEIPT_LINK_UNAVAILABLE` (`reason: not_configured`).
+     */
+    publicLink?: boolean;
+    /**
+     * The receipt account claim on or off (engine C3/32; send it only to change it: an engine before
+     * C3 refuses the field). Switching on without digital receipts or a storefront address is refused
+     * `POS_RECEIPT_LINK_UNAVAILABLE` (`reason: no_storefront`).
+     */
+    accountClaim?: boolean;
+}
+/** A completed till sale's receipt document (engine sprint 22). Money in minor units. */
+export interface PosReceipt {
+    /** `SALE` today; read an unknown kind as a sale. */
+    kind: string;
+    orderId: string;
+    orderCode: string;
+    receiptNumber: string;
+    /** When the sale was placed (ISO). */
+    issuedAt: string;
+    /** The receipt's language: the store's when the till speaks it, else `en`. */
+    language: string;
+    /** BCP 47, for money and dates (`nl-NL`). */
+    locale: string;
+    /** IANA zone `issuedAt` is shown in. */
+    timeZone: string;
+    currencyCode: string;
+    taxDisplay: PosReceiptTaxDisplay;
+    header: PosReceiptIdentity & {
+        extraLines: string[];
+    };
+    cashierName: string | null;
+    registerName: string | null;
+    lines: PosReceiptLine[];
+    /** The lines at list price plus their own discount rows. */
+    subtotal: number;
+    adjustments: PosReceiptAdjustment[];
+    taxes: PosReceiptTax[];
+    /** The sale's billable total: what was paid. */
+    total: number;
+    tenders: PosReceiptTender[];
+    changeDue: number;
+    refunds: PosReceiptRefund[];
+    orderNote: string | null;
+    /** Where the sale's ship lines go (engine C3); null for a take-now sale. Absent before C3. */
+    delivery?: PosReceiptDelivery | null;
+    footerLines: string[];
+    /** The receipt's own thank-you line prints. */
+    thankYou: boolean;
+    /** The order code, printed as a Code 128 barcode. */
+    scanCode: string;
+}
+export interface PosReceiptLine {
+    orderLineId: string;
+    name: string;
+    /** Null for a custom item. */
+    sku: string | null;
+    quantity: number;
+    unitPrice: number;
+    amount: number;
+    /** Percent. */
+    taxRate: number;
+    discounts: Array<{
+        kind: 'PROMOTION' | 'TILL';
+        description: string | null;
+        amount: number;
+    }>;
+    note: string | null;
+    /** Shipped to the customer: printed "To be delivered" (engine C3). Absent before C3. */
+    ships?: boolean;
+}
+/** Where a sale's ship lines go (engine C3): the customer's delivery address, never a phone. */
+export interface PosReceiptDelivery {
+    name: string | null;
+    addressLines: string[];
+    /** The delivery method's name in the receipt language. */
+    methodName: string | null;
+}
+export interface PosReceiptAdjustment {
+    kind: 'PROMOTION' | 'TILL_DISCOUNT' | 'SURCHARGE' | 'SHIPPING' | 'ROUNDING';
+    description: string | null;
+    amount: number;
+}
+export interface PosReceiptTax {
+    description: string;
+    rate: number;
+    base: number;
+    amount: number;
+}
+export interface PosReceiptTender {
+    kind: 'cash' | 'card' | 'other';
+    /**
+     * An exchange's carried credit (engine C3): label it from the receipt's own words, never
+     * `methodName`. Absent from an older engine's answer.
+     */
+    exchange?: boolean;
+    /** The payment method's name in the receipt language. */
+    methodName: string | null;
+    amount: number;
+    /** Cash only. */
+    tendered: number | null;
+    /** Cash only: + the drawer kept more than the amount. */
+    cashRounding: number | null;
+    /** Cash only. */
+    change: number | null;
+}
+export interface PosReceiptRefund {
+    kind: 'cash' | 'card' | 'other';
+    /** A refund of an exchange's carried credit (engine C3). */
+    exchange?: boolean;
+    methodName: string | null;
+    /** Positive: the money returned. */
+    amount: number;
+    refundedAt: string;
+}
+/** A store's cash controls at the till's close (engine sprint 25b). */
+export interface PosCashControls {
+    /** The cashier counts the drawer without seeing the expected cash; the variance shows after. */
+    blindCount: boolean;
+    /** A variance above this (minor units) needs a manager; null for never. */
+    varianceThreshold: number | null;
+}
+export interface PosCashControlsInput {
+    blindCount: boolean;
+    /** Omitted keeps the stored threshold; null sets "never". */
+    varianceThreshold?: number | null;
+}
+/** A store's business day and the auto-close of forgotten drawers (engine sprint 26). */
+export interface PosDayControls {
+    /** When a business day begins, `HH:MM` (00:00 to 12:00): a drawer opened earlier is the day before's. */
+    businessDayStartsAt: string;
+    /** When the store closes, `HH:MM`; at or before the day start it is on the next calendar day. Null: none. */
+    closingTime: string | null;
+    /** A drawer still open this many minutes after the closing time is closed without a count. */
+    autoCloseAfterClosingMinutes: number;
+    /** A drawer idle this many minutes is closed without a count; null for never. */
+    autoCloseIdleMinutes: number | null;
+}
+export interface PosDayControlsInput {
+    businessDayStartsAt: string;
+    /** Omitted or null: no closing time. */
+    closingTime?: string | null;
+    autoCloseAfterClosingMinutes: number;
+    /** Omitted keeps the stored idle time; null switches the idle close off. */
+    autoCloseIdleMinutes?: number | null;
+}
+/** Needs `UpdateSettings` or `ManagePosDevices`. */
+export interface PosTerminalsModule {
+    /**
+     * The Mollie terminals the store's till key reaches, read from Mollie now (at most 250; the whole
+     * list in one page). Refusals, each carrying `.code`: POS_MOLLIE_KEY_INVALID (Mollie refused the
+     * key; a `ValidationError`), POS_MOLLIE_KEY_MISSING, POS_MOLLIE_KEY_UNREADABLE,
+     * POS_MOLLIE_UNREACHABLE (try again) and POS_MOLLIE_REQUEST_REFUSED (each a `BusinessRuleError`),
+     * and POS_ENCRYPTION_NOT_CONFIGURED (the engine cannot store or read a card key yet: its
+     * operator must configure it; a non-retryable 500, Mollie not asked). Branch on the code.
+     */
+    list(options?: Call): Promise<Page<PosMollieTerminal>>;
+}
+/**
+ * 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 declare const POS_STAFF_LOCALES: readonly ["en", "nl", "de", "fr"];
+export type PosStaffLocale = (typeof POS_STAFF_LOCALES)[number];
+export type PosStaffRole = 'cashier' | 'manager';
+/** A cashier or manager of the store, as the back office manages them. */
+export interface PosStaffMember {
+    id: string;
+    name: string;
+    /** A manager can approve what a cashier may not do alone (a discount, a refund, a paid-out). */
+    role: PosStaffRole;
+    /** An inactive staff member cannot sign in on a till. */
+    active: boolean;
+    /** The back-office administrator this staff member is linked to, if any. */
+    administratorId: string | null;
+    /**
+     * Their own till language, or null to follow the store's. A string, not narrowed to
+     * {@link PosStaffLocale}, so a language a newer engine adds never fails a read.
+     */
+    locale: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface PosStaffCreateInput {
+    name: string;
+    /** The first PIN, which the cashier signs in with on the till. Never readable again. */
+    pin: string;
+    /** `cashier` when omitted. */
+    role?: PosStaffRole;
+    /** Their own till language; omitted or null follows the store's. */
+    locale?: PosStaffLocale | null;
+}
+export interface PosStaffUpdateInput {
+    name?: string;
+    role?: PosStaffRole;
+    active?: boolean;
+    /** Their own till language; null follows the store's; omitted leaves it as it is. */
+    locale?: PosStaffLocale | null;
+}
+/**
+ * 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 declare const POS_STAFF_GRANTS: readonly ["manual_price", "discount", "custom_item_over_limit", "refund", "discard_held_sale", "paid_out", "no_sale", "safe_drop", "float_adjust", "return_items", "void_sale", "no_receipt_return", "online_return"];
+export type PosStaffGrant = (typeof POS_STAFF_GRANTS)[number];
+/** What one staff member may do at a till without a manager, as the store stored it. */
+export interface PosStaffGrants {
+    id: string;
+    role: PosStaffRole;
+    /**
+     * The stored grants, as strings: a grant a newer engine adds never fails a read. A manager may do
+     * everything whatever this says (the list is kept, unused, while they are a manager).
+     */
+    grants: string[];
+}
+/**
+ * The store's staff. Every method needs `UpdateSettings` or `ManagePosDevices`.
+ *
+ * `locale` is checked before anything is sent: a value outside {@link POS_STAFF_LOCALES} (`nl_BE`,
+ * `es`) is refused `POS_LOCALE_UNSUPPORTED` as a `ValidationError` (`details[0].field` is
+ * `locale`); the engine's own refusal of that code arrives as the same class (400), by core's code
+ * table. It is trimmed and lower-cased like the engine does (`' NL '` is `nl`), and an empty one
+ * follows the store, as null does. A language the till has not released yet is accepted: the till
+ * uses the store's language until it ships.
+ *
+ * Every staff document names `locale`, so an engine older than the staff language refuses each
+ * call (`GRAPHQL_VALIDATION_FAILED`, or `BAD_REQUEST` over HTTP 400) before running it.
+ */
+export interface PosStaffModule {
+    /**
+     * Every staff member of the store, inactive ones included, oldest first; returned whole.
+     *
+     * @effect read
+     */
+    list(options?: Call): Promise<Page<PosStaffMember>>;
+    /**
+     * One staff member, or null when the id is not one of this store's.
+     *
+     * @effect read
+     */
+    get(id: string, options?: Call): Promise<PosStaffMember | null>;
+    /**
+     * A new staff member, active, with their first PIN (the engine checks its format, as
+     * {@link PosStaffModule.setPin} says). On an organization workspace refused
+     * `ORGANIZATION_WORKSPACE_NOT_A_STORE`.
+     *
+     * @effect write
+     */
+    create(input: PosStaffCreateInput, options?: Call): Promise<PosStaffMember>;
+    /**
+     * Change what `input` names; a field left out is left as it is. `active: false` is how a staff
+     * member leaves: they can no longer sign in on a till and a shift they have open stops working,
+     * while every sale, drawer and approval they made stays theirs; `active: true` brings them back
+     * (refused `POS_STAFF_NAME_TAKEN` while an active member has the name). There is no delete.
+     * Refused `POS_STAFF_NOT_FOUND` (`NotFoundError`, 404) for an id that is not this store's.
+     *
+     * @effect write
+     */
+    update(id: string, input: PosStaffUpdateInput, options?: Call): Promise<PosStaffMember>;
+    /**
+     * Replace a staff member's PIN. The PIN is 4 to 8 digits, neither one digit repeated (`1111`)
+     * nor a run (`1234`, `9876`); anything else is refused `POS_PIN_FORMAT_INVALID`
+     * (`ValidationError`, 400, the engine's sentence naming the rule, never the PIN) before
+     * anything is read. A new PIN also clears the member's wrong-PIN count, which is how a locked
+     * member is unlocked (the till's own count is left). The PIN is never read back, and this SDK
+     * never puts it in an error or a log. Refused `POS_STAFF_NOT_FOUND` (`NotFoundError`, 404) for an
+     * id that is not this store's. Needs `UpdateSettings` or `ManagePosDevices`.
+     *
+     * @effect write
+     */
+    setPin(id: string, pin: string, options?: Call): Promise<void>;
+    /**
+     * What one staff member may do without a manager (engine sprint 18), or null when the id is not
+     * one of this store's. An engine older than sprint 18 refuses the document
+     * (`GRAPHQL_VALIDATION_FAILED`, or `BAD_REQUEST` over HTTP 400).
+     *
+     * @effect read
+     */
+    grants(id: string, options?: Call): Promise<PosStaffGrants | null>;
+    /**
+     * Every staff member's grants, inactive ones included; returned whole (engine sprint 18).
+     *
+     * @effect read
+     */
+    listGrants(options?: Call): Promise<Page<PosStaffGrants>>;
+    /**
+     * Replace a staff member's grants (engine sprint 18): what they may do at a till without a
+     * manager. The engine stores the set deduplicated, in its own order, and writes (and audits)
+     * only a change. A manager keeps every power whatever is stored. Refused `POS_STAFF_NOT_FOUND`
+     * (`NotFoundError`, 404) for an id that is not this store's, `ORGANIZATION_WORKSPACE_NOT_A_STORE`
+     * on a workspace; a value outside the engine's `PosStaffGrant` enum fails its validation.
+     *
+     * @effect write
+     */
+    setGrants(id: string, grants: readonly PosStaffGrant[], options?: Call): Promise<PosStaffGrants>;
+}
 export declare const POS_REGISTERS_QUERY = "query PosRegisters { posRegisters { id stockLocationId name status createdAt updatedAt } }";
 export declare const POS_REGISTER_QUERY = "query PosRegister($id: ID!) { posRegister(id: $id) { id stockLocationId name status createdAt updatedAt } }";
 export declare const CREATE_POS_REGISTER_MUTATION = "mutation CreatePosRegister($input: CreatePosRegisterInput!) { createPosRegister(input: $input) { id stockLocationId name status createdAt updatedAt } }";
@@ -546,22 +2564,97 @@ export declare const OPEN_POS_SESSION_MUTATION = "mutation OpenPosRegisterSessio
 export declare const CLOSE_POS_SESSION_MUTATION = "mutation ClosePosRegisterSession($input: ClosePosRegisterSessionInput!, $staffToken: String) { closePosRegisterSession(input: $input, staffToken: $staffToken) { id registerId deviceId openedByStaffId openingFloat status expectedCash countedCash cashOverShort totals openedAt closedAt } }";
 export declare const POS_X_REPORT_QUERY = "query PosXReport($sessionId: ID!) { posXReport(sessionId: $sessionId) { sessionId openingFloat expectedCash movementCount totals { cash card other refunds net saleCount } } }";
 export declare const POS_SESSION_QUERY = "query PosRegisterSession($id: ID!) { posRegisterSession(id: $id) { id registerId deviceId openedByStaffId openingFloat status expectedCash countedCash cashOverShort totals openedAt closedAt } }";
+export declare const POS_SESSION_DETAIL_QUERY = "query PosRegisterSessionDetail($id: ID!) { posRegisterSession(id: $id) { id registerId deviceId openedByStaffId openingFloat status expectedCash countedCash cashOverShort totals openedAt closedAt closedByStaffId blindCount varianceThreshold varianceApproval varianceApprovedByStaffId varianceApprovedAt } }";
+export declare const POS_SESSION_APPROVAL_QUERY = "query PosRegisterSessionApproval($id: ID!) { posRegisterSession(id: $id) { id varianceApproval varianceThreshold varianceApprovedByStaffId varianceApprovedAt varianceApprovedByUserId varianceApprovedByUserName varianceApprovedByCredential varianceApprovalNote } }";
+export declare const APPROVE_POS_SESSION_CLOSE_MUTATION = "mutation ApprovePosRegisterSessionClose($input: ApprovePosRegisterSessionCloseInput!) { approvePosRegisterSessionClose(input: $input) { id registerId deviceId openedByStaffId openingFloat status expectedCash countedCash cashOverShort totals openedAt closedAt closedByStaffId blindCount varianceThreshold varianceApproval varianceApprovedByStaffId varianceApprovedAt varianceApprovedByUserId varianceApprovedByUserName varianceApprovedByCredential varianceApprovalNote } }";
+export declare const SESSION_RECORD_FIELDS = "businessDay stockLocationId timeZone zNumber closeSource closedByUserId autoCloseReason closeNote countedAt countedByUserId countNote";
+export declare const SESSION_RECORD_NAME_FIELDS = "varianceApprovedByUserName closedByUserName countedByUserName";
+export declare const POS_SESSION_RECORD_QUERY = "query PosRegisterSessionRecord($id: ID!) { posRegisterSession(id: $id) { id registerId deviceId openedByStaffId openingFloat status expectedCash countedCash cashOverShort totals openedAt closedAt closedByStaffId blindCount varianceThreshold varianceApproval varianceApprovedByStaffId varianceApprovedAt varianceApprovedByUserId varianceApprovedByCredential varianceApprovalNote businessDay stockLocationId timeZone zNumber closeSource closedByUserId autoCloseReason closeNote countedAt countedByUserId countNote varianceApprovedByUserName closedByUserName countedByUserName } }";
+export declare const POS_SESSION_RECORDS_QUERY = "query PosRegisterSessionRecords($options: PosRegisterSessionListOptions) { posRegisterSessions(options: $options) { totalItems items { id registerId deviceId openedByStaffId openingFloat status expectedCash countedCash cashOverShort totals openedAt closedAt closedByStaffId blindCount varianceThreshold varianceApproval varianceApprovedByStaffId varianceApprovedAt varianceApprovedByUserId varianceApprovedByCredential varianceApprovalNote businessDay stockLocationId timeZone zNumber closeSource closedByUserId autoCloseReason closeNote countedAt countedByUserId countNote } } }";
+export declare const CLOSE_POS_SESSION_UNCOUNTED_MUTATION = "mutation ClosePosRegisterSessionUncounted($input: ClosePosRegisterSessionUncountedInput!) { closePosRegisterSessionUncounted(input: $input) { id registerId deviceId openedByStaffId openingFloat status expectedCash countedCash cashOverShort totals openedAt closedAt closedByStaffId blindCount varianceThreshold varianceApproval varianceApprovedByStaffId varianceApprovedAt varianceApprovedByUserId varianceApprovedByCredential varianceApprovalNote businessDay stockLocationId timeZone zNumber closeSource closedByUserId autoCloseReason closeNote countedAt countedByUserId countNote varianceApprovedByUserName closedByUserName countedByUserName } }";
+export declare const COUNT_POS_SESSION_MUTATION = "mutation CountPosRegisterSession($input: CountPosRegisterSessionInput!) { countPosRegisterSession(input: $input) { id registerId deviceId openedByStaffId openingFloat status expectedCash countedCash cashOverShort totals openedAt closedAt closedByStaffId blindCount varianceThreshold varianceApproval varianceApprovedByStaffId varianceApprovedAt varianceApprovedByUserId varianceApprovedByCredential varianceApprovalNote businessDay stockLocationId timeZone zNumber closeSource closedByUserId autoCloseReason closeNote countedAt countedByUserId countNote varianceApprovedByUserName closedByUserName countedByUserName } }";
+export declare const POS_ORDERS_QUERY = "query PosOrders($input: PosOrderListInput) { posOrders(input: $input) { totalItems items { orderId orderCode receiptNumber placedAt state currencyCode totalWithTax totalQuantity refundedTotal tenderKinds customerKind customerName registerId registerName sessionId deviceId deviceLabel staffId staffName } } }";
+export declare const POS_TILL_SALE_QUERY = "query PosTillSale($orderId: ID!) { posTillOrder(orderId: $orderId) { order { id code state } receiptNumber placedAt customerKind deviceId deviceLabel registerId registerName sessionId staffId staffName payments { paymentId kind method state amount refunded refundUnknown refundable } 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 declare const POS_TILL_SALE_QUERY_LEGACY = "query PosTillSale($orderId: ID!) { posTillOrder(orderId: $orderId) { order { id code state } receiptNumber placedAt customerKind deviceId deviceLabel registerId registerName sessionId staffId staffName payments { paymentId kind method state amount refunded refundUnknown refundable } } }";
+export declare 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 } } }";
+export declare const STORE_DAY_TOTALS_FIELDS = "currencyCode sessionCount uncountedCount openingFloat expectedCash countedCash cashOverShort cash card other refunds net saleCount cashRefunds cardRefunds otherRefunds cashRounding";
+export declare 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 declare const STORE_DAY_FIELDS = "id stockLocationId businessDay timeZone startsAt endsAt status totalsFinal totals { currencyCode sessionCount uncountedCount openingFloat expectedCash countedCash cashOverShort cash card other refunds net saleCount cashRefunds cardRefunds otherRefunds cashRounding } 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 declare const STORE_DAY_DETAIL_FIELDS = "sessions { sessionId registerId registerName zNumber status closeSource openedAt closedAt openingFloat expectedCash countedCash cashOverShort varianceApproval totals { cash card other refunds net saleCount cashRefunds cardRefunds otherRefunds cashRounding } } closedByUserName reopenedByUserName";
+export declare const POS_STORE_DAY_QUERY = "query PosStoreDay($stockLocationId: ID!, $businessDay: String!) { posStoreDay(stockLocationId: $stockLocationId, businessDay: $businessDay) { id stockLocationId businessDay timeZone startsAt endsAt status totalsFinal totals { currencyCode sessionCount uncountedCount openingFloat expectedCash countedCash cashOverShort cash card other refunds net saleCount cashRefunds cardRefunds otherRefunds cashRounding } openSessionCount pendingCount uncountedCount closedAt closedByUserId closedByCredential closeNote closeCount reopenedAt reopenedByUserId reopenNote sessions { sessionId registerId registerName zNumber status closeSource openedAt closedAt openingFloat expectedCash countedCash cashOverShort varianceApproval totals { cash card other refunds net saleCount cashRefunds cardRefunds otherRefunds cashRounding } } closedByUserName reopenedByUserName } }";
+export declare const POS_STORE_DAYS_QUERY = "query PosStoreDays($input: PosStoreDayListInput!) { posStoreDays(input: $input) { totalItems items { id stockLocationId businessDay timeZone startsAt endsAt status totalsFinal totals { currencyCode sessionCount uncountedCount openingFloat expectedCash countedCash cashOverShort cash card other refunds net saleCount cashRefunds cardRefunds otherRefunds cashRounding } openSessionCount pendingCount uncountedCount closedAt closedByUserId closedByCredential closeNote closeCount reopenedAt reopenedByUserId reopenNote } } }";
+export declare const CLOSE_POS_STORE_DAY_MUTATION = "mutation ClosePosStoreDay($input: ClosePosStoreDayInput!) { closePosStoreDay(input: $input) { id stockLocationId businessDay timeZone startsAt endsAt status totalsFinal totals { currencyCode sessionCount uncountedCount openingFloat expectedCash countedCash cashOverShort cash card other refunds net saleCount cashRefunds cardRefunds otherRefunds cashRounding } openSessionCount pendingCount uncountedCount closedAt closedByUserId closedByCredential closeNote closeCount reopenedAt reopenedByUserId reopenNote sessions { sessionId registerId registerName zNumber status closeSource openedAt closedAt openingFloat expectedCash countedCash cashOverShort varianceApproval totals { cash card other refunds net saleCount cashRefunds cardRefunds otherRefunds cashRounding } } closedByUserName reopenedByUserName } }";
+export declare const REOPEN_POS_STORE_DAY_MUTATION = "mutation ReopenPosStoreDay($input: ReopenPosStoreDayInput!) { reopenPosStoreDay(input: $input) { id stockLocationId businessDay timeZone startsAt endsAt status totalsFinal totals { currencyCode sessionCount uncountedCount openingFloat expectedCash countedCash cashOverShort cash card other refunds net saleCount cashRefunds cardRefunds otherRefunds cashRounding } openSessionCount pendingCount uncountedCount closedAt closedByUserId closedByCredential closeNote closeCount reopenedAt reopenedByUserId reopenNote sessions { sessionId registerId registerName zNumber status closeSource openedAt closedAt openingFloat expectedCash countedCash cashOverShort varianceApproval totals { cash card other refunds net saleCount cashRefunds cardRefunds otherRefunds cashRounding } } closedByUserName reopenedByUserName } }";
+export declare const POS_SESSION_LIST_QUERY = "query PosRegisterSessionList($options: PosRegisterSessionListOptions) { posRegisterSessions(options: $options) { totalItems items { id registerId deviceId openedByStaffId openingFloat status expectedCash countedCash cashOverShort totals openedAt closedAt closedByStaffId blindCount varianceThreshold varianceApproval varianceApprovedByStaffId varianceApprovedAt } } }";
 export declare const RECORD_POS_CASH_MOVEMENT_MUTATION = "mutation RecordPosCashMovement($input: RecordPosCashMovementInput!, $staffToken: String) { recordPosCashMovement(input: $input, staffToken: $staffToken) { id sessionId type amount reason orderId createdAt } }";
+export declare 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 declare const POS_CREATE_CART_MUTATION = "mutation PosCreateCart($registerId: ID) { posCreateCart(registerId: $registerId) { id code state currencyCode total totalWithTax couponCodes\n  lines { id quantity productVariant { id } linePriceWithTax }\n  surcharges { description sku price priceWithTax taxRate } } }";
 export declare const POS_ADD_ITEM_MUTATION = "mutation PosAddItem($input: PosAddItemInput!) { posAddItem(input: $input) { id code state currencyCode total totalWithTax couponCodes\n  lines { id quantity productVariant { id } linePriceWithTax }\n  surcharges { description sku price priceWithTax taxRate } } }";
 export declare const POS_APPLY_DISCOUNT_MUTATION = "mutation PosApplyDiscount($input: PosApplyDiscountInput!, $staffToken: String) { posApplyDiscount(input: $input, staffToken: $staffToken) { id code state currencyCode total totalWithTax couponCodes\n  lines { id quantity productVariant { id } linePriceWithTax }\n  surcharges { description sku price priceWithTax taxRate } } }";
 export declare const POS_APPLY_COUPON_CODE_MUTATION = "mutation PosApplyCouponCode($input: PosCouponCodeInput!) { posApplyCouponCode(input: $input) { id code state currencyCode total totalWithTax couponCodes\n  lines { id quantity productVariant { id } linePriceWithTax }\n  surcharges { description sku price priceWithTax taxRate } } }";
 export declare const POS_REMOVE_COUPON_CODE_MUTATION = "mutation PosRemoveCouponCode($input: PosCouponCodeInput!) { posRemoveCouponCode(input: $input) { id code state currencyCode total totalWithTax couponCodes\n  lines { id quantity productVariant { id } linePriceWithTax }\n  surcharges { description sku price priceWithTax taxRate } } }";
+export declare const POS_ADD_CUSTOM_ITEM_MUTATION = "mutation PosAddCustomItem($input: PosAddCustomItemInput!, $staffToken: String, $approvalToken: String) { posAddCustomItem(input: $input, staffToken: $staffToken, approvalToken: $approvalToken) { id code state currencyCode total totalWithTax couponCodes\n  lines { id quantity productVariant { id } linePriceWithTax }\n  surcharges { description sku price priceWithTax taxRate } lines { id customFields { posCustomItemName } } } }";
+export declare const POS_SET_ORDER_NOTE_MUTATION = "mutation PosSetOrderNote($input: PosSetOrderNoteInput!, $staffToken: String) { posSetOrderNote(input: $input, staffToken: $staffToken) { id code state currencyCode total totalWithTax couponCodes\n  lines { id quantity productVariant { id } linePriceWithTax }\n  surcharges { description sku price priceWithTax taxRate } customFields { posOrderNote } lines { id customFields { posCustomItemName posLineNote } } } }";
+export declare const POS_SET_LINE_NOTE_MUTATION = "mutation PosSetLineNote($input: PosSetLineNoteInput!, $staffToken: String) { posSetLineNote(input: $input, staffToken: $staffToken) { id code state currencyCode total totalWithTax couponCodes\n  lines { id quantity productVariant { id } linePriceWithTax }\n  surcharges { description sku price priceWithTax taxRate } customFields { posOrderNote } lines { id customFields { posCustomItemName posLineNote } } } }";
+export declare const POS_TILL_SALE_DETAILS_QUERY = "query PosTillSaleDetails($id: ID!) { order(id: $id) { id customFields { isPosOrder posOrderNote } lines { id customFields { posCustomItemName posLineNote } } } }";
+export declare const POS_CLEAR_CART_MUTATION = "mutation PosClearCart($input: PosClearCartInput!, $staffToken: String) { posClearCart(input: $input, staffToken: $staffToken) { orderId orderCode } }";
 export declare const POS_COMPLETE_SALE_MUTATION = "mutation PosCompleteSale($input: PosCompleteSaleInput!, $staffToken: String) { posCompleteSale(input: $input, staffToken: $staffToken) { orderId orderCode receiptNumber state } }";
 export declare const POS_TENDER_CASH_MUTATION = "mutation PosTenderCash($input: PosTenderCashInput!, $staffToken: String) { posTenderCash(input: $input, staffToken: $staffToken) { orderId paymentId covered outstanding change } }";
 export declare const POS_TENDER_CARD_MUTATION = "mutation PosTenderCard($input: PosTenderCardInput!, $staffToken: String) { posTenderCard(input: $input, staffToken: $staffToken) { orderId paymentId covered outstanding change } }";
 export declare const POS_TENDER_STORED_VALUE_MUTATION = "mutation PosTenderStoredValue($input: PosTenderStoredValueInput!, $staffToken: String) { posTenderStoredValue(input: $input, staffToken: $staffToken) { orderId paymentId covered outstanding change } }";
 export declare const POS_TENDER_MANUAL_MUTATION = "mutation PosTenderManual($input: PosTenderManualInput!, $staffToken: String) { posTenderManual(input: $input, staffToken: $staffToken) { orderId paymentId covered outstanding change } }";
 export declare const POS_REFUND_MUTATION = "mutation PosRefund($input: PosRefundInput!, $staffToken: String) { posRefund(input: $input, staffToken: $staffToken) { orderId refundId state } }";
-export declare const POS_DEVICES_QUERY = "query PosDevices { posDevices { id stockLocationId registerId label status paired lastSeenAt } }";
+export declare const POS_DEVICES_QUERY = "query PosDevices { posDevices { id stockLocationId registerId label status paired lastSeenAt mollieTerminalId createdAt updatedAt } }";
 export declare const POS_DEVICE_QUERY = "query PosDevice($id: ID!) { posDevice(id: $id) { lastSeenAt } }";
 export declare const POS_PAIRING_CODE_MUTATION = "mutation GeneratePosPairingCode($deviceId: ID!) { generatePosPairingCode(deviceId: $deviceId) { code expiresAt } }";
-export declare const REVOKE_POS_DEVICE_MUTATION = "mutation RevokePosDevice($deviceId: ID!) { revokePosDevice(deviceId: $deviceId) { id stockLocationId registerId label status paired lastSeenAt } }";
+export declare const REVOKE_POS_DEVICE_MUTATION = "mutation RevokePosDevice($deviceId: ID!) { revokePosDevice(deviceId: $deviceId) { id stockLocationId registerId label status paired lastSeenAt mollieTerminalId createdAt updatedAt } }";
+export declare const POS_DEVICE_DETAIL_QUERY = "query PosDeviceDetail($id: ID!) { posDevice(id: $id) { id stockLocationId registerId label status paired lastSeenAt mollieTerminalId createdAt updatedAt } }";
+export declare const ASSIGN_POS_DEVICE_LOCATION_MUTATION = "mutation AssignPosDeviceLocation($deviceId: ID!, $stockLocationId: ID!) { assignPosDeviceLocation(deviceId: $deviceId, stockLocationId: $stockLocationId) { id stockLocationId registerId label status paired lastSeenAt mollieTerminalId createdAt updatedAt } }";
+export declare const ASSIGN_POS_DEVICE_REGISTER_MUTATION = "mutation AssignPosDeviceRegister($deviceId: ID!, $registerId: ID!) { assignPosDeviceRegister(deviceId: $deviceId, registerId: $registerId) { id stockLocationId registerId label status paired lastSeenAt mollieTerminalId createdAt updatedAt } }";
+export declare const ASSIGN_POS_DEVICE_TERMINAL_MUTATION = "mutation AssignPosDeviceMollieTerminal($deviceId: ID!, $terminalId: String!) { assignPosDeviceMollieTerminal(deviceId: $deviceId, terminalId: $terminalId) { id stockLocationId registerId label status paired lastSeenAt mollieTerminalId createdAt updatedAt } }";
+export declare const ASSIGN_POS_DEVICE_LOCATION_WITH_REGISTER_MUTATION = "mutation AssignPosDeviceLocationWithRegister($deviceId: ID!, $stockLocationId: ID!, $registerId: ID!) { assignPosDeviceLocation(deviceId: $deviceId, stockLocationId: $stockLocationId, registerId: $registerId) { id stockLocationId registerId label status paired lastSeenAt mollieTerminalId createdAt updatedAt } }";
+export declare const CLEAR_POS_DEVICE_TERMINAL_MUTATION = "mutation ClearPosDeviceMollieTerminal($deviceId: ID!) { clearPosDeviceMollieTerminal(deviceId: $deviceId) { id stockLocationId registerId label status paired lastSeenAt mollieTerminalId createdAt updatedAt } }";
+export declare const POS_OPEN_SESSION_FOR_DEVICE_QUERY = "query PosOpenSessionForDevice($deviceId: ID!) { posOpenSessionForDevice(deviceId: $deviceId) { id registerId deviceId openedByStaffId openingFloat status expectedCash countedCash cashOverShort totals openedAt closedAt } }";
+export declare const CREATE_POS_DEVICE_MUTATION = "mutation CreatePosDevice($input: CreatePosDeviceInput!) { createPosDevice(input: $input) { id stockLocationId registerId label status paired lastSeenAt mollieTerminalId createdAt updatedAt } }";
+export declare const CREATE_POS_DEVICE_KIND_MUTATION = "mutation CreatePosDeviceOfKind($input: CreatePosDeviceInput!) { createPosDevice(input: $input) { id stockLocationId registerId label status paired lastSeenAt mollieTerminalId createdAt updatedAt kind } }";
+export declare const POS_DEVICE_FLEET_QUERY = "query PosDeviceFleet($stockLocationId: ID) { posDeviceFleet(stockLocationId: $stockLocationId) { device { id stockLocationId registerId label status paired lastSeenAt mollieTerminalId createdAt updatedAt heartbeatAt lockedAt silentSince kind } health { status lastHeardAt silentSince } report { appVersion buildNumber runtimeVersion updateId updateChannel platform connection outboxPending offlineSalesPending offlineSalesRefused printer reportedAt } openDrawer { sessionId registerId openedAt openedByStaffName } lockedByUserName } }";
+export declare const LOCK_POS_DEVICE_MUTATION = "mutation LockPosDevice($deviceId: ID!) { lockPosDevice(deviceId: $deviceId) { id stockLocationId registerId label status paired lastSeenAt mollieTerminalId createdAt updatedAt heartbeatAt lockedAt silentSince kind } }";
+export declare const UNLOCK_POS_DEVICE_MUTATION = "mutation UnlockPosDevice($deviceId: ID!) { unlockPosDevice(deviceId: $deviceId) { id stockLocationId registerId label status paired lastSeenAt mollieTerminalId createdAt updatedAt heartbeatAt lockedAt silentSince kind } }";
 export declare const POS_RECEIPT_NUMBERING_QUERY = "query PosReceiptNumberingConfig { posReceiptNumberingConfig { prefix suffix digits } }";
 export declare const UPDATE_POS_RECEIPT_NUMBERING_MUTATION = "mutation UpdatePosReceiptNumberingConfig($input: UpdatePosReceiptNumberingConfigInput!) { updatePosReceiptNumberingConfig(input: $input) { prefix suffix digits } }";
+export declare const POS_SETTINGS_QUERY = "query PosSettings { getPosConfig { enabled cashPaymentMethodCode cardPaymentMethodCode inStoreShippingMethodId defaultStockLocationId cashRoundingMode hasMollieKey maskedMollieApiKey } }";
+export declare const UPDATE_POS_SETTINGS_MUTATION = "mutation UpdatePosSettings($input: UpdatePosConfigInput!) { updatePosConfig(input: $input) { enabled cashPaymentMethodCode cardPaymentMethodCode inStoreShippingMethodId defaultStockLocationId cashRoundingMode hasMollieKey maskedMollieApiKey } }";
+export declare const POS_MOLLIE_TERMINALS_QUERY = "query PosMollieTerminals { posMollieTerminals { terminalId description status brand model serialNumber currency } }";
+export declare const POS_CASH_CONTROLS_QUERY = "query PosCashControls { getPosConfig { cashControls { blindCount varianceThreshold } } }";
+export declare const SET_POS_CASH_CONTROLS_MUTATION = "mutation SetPosCashControls($input: PosCashControlsInput!) { setPosCashControls(input: $input) { blindCount varianceThreshold } }";
+export declare const POS_RECEIPT_SETTINGS_QUERY = "query PosReceiptSettings { getPosConfig { receipt { configured showStoreName showAddress showPhone showVatNumber headerLines footerLines taxDisplay identity { storeName addressLines phone vatNumber registrationNumber } } } }";
+export declare const SET_POS_RECEIPT_SETTINGS_MUTATION = "mutation SetPosReceiptSettings($input: PosReceiptSettingsInput!) { setPosReceiptSettings(input: $input) { configured showStoreName showAddress showPhone showVatNumber headerLines footerLines taxDisplay identity { storeName addressLines phone vatNumber registrationNumber } } }";
+export declare const POS_RECEIPT_PREVIEW_QUERY = "query PosReceiptPreview($input: PosReceiptSettingsInput) { posReceiptPreview(input: $input) { 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 declare const POS_RECEIPT_QUERY = "query PosReceipt($orderId: ID!) { posReceipt(orderId: $orderId) { 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 declare const POS_RECEIPT_SHARING_QUERY = "query PosReceiptSharing($orderId: ID!) { posReceiptSharing(orderId: $orderId) { available enabled ttlDays links { variant state url issuedAt expiresAt revokedAt revokeReason } receiptCopies giftPrints } }";
+export declare const POS_ISSUE_RECEIPT_LINK_MUTATION = "mutation PosIssueReceiptLink($orderId: ID!, $variant: PosReceiptVariant!) { posIssueReceiptLink(orderId: $orderId, variant: $variant) { variant state url issuedAt expiresAt revokedAt revokeReason } }";
+export declare const REVOKE_POS_RECEIPT_LINK_MUTATION = "mutation RevokePosReceiptLink($orderId: ID!, $variant: PosReceiptVariant!) { revokePosReceiptLink(orderId: $orderId, variant: $variant) { variant state url issuedAt expiresAt revokedAt revokeReason } }";
+export declare const POS_PRINT_RECEIPT_MUTATION = "mutation PosPrintReceipt($input: PosPrintReceiptInput!, $staffToken: String) { posPrintReceipt(input: $input, staffToken: $staffToken) { orderId variant printNumber copy receipt { 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 link { variant url issuedAt expiresAt } copy { number printedAt } } giftReceipt { orderId orderCode receiptNumber issuedAt language locale timeZone header { storeName addressLines phone vatNumber registrationNumber extraLines } registerName lines { orderLineId name sku quantity } footerLines thankYou scanCode link { variant url issuedAt expiresAt } copy { number printedAt } } } }";
+export declare const POS_GIFT_RECEIPT_QUERY = "query PosGiftReceipt($orderId: ID!) { posReceipt(orderId: $orderId) { gift { orderId orderCode receiptNumber issuedAt language locale timeZone header { storeName addressLines phone vatNumber registrationNumber extraLines } registerName lines { orderLineId name sku quantity } footerLines thankYou scanCode link { variant url issuedAt expiresAt } copy { number printedAt } } } }";
+export declare const POS_DIGITAL_RECEIPTS_QUERY = "query PosDigitalReceipts { getPosConfig { receipt { publicLink publicLinkAvailable } } }";
+export declare const POS_RECEIPT_ACCOUNT_CLAIM_QUERY = "query PosReceiptAccountClaim { getPosConfig { receipt { accountClaim accountClaimAvailable } } }";
+export declare const POS_EMAIL_RECEIPT_MUTATION = "mutation PosEmailReceipt($input: PosEmailReceiptInput!, $staffToken: String) { posEmailReceipt(input: $input, staffToken: $staffToken) { orderId source sentForSale } }";
+export declare const POS_DAY_CONTROLS_QUERY = "query PosDayControls { getPosConfig { id dayControls { businessDayStartsAt closingTime autoCloseAfterClosingMinutes autoCloseIdleMinutes } } }";
+export declare const SET_POS_DAY_CONTROLS_MUTATION = "mutation SetPosDayControls($input: PosDayControlsInput!) { setPosDayControls(input: $input) { businessDayStartsAt closingTime autoCloseAfterClosingMinutes autoCloseIdleMinutes } }";
+export declare const POS_SETUP_READINESS_QUERY = "query PosSetupReadiness { posSetupReadiness { ready checks { check ok required reason } } }";
+export declare const POS_CUSTOM_ITEM_POLICY_QUERY = "query PosCustomItemPolicy { posCustomItemPolicy { enabled available maxUnitPrice cashierLimit amountsIncludeTax currencyCode taxCategories { id name taxRate } taxCategoryChoices { id name taxRate } } }";
+export declare const SET_POS_CUSTOM_ITEM_POLICY_MUTATION = "mutation SetPosCustomItemPolicy($input: PosCustomItemPolicyInput!) { setPosCustomItemPolicy(input: $input) { enabled available maxUnitPrice cashierLimit amountsIncludeTax currencyCode taxCategories { id name taxRate } taxCategoryChoices { id name taxRate } } }";
+export declare const POS_STAFF_LIST_QUERY = "query PosStaffList { posStaffList { id name role active administratorId locale createdAt updatedAt } }";
+export declare const POS_STAFF_QUERY = "query PosStaff($id: ID!) { posStaff(id: $id) { id name role active administratorId locale createdAt updatedAt } }";
+export declare const CREATE_POS_STAFF_MUTATION = "mutation CreatePosStaff($input: CreatePosStaffInput!) { createPosStaff(input: $input) { id name role active administratorId locale createdAt updatedAt } }";
+export declare const UPDATE_POS_STAFF_MUTATION = "mutation UpdatePosStaff($id: ID!, $input: UpdatePosStaffInput!) { updatePosStaff(id: $id, input: $input) { id name role active administratorId locale createdAt updatedAt } }";
+export declare const SET_POS_STAFF_PIN_MUTATION = "mutation SetPosStaffPin($id: ID!, $pin: String!) { setPosStaffPin(id: $id, pin: $pin) }";
+export declare const POS_STAFF_GRANTS_QUERY = "query PosStaffGrants($id: ID!) { posStaff(id: $id) { id role grants } }";
+export declare const POS_STAFF_GRANTS_LIST_QUERY = "query PosStaffGrantsList { posStaffList { id role grants } }";
+export declare const SET_POS_STAFF_GRANTS_MUTATION = "mutation SetPosStaffGrants($id: ID!, $grants: [PosStaffGrant!]!) { setPosStaffGrants(id: $id, grants: $grants) { id role grants } }";
 export declare function createPosModule(transport: Transport): PosModule;