@sixtyninecommerce/admin 0.8.0 → 0.10.0

package/dist/orders/index.d.ts

@@ -1,8 +1,48 @@
-import type { Transport } from '@sixtyninecommerce/core';
+import { type Transport } from '@sixtyninecommerce/core';
+import type { JobHandle } from '../jobs/index.js';
 import type { OrderPaymentPosition, PaidOrder } from '../payments/index.js';
 import type { Call } from '../types.js';
+import { type OrderBulkInput, type OrderBulkRun } from './bulk.js';
+import { type OrderCommitEditModule } from './commit-edit.js';
+import { type OrderDepositPolicyModule } from './deposit-policy.js';
+import { type OrderGetModule } from './get.js';
+import { type OrderLinePricePreviewModule } from './line-price-preview.js';
+import { type ManualDiscountsModule } from './manual-discounts.js';
+import { type OrderManualPricingModule } from './manual-pricing.js';
+import { type OrderEntryModule } from './order-entry.js';
+import { type OrderParcelChargeModule } from './parcel-charge.js';
+import { type OrderPlanEditModule } from './plan-edit.js';
+import { type OrderStatusModule } from './status.js';
 import { type SurchargesModule } from './surcharges.js';
 export type { PaidOrder } from '../payments/index.js';
+export type { OrderBulkAction, OrderBulkCapture, OrderBulkInput, OrderBulkItem, OrderBulkRun, } from './bulk.js';
+export { MAX_BULK_ORDERS, ORDER_BULK_ACTIONS, ORDER_BULK_TRANSITION_REFUSED } from './bulk.js';
+export type { OrderDepositPolicy, OrderDepositPolicyModule, StorefrontDepositPolicy, } from './deposit-policy.js';
+export type { DiscountPolicy, DiscountPolicyInput, DiscountPolicyModule, DiscountReason, DiscountReasonInput, DiscountReasonsModule, ManualDiscountsModule, OrderManualDiscount, } from './manual-discounts.js';
+export type { ExternalLinePriceBasis, ExternalOrder, ExternalOrderAddressInput, ExternalOrderCall, ExternalOrderCatalogLine, ExternalOrderExternalLine, ExternalOrderFulfilment, ExternalOrderInput, ExternalOrderLine, ExternalOrderLineInput, ExternalOrderSurcharge, ExternalOrderSurchargeInput, ExternalOrderTargetState, ExternalOrderTaxLine, } from './order-entry.js';
+/** An app provider an order is running without (`admin.orders.providerFallbacks`). */
+export interface OrderProviderFallback {
+    /** `shipping.rates` or `tax.calculate`. */
+    kind: string;
+    installationId: string;
+    /**
+     * `timeout`, `network`, `tls`, `redirect`, `http_status`, `invalid_response`,
+     * `private_host`, `suspended`, `not_configured` — the app could not answer, or
+     * was not asked because it is switched off (`suspended`: after 20 failures, or
+     * the installation or app suspended) — or one the MERCHANT fixes, not the app
+     * vendor:
+     * - `tax_class` (`shipping.rates`): the app answered, but the store's tax
+     *   classes cannot tax any rate it offered; map the class.
+     * - `withdrawn` (`tax.calculate`): the store's assigned tax provider no longer
+     *   declares the hook, or its installation no longer consents to it; approve
+     *   the app's pending consent, or unassign the provider.
+     *
+     * Treat an unknown value as "not available": reasons are added over time.
+     */
+    reason: string;
+    /** ISO-8601 with offset: when the order started running without it. */
+    since: string;
+}
 /** The result of settling an order. */
 export interface OrderSettlement {
     order: PaidOrder;
@@ -21,8 +61,98 @@ export interface OrderSettlement {
  * deposit flow: hold an order while the rest of the money is arranged, read
  * what it stands at, and settle it once the money is really there.
  */
-export interface OrdersModule {
+/**
+ * `OrderEntryModule`'s three methods sit DIRECTLY on `admin.orders` rather than
+ * under a nested namespace: composing an order and recovering it are order
+ * operations, not a sub-resource, and `admin.orders.byExternalRef(ref)` is the
+ * sentence a vertical's own code wants to write.
+ *
+ * The manual pricing doors (`setLinePrices`, `setOneTimeDiscounts`) sit there too, beside their
+ * read twin `previewLinePrices`, which prices the same changes without saving them.
+ */
+export interface OrdersModule extends OrderEntryModule, OrderGetModule, OrderParcelChargeModule, OrderLinePricePreviewModule, OrderManualPricingModule, OrderPlanEditModule, OrderCommitEditModule, OrderStatusModule {
     surcharges: SurchargesModule;
+    /**
+     * Manual discounts with a reason (incentives spec §4 decision 6): read an order's records,
+     * and the store's reason list and policy (`reasons`, `policy`). A discount itself is given
+     * through the doors that move the money, each taking a reason code: `setLinePrices` and
+     * `setOneTimeDiscounts` on this module.
+     */
+    manualDiscounts: ManualDiscountsModule;
+    /**
+     * Move, cancel, delete or mark paid up to `MAX_BULK_ORDERS` (50) orders of the store in ONE
+     * call (headless spec §7 `orders.bulk`; rulings G19, G28).
+     *
+     * **The run is a job.** The call answers a receipt (`runId`) once the run is queued;
+     * `handle.wait()` polls it until it ends and resolves with the run, whatever the ending.
+     * `bulkRun(runId)` reads it again later, from any process. Each order's outcome is in
+     * `run.items`, in the order the ids were named.
+     *
+     * **Each order is judged as on its own page, and succeeds or fails alone.** First by its own
+     * status (`orders.status`): an action the order's status does not offer, or a TRANSITION target
+     * outside the order's own `nextStates`, answers `ORDER_ACTION_UNAVAILABLE` with `reasonCode`
+     * (that read's vocabulary), before anything is written. Then by its single door, under the
+     * door's own lock, with the door's own code: `ORDER_STATE_TRANSITION_ERROR` (and core's other
+     * order codes), `ORDER_CART_NOT_CANCELLABLE`, `ORDER_UNITS_SHIPPED`,
+     * `ORDER_HAS_ACTIVE_FULFILLMENT`, `ORDER_INVOICE_LOCKED`, `ORDER_HAS_RECORDS`,
+     * `ORDER_NOT_DELETED`. Another store's order answers `ENTITY_NOT_FOUND` on its item. A
+     * `SUCCEEDED` run can hold `FAILED` items: read them.
+     *
+     * - `TRANSITION` (`toState` required): as `transitionOrderToState`. Never `Cancelled` (use
+     *   `CANCEL`), `PaymentSettled` (use `MARK_PAID`), `Modifying` or `AddingItems`.
+     * - `CANCEL` (`reason` optional): the whole order, shipping included, as `cancelOrder`. **It
+     *   moves no money:** a paid order keeps its payment, to be refunded through `payments.refund`.
+     * - `DELETE`: a draft or a cart holding no payment or stock movement, as `deleteOrder`.
+     * - `MARK_PAID`: **captures** each payment of the order that is `Authorized` when the run reaches
+     *   it, read by the engine (never your list's copy), each as `settlePayment` and on its own
+     *   (ruling G19). Each order's `captured` lists every payment acted on. **A decline is a result,
+     *   not a retry:** the order answers `SETTLE_PAYMENT_ERROR`, the payment keeps the state the
+     *   provider left, and the run never asks again. **An unknown provider answer must be
+     *   reconciled, never retried blind:** `IDEMPOTENCY_OUTCOME_UNKNOWN` means the provider was asked
+     *   and its answer was lost; check the payment with the provider. `IDEMPOTENCY_IN_PROGRESS` means
+     *   a capture under the same request may still be running. An order with no authorized payment
+     *   answers `NOTHING_TO_CAPTURE`: it is never marked paid without money (ruling G28).
+     *
+     * **Idempotency.** `options.idempotencyKey` (minted when omitted): the same key with the same
+     * input answers the SAME run, so a resubmit never captures twice; another input under the key is
+     * `IDEMPOTENCY_CONFLICT` (409 `ConflictError`). Each order, and each capture, is keyed within the
+     * run, so a run the platform processes again (a worker restart) answers what it already did from
+     * that record and never asks a provider twice.
+     *
+     * **No dry run.** The refusals that matter are the doors' own, made under their locks, so a
+     * rehearsal could answer "ok" for an order the real run refuses.
+     *
+     * Needs `UpdateOrder` (`DeleteOrder` for `DELETE`); reading the run needs `ReadOrder`. Refusals
+     * of the call itself (nothing is queued): `BULK_ACTION_INPUT_INVALID` (`ValidationError`, 400:
+     * no orders, more than 50, one named twice, an unknown action, a missing or refused `toState`,
+     * an option the action takes none of; refused before sending too), `BULK_ACTION_NOT_ALLOWED`
+     * (`PermissionDeniedError`, 403), `IDEMPOTENCY_CONFLICT`.
+     *
+     * Platform releases before this method do not have the mutation and refuse it as
+     * `ValidationError` `GRAPHQL_VALIDATION_FAILED` (400): deploy the engine first.
+     */
+    bulk(input: OrderBulkInput, options?: Call): Promise<JobHandle<OrderBulkRun>>;
+    /**
+     * One read of a bulk order run, by the `runId` `bulk()` answered. A run of another store, or one
+     * that does not exist, is `BULK_ACTION_RUN_NOT_FOUND` (`NotFoundError`, 404).
+     */
+    bulkRun(runId: string, options?: Call): Promise<OrderBulkRun>;
+    /**
+     * Delete ONE order: a draft or a cart (`AddingItems`) holding no payment and no stock movement,
+     * as the order page's Delete (ruling G29). Needs `DeleteOrder`. Anything else is kept:
+     * `ORDER_INVOICE_LOCKED` (an invoiced order, for every caller), `ORDER_HAS_RECORDS` (cancel it
+     * instead: `orders.bulk` with `CANCEL`), or `ORDER_NOT_DELETED` (`ConflictError`, 409, as every `*_NOT_DELETED` of this SDK) with
+     * the engine's own reason for an order in another state, or one this store does not have.
+     * Placed orders are cancelled, never deleted.
+     */
+    delete(orderId: string, options?: Call): Promise<void>;
+    /**
+     * The store's deposit policy (`orderDepositPolicy`): whether staff may take a
+     * deposit and {@link OrdersModule.park} an order, the minimum a deposit must be,
+     * and whether a shopper may pay one at checkout. `get` answers what the engine
+     * applies; `set` replaces it, validated against the schema's bounds first.
+     */
+    depositPolicy: OrderDepositPolicyModule;
     /**
      * Hold a placed order while the rest of its money is arranged. Needs
      * `UpdateOrder`.
@@ -32,16 +162,21 @@ export interface OrdersModule {
      * is off unless a merchant chose it. Refusals carry the order's position:
      * `DEPOSITS_NOT_ENABLED` (the store has not turned deposits on — the default,
      * so this is the first one you will meet), `DEPOSIT_REQUIRED` (nothing paid,
-     * and the store does not allow that), `DEPOSIT_BELOW_MINIMUM`,
-     * `ORDER_NOT_PARKABLE` (wrong state), `PARK_REASON_TOO_LONG` (500
-     * characters).
-     *
-     * Parking does not RESERVE stock: the platform allocates at the payment edge,
-     * so an order parked while arranging payment usually holds no allocations
-     * yet. What it protects is the ORDER — the stock-allocation sweeper leaves a
-     * parked order alone deliberately, so an expiring allocation TTL cannot
-     * cancel an order a customer has already paid a deposit on, and allocations
-     * it does hold stay put while it waits.
+     * and the store does not allow that), `DEPOSIT_BELOW_MINIMUM` (the minimum is
+     * set in the store's default currency and converted into the order's),
+     * `EXCHANGE_RATE_UNAVAILABLE` (no exchange rate to convert it into the
+     * order's currency),
+     * `ORDER_NOT_PARKABLE` (wrong state), `INSUFFICIENT_STOCK` (the goods sold
+     * since the order reached payment; `extensions.lines` names each short line),
+     * `PARK_REASON_TOO_LONG` (500 characters).
+     *
+     * Parking RESERVES the order's stock for the life of the park, without
+     * placing the order: no confirmation email, no `order.created`, no ERP push
+     * until it settles, and settling does not reserve twice. `unpark` and a
+     * cancellation give the stock back. A line's backorder or pre-order part is
+     * reserved as it would be at payment. The stock-allocation sweeper leaves a
+     * parked order alone, so an expiring allocation TTL cannot cancel an order a
+     * customer has already paid a deposit on.
      */
     park(orderId: string, options?: Call & {
         reason?: string;
@@ -55,11 +190,16 @@ export interface OrdersModule {
      * parked it. `PARK_ORIGIN_UNKNOWN` is the refusal when that history does not
      * say — move such an order on explicitly with a state transition instead.
      *
-     * There is no storefront equivalent today: a parked order's remainder is
-     * recorded WHERE IT STANDS with `payments.record`, and the payment that
-     * clears it settles, places and allocates the order without ever leaving
-     * `Parked` first. Use this when the order has to be EDITED, which is the one
-     * thing it cannot do while held.
+     * A shopper can pay a parked order's remainder from the storefront
+     * (`commerce.payParkedOrder` / `commerce.createParkedOrderPaymentIntent`),
+     * and a merchant records it WHERE IT STANDS with `payments.record`; the
+     * payment that clears it settles and places the order, keeping the stock the
+     * park reserved, without ever leaving `Parked` first. Use this when the order
+     * has to be EDITED, which is the one thing it cannot do while held; it gives
+     * the park's reserved stock back. On a paid order an installed app held for
+     * review it does NOT accept it: the hold goes back to `ArrangingPayment` with the
+     * order, and nothing places it until staff accept it with {@link OrdersModule.settle}
+     * (or it goes back to the cart and the apps are asked again).
      *
      * It moves no money and changes no payment. Other refusals:
      * `ORDER_NOT_PARKED`, `UNPARK_TRANSITION_REFUSED` (the origin was known and
@@ -76,10 +216,27 @@ export interface OrdersModule {
      * Refuses `COVERAGE_INSUFFICIENT` while the order's SETTLED money does not
      * cover its total, with the position attached. Settled, not covered: an
      * authorization is permission to take money, not money, so an order whose
-     * remainder is merely authorized is settled from `ArrangingPayment` after the
-     * authorization is captured, like any other order. `ORDER_NOT_SETTLEABLE` is
-     * the other refusal — a state a settlement cannot be reached from, which
-     * paying more can never fix.
+     * remainder is merely authorized settles once that authorization is captured
+     * where it stands (`settlePayment` on the Admin API): the capture settles it,
+     * out of a park included, and a parked order never goes back to
+     * `ArrangingPayment` for it (that is {@link OrdersModule.unpark}, which gives
+     * the reserved stock back). `ORDER_NOT_SETTLEABLE` is the other refusal — a
+     * state a settlement cannot be reached from, which paying more can never fix.
+     *
+     * This is also how staff ACCEPT a paid order held for review — an installed
+     * app refused it after it was paid, or a check an ordinary checkout would have
+     * refused it for (it is `Parked`, or `ArrangingPayment` after an un-park or
+     * when it could not be parked; `admin.orders.status(orderId).hold` gives the
+     * refusal's code, and the app when an app refused). Nothing else settles such an order: money that lands on it meanwhile
+     * is recorded and the order stays where it is. A settled one settles here and
+     * is placed; one that still owes money is accepted WITHOUT settling — the hold
+     * ends and the answer's `order.state` stays where it was (for a parked order,
+     * an ordinary part-paid park the shopper can now pay off). One whose balance
+     * is covered only by an AUTHORIZED payment owes nothing and is refused
+     * `COVERAGE_INSUFFICIENT` with the hold kept: accept it by capturing that
+     * payment with `settlePayment`, which settles and places it. To turn the order
+     * down, refund the payment, then {@link OrdersModule.unpark} and cancel it: a
+     * refund alone leaves it parked, held and holding its stock.
      *
      * Calling this on an order the platform ALREADY settled succeeds rather than
      * refusing. Expect that to be the common case: the engine settles an order as
@@ -98,6 +255,14 @@ export interface OrdersModule {
     settle(orderId: string, options?: Call & {
         fulfil?: boolean;
     }): Promise<OrderSettlement>;
+    /**
+     * The app providers this order is currently running WITHOUT (spec §15.19): a
+     * rates or tax app that could not answer, so the platform's own behaviour was
+     * used instead. Empty when none. Needs `ReadOrder`; `ORDER_NOT_FOUND` for an
+     * order this store does not have. {@link OrderStatusModule.status} answers
+     * the same list beside everything else about the order.
+     */
+    providerFallbacks(orderId: string, options?: Call): Promise<OrderProviderFallback[]>;
 }
 export declare const PARK_ORDER_MUTATION = "\n  mutation ParkOrder($orderId: ID!, $reason: String, $idempotencyKey: String) {\n    parkOrder(orderId: $orderId, reason: $reason, idempotencyKey: $idempotencyKey) {\n      id\n      code\n      state\n      currencyCode\n      total\n      totalWithTax\n    }\n  }\n";
 export declare const UNPARK_ORDER_MUTATION = "\n  mutation UnparkOrder($orderId: ID!, $idempotencyKey: String) {\n    unparkOrder(orderId: $orderId, idempotencyKey: $idempotencyKey) {\n      id\n      code\n      state\n      currencyCode\n      total\n      totalWithTax\n    }\n  }\n";

package/dist/orders/index.js

@@ -1,4 +1,30 @@
+import { NotFoundError } from '@sixtyninecommerce/core';
+import { bulkOrders, deleteOrder, readOrderBulkRun, } from './bulk.js';
+import { createOrderCommitEditModule } from './commit-edit.js';
+import { createOrderDepositPolicyModule } from './deposit-policy.js';
+import { createOrderGetModule } from './get.js';
+import { createOrderLinePricePreviewModule, } from './line-price-preview.js';
+import { createManualDiscountsModule } from './manual-discounts.js';
+import { createOrderManualPricingModule } from './manual-pricing.js';
+import { createOrderEntryModule } from './order-entry.js';
+import { createOrderParcelChargeModule } from './parcel-charge.js';
+import { createOrderPlanEditModule } from './plan-edit.js';
+import { createOrderStatusModule } from './status.js';
 import { createSurchargesModule } from './surcharges.js';
+export { MAX_BULK_ORDERS, ORDER_BULK_ACTIONS, ORDER_BULK_TRANSITION_REFUSED } from './bulk.js';
+const ORDER_PROVIDER_FALLBACKS_QUERY = /* GraphQL */ `
+  query OrderProviderFallbacks($id: ID!) {
+    order(id: $id) {
+      id
+      providerFallbacks {
+        kind
+        installationId
+        reason
+        since
+      }
+    }
+  }
+`;
 const SETTLEMENT_FIELDS = /* GraphQL */ `
   order {
     id
@@ -67,7 +93,26 @@ export const ORDER_POSITION_QUERY = /* GraphQL */ `
 `;
 export function createOrdersModule(transport) {
     return {
+        ...createOrderEntryModule(transport),
+        ...createOrderGetModule(transport),
+        ...createOrderParcelChargeModule(transport),
+        ...createOrderLinePricePreviewModule(transport),
+        ...createOrderManualPricingModule(transport),
+        ...createOrderPlanEditModule(transport),
+        ...createOrderCommitEditModule(transport),
+        ...createOrderStatusModule(transport),
         surcharges: createSurchargesModule(transport),
+        manualDiscounts: createManualDiscountsModule(transport),
+        depositPolicy: createOrderDepositPolicyModule(transport),
+        bulk(input, options) {
+            return bulkOrders(transport, input, options);
+        },
+        bulkRun(runId, options) {
+            return readOrderBulkRun(transport, runId, options);
+        },
+        delete(orderId, options) {
+            return deleteOrder(transport, orderId, options);
+        },
         async park(orderId, options) {
             const data = await transport.graphql({
                 api: 'admin',
@@ -92,6 +137,18 @@ export function createOrdersModule(transport) {
             }, options);
             return data.unparkOrder;
         },
+        async providerFallbacks(orderId, options) {
+            const data = await transport.graphql({ api: 'admin', query: ORDER_PROVIDER_FALLBACKS_QUERY, variables: { id: orderId } }, options);
+            if (!data.order) {
+                throw new NotFoundError({
+                    code: 'ORDER_NOT_FOUND',
+                    message: `This store has no order ${orderId}.`,
+                    status: 404,
+                    service: 'vendure',
+                });
+            }
+            return data.order.providerFallbacks;
+        },
         async paymentPosition(orderId, options) {
             const data = await transport.graphql({ api: 'admin', query: ORDER_POSITION_QUERY, variables: { orderId } }, options);
             return data.orderPaymentPosition;

package/dist/orders/line-price-preview.d.ts

@@ -0,0 +1,297 @@
+import type { Transport } from '@sixtyninecommerce/core';
+import type { Call } from '../types.js';
+/** The tax basis a unit price is stated in. */
+export type OrderLinePriceBasis = 'NET' | 'GROSS';
+/**
+ * One layer a line's price goes through: the catalogue price, a manual unit
+ * price, the customer's price list, or the order's own one-time pricing.
+ */
+export type OrderLinePriceSource = 'RETAIL' | 'OVERRIDE' | 'PRICE_LIST' | 'ONE_TIME';
+/** How a one-time discount is stated. */
+export type PreviewLineDiscountType = 'PERCENTAGE' | 'FIXED_AMOUNT' | 'FIXED_PRICE';
+/** A manual unit price to stage on a line. */
+export interface PreviewLinePriceOverride {
+    /**
+     * Minor units, a whole number of 0 or more, stated in `basis`. Stated in the
+     * line's own basis (the answer's `basis`) it is taken as it is, on every
+     * line. Stated in the other basis it is converted only at a tax rate the
+     * preview evaluated: the rate the platform taxes the line at on the order as
+     * it is now.
+     */
+    amount: number;
+    /**
+     * The basis `amount` is stated in. The line's own `basis` is always
+     * accepted. The other basis is refused with `INVALID_PREVIEW_INPUT`, in a
+     * message that names the basis to state it in, where the preview evaluates
+     * no tax rate for the line: on every line, stored or new, of a store with an
+     * active tax provider app, and on a line of the order whose variant was
+     * moved to another tax category since. To learn a line's basis first,
+     * preview it without an `override` and read `basis`.
+     */
+    basis: OrderLinePriceBasis;
+}
+/**
+ * A one-time discount to stage: on one line's product variant, or on the whole
+ * order (`options.orderDiscount`).
+ */
+export interface PreviewOneTimeDiscount {
+    /** A whole-order discount is `PERCENTAGE` or `FIXED_AMOUNT`, never `FIXED_PRICE`. */
+    discountType: PreviewLineDiscountType;
+    /**
+     * A whole number. `PERCENTAGE`: basis points, 1 to 10000. `FIXED_AMOUNT`:
+     * minor units off each unit, 1 or more. `FIXED_PRICE`: the unit price in
+     * minor units, 0 or more. The two money kinds are in the CHANNEL's tax basis,
+     * which is not always the line's. These are the values the Admin API's
+     * `setOrderPriceListDiscounts` takes.
+     */
+    discountValue: number;
+}
+/**
+ * One line to preview.
+ *
+ * `override` and `oneTimeDiscount` each have three states: leave the key out
+ * to keep what the order has, pass `null` to clear it, pass a value to stage
+ * it. The SDK sends each as given. A key set to `undefined` counts as left out.
+ */
+export interface PreviewLinePriceLine {
+    /**
+     * The order line to preview. Leave it out, or pass `null`, for a line that is
+     * not on the order yet. An order line may appear once per call.
+     */
+    lineId?: string | null;
+    /** Required on every line. With `lineId` it must be that line's variant. */
+    productVariantId: string;
+    /**
+     * The quantity the line would have, a whole number of 1 or more. It selects
+     * the quantity tier. A removed line cannot be staged.
+     */
+    quantity: number;
+    /** A staged manual unit price. */
+    override?: PreviewLinePriceOverride | null;
+    /**
+     * A staged one-time discount. It applies to the product variant, so to every
+     * line of it: two lines of one variant that stage different discounts are
+     * refused.
+     */
+    oneTimeDiscount?: PreviewOneTimeDiscount | null;
+}
+/** One layer of a previewed price. */
+export interface LinePriceStackingStep {
+    source: OrderLinePriceSource;
+    /** The unit price after this layer, minor units in the line's `basis`. */
+    amount: number;
+}
+/**
+ * Why a line has no price to charge, as a platform code. A string on the wire.
+ * `VARIANT_NOT_FOR_SALE_IN_CURRENCY`: the store does not sell the variant in
+ * the order's currency, and no price was stated for the line.
+ */
+export type LineNotPurchasableCode = 'VARIANT_NOT_FOR_SALE_IN_CURRENCY' | (string & {});
+/** What a preview says of every line, whether it has a price or not. */
+export interface LinePricePreviewBase {
+    /** The order line previewed. `null` for a line that is not on the order yet. */
+    lineId: string | null;
+    productVariantId: string;
+    /**
+     * The basis the engine prices the line in. Send a manual unit price to the
+     * Admin API's `applyOrderLinePriceOverrides` in this basis: the `OVERRIDE`
+     * step of `stacking` is that figure.
+     */
+    basis: OrderLinePriceBasis;
+    /** Always `true`: the engine prices the line in the order's tax zone itself. */
+    basisKnown: boolean;
+    /**
+     * The CATALOGUE retail moved since the stored line was priced: a re-price
+     * starts from another catalogue retail than `retailBase`. For a line a price
+     * list priced, the line recorded that retail gross and no tax rate of its
+     * day, so the two are compared gross. Besides a moved catalogue price, a
+     * change of the rate the catalogue taxes the variant at for this order can
+     * therefore set it too, while the net catalogue price did not move: the rate
+     * of the order's tax zone changed, the order now falls in another tax zone,
+     * or the variant moved to another tax category.
+     *
+     * A changed price list or quantity tier, and a tax driver that changes only
+     * the line's own tax (a reverse charge, tax removed), can move the previewed
+     * figures and leave it `false`. It is always `false` for a list-priced line
+     * of an order outside the store's default currency. To know
+     * whether a re-price would move a stored line, compare BOTH figures with the
+     * line's own: `chargedUnitPrice` with `unitPrice`, and
+     * `chargedUnitPriceWithTax` with `unitPriceWithTax` (a changed tax driver
+     * can move one of them and not the other). The comparison does not see a
+     * changed tax driver on a line that keeps the tax rate it carries: every
+     * line of the order on a store with an active tax provider app, and a line
+     * whose variant was moved to another tax category since.
+     */
+    catalogueChanged: boolean;
+    /**
+     * The layers a re-price goes through, in order. It starts with a `RETAIL`
+     * step at TODAY's catalogue price when the line has one, which is not always
+     * `retailBase`. The last step is the charged unit price in `basis`. Empty for
+     * a line that is not purchasable.
+     */
+    stacking: LinePriceStackingStep[];
+    /** A manual unit price is set, and a contract (fixed) price won over it. */
+    overrideInert: boolean;
+    /**
+     * The net/gross split is the PLATFORM's tax where the store's tax provider
+     * app decides. `true` for a line that is not on the order yet, on a store
+     * with an active tax provider app: a preview never asks the app, which
+     * answers when the line is added. The figure in the line's `basis` is firm.
+     * The OTHER one (the gross of a `NET` line, the net of a `GROSS` line) is
+     * derived at the platform's rate and may differ: show it as provisional.
+     *
+     * A manual price for such a line must be stated in the line's `basis`. One
+     * stated in the other basis is refused with `INVALID_PREVIEW_INPUT`, because
+     * converting it needs the app's rate. To learn the basis first, preview the
+     * line without an `override` and read `basis`. This is not the only line
+     * with that rule: see `PreviewLinePriceOverride.basis`.
+     *
+     * `false` everywhere else, and on a line that is not purchasable, which has
+     * no money to qualify.
+     */
+    taxProvisional: boolean;
+}
+/** A line with a price. Money is minor units in the order's currency, before promotions. */
+export interface PurchasableLinePricePreview extends LinePricePreviewBase {
+    purchasable: true;
+    notPurchasableCode: null;
+    /**
+     * Net unit price the line would be charged. Provisional on a `GROSS` line
+     * while `taxProvisional` is `true`.
+     */
+    chargedUnitPrice: number;
+    /**
+     * Gross unit price the line would be charged. Provisional on a `NET` line
+     * while `taxProvisional` is `true`.
+     */
+    chargedUnitPriceWithTax: number;
+    /**
+     * The retail the line was PRICED AT, in `basis`: the base a percentage is
+     * measured against. For a line that is not on the order yet it is today's
+     * catalogue price. `null` when a stored line recorded none (a manual price
+     * with no price list), and when the line has no catalogue price (an
+     * externally priced line, or a variant not for sale in the order's currency
+     * that a stated price makes purchasable).
+     */
+    retailBase: number | null;
+}
+/**
+ * A line with no price to charge: the store does not sell the variant in the
+ * order's currency and no price was stated for the line. Every money field is
+ * `null`, never 0 and never a rate-derived figure.
+ */
+export interface NotPurchasableLinePricePreview extends LinePricePreviewBase {
+    purchasable: false;
+    notPurchasableCode: LineNotPurchasableCode;
+    chargedUnitPrice: null;
+    chargedUnitPriceWithTax: null;
+    retailBase: null;
+}
+/**
+ * What one line would cost. Check `purchasable` before reading a price: the
+ * money fields are numbers only on a purchasable line.
+ */
+export type LinePricePreview = PurchasableLinePricePreview | NotPurchasableLinePricePreview;
+/**
+ * Its own document on purpose: `previewOrderLinePrices` exists only on an
+ * engine with the line price preview, so on an older one this call alone fails
+ * validation and no other order call does.
+ */
+export declare const PREVIEW_ORDER_LINE_PRICES_QUERY = "\n  query PreviewOrderLinePrices($input: PreviewOrderLinePricesInput!) {\n    previewOrderLinePrices(input: $input) {\n      lineId\n      productVariantId\n      purchasable\n      notPurchasableCode\n      chargedUnitPrice\n      chargedUnitPriceWithTax\n      basis\n      basisKnown\n      retailBase\n      catalogueChanged\n      stacking {\n        source\n        amount\n      }\n      overrideInert\n      taxProvisional\n    }\n  }\n";
+export interface OrderLinePricePreviewModule {
+    /**
+     * What lines of an order would cost, before anything is saved: the pricing
+     * engine's own answer for a staged manual unit price, one-time discount and
+     * quantity, on stored lines and on lines that are not on the order yet. One
+     * result per entry of `lines`, in the order of `lines`. Needs `ReadOrder`,
+     * and an engine that serves `previewOrderLinePrices`.
+     *
+     * A pure read: nothing is saved, no event is published, and no payment or
+     * tax provider is contacted.
+     *
+     * The answer is what a re-price of the line gives now: today's catalogue
+     * price, price lists, tiers and tax. A stored line that a save does not
+     * re-price keeps its stored price, so compare `chargedUnitPrice` and
+     * `chargedUnitPriceWithTax` with the line's own `unitPrice` and
+     * `unitPriceWithTax` to see whether they differ (a changed tax driver can
+     * move one of the two and not the other). `catalogueChanged` reports a
+     * moved catalogue retail only; its own description says what counts as one.
+     *
+     * Two kinds of stored line KEEP the tax rate they carry, and their tax is
+     * not re-evaluated: every line of the order on a store with an active tax
+     * provider app (the app is not asked), and a line whose variant was moved to
+     * another tax category since. A tax driver that changed since (a VAT number
+     * validated, tax removed) does not show in such a line's figures, so the
+     * comparison above does not see it.
+     *
+     * The preview does not
+     * predict what a save refuses: a staged one-time discount that the Admin
+     * API's `setOrderPriceListDiscounts` would refuse is still priced, and shows
+     * no `ONE_TIME` step when the pricing rules skipped it.
+     *
+     * Every figure is minor units in the order's currency, before promotions. A
+     * placed order converts at the rate it was placed at. Each line is taxed as
+     * a re-price would tax it now, apart from the two kinds of stored line named
+     * above.
+     *
+     * A store with an active tax provider app gets a platform-taxed preview for
+     * new lines. There a line of the order keeps the rate it carries, but a
+     * line that is not on the order yet is taxed at the platform's rate: the app
+     * is never asked by a preview and answers when the line is added.
+     * `taxProvisional` marks those lines. Their figure in `basis` is firm. The
+     * other one (the gross of a `NET` line, the net of a `GROSS` line) may then
+     * differ, so show it as provisional.
+     *
+     * On such a store, state every manual price in the line's `basis`, for a
+     * line of the order as well as a new one: preview the line without an
+     * `override` first and read `basis`. One stated in the other basis is
+     * refused there, and on a line of the order whose variant was moved to
+     * another tax category, because the preview never converts a price at a
+     * tax rate it did not evaluate (`PreviewLinePriceOverride.basis`).
+     *
+     * Check `purchasable` before reading a price. A variant the store does not
+     * sell in the order's currency is answered `purchasable: false` with
+     * `notPurchasableCode` set and every money field `null`, never 0, unless a
+     * price is stated for the line (for example a manual unit price, staged or
+     * stored). The own lines of an order placed at a recorded exchange rate are
+     * not judged; a line that is not on the order yet always is.
+     *
+     * `basis` on a result is the basis a manual unit price must be sent in to
+     * the Admin API's `applyOrderLinePriceOverrides`, and the `OVERRIDE` step of
+     * `stacking` is that figure.
+     *
+     * `override` and `oneTimeDiscount` on a line, and `options.orderDiscount`
+     * (a whole-order one-time discount, `PERCENTAGE` or `FIXED_AMOUNT`), each
+     * have three states: left out keeps what the order has, `null` clears it, a
+     * value stages it. The SDK sends them as given.
+     *
+     * At least 1 and at most 100 lines per call. Each call prices from the saved
+     * order plus what that call stages: stage a whole-order discount, and every
+     * quantity a collection or facet tier depends on, in the same call as the
+     * lines they affect. A removed line cannot be staged (a quantity is 1 or
+     * more): the collection and facet tiers of the other lines still count it at
+     * its stored quantity.
+     *
+     * Refusals:
+     * - `PREVIEW_ORDER_NOT_FOUND`, `PREVIEW_ORDER_LINE_NOT_FOUND` and
+     *   `PREVIEW_VARIANT_NOT_FOUND` (`NotFoundError`, 404). An id of another
+     *   store answers like a missing one, and a cancelled line is not found. An
+     *   id that is not a uuid is refused before that with core's
+     *   `ENTITY_NOT_FOUND`, also a `NotFoundError`: branch on the class for
+     *   not-found, not on one code.
+     * - `INVALID_PREVIEW_INPUT` (`ValidationError`, 400): no lines or more than
+     *   100, a quantity below 1, an order line given twice, a `lineId` that is
+     *   not a line of that `productVariantId`, an amount or discount value out
+     *   of range, a `FIXED_PRICE` whole-order discount, two lines of one variant
+     *   staging different one-time discounts, `override: null` on an externally
+     *   priced line (it has no catalogue price to fall back to), or an `override`
+     *   stated in the other basis than the line's on a line whose tax rate the
+     *   preview does not evaluate (`PreviewLinePriceOverride.basis`).
+     * - `PREVIEW_CHANNEL_NOT_ALLOWED` (`PermissionDeniedError`, 403): the call
+     *   was made from the default channel instead of the order's own.
+     */
+    previewLinePrices(orderId: string, lines: PreviewLinePriceLine[], options?: Call & {
+        orderDiscount?: PreviewOneTimeDiscount | null;
+    }): Promise<LinePricePreview[]>;
+}
+export declare function createOrderLinePricePreviewModule(transport: Transport): OrderLinePricePreviewModule;