@sixtyninecommerce/admin 0.8.0 → 0.10.0

package/dist/pos/index.d.ts

@@ -0,0 +1,567 @@
+import { type Page, type Transport } from '@sixtyninecommerce/core';
+import type { Call } from '../types.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 —
+ * with no paired tablet.
+ *
+ * ## The credential and the place
+ *
+ * Mint an API token with the **`pos` template** (permission `OperatePos`) and
+ * restrict it to the stock location it sells from (`locationIds`). Every call
+ * then needs `TenantContext.location` set to that location — the SDK sends it as
+ * `x-location`, the server verifies it belongs to the store and to the token's
+ * restriction, and the SALE DEBITS THAT LOCATION'S STOCK. A till is never given
+ * a default location: without one every call is refused
+ * `POS_LOCATION_REQUIRED`. A location-restricted token cannot operate at another
+ * location (`LOCATION_NOT_ALLOWED` at the door; `POS_LOCATION_MISMATCH` for a
+ * cart, register or session that stands somewhere else).
+ *
+ * A `pos` token cannot change the store's POS settings: `updatePosConfig`
+ * stays on `UpdateSettings`. Managing the estate (`devices`, creating
+ * `registers`, `receiptNumbering.set`) needs `ManagePosDevices`, which the
+ * template deliberately leaves out.
+ *
+ * ## Who acted
+ *
+ * A machine credential has no cashier PIN. Send the person as
+ * `TenantContext.actor` (`staffRef` → `x-on-behalf-of`, and your own `deviceRef`
+ * / `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.
+ *
+ * ## Money
+ *
+ * Integer minor units of the order's currency, everywhere. **Every money method
+ * requires `{ idempotencyKey }`**: a retry under the same key returns the first
+ * call's result instead of moving the money again. Use a fresh key per intended
+ * operation (a UUIDv7 is ideal) and reuse it only to retry that operation.
+ *
+ * The flow: `sessions.open` on a register → `sale.createCart({ registerId })`
+ * → `sale.addItem` → `tenders.cash` / `tenders.card` → `sale.complete` →
+ * `sessions.xReport` → `sessions.close` (the Z) → `sessions.zReport`.
+ *
+ * ## Which orders a till may act on
+ *
+ * An order id of another store is not found (`ENTITY_NOT_FOUND`), exactly as an
+ * id that does not exist, on every method that takes one. Within the store:
+ *
+ * - the cart methods (`sale.addItem`, `sale.applyDiscount`) change only an OPEN
+ *   till cart, one a till opened with `sale.createCart` that is not yet placed,
+ *   at your location. A shopper's cart, a back-office or order-entry draft and
+ *   every placed order (a completed till sale included) are refused
+ *   `POS_ORDER_NOT_EDITABLE`, and nothing is changed: start a new cart;
+ * - 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.
+ */
+export interface PosModule {
+    registers: PosRegistersModule;
+    sessions: PosSessionsModule;
+    cash: PosCashModule;
+    sale: PosSaleModule;
+    tenders: PosTendersModule;
+    refunds: PosRefundsModule;
+    devices: PosDevicesModule;
+    receiptNumbering: PosReceiptNumberingModule;
+}
+/**
+ * A money call: the key is REQUIRED, not optional. The server claims it before
+ * the work runs: a repeat of a finished call returns the first result, and a
+ * repeat while the first is still running is refused `IDEMPOTENCY_IN_PROGRESS`
+ * (retry shortly with the SAME key).
+ */
+export type PosMoneyCall = Call & {
+    idempotencyKey: string;
+};
+/**
+ * Options for a till call. `staffToken` is a paired DEVICE's cashier PIN
+ * session; a machine principal omits it and sends `tenant.actor` instead.
+ */
+export type PosCall = Call & {
+    staffToken?: string;
+};
+export interface PosRegister {
+    id: string;
+    stockLocationId: string;
+    name: string;
+    /** `active`, or whatever the merchant retired it as. Only an active register opens a session. */
+    status: string;
+    createdAt: string;
+    updatedAt: string;
+}
+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.
+     */
+    list(options?: Call): Promise<Page<PosRegister>>;
+    /** One register, or null (also for another location's register, to a principal). */
+    get(id: string, options?: Call): Promise<PosRegister | null>;
+    /** Needs `ManagePosDevices` (or `UpdateSettings`). */
+    create(input: {
+        name: string;
+        stockLocationId: string;
+    }, options?: Call): Promise<PosRegister>;
+    /** Needs `ManagePosDevices` (or `UpdateSettings`). */
+    update(id: string, input: {
+        name?: string;
+        status?: string;
+    }, options?: Call): Promise<PosRegister>;
+}
+export interface PosSessionTotals {
+    /** Cash taken in sales, minor units. */
+    cash: number;
+    /** Card and other tenders are reconciled from payments, not the drawer: always 0 here. */
+    card: number;
+    other: number;
+    refunds: number;
+    net: number;
+    saleCount: number;
+}
+/** A register session: one drawer, from its opening float to its Z. */
+export interface PosRegisterSession {
+    id: string;
+    registerId: string;
+    /** The paired tablet that opened it; null when a machine principal did. */
+    deviceId: string | null;
+    /** The cashier's PIN session; null when a machine principal opened it. */
+    openedByStaffId: string | null;
+    openingFloat: number;
+    status: 'open' | 'closed';
+    /** Set by the Z (`sessions.close`); null while open. */
+    expectedCash: number | null;
+    countedCash: number | null;
+    /** `countedCash - expectedCash`; negative is short. Null while open. */
+    cashOverShort: number | null;
+    totals: PosSessionTotals | null;
+    openedAt: string;
+    closedAt: string | null;
+}
+/** A mid-shift snapshot. Reading it changes nothing. */
+export interface PosXReport {
+    sessionId: string;
+    openingFloat: number;
+    expectedCash: number;
+    totals: PosSessionTotals;
+    movementCount: number;
+}
+export interface OpenPosSessionInput {
+    /**
+     * REQUIRED for a machine principal: the register (at your verified location)
+     * whose drawer this is. One open session per register.
+     */
+    registerId?: string;
+    /** A paired tablet only; a machine principal naming one is refused `POS_DEVICE_NOT_ALLOWED`. */
+    deviceId?: string;
+    openingFloat: number;
+    /** Denomination counts, e.g. `{ "500": 2, "200": 5 }`. */
+    openingCounts?: Record<string, number>;
+}
+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.
+     */
+    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.
+     */
+    close(input: {
+        sessionId: string;
+        countedCash: number;
+        closingCounts?: Record<string, number>;
+    }, options?: PosCall): Promise<PosRegisterSession>;
+    /** The X report: the drawer so far, read-only. */
+    xReport(sessionId: string, options?: Call): Promise<PosXReport>;
+    /**
+     * 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>;
+}
+export type PosCashMovementType = 'sale' | 'refund' | 'paid_in' | 'paid_out' | 'no_sale' | 'float_adjust';
+export interface PosCashMovement {
+    id: string;
+    sessionId: string;
+    type: PosCashMovementType;
+    /** Signed minor units: positive into the drawer, negative out. */
+    amount: number;
+    reason: string | null;
+    orderId: string | null;
+    createdAt: string;
+}
+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.
+     *
+     * 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.
+     */
+    record(input: {
+        sessionId: string;
+        type: PosCashMovementType;
+        amount: number;
+        reason?: string;
+        orderId?: string;
+    }, options?: PosCall): Promise<PosCashMovement>;
+}
+/** A till cart — a draft order — as far as this module projects it. */
+export interface PosCart {
+    id: string;
+    code: string;
+    state: string;
+    currencyCode: string;
+    /** Net total, minor units. */
+    total: number;
+    /** Gross total, minor units — what the customer pays. */
+    totalWithTax: number;
+    /**
+     * The coupon codes on the cart. A unique code shows as its promotion's own
+     * code; `pricing.discounts(id)` names what each discount did to each line.
+     */
+    couponCodes: string[];
+    lines: Array<{
+        id: string;
+        quantity: number;
+        productVariantId: string;
+        linePriceWithTax: number;
+    }>;
+    surcharges: Array<{
+        description: string;
+        sku: string;
+        price: number;
+        priceWithTax: number;
+        taxRate: number;
+    }>;
+}
+export interface CompletedPosSale {
+    orderId: string;
+    orderCode: string;
+    /** Gap-free per register. */
+    receiptNumber: string;
+    state: string;
+}
+export interface PosSaleModule {
+    /**
+     * Open a cart at your verified location. Name the `registerId` whose OPEN
+     * session takes this cart's cash — without one the cart can still take card,
+     * but `tenders.cash` is refused `POS_SESSION_REQUIRED`.
+     */
+    createCart(input?: {
+        registerId?: string;
+    }, options?: Call): Promise<PosCart>;
+    /**
+     * Add a variant to an open till cart opened at your location. Any other order
+     * of the store is refused `POS_ORDER_NOT_EDITABLE` (a paired tablet's cart:
+     * `POS_LOCATION_MISMATCH`), and nothing is changed.
+     */
+    addItem(input: {
+        orderId: string;
+        variantId: string;
+        quantity: number;
+    }, options?: Call): Promise<PosCart>;
+    /**
+     * An ad-hoc discount, `amount` in minor units on the basis the lines are
+     * priced in (gross on a tax-inclusive store, net otherwise). It takes the VAT
+     * off with the money: one negative surcharge per tax rate in the basket,
+     * each carrying that rate. Omit `lineId` for the whole cart. Only on an open
+     * till cart, as {@link PosSaleModule.addItem}; a cart that already holds a
+     * payment is refused `POS_ORDER_HAS_PAYMENTS`.
+     *
+     * `reasonCode` is optional: one of the store's active discount reasons
+     * (`orders.manualDiscounts.reasons.list`, readable with the `pos` token),
+     * recorded with the discount. A discount without one is accepted whatever the
+     * store's policy says (the policy binds the back office's doors, not the
+     * till); a code that is not an active reason is `DISCOUNT_REASON_UNKNOWN`, and
+     * the cart is unchanged. Each discount is recorded in the order's
+     * manual-discount log (`orders.manualDiscounts.list`, door `till`). Takes
+     * `options.idempotencyKey`: a retry under the same key answers the cart as it
+     * is now instead of taking the money off twice.
+     */
+    applyDiscount(input: {
+        orderId: string;
+        amount: number;
+        description?: string;
+        lineId?: string;
+        reasonCode?: string;
+    }, options?: PosCall): Promise<PosCart>;
+    /**
+     * Apply a coupon — a promotion's own code or a unique code generated for it —
+     * to an open till cart opened at your location, before any tender
+     * (`POS_ORDER_HAS_PAYMENTS` after one). The platform's coupon rules and
+     * refusals, as `pricing.coupons.apply`: `COUPON_INVALID`, `COUPON_EXPIRED`,
+     * `COUPON_NOT_YET_VALID`, `COUPON_USAGE_EXHAUSTED`, `COUPON_NOT_APPLICABLE`;
+     * the cart is unchanged on a refusal. Takes `options.idempotencyKey`: the
+     * same key and code replay the first answer.
+     */
+    applyCouponCode(input: {
+        orderId: string;
+        couponCode: string;
+    }, options?: Call): Promise<PosCart>;
+    /**
+     * Take a coupon off an open till cart before any tender. A code that is not
+     * on the cart answers the cart unchanged.
+     */
+    removeCouponCode(input: {
+        orderId: string;
+        couponCode: string;
+    }, options?: Call): Promise<PosCart>;
+    /**
+     * Finalise a fully paid sale: settles the order, debits your location's
+     * stock through its fulfillment profile (none at that location is
+     * `POS_NO_FULFILLMENT_PROFILE`, never a default), and numbers the receipt.
+     */
+    complete(orderId: string, options: PosMoneyCall & {
+        staffToken?: string;
+    }): Promise<CompletedPosSale>;
+}
+export interface PosTenderResult {
+    orderId: string;
+    paymentId: string;
+    /** True once settled payments cover the order total. */
+    covered: boolean;
+    outstanding: number;
+    /** Cash only: `tendered - amount`, floored at zero. */
+    change: number;
+}
+export interface PosTendersModule {
+    /**
+     * Cash into the drawer of the cart's register session. `tendered` is what the
+     * customer handed over; the difference comes back as `change`.
+     *
+     * On an order the till did NOT open (see {@link PosTendersModule.card}) there
+     * is no cart session, so name the `registerId` whose open session takes the
+     * cash — without it the tender is refused `POS_SESSION_REQUIRED`. Send
+     * `registerId` only for such an order: a server older than this field
+     * refuses the whole call.
+     *
+     * Cash is taken only on an order in the store's default currency, the
+     * currency the drawer holds. On an order in another currency the tender is
+     * refused `CASH_TENDER_CURRENCY_NOT_SUPPORTED`, its message naming both
+     * currencies, and nothing is taken. Take the payment with
+     * {@link PosTendersModule.card} or {@link PosTendersModule.manual} instead:
+     * neither touches the drawer, so this rule does not apply to them.
+     *
+     * 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
+     * `HOOK_UNAVAILABLE` (`HookUnavailableError`), and no tender is recorded.
+     * A cart the store's placement rules refuse as it is readied for payment (an
+     * order minimum not met, a product out of stock, …) is
+     * `ORDER_TRANSITION_REFUSED` (a `BusinessRuleError`), as order entry answers
+     * it, whose `message` says which rule refused: the cart stays open, so fix it
+     * and tender again. The rule's own code and the buyer's sentence
+     * (`placementCode`, `customerMessage`) are only on the raw GraphQL
+     * `extensions.details` for now: this SDK does not lift them yet, so the
+     * error's `details` is empty.
+     * A coupon used up since it went on is `COUPON_USAGE_EXHAUSTED` (take it off)
+     * and a tax provider's changed answer `TAX_CHANGED` (tender again at the new
+     * total). Only a cart that is no longer open is `POS_ORDER_NOT_PAYABLE`.
+     * The same holds for {@link PosTendersModule.card} and
+     * {@link PosTendersModule.manual}.
+     */
+    cash(input: {
+        orderId: string;
+        amount: number;
+        tendered: number;
+        registerId?: string;
+    }, options: PosMoneyCall & {
+        staffToken?: string;
+    }): Promise<PosTenderResult>;
+    /**
+     * A card payment on the terminal assigned to your location (Settings →
+     * Payments), through the store's payment connection. It lands `Authorized`
+     * and settles when the provider confirms the tap; `covered` stays false until
+     * then. No terminal there is `POS_TERMINAL_NOT_AVAILABLE`. A location with
+     * several readers (one per till) needs `terminalId` — the reader's provider id
+     * — or the tender is refused `POS_TERMINAL_AMBIGUOUS` rather than prompting a
+     * customer at another till.
+     *
+     * ## An order the till did not open
+     *
+     * The tenders also take money on an EXISTING order of your store — a deposit
+     * order parked in the back office whose customer pays the rest at the counter
+     * — when it is `Parked` or `ArrangingPayment`, still owes something, and
+     * names your location or no location (its `posLocationId`, or the `location`
+     * it was composed for). The money goes through the store's payment position,
+     * exactly like `payments.record`:
+     *
+     * - at most what the order still owes, or `POS_TENDER_EXCEEDS_OUTSTANDING`
+     *   (the order's position rides the error's `extensions.position`);
+     * - a tender that leaves a balance on a store without deposits is refused
+     *   `DEPOSITS_NOT_ENABLED`;
+     * - each settled tender raises `payment.partial_recorded`. A card tender
+     *   raises it when the provider settles it, which is why `covered` can stay
+     *   false for a moment;
+     * - a `Parked` order stays parked while money is owed, and the tender that
+     *   clears it settles, places and allocates the order;
+     * - `sale.complete` then numbers the receipt and fulfils at your location —
+     *   only on an order your credential took money on; any other order you did
+     *   not open is refused `POS_ORDER_UNSTAMPED`, as before.
+     *
+     * Refusals: another location's order is `POS_LOCATION_MISMATCH`. Any other
+     * state (`Cancelled` included) is `POS_ORDER_NOT_PAYABLE`. Another store's
+     * order is not found (`ENTITY_NOT_FOUND`). A paired device's cart stays the
+     * device's.
+     */
+    card(input: {
+        orderId: string;
+        amount: number;
+        terminalId?: string;
+    }, options: PosMoneyCall & {
+        staffToken?: string;
+    }): Promise<PosTenderResult>;
+    /**
+     * A tender taken OUTSIDE the platform's terminal — a standalone card machine,
+     * a voucher — recorded as settled on an offline payment method of this store
+     * (never the cash or terminal method). At most the outstanding amount.
+     */
+    manual(input: {
+        orderId: string;
+        amount: number;
+        method: string;
+        reference?: string;
+    }, options: PosMoneyCall & {
+        staffToken?: string;
+    }): Promise<PosTenderResult>;
+    /**
+     * A gift card or store credit pays (`posTenderStoredValue`): a settled payment on the store's
+     * stored-value method, the account debited in the payment's own transaction. At most the
+     * outstanding amount (stored value gives no change). Refusals: `POS_STORED_VALUE_UNAVAILABLE`
+     * and the ledger's `STORED_VALUE_*` (balance, expiry, block, owner, currency).
+     */
+    storedValue(input: {
+        orderId: string;
+        amount: number;
+        accountId: string;
+    }, options: PosMoneyCall & {
+        staffToken?: string;
+    }): Promise<PosTenderResult>;
+}
+export interface PosRefund {
+    orderId: string;
+    refundId: string;
+    /** `Settled` once the money moved (an offline refund settles on the spot). */
+    state: string;
+}
+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.
+     *
+     * `IDEMPOTENCY_OUTCOME_UNKNOWN` is neither: the card refund reached the
+     * payment provider and then failed (no answer, a timeout, a provider error),
+     * so the money MAY have been returned. The key is spent — this call and every
+     * repeat under it answer the same code, and the provider is never asked
+     * twice. The attempt is recorded as a refund whose outcome is unknown and
+     * its amount stays reserved: the till, `payments.refund`, credit notes,
+     * returns and core's own `refundOrder` (the dashboard's Refund button) can
+     * then no longer refund that payment past what it took, but a new request
+     * for the same partial amount is not
+     * stopped, so never retry under a new key. The recorded refund's id is not on
+     * the SDK error (`PlatformError` carries only code, message, details and
+     * trace id): read it with `payments.unreconciledRefunds(orderId)`. Show the
+     * till a "check before refunding" state, not "refused": someone checks the
+     * provider and records the answer with `payments.reconcileRefund` — after
+     * which a repeat under the SAME key answers the refund (made) or runs again
+     * (not made).
+     *
+     * A refund of a CASH payment pays out of the drawer, so on an order that is
+     * not in the store's default currency it is refused
+     * `CASH_TENDER_CURRENCY_NOT_SUPPORTED` before anything moves. Refund that
+     * payment from the order in the back office instead.
+     *
+     * 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`.
+     */
+    create(input: {
+        orderId: string;
+        paymentId: string;
+        amount: number;
+        reason?: string;
+    }, options: PosMoneyCall & {
+        staffToken?: string;
+    }): Promise<PosRefund>;
+}
+export interface PosDevice {
+    id: string;
+    stockLocationId: string;
+    registerId: string | null;
+    label: string;
+    status: 'active' | 'revoked';
+    paired: boolean;
+    /** Recorded server-side every time the tablet authenticates. */
+    lastSeenAt: string | null;
+}
+/** Paired tablets. Every method needs `ManagePosDevices` (or `UpdateSettings`). */
+export interface PosDevicesModule {
+    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.
+     */
+    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.
+     */
+    heartbeat(deviceId: string, options?: Call): Promise<{
+        lastSeenAt: string | null;
+    } | null>;
+}
+export interface PosReceiptNumbering {
+    prefix: string;
+    suffix: string;
+    /** Zero-padding width, 3..8. */
+    digits: number;
+}
+/** Needs `ManagePosDevices` (or `UpdateSettings`). */
+export interface PosReceiptNumberingModule {
+    get(options?: Call): Promise<PosReceiptNumbering>;
+    set(input: Partial<PosReceiptNumbering>, options?: Call): Promise<PosReceiptNumbering>;
+}
+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 } }";
+export declare const UPDATE_POS_REGISTER_MUTATION = "mutation UpdatePosRegister($id: ID!, $input: UpdatePosRegisterInput!) { updatePosRegister(id: $id, input: $input) { id stockLocationId name status createdAt updatedAt } }";
+export declare const OPEN_POS_SESSION_MUTATION = "mutation OpenPosRegisterSession($input: OpenPosRegisterSessionInput!, $staffToken: String) { openPosRegisterSession(input: $input, staffToken: $staffToken) { id registerId deviceId openedByStaffId openingFloat status expectedCash countedCash cashOverShort totals openedAt closedAt } }";
+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 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_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_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_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 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 function createPosModule(transport: Transport): PosModule;