@sixtyninecommerce/admin 0.10.0 → 0.12.0

package/dist/pos/no-receipt.d.ts

@@ -0,0 +1,94 @@
+import type { Transport } from '@sixtyninecommerce/core';
+import type { Call } from '../types.js';
+/**
+ * Returns without a receipt (POS engine sprint 21): goods come back with no sale to return them
+ * against, as a document of their own (`NR-000001`, never an order). Each line at its current
+ * catalogue price incl. tax (or a lower typed price), its tax reversed per line; the money goes to
+ * a named customer's store credit or, where the store allows it, out of a till's open drawer with a
+ * manager. Money is integer minor units of the store's currency.
+ *
+ * - `policy.get` / `policy.set`: the store's rules (off, cash off, no limits until saved). `set`
+ *   needs UpdateSettings; an omitted field keeps its value, null clears a limit. Refused
+ *   `POS_NO_RECEIPT_POLICY_INVALID` (`extensions.field`).
+ * - `quote`: what a return would do now (lines, tax, total, what today's cap still allows, the
+ *   cash to hand out). A read; why it cannot be done now is `blockedBy`, never thrown.
+ *
+ * The return itself (`posNoReceiptReturn`) is taken at a PAIRED TILL: it pays out of, and is
+ * counted in, that till's open drawer, so a headless till (a machine principal) is refused
+ * `POS_PRINCIPAL_REQUIRED` and this module offers no `create` yet.
+ */
+export type PosNoReceiptPayout = 'STORE_CREDIT' | 'CASH';
+export interface PosNoReceiptReturnPolicy {
+    enabled: boolean;
+    /** Cash may be paid out (always with a manager and a reason). */
+    cashAllowed: boolean;
+    /** Highest total of one return; null: none. */
+    maxPerReturn: number | null;
+    /** Highest total per day (the till location's zone), both payouts; null: none. */
+    dailyCap: number | null;
+    currencyCode: string;
+    /** The store can credit a customer's store credit (a stored-value method and the entitlement). */
+    storeCreditAvailable: boolean;
+}
+/** What `policy.set` changes: an omitted field keeps its value; null clears a limit. */
+export interface PosNoReceiptReturnPolicyInput {
+    enabled?: boolean;
+    cashAllowed?: boolean;
+    maxPerReturn?: number | null;
+    dailyCap?: number | null;
+}
+export interface PosNoReceiptQuoteInput {
+    lines?: Array<{
+        variantId: string;
+        quantity: number;
+        unitPriceWithTax?: number;
+    }>;
+    customerId?: string;
+    /** Omitted: STORE_CREDIT. */
+    payout?: PosNoReceiptPayout;
+}
+export interface PosNoReceiptLine {
+    variantId: string;
+    name: string;
+    sku: string;
+    quantity: number;
+    catalogueUnitPriceWithTax: number;
+    unitPriceWithTax: number;
+    lineTotal: number;
+    /** Percent. */
+    taxRate: number;
+    lineTax: number;
+    restockable: boolean;
+    reasonCode: string | null;
+    restock: boolean | null;
+}
+export interface PosNoReceiptQuote {
+    currencyCode: string;
+    lines: PosNoReceiptLine[];
+    total: number;
+    tax: number;
+    taxSummary: Array<{
+        taxRate: number;
+        base: number;
+        tax: number;
+    }>;
+    policy: PosNoReceiptReturnPolicy;
+    remainingToday: number | null;
+    cashPaidOut: number;
+    restockLocationName: string | null;
+    /** A POS_NO_RECEIPT_* code (or POS_SESSION_REQUIRED), or null. More may come. */
+    blockedBy: string | null;
+    blockedReason: string | null;
+}
+export interface PosNoReceiptModule {
+    policy: {
+        get(options?: Call): Promise<PosNoReceiptReturnPolicy>;
+        set(input: PosNoReceiptReturnPolicyInput, options?: Call): Promise<PosNoReceiptReturnPolicy>;
+    };
+    /** What a return without a receipt would do now. Writes nothing. */
+    quote(input: PosNoReceiptQuoteInput, options?: Call): Promise<PosNoReceiptQuote>;
+}
+export declare const POS_NO_RECEIPT_RETURN_POLICY_QUERY = "query PosNoReceiptReturnPolicy { posNoReceiptReturnPolicy { enabled cashAllowed maxPerReturn dailyCap currencyCode storeCreditAvailable } }";
+export declare const SET_POS_NO_RECEIPT_RETURN_POLICY_MUTATION = "mutation SetPosNoReceiptReturnPolicy($input: PosNoReceiptReturnPolicyInput!) { setPosNoReceiptReturnPolicy(input: $input) { enabled cashAllowed maxPerReturn dailyCap currencyCode storeCreditAvailable } }";
+export declare const POS_NO_RECEIPT_RETURN_QUOTE_QUERY = "query PosNoReceiptReturnQuote($input: PosNoReceiptQuoteInput!) { posNoReceiptReturnQuote(input: $input) { currencyCode lines { variantId name sku quantity catalogueUnitPriceWithTax unitPriceWithTax lineTotal taxRate lineTax restockable reasonCode restock } total tax taxSummary { taxRate base tax } policy { enabled cashAllowed maxPerReturn dailyCap currencyCode storeCreditAvailable } remainingToday cashPaidOut restockLocationName blockedBy blockedReason } }";
+export declare function createPosNoReceiptModule(transport: Transport): PosNoReceiptModule;

package/dist/pos/no-receipt.js

@@ -0,0 +1,25 @@
+const POLICY_FIELDS = 'enabled cashAllowed maxPerReturn dailyCap currencyCode storeCreditAvailable';
+const LINE_FIELDS = 'variantId name sku quantity catalogueUnitPriceWithTax unitPriceWithTax lineTotal taxRate lineTax restockable reasonCode restock';
+export const POS_NO_RECEIPT_RETURN_POLICY_QUERY = `query PosNoReceiptReturnPolicy { posNoReceiptReturnPolicy { ${POLICY_FIELDS} } }`;
+export const SET_POS_NO_RECEIPT_RETURN_POLICY_MUTATION = `mutation SetPosNoReceiptReturnPolicy($input: PosNoReceiptReturnPolicyInput!) { setPosNoReceiptReturnPolicy(input: $input) { ${POLICY_FIELDS} } }`;
+export const POS_NO_RECEIPT_RETURN_QUOTE_QUERY = `query PosNoReceiptReturnQuote($input: PosNoReceiptQuoteInput!) { posNoReceiptReturnQuote(input: $input) { currencyCode lines { ${LINE_FIELDS} } total tax taxSummary { taxRate base tax } policy { ${POLICY_FIELDS} } remainingToday cashPaidOut restockLocationName blockedBy blockedReason } }`;
+export function createPosNoReceiptModule(transport) {
+    const gql = async (query, variables, options) => transport.graphql({ api: 'admin', query, variables }, options);
+    return {
+        policy: {
+            async get(options) {
+                const data = await gql(POS_NO_RECEIPT_RETURN_POLICY_QUERY, {}, options);
+                return data.posNoReceiptReturnPolicy;
+            },
+            async set(input, options) {
+                // Sent as given: an omitted field keeps its value, an explicit null clears a limit.
+                const data = await gql(SET_POS_NO_RECEIPT_RETURN_POLICY_MUTATION, { input: { ...input } }, options);
+                return data.setPosNoReceiptReturnPolicy;
+            },
+        },
+        async quote(input, options) {
+            const data = await gql(POS_NO_RECEIPT_RETURN_QUOTE_QUERY, { input }, options);
+            return data.posNoReceiptReturnQuote;
+        },
+    };
+}

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

@@ -0,0 +1,228 @@
+import { type Page, type Transport } from '@sixtyninecommerce/core';
+import type { Call, ListOptions } from '../types.js';
+/**
+ * Offline cash sales (engine sprint 45, shipped dark): a till that loses its connection may keep
+ * selling for cash, within the store's limits, and sends each sale when it is back. The engine
+ * records each sale once, at the prices the till charged, into the drawer it was rung in; a sale
+ * it cannot record as rung waits for a manager.
+ *
+ * - `admin.pos.settings.offlineCashSales()` / `setOfflineCashSales(input)`: the store's switch
+ *   (off by default) and its three limits, with whether the store can sell offline now.
+ * - `admin.pos.offlineSales.list` / `resolve`: the manager's queue. `needs_review` (recorded, a
+ *   reason to look at) and `refused` (nothing recorded but the row) wait until a manager marks
+ *   them handled with a note; `recorded` needs nobody.
+ * - `admin.pos.devices.offlineSalesToReview()`: how many of each device's offline sales wait.
+ *
+ * The replay itself (`posRecordOfflineSale`) is a paired till's door alone: a machine principal
+ * is online by nature, so this SDK offers no method for it. An engine before 45 answers every
+ * call here `GRAPHQL_VALIDATION_FAILED` (or a 400 the transport reports as `BAD_REQUEST`); each
+ * is a document of its own, so every other call keeps working there.
+ */
+/**
+ * The bounds of each limit, both inclusive, and the engine's default for a store that never saved
+ * them. Money in minor units of the store's default currency; minutes count from the server's
+ * last answer to the till. Outside the bounds the save is refused `POS_OFFLINE_POLICY_INVALID`.
+ */
+export declare const POS_OFFLINE_CASH_SALES_LIMITS: {
+    readonly maxSaleAmount: {
+        readonly min: 100;
+        readonly max: 500000;
+        readonly default: 10000;
+    };
+    readonly maxSalesPerOutage: {
+        readonly min: 1;
+        readonly max: 200;
+        readonly default: 25;
+    };
+    readonly maxOfflineMinutes: {
+        readonly min: 15;
+        readonly max: 720;
+        readonly default: 240;
+    };
+};
+/** What a manager writes when marking an offline sale handled: 1 to this many characters, trimmed. */
+export declare const POS_OFFLINE_SALE_NOTE_MAX_LENGTH = 500;
+/** Why a store cannot sell offline now, in the order the engine lists them. More may come. */
+export declare const POS_OFFLINE_NOT_READY_REASONS: readonly ["prices_exclude_tax", "automatic_promotions", "no_cash_method", "pos_disabled"];
+export type PosOfflineNotReadyReason = (typeof POS_OFFLINE_NOT_READY_REASONS)[number];
+/**
+ * Why the engine refused or flagged an offline sale, in the order an answer lists them: the
+ * refusals first (`item_gone` to `price_over_limit`: nothing was recorded but the row), then the
+ * reviews (`price_changed` to `sold_at_suspect`: the sale is recorded). More may come.
+ */
+export declare const POS_OFFLINE_SALE_REASONS: readonly ["item_gone", "drawer_closed", "currency_changed", "prices_exclude_tax", "out_of_stock", "gift_card", "total_mismatch", "rounding_mismatch", "price_over_limit", "price_changed", "not_fulfilled", "cashier_changed", "policy_off", "over_cap", "sold_at_suspect", "cashier_unverified", "item_gone_stand_in", "stock_short_stand_in", "total_corrected", "rounding_as_rung"];
+export type PosOfflineSaleReason = (typeof POS_OFFLINE_SALE_REASONS)[number];
+/**
+ * The reasons the engine REFUSES a sale for (nothing recorded but its row): `item_gone` to
+ * `price_over_limit`. Every other reason is a review of a recorded sale. A reason this release does
+ * not know is neither: show it as it is.
+ */
+export declare const POS_OFFLINE_SALE_REFUSAL_REASONS: readonly PosOfflineSaleReason[];
+/**
+ * `recorded` (the order, the cash and the receipt number exist, as the till rang it),
+ * `needs_review` (recorded, with a reason to look at) or `refused` (nothing but this row). More
+ * may come: show an unknown status as it is.
+ */
+export type PosOfflineSaleStatus = 'recorded' | 'needs_review' | 'refused';
+/** A store's offline cash sales (engine sprint 45): the switch, its limits, and its readiness. */
+export interface PosOfflineCashSales {
+    /** Off until a manager turns it on. */
+    enabled: boolean;
+    /** The largest offline sale, minor units of the store's default currency. */
+    maxSaleAmount: number;
+    /** Offline sales a till makes in one outage. */
+    maxSalesPerOutage: number;
+    /** Minutes after the server last answered that a till still sells offline. */
+    maxOfflineMinutes: number;
+    /** Whether this store can sell offline now: switched on is not enough. */
+    ready: boolean;
+    /** Why not; empty when ready. Strings, so a reason a newer engine adds never fails a read. */
+    notReadyReasons: Array<PosOfflineNotReadyReason | (string & {})>;
+}
+/** What `setOfflineCashSales` stores: every field, each within {@link POS_OFFLINE_CASH_SALES_LIMITS}. */
+export interface PosOfflineCashSalesInput {
+    enabled: boolean;
+    maxSaleAmount: number;
+    maxSalesPerOutage: number;
+    maxOfflineMinutes: number;
+}
+/** One line of an offline sale: what the till charged, and the server's price beside it. */
+export interface PosOfflineSaleLine {
+    variantId: string;
+    quantity: number;
+    /** The unit price with tax the till charged, minor units. */
+    unitPriceWithTax: number;
+    /**
+     * The server's unit price with tax when the sale was recorded; null when the variant was gone or
+     * the sale was refused before it was built.
+     */
+    serverUnitPriceWithTax: number | null;
+}
+/** An offline sale as the engine recorded or refused it (engine sprint 45). Money in minor units. */
+export interface PosOfflineSale {
+    id: string;
+    deviceId: string;
+    /** The till's name as the store names it now; null when it is gone. */
+    deviceLabel: string | null;
+    /** The drawer the till had open when it sold. */
+    registerSessionId: string;
+    /** The till's own id for the sale (a uuid). */
+    offlineSaleId: string;
+    /** The number printed on the provisional receipt the customer took. */
+    provisionalReceiptNumber: string;
+    /** When the till completed it, by the till's clock. */
+    soldAt: string;
+    /** When the engine received it. */
+    recordedAt: string;
+    status: PosOfflineSaleStatus | (string & {});
+    /** {@link PosOfflineSaleReason}s; strings, so one a newer engine adds never fails a read. */
+    reasons: Array<PosOfflineSaleReason | (string & {})>;
+    /** The order it became; null when refused. */
+    orderId: string | null;
+    orderCode: string | null;
+    /** The final receipt number; null when refused. */
+    receiptNumber: string | null;
+    currencyCode: string;
+    totalWithTax: number;
+    cashTendered: number;
+    changeGiven: number;
+    /** The cash rounding the till applied, signed. */
+    cashRounding: number;
+    lines: PosOfflineSaleLine[];
+    /** The cashier signed in when the till sent it (verified), as the store names them now. */
+    staffName: string | null;
+    /** The cashier the till says rang it up: its claim. */
+    claimedStaffName: string | null;
+    /** When a manager marked it handled; null while it waits (or for a `recorded` sale). */
+    resolvedAt: string | null;
+    resolvedByUserName: string | null;
+    /** What the manager wrote they did about it. Staff text. */
+    resolutionNote: string | null;
+    /**
+     * When a manager recorded it again (engine with POS polish PR 6), and their name now. Answered
+     * by `recordAgain` and `list` (an engine before PR 6 answers its list without them: absent);
+     * absent from `resolve`.
+     */
+    recordedAgainAt?: string | null;
+    recordedAgainByUserName?: string | null;
+    /**
+     * The drawer the sale's cash went into once recorded (its order's): the one it was rung in, or
+     * the one a manager recorded it again into (engine with POS polish PR 6); null while nothing is
+     * recorded, absent from an older engine (link `registerSessionId` then).
+     */
+    cashRegisterSessionId?: string | null;
+}
+/** `open` (the default): the sales a manager must still handle; `all`: every offline sale. */
+export type PosOfflineSaleFilter = 'open' | 'all';
+export interface PosOfflineSaleListOptions extends ListOptions {
+    filter?: PosOfflineSaleFilter;
+    /** One device's sales. */
+    deviceId?: string;
+}
+/** How many of a device's offline sales wait for a manager (the fleet's `offlineSalesToReview`). */
+export interface PosDeviceOfflineSalesToReview {
+    deviceId: string;
+    /** `needs_review` or `refused`, not yet handled. */
+    offlineSalesToReview: number;
+}
+export interface PosOfflineSalesModule {
+    /**
+     * The store's offline sales, newest first (`posOfflineSales`). `filter: 'open'` (the default)
+     * keeps the ones a manager must still handle (`needs_review` or `refused`, not yet handled);
+     * `'all'` every one. `deviceId` keeps one device's. `limit` is at most 100 (50 when omitted);
+     * `after` is the previous page's cursor; `total` counts the whole filter. A location-restricted
+     * caller sees the tills at its locations only. Refused `POS_LIST_RANGE_INVALID`
+     * (`extensions.field`, `reason`). Needs `UpdateSettings` or `ManagePosDevices`.
+     */
+    list(options?: PosOfflineSaleListOptions): Promise<Page<PosOfflineSale>>;
+    /**
+     * Mark an offline sale handled, with what was done about it (`note`: 1 to 500 characters once
+     * trimmed, no control character but a line break or a tab). Nothing is recorded again: fix the
+     * order, the stock or the drawer first, then say so here. Idempotent by state: the same note
+     * again answers the sale unchanged. Refused `POS_OFFLINE_NOTE_INVALID` (`ValidationError`,
+     * `details[0].field` `note`), `POS_OFFLINE_SALE_NOT_FOUND` (`NotFoundError`: another store's, a
+     * till the caller may not see, an unknown id, or a `recorded` sale, which needs nobody) and
+     * `POS_OFFLINE_SALE_RESOLVED` (`BusinessRuleError`, `extensions.resolvedAt`: already handled
+     * with another note). Needs `UpdateSettings` or `ManagePosDevices`.
+     */
+    resolve(input: {
+        id: string;
+        note: string;
+    }, options?: Call): Promise<PosOfflineSale>;
+    /**
+     * Record a REFUSED offline sale again (engine with POS polish PR 6): the engine builds it the
+     * way the till's replay does, into the sale's own drawer while that is open, else the open drawer
+     * `registerSessionId` names (ignored while the own one is open); it is attributed to the caller
+     * (`recordedAgainAt`, `recordedAgainByUserName`). A sale refused again stays `refused` with its new
+     * reasons; one recorded again already answers as it is. Refused `POS_OFFLINE_SALE_NOT_FOUND`
+     * (`NotFoundError`: another store's, a till the caller may not see, an unknown id, or a sale that
+     * is not refused) and `POS_OFFLINE_SALE_DRAWER_INVALID` (`ValidationError`,
+     * `extensions.registerSessionId`: the own drawer is closed and none, or no open drawer of the
+     * store, was named) and `LOCATION_NOT_ALLOWED` (`PermissionDeniedError`: the drawer, the sale's
+     * own or the one named, stands at a location a location-restricted caller may not act at).
+     * Needs `UpdateSettings` or `ManagePosDevices`, and `CreateOrder` (it records an order and its
+     * cash). An engine before PR 6 refuses the document.
+     */
+    recordAgain(input: {
+        id: string;
+        registerSessionId?: string;
+    }, options?: Call): Promise<PosOfflineSale>;
+}
+export declare const POS_OFFLINE_CASH_SALES_QUERY = "query PosOfflineCashSales { getPosConfig { offlineCashSales { enabled maxSaleAmount maxSalesPerOutage maxOfflineMinutes ready notReadyReasons } } }";
+export declare const SET_POS_OFFLINE_CASH_SALES_MUTATION = "mutation SetPosOfflineCashSales($input: PosOfflineCashSalesInput!) { setPosOfflineCashSales(input: $input) { enabled maxSaleAmount maxSalesPerOutage maxOfflineMinutes ready notReadyReasons } }";
+/** The list, naming who recorded a sale again (engine POS polish PR 6). */
+export declare const POS_OFFLINE_SALES_QUERY = "query PosOfflineSales($input: PosOfflineSaleListInput) { posOfflineSales(input: $input) { items { id deviceId deviceLabel registerSessionId offlineSaleId provisionalReceiptNumber soldAt recordedAt status reasons orderId orderCode receiptNumber currencyCode totalWithTax cashTendered changeGiven cashRounding lines { variantId quantity unitPriceWithTax serverUnitPriceWithTax } staffName claimedStaffName resolvedAt resolvedByUserName resolutionNote recordedAgainAt recordedAgainByUserName cashRegisterSessionId } totalItems } }";
+/** The list as an engine before PR 6 reads it: sent once that engine refused the fields. */
+export declare const POS_OFFLINE_SALES_QUERY_BEFORE_RECORD_AGAIN = "query PosOfflineSales($input: PosOfflineSaleListInput) { posOfflineSales(input: $input) { items { id deviceId deviceLabel registerSessionId offlineSaleId provisionalReceiptNumber soldAt recordedAt status reasons orderId orderCode receiptNumber currencyCode totalWithTax cashTendered changeGiven cashRounding lines { variantId quantity unitPriceWithTax serverUnitPriceWithTax } staffName claimedStaffName resolvedAt resolvedByUserName resolutionNote } totalItems } }";
+export declare const RESOLVE_POS_OFFLINE_SALE_MUTATION = "mutation ResolvePosOfflineSale($input: ResolvePosOfflineSaleInput!) { resolvePosOfflineSale(input: $input) { id deviceId deviceLabel registerSessionId offlineSaleId provisionalReceiptNumber soldAt recordedAt status reasons orderId orderCode receiptNumber currencyCode totalWithTax cashTendered changeGiven cashRounding lines { variantId quantity unitPriceWithTax serverUnitPriceWithTax } staffName claimedStaffName resolvedAt resolvedByUserName resolutionNote } }";
+export declare const RECORD_POS_OFFLINE_SALE_AGAIN_MUTATION = "mutation RecordPosOfflineSaleAgain($input: RecordPosOfflineSaleAgainInput!) { recordPosOfflineSaleAgain(input: $input) { id deviceId deviceLabel registerSessionId offlineSaleId provisionalReceiptNumber soldAt recordedAt status reasons orderId orderCode receiptNumber currencyCode totalWithTax cashTendered changeGiven cashRounding lines { variantId quantity unitPriceWithTax serverUnitPriceWithTax } staffName claimedStaffName resolvedAt resolvedByUserName resolutionNote recordedAgainAt recordedAgainByUserName cashRegisterSessionId } }";
+export declare const POS_DEVICE_OFFLINE_SALES_TO_REVIEW_QUERY = "query PosDeviceOfflineSalesToReview($stockLocationId: ID) { posDeviceFleet(stockLocationId: $stockLocationId) { device { id } offlineSalesToReview } }";
+/** `admin.pos.settings.offlineCashSales()`: null when POS was never set up. */
+export declare function readOfflineCashSales(transport: Transport, options?: Call): Promise<PosOfflineCashSales | null>;
+/** `admin.pos.settings.setOfflineCashSales(input)`: the four fields, as given. */
+export declare function writeOfflineCashSales(transport: Transport, input: PosOfflineCashSalesInput, options?: Call): Promise<PosOfflineCashSales>;
+/** `admin.pos.devices.offlineSalesToReview()`: one row per device the fleet lists, whole. */
+export declare function readOfflineSalesToReview(transport: Transport, options?: {
+    stockLocationId?: string;
+} & Call): Promise<PosDeviceOfflineSalesToReview[]>;
+export declare function createPosOfflineSalesModule(transport: Transport): PosOfflineSalesModule;

package/dist/pos/offline-sales.js

@@ -0,0 +1,170 @@
+import { pageFromVendureList, readOffsetCursor, } from '@sixtyninecommerce/core';
+import { isUnknownFieldRejection } from '../payments/store-credit-fields.js';
+/**
+ * Offline cash sales (engine sprint 45, shipped dark): a till that loses its connection may keep
+ * selling for cash, within the store's limits, and sends each sale when it is back. The engine
+ * records each sale once, at the prices the till charged, into the drawer it was rung in; a sale
+ * it cannot record as rung waits for a manager.
+ *
+ * - `admin.pos.settings.offlineCashSales()` / `setOfflineCashSales(input)`: the store's switch
+ *   (off by default) and its three limits, with whether the store can sell offline now.
+ * - `admin.pos.offlineSales.list` / `resolve`: the manager's queue. `needs_review` (recorded, a
+ *   reason to look at) and `refused` (nothing recorded but the row) wait until a manager marks
+ *   them handled with a note; `recorded` needs nobody.
+ * - `admin.pos.devices.offlineSalesToReview()`: how many of each device's offline sales wait.
+ *
+ * The replay itself (`posRecordOfflineSale`) is a paired till's door alone: a machine principal
+ * is online by nature, so this SDK offers no method for it. An engine before 45 answers every
+ * call here `GRAPHQL_VALIDATION_FAILED` (or a 400 the transport reports as `BAD_REQUEST`); each
+ * is a document of its own, so every other call keeps working there.
+ */
+/**
+ * The bounds of each limit, both inclusive, and the engine's default for a store that never saved
+ * them. Money in minor units of the store's default currency; minutes count from the server's
+ * last answer to the till. Outside the bounds the save is refused `POS_OFFLINE_POLICY_INVALID`.
+ */
+export const POS_OFFLINE_CASH_SALES_LIMITS = {
+    maxSaleAmount: { min: 100, max: 500_000, default: 10_000 },
+    maxSalesPerOutage: { min: 1, max: 200, default: 25 },
+    maxOfflineMinutes: { min: 15, max: 720, default: 240 },
+};
+/** What a manager writes when marking an offline sale handled: 1 to this many characters, trimmed. */
+export const POS_OFFLINE_SALE_NOTE_MAX_LENGTH = 500;
+/** Why a store cannot sell offline now, in the order the engine lists them. More may come. */
+export const POS_OFFLINE_NOT_READY_REASONS = [
+    'prices_exclude_tax',
+    'automatic_promotions',
+    'no_cash_method',
+    'pos_disabled',
+];
+/**
+ * Why the engine refused or flagged an offline sale, in the order an answer lists them: the
+ * refusals first (`item_gone` to `price_over_limit`: nothing was recorded but the row), then the
+ * reviews (`price_changed` to `sold_at_suspect`: the sale is recorded). More may come.
+ */
+export const POS_OFFLINE_SALE_REASONS = [
+    'item_gone',
+    'drawer_closed',
+    'currency_changed',
+    'prices_exclude_tax',
+    'out_of_stock',
+    'gift_card',
+    'total_mismatch',
+    'rounding_mismatch',
+    'price_over_limit',
+    'price_changed',
+    'not_fulfilled',
+    'cashier_changed',
+    'policy_off',
+    'over_cap',
+    'sold_at_suspect',
+    'cashier_unverified',
+    'item_gone_stand_in',
+    'stock_short_stand_in',
+    'total_corrected',
+    'rounding_as_rung',
+];
+/**
+ * The reasons the engine REFUSES a sale for (nothing recorded but its row): `item_gone` to
+ * `price_over_limit`. Every other reason is a review of a recorded sale. A reason this release does
+ * not know is neither: show it as it is.
+ */
+export const POS_OFFLINE_SALE_REFUSAL_REASONS = [
+    'item_gone',
+    'drawer_closed',
+    'currency_changed',
+    'prices_exclude_tax',
+    'out_of_stock',
+    'gift_card',
+    'total_mismatch',
+    'rounding_mismatch',
+    'price_over_limit',
+];
+const DEFAULT_PAGE = 50;
+const MAX_PAGE = 100;
+const POLICY_FIELDS = 'enabled maxSaleAmount maxSalesPerOutage maxOfflineMinutes ready notReadyReasons';
+const SALE_FIELDS = 'id deviceId deviceLabel registerSessionId offlineSaleId provisionalReceiptNumber soldAt recordedAt status reasons orderId orderCode receiptNumber currencyCode totalWithTax cashTendered changeGiven cashRounding lines { variantId quantity unitPriceWithTax serverUnitPriceWithTax } staffName claimedStaffName resolvedAt resolvedByUserName resolutionNote';
+export const POS_OFFLINE_CASH_SALES_QUERY = `query PosOfflineCashSales { getPosConfig { offlineCashSales { ${POLICY_FIELDS} } } }`;
+export const SET_POS_OFFLINE_CASH_SALES_MUTATION = `mutation SetPosOfflineCashSales($input: PosOfflineCashSalesInput!) { setPosOfflineCashSales(input: $input) { ${POLICY_FIELDS} } }`;
+/** The list, naming who recorded a sale again (engine POS polish PR 6). */
+export const POS_OFFLINE_SALES_QUERY = `query PosOfflineSales($input: PosOfflineSaleListInput) { posOfflineSales(input: $input) { items { ${SALE_FIELDS} recordedAgainAt recordedAgainByUserName cashRegisterSessionId } totalItems } }`;
+/** The list as an engine before PR 6 reads it: sent once that engine refused the fields. */
+export const POS_OFFLINE_SALES_QUERY_BEFORE_RECORD_AGAIN = `query PosOfflineSales($input: PosOfflineSaleListInput) { posOfflineSales(input: $input) { items { ${SALE_FIELDS} } totalItems } }`;
+export const RESOLVE_POS_OFFLINE_SALE_MUTATION = `mutation ResolvePosOfflineSale($input: ResolvePosOfflineSaleInput!) { resolvePosOfflineSale(input: $input) { ${SALE_FIELDS} } }`;
+// Engine POS polish PR 6: only this document selects who recorded it again.
+export const RECORD_POS_OFFLINE_SALE_AGAIN_MUTATION = `mutation RecordPosOfflineSaleAgain($input: RecordPosOfflineSaleAgainInput!) { recordPosOfflineSaleAgain(input: $input) { ${SALE_FIELDS} recordedAgainAt recordedAgainByUserName cashRegisterSessionId } }`;
+// The fleet's count beside the device's id alone, its own document: the fleet read
+// (`POS_DEVICE_FLEET_QUERY`) never names it, so an engine before 45 keeps answering the fleet.
+export const POS_DEVICE_OFFLINE_SALES_TO_REVIEW_QUERY = 'query PosDeviceOfflineSalesToReview($stockLocationId: ID) { posDeviceFleet(stockLocationId: $stockLocationId) { device { id } offlineSalesToReview } }';
+function gqlOf(transport) {
+    return async (query, variables, options) => transport.graphql({ api: 'admin', query, variables }, options);
+}
+/** `admin.pos.settings.offlineCashSales()`: null when POS was never set up. */
+export async function readOfflineCashSales(transport, options) {
+    const data = await gqlOf(transport)(POS_OFFLINE_CASH_SALES_QUERY, {}, options);
+    return data.getPosConfig?.offlineCashSales ?? null;
+}
+/** `admin.pos.settings.setOfflineCashSales(input)`: the four fields, as given. */
+export async function writeOfflineCashSales(transport, input, options) {
+    const { enabled, maxSaleAmount, maxSalesPerOutage, maxOfflineMinutes } = input;
+    const data = await gqlOf(transport)(SET_POS_OFFLINE_CASH_SALES_MUTATION, { input: { enabled, maxSaleAmount, maxSalesPerOutage, maxOfflineMinutes } }, options);
+    return data.setPosOfflineCashSales;
+}
+/** `admin.pos.devices.offlineSalesToReview()`: one row per device the fleet lists, whole. */
+export async function readOfflineSalesToReview(transport, options) {
+    const data = await gqlOf(transport)(POS_DEVICE_OFFLINE_SALES_TO_REVIEW_QUERY, { stockLocationId: options?.stockLocationId ?? null }, options);
+    return data.posDeviceFleet.map((row) => ({
+        deviceId: row.device.id,
+        offlineSalesToReview: row.offlineSalesToReview,
+    }));
+}
+export function createPosOfflineSalesModule(transport) {
+    const gql = gqlOf(transport);
+    // An engine before PR 6 refused the list's record-again fields once: every later page asks
+    // without them (one refused request per module, not per page).
+    let listBeforeRecordAgain = false;
+    async function listDocument(variables, options) {
+        if (!listBeforeRecordAgain) {
+            try {
+                return await gql(POS_OFFLINE_SALES_QUERY, variables, options);
+            }
+            catch (error) {
+                // Refused before it ran: the same read without the fields. Any other failure is the read's.
+                if (!isUnknownFieldRejection(error))
+                    throw error;
+                listBeforeRecordAgain = true;
+            }
+        }
+        return gql(POS_OFFLINE_SALES_QUERY_BEFORE_RECORD_AGAIN, variables, options);
+    }
+    async function salePage(skip, take, options) {
+        const input = { skip, take };
+        if (options?.filter !== undefined)
+            input.filter = options.filter;
+        if (options?.deviceId !== undefined)
+            input.deviceId = options.deviceId;
+        const data = await listDocument({ input }, options);
+        return pageFromVendureList(data.posOfflineSales, skip, take, (cursor) => salePage(readOffsetCursor(cursor), take, options));
+    }
+    return {
+        async list(options) {
+            const take = Math.min(Math.max(Math.trunc(options?.limit ?? DEFAULT_PAGE), 1), MAX_PAGE);
+            const skip = options?.after === undefined ? 0 : readOffsetCursor(options.after);
+            return salePage(skip, take, options);
+        },
+        async resolve(input, options) {
+            // Sent as given: the engine trims and judges the note (POS_OFFLINE_NOTE_INVALID).
+            const data = await gql(RESOLVE_POS_OFFLINE_SALE_MUTATION, { input: { id: input.id, note: input.note } }, options);
+            return data.resolvePosOfflineSale;
+        },
+        async recordAgain(input, options) {
+            const data = await gql(RECORD_POS_OFFLINE_SALE_AGAIN_MUTATION, {
+                input: {
+                    id: input.id,
+                    ...(input.registerSessionId ? { registerSessionId: input.registerSessionId } : {}),
+                },
+            }, options);
+            return data.recordPosOfflineSaleAgain;
+        },
+    };
+}