@sixtyninecommerce/admin 0.10.0 → 0.12.0

package/dist/orders/list.js

@@ -0,0 +1,487 @@
+import { pageFromVendureList, readOffsetCursor, UpstreamError, ValidationError, } from '@sixtyninecommerce/core';
+import { redactionWatcher } from '../customer-data-redaction.js';
+export const ORDER_LIST_SORT_FIELDS = [
+    'orderPlacedAt',
+    'createdAt',
+    'updatedAt',
+    'code',
+    'state',
+    'total',
+    'totalWithTax',
+    'customerLastName',
+];
+/** The engine's `adminListQueryLimit`: a larger page is refused. */
+export const MAX_ORDER_LIST_TAKE = 1000;
+const DEFAULT_TAKE = 25;
+/** {@link ORDER_SUMMARY_FIELDS} as an engine before `Order.billableTotalWithTax` accepts it. */
+const ORDER_SUMMARY_FIELDS_BEFORE_BILLABLE = /* GraphQL */ `
+  id
+  code
+  state
+  total
+  totalWithTax
+  currencyCode
+  orderPlacedAt
+  customer {
+    id
+    firstName
+    lastName
+    emailAddress
+    addresses {
+      company
+      defaultBillingAddress
+      defaultShippingAddress
+    }
+  }
+  billingAddress {
+    company
+  }
+  shippingAddress {
+    company
+  }
+  lines {
+    quantity
+  }
+  payments {
+    id
+    state
+  }
+  customFields {
+    externalOrderId
+    externalPlatform
+    isGift
+    paymentStatus
+    fulfillmentStatus
+    returnStatus
+    lifecycleStatus
+    statusOverrides {
+      fulfillmentHoldReason
+    }
+  }
+`;
+export const ORDER_SUMMARY_FIELDS = /* GraphQL */ `
+  ${ORDER_SUMMARY_FIELDS_BEFORE_BILLABLE}
+  billableTotals {
+    total
+    totalExcludingTax
+  }
+`;
+// Each document is spelled out with a named constant inside, never built by a function: the
+// GraphQL cost spec (`graphql-cost-fits-repo.spec.ts`) resolves `${NAME}` statically.
+export const ORDERS_LIST_QUERY = /* GraphQL */ `
+  query OrdersList($options: OrderListOptions) {
+    orders(options: $options) {
+      items {
+        ${ORDER_SUMMARY_FIELDS}
+      }
+      totalItems
+    }
+  }
+`;
+const ORDERS_LIST_QUERY_BEFORE_BILLABLE = /* GraphQL */ `
+  query OrdersList($options: OrderListOptions) {
+    orders(options: $options) {
+      items {
+        ${ORDER_SUMMARY_FIELDS_BEFORE_BILLABLE}
+      }
+      totalItems
+    }
+  }
+`;
+export const ORDERS_COUNT_QUERY = /* GraphQL */ `
+  query OrdersCount($options: OrderListOptions) {
+    orders(options: $options) {
+      totalItems
+    }
+  }
+`;
+export const CUSTOMER_ORDERS_QUERY = /* GraphQL */ `
+  query CustomerOrders($id: ID!, $options: OrderListOptions) {
+    customer(id: $id) {
+      id
+      orders(options: $options) {
+        items {
+          ${ORDER_SUMMARY_FIELDS}
+        }
+        totalItems
+      }
+    }
+  }
+`;
+const CUSTOMER_ORDERS_QUERY_BEFORE_BILLABLE = /* GraphQL */ `
+  query CustomerOrders($id: ID!, $options: OrderListOptions) {
+    customer(id: $id) {
+      id
+      orders(options: $options) {
+        items {
+          ${ORDER_SUMMARY_FIELDS_BEFORE_BILLABLE}
+        }
+        totalItems
+      }
+    }
+  }
+`;
+/**
+ * Whether a failure is "this engine does not know that field yet": the document refused before
+ * it ran, never an execution-time refusal or a transient failure (the purchasing module's rule).
+ */
+function isUnknownFieldRejection(error) {
+    if (!(error instanceof ValidationError) || error.service !== 'vendure')
+        return false;
+    return (error.code === 'BAD_REQUEST' ||
+        error.code === 'GRAPHQL_VALIDATION_FAILED' ||
+        /Cannot query field/i.test(error.message));
+}
+/**
+ * Sends the current document; only an engine that refuses it as naming an unknown field (one
+ * before `Order.billableTotals`, services deploy separately) is sent the one before it.
+ */
+async function withBillableFallback(send) {
+    try {
+        return await send(false);
+    }
+    catch (error) {
+        if (!isUnknownFieldRejection(error))
+            throw error;
+        return send(true);
+    }
+}
+function invalid(message) {
+    return new ValidationError({
+        code: 'INVALID_ORDER_LIST_OPTIONS',
+        message,
+        status: 400,
+        service: 'vendure',
+    });
+}
+function stringList(value, path) {
+    if (!Array.isArray(value) || value.some((item) => typeof item !== 'string')) {
+        throw invalid(`${path} must be a list of strings.`);
+    }
+    return [...value];
+}
+function text(value, path) {
+    if (typeof value !== 'string')
+        throw invalid(`${path} must be a string.`);
+    return value;
+}
+/**
+ * An instant the engine compares without guessing a zone: a string with no offset would be read
+ * in the database server's zone, so a range would shift by hours with the server.
+ */
+const INSTANT = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?(?:Z|[+-]\d{2}:\d{2})$/;
+function instant(value, path) {
+    if (typeof value !== 'string' || !INSTANT.test(value) || Number.isNaN(Date.parse(value))) {
+        throw invalid(`${path} must be an ISO-8601 instant with an offset or Z.`);
+    }
+    return value;
+}
+function escapeRegex(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/** The Admin API's `OrderFilterParameter` for a typed filter; unknown keys are refused. */
+export function toOrderFilterParameter(filter) {
+    if (filter === undefined)
+        return {};
+    if (typeof filter !== 'object' || filter === null || Array.isArray(filter)) {
+        throw invalid('filter must be an object.');
+    }
+    const out = {};
+    for (const [key, value] of Object.entries(filter)) {
+        if (value === undefined)
+            continue;
+        switch (key) {
+            case 'ids':
+                out.id = { in: stringList(value, 'filter.ids') };
+                break;
+            case 'state':
+            case 'paymentStatus':
+            case 'lifecycleStatus':
+                out[key] = { in: stringList(value, `filter.${key}`) };
+                break;
+            case 'code': {
+                const code = value;
+                if (typeof code !== 'object' || code === null)
+                    throw invalid('filter.code must be an object.');
+                const operators = {};
+                for (const [operator, operand] of Object.entries(code)) {
+                    if (operand === undefined)
+                        continue;
+                    const path = `filter.code.${operator}`;
+                    if (operator === 'eq' || operator === 'contains')
+                        operators[operator] = text(operand, path);
+                    else if (operator === 'startsWith')
+                        operators.regex = `^${escapeRegex(text(operand, path))}`;
+                    else
+                        throw invalid(`${path} is not a code filter; use eq, contains or startsWith.`);
+                }
+                out.code = operators;
+                break;
+            }
+            case 'orderPlacedAt': {
+                const placed = value;
+                if (typeof placed !== 'object' || placed === null) {
+                    throw invalid('filter.orderPlacedAt must be an object.');
+                }
+                const operators = {};
+                for (const [operator, operand] of Object.entries(placed)) {
+                    if (operand === undefined)
+                        continue;
+                    const path = `filter.orderPlacedAt.${operator}`;
+                    if (operator === 'isNull') {
+                        if (typeof operand !== 'boolean')
+                            throw invalid(`${path} must be a boolean.`);
+                        operators.isNull = operand;
+                    }
+                    else if (operator === 'before' || operator === 'after') {
+                        operators[operator] = instant(operand, path);
+                    }
+                    else {
+                        throw invalid(`${path} is not a date filter; use isNull, before or after.`);
+                    }
+                }
+                out.orderPlacedAt = operators;
+                break;
+            }
+            case 'active':
+                if (typeof value !== 'boolean')
+                    throw invalid('filter.active must be a boolean.');
+                out.active = { eq: value };
+                break;
+            case 'currencyCode':
+                out.currencyCode = { eq: text(value, 'filter.currencyCode') };
+                break;
+            case 'externalPlatform':
+                out.externalPlatform =
+                    value === null ? { isNull: true } : { eq: text(value, 'filter.externalPlatform') };
+                break;
+            case 'customerLastName':
+                out.customerLastName = { contains: text(value, 'filter.customerLastName') };
+                break;
+            default:
+                throw invalid(`filter.${key} is not an order list filter.`);
+        }
+    }
+    return out;
+}
+function toOrderSort(sort) {
+    if (sort === undefined)
+        return undefined;
+    if (typeof sort !== 'object' ||
+        sort === null ||
+        !ORDER_LIST_SORT_FIELDS.includes(sort.field) ||
+        (sort.direction !== 'ASC' && sort.direction !== 'DESC')) {
+        throw invalid(`sort must be { field: ${ORDER_LIST_SORT_FIELDS.join(' | ')}, direction: ASC | DESC }.`);
+    }
+    return { [sort.field]: sort.direction };
+}
+function pageBounds(options) {
+    const take = options?.take ?? DEFAULT_TAKE;
+    const skip = options?.skip ?? 0;
+    if (!Number.isInteger(take) || take < 1 || take > MAX_ORDER_LIST_TAKE) {
+        throw invalid(`take must be a whole number from 1 to ${String(MAX_ORDER_LIST_TAKE)}.`);
+    }
+    if (!Number.isInteger(skip) || skip < 0)
+        throw invalid('skip must be a whole number of 0 or more.');
+    return { skip, take };
+}
+/**
+ * Pages through one order list. `read` answers the list (or `null` when its owner is gone); each
+ * following page re-sends the same filter, sort and per-call options, so a page cannot walk
+ * another store's orders.
+ */
+async function listOrders(read, options) {
+    const { skip, take } = pageBounds(options);
+    const filter = toOrderFilterParameter(options?.filter);
+    const sort = toOrderSort(options?.sort);
+    const fetchPage = async (pageSkip) => {
+        const redaction = redactionWatcher();
+        const variables = {
+            options: {
+                skip: pageSkip,
+                take,
+                ...(Object.keys(filter).length > 0 ? { filter, filterOperator: 'AND' } : {}),
+                ...(sort ? { sort } : {}),
+            },
+        };
+        const list = await withBillableFallback((beforeBillable) => read(variables, redaction.onExtensions, beforeBillable));
+        if (list === null)
+            return null;
+        const items = list.items.map((item) => ({
+            ...item,
+            billableTotals: item.billableTotals ?? null,
+        }));
+        return pageFromVendureList({ items: items.map((item) => redaction.mark(item)), totalItems: list.totalItems }, pageSkip, take, async (cursor) => {
+            const next = await fetchPage(readOffsetCursor(cursor));
+            if (next === null) {
+                throw new UpstreamError({
+                    code: 'UNEXPECTED_RESPONSE',
+                    message: 'The customer was gone by the next page of their orders.',
+                    status: 502,
+                    service: 'vendure',
+                });
+            }
+            return next;
+        });
+    };
+    return fetchPage(skip);
+}
+export function createOrderListModule(transport) {
+    return {
+        async list(options) {
+            const page = await listOrders(async (variables, onExtensions, beforeBillable) => {
+                const query = beforeBillable ? ORDERS_LIST_QUERY_BEFORE_BILLABLE : ORDERS_LIST_QUERY;
+                const data = await transport.graphql({ api: 'admin', query, variables, onExtensions }, options);
+                return data.orders;
+            }, options);
+            // `read` above never answers null: the store's own list always exists.
+            return page;
+        },
+        async count(filter, options) {
+            const parameter = toOrderFilterParameter(filter);
+            const data = await transport.graphql({
+                api: 'admin',
+                query: ORDERS_COUNT_QUERY,
+                variables: {
+                    options: {
+                        // Never 0: Vendure passes it through and TypeORM then sends no LIMIT, so a
+                        // "count" would load every matching order. One row costs nothing.
+                        take: 1,
+                        ...(Object.keys(parameter).length > 0
+                            ? { filter: parameter, filterOperator: 'AND' }
+                            : {}),
+                    },
+                },
+            }, options);
+            return data.orders.totalItems;
+        },
+    };
+}
+/**
+ * One customer's orders, as `customers.orders` reads them: the same rows, filter, sort and paging
+ * as `orders.list`, or `null` when the store holds no customer with that id.
+ */
+export async function listCustomerOrders(transport, customerId, options) {
+    return listOrders(async (variables, onExtensions, beforeBillable) => {
+        const data = await transport.graphql({
+            api: 'admin',
+            query: beforeBillable ? CUSTOMER_ORDERS_QUERY_BEFORE_BILLABLE : CUSTOMER_ORDERS_QUERY,
+            variables: { id: customerId, ...variables },
+            onExtensions,
+        }, options);
+        return data.customer?.orders ?? null;
+    }, options);
+}
+/** The most orders `customers.recentOrders` answers. */
+export const MAX_RECENT_ORDERS = 20;
+const DEFAULT_RECENT_ORDERS = 5;
+export const CUSTOMER_RECENT_ORDERS_QUERY = /* GraphQL */ `
+  query CustomerRecentOrders($id: ID!, $options: OrderListOptions) {
+    customer(id: $id) {
+      id
+      orders(options: $options) {
+        items {
+          id
+          code
+          orderPlacedAt
+          totalWithTax
+          billableTotals {
+            total
+            totalExcludingTax
+          }
+          currencyCode
+          lines {
+            id
+            quantity
+            listPriceIncludesTax
+            productVariant {
+              id
+              name
+              sku
+              product {
+                id
+                name
+              }
+            }
+            customFields {
+              unitPriceOverride
+              unitPriceImported
+            }
+          }
+        }
+        totalItems
+      }
+    }
+  }
+`;
+const CUSTOMER_RECENT_ORDERS_QUERY_BEFORE_BILLABLE = /* GraphQL */ `
+  query CustomerRecentOrders($id: ID!, $options: OrderListOptions) {
+    customer(id: $id) {
+      id
+      orders(options: $options) {
+        items {
+          id
+          code
+          orderPlacedAt
+          totalWithTax
+          currencyCode
+          lines {
+            id
+            quantity
+            listPriceIncludesTax
+            productVariant {
+              id
+              name
+              sku
+              product {
+                id
+                name
+              }
+            }
+            customFields {
+              unitPriceOverride
+              unitPriceImported
+            }
+          }
+        }
+        totalItems
+      }
+    }
+  }
+`;
+/**
+ * A customer's last placed orders, newest first, each with its lines, as `customers.recentOrders`
+ * reads them; `null` when the store holds no customer with that id.
+ */
+export async function listCustomerRecentOrders(transport, customerId, options) {
+    const { take = DEFAULT_RECENT_ORDERS, ...call } = options ?? {};
+    if (!Number.isInteger(take) || take < 1 || take > MAX_RECENT_ORDERS) {
+        throw invalid(`take must be a whole number from 1 to ${String(MAX_RECENT_ORDERS)}.`);
+    }
+    const data = await withBillableFallback((beforeBillable) => transport.graphql({
+        api: 'admin',
+        query: beforeBillable
+            ? CUSTOMER_RECENT_ORDERS_QUERY_BEFORE_BILLABLE
+            : CUSTOMER_RECENT_ORDERS_QUERY,
+        variables: {
+            id: customerId,
+            options: {
+                take,
+                // Placed orders only: sorted on its own, `orderPlacedAt` descending lists the carts
+                // and drafts (no date) first.
+                filter: { orderPlacedAt: { isNull: false } },
+                // ONE key, on purpose. The engine applies the keys of a sort in the order its schema
+                // declares them, not the order they are sent in, and `id` is declared before
+                // `orderPlacedAt`: an id "tie-breaker" here sorted the orders by id (found live).
+                sort: { orderPlacedAt: 'DESC' },
+            },
+        },
+    }, call));
+    // The document selects the members of `RecentOrder`; an older engine leaves out the billable one.
+    return data.customer
+        ? data.customer.orders.items.map((order) => ({
+            ...order,
+            billableTotals: order.billableTotals ?? null,
+        }))
+        : null;
+}

package/dist/orders/manual-discounts.d.ts

@@ -41,7 +41,10 @@ export interface DiscountPolicy {
      * The store's ceiling on manual discounts in basis points (1000 = 10 %), or `null` for none: how
      * far below the price the customer would get anyway (its contract included) staff without the
      * `OverrideDiscountLimit` permission may take a line (`DISCOUNT_OVER_LIMIT`). Reducing a
-     * discount is never refused. The POS till is not held to it.
+     * discount is never refused. The POS till is held to it too (a till discount and a lowered
+     * till price, cart-wide and per line): there only a session holding `OverrideDiscountLimit`, or
+     * a staff member holding the explicit `discount_over_limit` grant (a grant no role holds by
+     * default), goes past it.
      */
     maxDiscountBps: number | null;
 }
@@ -63,14 +66,16 @@ export interface OrderManualDiscount {
     /** The line the movement was on; `null` for a till discount on the whole cart. */
     orderLineId: string | null;
     /**
-     * `price_list`, `line_override` or `till` (`pos.sale.applyDiscount`, one row per call). Accept a
-     * value you do not know.
+     * `price_list`, `line_override` or `till` (`pos.sale.applyDiscount`, one row per call, and a row
+     * per change the till made to that money since: a removal, a cap or a re-split). Accept a value
+     * you do not know.
      */
     door: string;
     /**
      * The change of the line's total, net: (unit price after − before) × quantity, minor units of
      * `currencyCode`, as the order holds it. Negative when the price fell (a manual discount). For
-     * `till`: the money the call's negative surcharges added.
+     * `till`: the money the call's negative surcharges added; a later row of that discount carries
+     * the till's change, signed, so an order's `till` rows sum to its till discount in force.
      */
     amount: number;
     /** The same movement gross. */
@@ -85,7 +90,10 @@ export interface OrderManualDiscount {
     } | null;
     /** The Vendure user of the session that moved it. */
     actorUserId: string | null;
-    /** The vouched-for `x-on-behalf-of` ref; for a till vouched for nothing, `pos-staff:<id>`. */
+    /**
+     * The vouched-for `x-on-behalf-of` ref; for a till vouched for nothing, `pos-staff:<id>`. A `till`
+     * row that changes a discount carries the ref of the row that gave it.
+     */
     onBehalfOfRef: string | null;
     /** The vouched-for `x-device-ref` ref; for a paired till vouched for nothing, `pos-device:<id>`. */
     deviceRef: string | null;

package/dist/orders/manual-pricing.d.ts

@@ -161,6 +161,11 @@ export interface OrderManualPricingModule {
      * neither `unitPriceOverride` nor `priceOverrideReason` (it asks for nothing); a negative price;
      * `unitPriceOverride: null` on a line an external system priced (`orders.createOrRecover`
      * external lines), which has no catalogue price to fall back to: state the price instead.
+     *
+     * `ORDER_LINE_VARIANT_UNPRICED` (`BusinessRuleError`, 422; absent from an engine released before
+     * 2026-10-10): `unitPriceOverride: null` on a line that states a manual price while its variant
+     * has no price in the store, which would leave the line nothing to charge. Nothing is written:
+     * state the price instead, or set a price for the variant in the store first.
      */
     setLinePrices(orderId: string, input: SetLinePricesInput, options?: Call): Promise<OrderDiscounts>;
     /**

package/dist/orders/money-view.d.ts

@@ -0,0 +1,149 @@
+/**
+ * `admin.orders.moneyView(orderId, { basis })`: an order's money as rows that add up exactly to
+ * its own totals, in one basis (pricing-display-consistency, USER O12). Every surface that shows
+ * an order's money prints these rows, so an order page, an email and an invoice cannot disagree
+ * by a cent. The engine builds them (`Order.moneyView`); this module only reads them.
+ */
+import { type Transport } from '@sixtyninecommerce/core';
+import type { Call } from '../types.js';
+/**
+ * Which prices a view shows. `GROSS` = incl. VAT, `NET` = excl. VAT. `STORE` follows how the
+ * store sets its prices; `CUSTOMER` how the shop shows prices to the order's customer. The view
+ * answers the one it used, `GROSS` or `NET`.
+ */
+export declare const ORDER_MONEY_BASES: readonly ["STORE", "CUSTOMER", "GROSS", "NET"];
+export type OrderMoneyBasis = (typeof ORDER_MONEY_BASES)[number];
+/** One order line. Money is an integer in minor units of the view's `currencyCode`. */
+export interface OrderMoneyLine {
+    orderLineId: string;
+    quantity: number;
+    taxRate: number;
+    /**
+     * The unit price, only when the line was priced in this basis (`unitAmount × quantity =
+     * amount`); null in the other basis, where only the line total multiplies out.
+     */
+    unitAmount: number | null;
+    /** The line total before promotions. */
+    amount: number;
+}
+/** A promotion, a surcharge or a shipping line. A discount is negative. */
+export interface OrderMoneyRow {
+    /** The promotion's adjustment source, the surcharge id or the shipping line id. */
+    key: string;
+    description: string;
+    amount: number;
+    /** The row's VAT rate; null for a promotion, which can span several. */
+    taxRate: number | null;
+}
+/** The VAT at one rate: goods, shipping and surcharges together, a staff rounding's VAT in. */
+export interface OrderMoneyTaxRow {
+    taxRate: number;
+    /** Excl. VAT. */
+    base: number;
+    amount: number;
+}
+/**
+ * Why a view gives no still-to-pay figure: `KEPT_IN_ERP`, the order was placed on a B2B account
+ * kept in an external accounting system, so print a note ("paid via your account in the
+ * accounting system") instead of an amount. A new value may be added.
+ */
+export type OrderMoneyStillToPayNote = 'KEPT_IN_ERP';
+/**
+ * What has been paid and what is still to pay, gross; a zero row is not printed. An engine that
+ * answers `stillToPayNote` (null included) reads the B2B account ledger: money paid or credited on
+ * an account invoice is in `paid` and `credited`. Without it (an older engine) it is not, so an
+ * order a live account invoice bills reads its whole remainder as `stillToPay`: do not print that
+ * figure for it.
+ */
+export interface OrderMoneyBalance {
+    /** Money received or held by a payment provider, less refunds; never a payment still to arrive. */
+    paid: number;
+    giftCard: number;
+    storeCredit: number;
+    /** What credit notes took off the bill. */
+    credited: number;
+    /** What the order bills less the four above, never below zero. A bank-transfer or net-terms promise still counts as to pay. Zero when `stillToPayNote` is set. */
+    stillToPay: number;
+    /** Set when no still-to-pay figure can be given (print its note); null otherwise; absent on an older engine. */
+    stillToPayNote?: OrderMoneyStillToPayNote | null;
+}
+/**
+ * The rows and their identities: `Σ lines + Σ goodsAdjustments + Σ surcharges = subtotal`;
+ * `Σ shipping + Σ shippingAdjustments = shippingTotal`; on `GROSS` `subtotal + shippingTotal +
+ * (rounding ?? 0) = total`; on `NET` `subtotal + shippingTotal + taxTotal + (rounding ?? 0) =
+ * total`; `Σ taxes = taxTotal`; `totalExcludingTax + taxTotal = total`.
+ */
+export interface OrderMoneyView {
+    basis: 'GROSS' | 'NET';
+    currencyCode: string;
+    lines: OrderMoneyLine[];
+    /** One row per promotion on the goods (price-list order rules and coupons included). */
+    goodsAdjustments: OrderMoneyRow[];
+    /** Fees (positive) and staff discounts (negative). */
+    surcharges: OrderMoneyRow[];
+    subtotal: number;
+    /** Each shipping line before its promotions. */
+    shipping: OrderMoneyRow[];
+    /** One row per promotion on shipping. */
+    shippingAdjustments: OrderMoneyRow[];
+    shippingTotal: number;
+    /** Everything excl. VAT, a staff rounding's net part in: the invoice's "Total excl. VAT". */
+    totalExcludingTax: number;
+    /** One row per VAT rate. */
+    taxes: OrderMoneyTaxRow[];
+    /** True on `GROSS`: the VAT rows are inside the total, not added to it. */
+    taxIncluded: boolean;
+    taxTotal: number;
+    /** A staff rounding, printed just above the total (gross on `GROSS`, excl. VAT on `NET`). */
+    rounding: number | null;
+    /** What the order bills, incl. VAT, after a staff rounding. */
+    total: number;
+    /** The total before a staff rounding. */
+    totalBeforeRounding: number;
+    balance: OrderMoneyBalance;
+    /** False only when the order's stored totals disagree with its own rows. */
+    reconciles: boolean;
+}
+/** Every field of an `OrderMoneyView`, at every depth: the selection each document reads it with. */
+export declare const ORDER_MONEY_VIEW_FIELDS = "\n        basis\n        currencyCode\n        lines { orderLineId quantity taxRate unitAmount amount }\n        goodsAdjustments { key description amount taxRate }\n        surcharges { key description amount taxRate }\n        subtotal\n        shipping { key description amount taxRate }\n        shippingAdjustments { key description amount taxRate }\n        shippingTotal\n        totalExcludingTax\n        taxes { taxRate base amount }\n        taxIncluded\n        taxTotal\n        rounding\n        total\n        totalBeforeRounding\n        balance { paid giftCard storeCredit credited stillToPay stillToPayNote }\n        reconciles\n";
+export declare const ORDER_MONEY_VIEW_QUERY = "\n  query OrderMoneyView($id: ID!, $basis: OrderMoneyBasis!) {\n    order(id: $id) {\n      id\n      moneyView(basis: $basis) {\n        basis\n        currencyCode\n        lines { orderLineId quantity taxRate unitAmount amount }\n        goodsAdjustments { key description amount taxRate }\n        surcharges { key description amount taxRate }\n        subtotal\n        shipping { key description amount taxRate }\n        shippingAdjustments { key description amount taxRate }\n        shippingTotal\n        totalExcludingTax\n        taxes { taxRate base amount }\n        taxIncluded\n        taxTotal\n        rounding\n        total\n        totalBeforeRounding\n        balance { paid giftCard storeCredit credited stillToPay stillToPayNote }\n        reconciles\n      }\n    }\n  }\n";
+/** `INVALID_ORDER_MONEY_BASIS` for a basis not in `ORDER_MONEY_BASES`, before anything is sent. */
+export declare function assertOrderMoneyBasis(basis: string): asserts basis is OrderMoneyBasis;
+export interface OrderMoneyViewModule {
+    /**
+     * The order's money as rows that add up exactly to its stored totals, in `options.basis`
+     * (default `STORE`). Print these rows as they come, never re-derived: an amount re-computed
+     * from them, or from the order's other figures, can miss the order's own total by a cent.
+     * Needs `ReadOrder`.
+     *
+     * - A unit price (`lines[].unitAmount`) is only answered in the basis the line was priced in;
+     *   show the line total alone in the other.
+     * - The VAT rows are one per rate. On a `GROSS` view they are included in the total
+     *   (`taxIncluded`): label them so, never as an addition.
+     * - `balance.stillToPay` is money not received yet: a bank-transfer or net-terms payment that
+     *   is promised still counts. With `balance.stillToPayNote` answered it reads the B2B account
+     *   ledger; `KEPT_IN_ERP` means print its note, not a figure. Not answered (an older engine,
+     *   resent without it): for an order a live account invoice bills, show the other rows only.
+     * - It reads the order as STORED: it cannot preview an edit (`planEdit`'s `preview.moneyView` does).
+     *
+     * Refused: `INVALID_ORDER_MONEY_BASIS` (`ValidationError`, 400, before sending) for a basis
+     * not in `ORDER_MONEY_BASES`; `ORDER_NOT_FOUND` (`NotFoundError`, 404) for an order this store
+     * does not hold. An engine before `Order.moneyView` refuses the document as
+     * `ValidationError` `GRAPHQL_VALIDATION_FAILED` (400): fall back to the order's own figures.
+     *
+     * @effect read
+     */
+    moneyView(orderId: string, options?: Call & {
+        basis?: OrderMoneyBasis;
+    }): Promise<OrderMoneyView>;
+}
+/** `document` without `stillToPayNote`: what an engine before it accepts. */
+export declare function withoutStillToPayNote(document: string): string;
+/**
+ * The transport, sending a document that names `balance.stillToPayNote` (pricing-display-consistency
+ * B1c) once more without it when the engine refused it as unknown. Safe for a mutation too: a
+ * refused document never ran. The newest money-view field, so it falls away first: wrap it inside
+ * any other `*Aware` transport.
+ */
+export declare function stillToPayNoteAware(transport: Pick<Transport, 'graphql'>): Pick<Transport, 'graphql'>;
+export declare function createOrderMoneyViewModule(transport: Transport): OrderMoneyViewModule;