@sixtyninecommerce/admin 0.8.0 → 0.10.0

package/dist/orders/line-price-preview.js

@@ -0,0 +1,50 @@
+/**
+ * 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 const PREVIEW_ORDER_LINE_PRICES_QUERY = /* GraphQL */ `
+  query PreviewOrderLinePrices($input: PreviewOrderLinePricesInput!) {
+    previewOrderLinePrices(input: $input) {
+      lineId
+      productVariantId
+      purchasable
+      notPurchasableCode
+      chargedUnitPrice
+      chargedUnitPriceWithTax
+      basis
+      basisKnown
+      retailBase
+      catalogueChanged
+      stacking {
+        source
+        amount
+      }
+      overrideInert
+      taxProvisional
+    }
+  }
+`;
+export function createOrderLinePricePreviewModule(transport) {
+    return {
+        async previewLinePrices(orderId, lines, options) {
+            const data = await transport.graphql({
+                api: 'admin',
+                query: PREVIEW_ORDER_LINE_PRICES_QUERY,
+                variables: {
+                    input: {
+                        orderId,
+                        // The lines and `orderDiscount` go out as given, never
+                        // normalised: left out, `null` and a value are three different
+                        // requests to the engine (keep, clear, stage). `JSON.stringify`
+                        // drops a key that is `undefined` and keeps a `null`, so adding
+                        // a `?? null` or a default here would turn "keep" into "clear".
+                        lines,
+                        orderDiscount: options?.orderDiscount,
+                    },
+                },
+            }, options);
+            return data.previewOrderLinePrices;
+        },
+    };
+}

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

@@ -0,0 +1,141 @@
+import type { Transport } from '@sixtyninecommerce/core';
+import type { Call } from '../types.js';
+/**
+ * Manual discounts with a reason (incentives spec §4 decision 6): a store's list of discount
+ * reasons, its discount policy, and the log of the price movements the two pricing doors made on
+ * an order. The discounts themselves are given through those two doors: a manual unit price
+ * (`orders.setLinePrices`, the Admin API's `applyOrderLinePriceOverrides`) and one-time pricing
+ * (`orders.setOneTimeDiscounts`, `setOrderPriceListDiscounts`). Each takes a reason code, and a
+ * call that lowers a line's price follows the store's policy.
+ *
+ * WHO GAVE IT is never an argument: a token's own user is recorded, and the staff member and
+ * device it acts for are the `x-on-behalf-of` / `x-device-ref` refs the SDK already sends from
+ * `tenant.actor` (`TenantContext.actor`). The platform records them only when the credential is
+ * a machine token or an app installation, which it vouches for.
+ */
+/** One of the store's reasons for a manual discount. */
+export interface DiscountReason {
+    id: string;
+    /** Stable code the store chose: lower-case letters, digits, `-` and `_`. */
+    code: string;
+    label: string;
+    /** An inactive reason stays on the records that name it and is refused for new ones. */
+    active: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface DiscountReasonInput {
+    code: string;
+    label: string;
+    /** Omitted keeps the stored state; a new reason starts active. */
+    active?: boolean;
+}
+/** The store's rule for the manual discount doors. */
+export interface DiscountPolicy {
+    /**
+     * When true, a call that lowers a line's pre-promotion unit price needs one of the store's
+     * active reasons for that line. A till discount (`pos.sale.applyDiscount`) is not held to it.
+     */
+    reasonRequired: boolean;
+    /**
+     * 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.
+     */
+    maxDiscountBps: number | null;
+}
+export interface DiscountPolicyInput {
+    /** Omitted keeps the stored value. */
+    reasonRequired?: boolean;
+    /** 0..10000 basis points; omitted keeps the stored value, `null` removes the ceiling. */
+    maxDiscountBps?: number | null;
+}
+/**
+ * One price movement a manual-discount door made on an order. Append-only. Each row is a price
+ * movement that door made; the sum of an order's rows is the net manual price movement recorded
+ * since the layer was enabled, not a statement of what discount is in force.
+ */
+export interface OrderManualDiscount {
+    id: string;
+    createdAt: string;
+    orderId: string;
+    /** 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.
+     */
+    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.
+     */
+    amount: number;
+    /** The same movement gross. */
+    amountWithTax: number;
+    currencyCode: string;
+    /** The reason the price fell under; `null` when it rose, or fell with none asked. */
+    reason: {
+        id: string;
+        code: string;
+        label: string;
+        active: boolean;
+    } | 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>`. */
+    onBehalfOfRef: string | null;
+    /** The vouched-for `x-device-ref` ref; for a paired till vouched for nothing, `pos-device:<id>`. */
+    deviceRef: string | null;
+    /** Shared by the rows of one call. */
+    callId: string;
+}
+export interface DiscountReasonsModule {
+    /**
+     * The store's reasons, active first. Needs `ReadOrder`, `ReadSettings` or `OperatePos` (the
+     * `pos` token, whose till sends one with `pos.sale.applyDiscount`).
+     */
+    list(options?: Call & {
+        includeInactive?: boolean;
+    }): Promise<DiscountReason[]>;
+    /**
+     * Create the reason, or change the label and active flag of the one with this code. A reason
+     * is never deleted: retire it with `active: false`. Needs `UpdateSettings`. Refused
+     * `DISCOUNT_REASON_CODE_INVALID` / `DISCOUNT_REASON_LABEL_INVALID` (→ `ValidationError`), and
+     * `DISCOUNT_REASON_LABEL_CONFLICT` when an active reason would share a label or code with
+     * another, so each name means one reason (staff read labels, integrations send codes). Only a
+     * `reasonCode` satisfies the policy; a price note is free text and never read as a reason.
+     */
+    upsert(input: DiscountReasonInput, options?: Call): Promise<DiscountReason>;
+}
+export interface DiscountPolicyModule {
+    /**
+     * The store's policy; the default (no reason required) when it never set one. Needs
+     * `ReadOrder`, `ReadSettings` or `OperatePos`.
+     */
+    get(options?: Call): Promise<DiscountPolicy>;
+    /** Needs `UpdateSettings`. */
+    update(input: DiscountPolicyInput, options?: Call): Promise<DiscountPolicy>;
+}
+/**
+ * A store's discount reasons and policy, and what an order was given (`ReadOrder`).
+ *
+ * The policy is applied by the doors that give a manual discount (`orders.setLinePrices`,
+ * `orders.setOneTimeDiscounts`), which refuse with `DISCOUNT_REASON_REQUIRED` and
+ * `DISCOUNT_REASON_UNKNOWN`. The till's
+ * `pos.sale.applyDiscount` records the reason it is given and refuses only an unknown code.
+ */
+export interface ManualDiscountsModule {
+    /** Every price movement recorded on the order, newest first. Another store's order answers `[]`. */
+    list(orderId: string, options?: Call): Promise<OrderManualDiscount[]>;
+    reasons: DiscountReasonsModule;
+    policy: DiscountPolicyModule;
+}
+export declare const DISCOUNT_REASONS_QUERY = "\n  query DiscountReasons($includeInactive: Boolean) {\n    discountReasons(includeInactive: $includeInactive) {\n      \n  id\n  code\n  label\n  active\n  createdAt\n  updatedAt\n\n    }\n  }\n";
+export declare const UPSERT_DISCOUNT_REASON_MUTATION = "\n  mutation UpsertDiscountReason($input: UpsertDiscountReasonInput!) {\n    upsertDiscountReason(input: $input) {\n      \n  id\n  code\n  label\n  active\n  createdAt\n  updatedAt\n\n    }\n  }\n";
+export declare const DISCOUNT_POLICY_QUERY = "\n  query DiscountPolicy {\n    discountPolicy {\n      reasonRequired\n      maxDiscountBps\n    }\n  }\n";
+export declare const UPDATE_DISCOUNT_POLICY_MUTATION = "\n  mutation UpdateDiscountPolicy($input: UpdateDiscountPolicyInput!) {\n    updateDiscountPolicy(input: $input) {\n      reasonRequired\n      maxDiscountBps\n    }\n  }\n";
+export declare const ORDER_MANUAL_DISCOUNTS_QUERY = "\n  query OrderManualDiscounts($orderId: ID!) {\n    orderManualDiscounts(orderId: $orderId) {\n      \n  id\n  createdAt\n  orderId\n  orderLineId\n  door\n  amount\n  amountWithTax\n  currencyCode\n  reason {\n    id\n    code\n    label\n    active\n  }\n  actorUserId\n  onBehalfOfRef\n  deviceRef\n  callId\n\n    }\n  }\n";
+export declare function createManualDiscountsModule(transport: Transport): ManualDiscountsModule;

package/dist/orders/manual-discounts.js

@@ -0,0 +1,97 @@
+const REASON_FIELDS = /* GraphQL */ `
+  id
+  code
+  label
+  active
+  createdAt
+  updatedAt
+`;
+const RECORD_FIELDS = /* GraphQL */ `
+  id
+  createdAt
+  orderId
+  orderLineId
+  door
+  amount
+  amountWithTax
+  currencyCode
+  reason {
+    id
+    code
+    label
+    active
+  }
+  actorUserId
+  onBehalfOfRef
+  deviceRef
+  callId
+`;
+export const DISCOUNT_REASONS_QUERY = /* GraphQL */ `
+  query DiscountReasons($includeInactive: Boolean) {
+    discountReasons(includeInactive: $includeInactive) {
+      ${REASON_FIELDS}
+    }
+  }
+`;
+export const UPSERT_DISCOUNT_REASON_MUTATION = /* GraphQL */ `
+  mutation UpsertDiscountReason($input: UpsertDiscountReasonInput!) {
+    upsertDiscountReason(input: $input) {
+      ${REASON_FIELDS}
+    }
+  }
+`;
+export const DISCOUNT_POLICY_QUERY = /* GraphQL */ `
+  query DiscountPolicy {
+    discountPolicy {
+      reasonRequired
+      maxDiscountBps
+    }
+  }
+`;
+export const UPDATE_DISCOUNT_POLICY_MUTATION = /* GraphQL */ `
+  mutation UpdateDiscountPolicy($input: UpdateDiscountPolicyInput!) {
+    updateDiscountPolicy(input: $input) {
+      reasonRequired
+      maxDiscountBps
+    }
+  }
+`;
+export const ORDER_MANUAL_DISCOUNTS_QUERY = /* GraphQL */ `
+  query OrderManualDiscounts($orderId: ID!) {
+    orderManualDiscounts(orderId: $orderId) {
+      ${RECORD_FIELDS}
+    }
+  }
+`;
+export function createManualDiscountsModule(transport) {
+    return {
+        async list(orderId, options) {
+            const data = await transport.graphql({ api: 'admin', query: ORDER_MANUAL_DISCOUNTS_QUERY, variables: { orderId } }, options);
+            return data.orderManualDiscounts;
+        },
+        reasons: {
+            async list(options) {
+                const data = await transport.graphql({
+                    api: 'admin',
+                    query: DISCOUNT_REASONS_QUERY,
+                    variables: { includeInactive: options?.includeInactive },
+                }, options);
+                return data.discountReasons;
+            },
+            async upsert(input, options) {
+                const data = await transport.graphql({ api: 'admin', query: UPSERT_DISCOUNT_REASON_MUTATION, variables: { input } }, options);
+                return data.upsertDiscountReason;
+            },
+        },
+        policy: {
+            async get(options) {
+                const data = await transport.graphql({ api: 'admin', query: DISCOUNT_POLICY_QUERY }, options);
+                return data.discountPolicy;
+            },
+            async update(input, options) {
+                const data = await transport.graphql({ api: 'admin', query: UPDATE_DISCOUNT_POLICY_MUTATION, variables: { input } }, options);
+                return data.updateDiscountPolicy;
+            },
+        },
+    };
+}

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

@@ -0,0 +1,192 @@
+import type { Transport } from '@sixtyninecommerce/core';
+import { type OrderDiscounts } from '../pricing/index.js';
+import type { Call } from '../types.js';
+/**
+ * The two doors that move a manual price on an order (incentives spec §4 decision 6): a line's
+ * manual unit price (`applyOrderLinePriceOverrides`) and the order's one-time discounts
+ * (`setOrderPriceListDiscounts`). Their read twin is `orders.previewLinePrices`, which prices the
+ * same changes without saving them; what each call moved is read back with
+ * `orders.manualDiscounts.list`.
+ *
+ * Both run in one transaction, re-price the lines they change, and re-total the order. Both move
+ * money with NO refund, so both refuse an order whose payment was collected. Change such an
+ * order through an order modification: plan it with `orders.planEdit` (which saves and refunds
+ * nothing), then carry it out through the Admin API's `modifyOrder` directly, which issues the
+ * refund. This SDK has no method for that step until `orders.commitEdit` ships.
+ */
+/** How a one-time discount is stated (the engine's `OrderPriceListDiscountType`). */
+export type OneTimeDiscountType = 'PERCENTAGE' | 'FIXED_AMOUNT' | 'FIXED_PRICE';
+/** One line's change for {@link OrderManualPricingModule.setLinePrices}. */
+export interface LinePriceInput {
+    orderLineId: string;
+    /**
+     * The manual unit price, a whole number of minor units, 0 or more, in the LINE's tax basis:
+     * gross when the line's `listPriceIncludesTax` is true (`orders.get`), net otherwise. That is
+     * the `basis` `orders.previewLinePrices` answers for the line, and it is not always the store's:
+     * a line priced in a customer-country tax zone is net on a store that prices gross. The engine
+     * takes no basis with it and converts nothing.
+     *
+     * Three states: left out keeps the stored price (a note-only change), `null` clears it and
+     * re-prices the line from the catalogue, a number sets it.
+     */
+    unitPriceOverride?: number | null;
+    /** A free-text note on the price. Left out keeps the stored one; `null` or `''` clears it. */
+    priceOverrideReason?: string | null;
+    /**
+     * One of the store's active discount reasons (`manualDiscounts.reasons`), by code, for this
+     * line when the call lowers its price. Wins over the call's `reasonCode` for this line.
+     */
+    reasonCode?: string | null;
+}
+export interface SetLinePricesInput {
+    /** At least one line; a line once per call. Lines not named keep the price they have. */
+    lines: LinePriceInput[];
+    /** The reason for every line whose price the call lowers and that names none of its own. */
+    reasonCode?: string | null;
+}
+/** A one-time discount on one line's product variant. */
+export interface OneTimeLineDiscountInput {
+    orderLineId: string;
+    discountType: OneTimeDiscountType;
+    /**
+     * A whole number. `PERCENTAGE`: basis points, 1 to 10000. `FIXED_AMOUNT`: minor units off each
+     * unit, 1 or more. `FIXED_PRICE`: the unit price itself, minor units, 0 or more. The two money
+     * kinds are in the STORE's tax basis (as its catalogue prices are entered), which is not always
+     * the line's, and in the order's currency.
+     */
+    discountValue: number;
+    /** One of the store's active discount reasons, by code, for this line when its price falls. */
+    reasonCode?: string | null;
+}
+/** The whole-order one-time discount: every live line without an entry of its own. */
+export interface OneTimeOrderDiscountInput {
+    /** `FIXED_PRICE` is refused: one absolute price for every product is never what is meant. */
+    discountType: Exclude<OneTimeDiscountType, 'FIXED_PRICE'>;
+    /**
+     * `PERCENTAGE`: basis points, 1 to 10000. `FIXED_AMOUNT`: minor units in the store's tax basis
+     * taken off EVERY UNIT, 1 or more. An amount off the order total is a surcharge
+     * (`orders.surcharges.add` with a negative price), not this.
+     */
+    discountValue: number;
+    /**
+     * One of the store's active discount reasons, for every line this discount covers whose price
+     * falls. Wins over the call's `reasonCode` for those lines.
+     */
+    reasonCode?: string | null;
+}
+/**
+ * The COMPLETE one-time pricing the order should end with. Not a change: a live line that is not
+ * in `lines` has no line discount afterwards, and `orderDiscount: null` removes the whole-order
+ * one. To keep what the order has, send it again (`orders.get(id, { include: ['priceList'] })`
+ * reads it).
+ */
+export interface SetOneTimeDiscountsInput {
+    /** Required, so that removing it is said out loud: `null` for no whole-order discount. */
+    orderDiscount: OneTimeOrderDiscountInput | null;
+    /** Every line discount the order should have. An empty list removes them all. */
+    lines: OneTimeLineDiscountInput[];
+    /** A free-text note kept once for the order. Left out or `null` keeps it; `''` clears it. */
+    reason?: string | null;
+    /** The reason for every line whose price the call lowers and that no other `reasonCode` covers. */
+    reasonCode?: string | null;
+}
+/**
+ * The two manual pricing doors. Each answers the order as the engine left it, read with the same
+ * fields as `pricing.discounts(orderId)`: every line's `unitPrice` / `unitPriceWithTax` is its
+ * price before promotions, which is where a manual price or a one-time discount shows (neither is
+ * a promotion, so neither appears in `discounts`). The record of what the call moved is
+ * `orders.manualDiscounts.list(orderId)`: one row per line whose price changed, with the reason
+ * when the price fell.
+ *
+ * **Reasons.** A line whose price before promotions the call LOWERS received a manual discount.
+ * When the store requires a reason (`orders.manualDiscounts.policy`), every such line needs one,
+ * from its own entry or from the call. A line whose price does not fall needs none: a raise, a
+ * price a contract's fixed price wins over, a note-only change. Only a `reasonCode` counts as a
+ * reason; a note is free text.
+ *
+ * **Idempotency.** Takes `options.idempotencyKey`, as the other money writes do. The first answer
+ * under a key is kept for 24 hours and given again to the same request without running it: a
+ * success (the order, re-read as it is now) and EVERY refusal with a 4xx status, the doors' own
+ * `USER_INPUT_ERROR` guards included (a collected payment, a completed order, a bad value). Only a
+ * failure with a 5xx, 408, 425 or 429 status frees the key for a retry. So once you have fixed
+ * the cause of a refusal (reopened the order, picked a reason), send the corrected request under a
+ * NEW key: the same key on a different request, the other door included, is
+ * `IDEMPOTENCY_CONFLICT`.
+ *
+ * **Coded refusals.** Nothing is written by a refused call.
+ * - `DISCOUNT_REASON_REQUIRED` (`BusinessRuleError`, 422): the store requires a reason, the call
+ *   lowered a line's price, and no reason covers that line. Ask the merchant for one of
+ *   `manualDiscounts.reasons.list()` and send it on the line or the call.
+ * - `DISCOUNT_REASON_UNKNOWN` (`BusinessRuleError`, 422): a code sent, at any level, is not one of
+ *   the store's active reasons (unknown, retired, or another store's). Checked before anything is
+ *   written, also on a call that lowers no price.
+ * - `IDEMPOTENCY_CONFLICT` (`ConflictError`, 409): the key was used for another request. Use a
+ *   fresh key per intended write. `IDEMPOTENCY_IN_PROGRESS` (`ConflictError`, 409): the first call
+ *   under the key is still running; ask again shortly. `IDEMPOTENCY_KEY_INVALID`
+ *   (`ValidationError`, 400): a key is 1 to 255 characters.
+ *
+ * **Uncoded refusals.** The doors' own guards are core `UserInputError`s: `ValidationError` (400)
+ * with code `USER_INPUT_ERROR` and the engine's sentence, which says what to do. Branch on the
+ * class and show the message; the engine gives these no codes of their own. They are:
+ * - the payment was collected (a settled payment, or one authorized on a card or online gateway):
+ *   plan the edit with `orders.planEdit`, then carry it out through the Admin API's `modifyOrder`
+ *   (no SDK method until `orders.commitEdit`), which refunds the difference. A payment authorized
+ *   on an offline method (bank transfer, invoice, net terms) collected nothing and does not
+ *   block. A payment whose method is no longer on the store cannot be judged: restore the method;
+ * - the order is invoiced (locked), completed (reopen it first) or cancelled;
+ * - the call was made from the default channel instead of the order's own;
+ * - the order is not this store's (the same answer as a missing one), or a named line is not on
+ *   it, has been cancelled, or is named twice.
+ *
+ * Each method lists the refusals of its own below. An id that is not a uuid is refused before all
+ * of this with core's `ENTITY_NOT_FOUND` (`NotFoundError`, 404).
+ *
+ * Both need `UpdateOrder`, and an engine with the discount-reason layer (one that serves
+ * `discountReasons`); on an older one only these two calls fail.
+ */
+export interface OrderManualPricingModule {
+    /**
+     * Set or clear the manual unit price, or its note, on lines of an order, and re-total it. Only
+     * the named lines are re-priced; every other line keeps its price. Taxes and totals are
+     * recalculated across the whole order.
+     *
+     * The manual price is a layer, not the final price: the customer's price list and the order's
+     * one-time discounts still apply on top of it, and a contract's fixed price wins over it
+     * (`previewLinePrices` answers `overrideInert` then). Setting or clearing a price takes the line
+     * out of the "exact price" state an imported, quoted or till-priced line arrives in
+     * (`customFields.unitPriceImported`), so those layers apply to it from then on; this door never
+     * sets that flag.
+     *
+     * Refusals of its own (`ValidationError`, `USER_INPUT_ERROR`): an empty `lines`; a line with
+     * 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.
+     */
+    setLinePrices(orderId: string, input: SetLinePricesInput, options?: Call): Promise<OrderDiscounts>;
+    /**
+     * Replace the order's one-time pricing with `input`, its complete desired state, and re-price
+     * the lines it affects. A one-time discount is a price list of the order's own, ranked above
+     * every other price list and applied on top of a manual unit price. It applies to a line's
+     * product VARIANT, so the engine refuses it on a variant that is on two live lines (merge them
+     * first). Under a whole-order discount, lines an external system or an import priced exactly
+     * and free lines are skipped. Fixed money is in the order's currency at the time of the call.
+     * A call that removes everything on an order that has nothing writes nothing.
+     *
+     * Refusals of its own (`ValidationError`, `USER_INPUT_ERROR`): a value out of range or not a
+     * whole number; a `FIXED_PRICE` whole-order discount; a line entry on a line priced exactly
+     * (an import, an accepted quote, a till price: give it a manual unit price instead), on a free
+     * line, or on a variant that is on another live line; a discount the pricing rules could not
+     * apply (a `FIXED_AMOUNT` larger than the unit price is skipped, never clamped, and the message
+     * names the SKU); fixed money stored in another currency than the order's now (remove the
+     * one-time pricing, then set it again); and two first writes on one order at once (reload the
+     * order, then try again).
+     */
+    setOneTimeDiscounts(orderId: string, input: SetOneTimeDiscountsInput, options?: Call): Promise<OrderDiscounts>;
+}
+/**
+ * Each door its own document: the reason and key arguments exist only on an engine with the
+ * discount-reason layer, so on an older one these calls alone fail validation.
+ */
+export declare const APPLY_ORDER_LINE_PRICE_OVERRIDES_MUTATION = "\n  mutation ApplyOrderLinePriceOverrides(\n    $orderId: ID!\n    $lines: [OrderLinePriceOverrideInput!]!\n    $reasonCode: String\n    $idempotencyKey: String\n  ) {\n    applyOrderLinePriceOverrides(\n      orderId: $orderId\n      lines: $lines\n      reasonCode: $reasonCode\n      idempotencyKey: $idempotencyKey\n    ) {\n      \n  id\n  code\n  state\n  currencyCode\n  couponCodes\n  subTotal\n  subTotalWithTax\n  shipping\n  shippingWithTax\n  total\n  totalWithTax\n  discounts { promotionId adjustmentSource type description amount amountWithTax }\n  promotions { id name }\n  lines {\n    id\n    quantity\n    productVariant { id sku name }\n    unitPrice\n    unitPriceWithTax\n    linePrice\n    linePriceWithTax\n    discountedLinePrice\n    discountedLinePriceWithTax\n    proratedLinePrice\n    proratedLinePriceWithTax\n    discounts { promotionId adjustmentSource type description amount amountWithTax }\n  }\n  surcharges { id description sku price priceWithTax }\n  packages { promotionId label price priceWithTax lineIds quantity }\n\n    }\n  }\n";
+export declare const SET_ORDER_PRICE_LIST_DISCOUNTS_MUTATION = "\n  mutation SetOrderPriceListDiscounts(\n    $input: SetOrderPriceListDiscountsInput!\n    $idempotencyKey: String\n  ) {\n    setOrderPriceListDiscounts(input: $input, idempotencyKey: $idempotencyKey) {\n      \n  id\n  code\n  state\n  currencyCode\n  couponCodes\n  subTotal\n  subTotalWithTax\n  shipping\n  shippingWithTax\n  total\n  totalWithTax\n  discounts { promotionId adjustmentSource type description amount amountWithTax }\n  promotions { id name }\n  lines {\n    id\n    quantity\n    productVariant { id sku name }\n    unitPrice\n    unitPriceWithTax\n    linePrice\n    linePriceWithTax\n    discountedLinePrice\n    discountedLinePriceWithTax\n    proratedLinePrice\n    proratedLinePriceWithTax\n    discounts { promotionId adjustmentSource type description amount amountWithTax }\n  }\n  surcharges { id description sku price priceWithTax }\n  packages { promotionId label price priceWithTax lineIds quantity }\n\n    }\n  }\n";
+export declare function createOrderManualPricingModule(transport: Transport): OrderManualPricingModule;

package/dist/orders/manual-pricing.js

@@ -0,0 +1,72 @@
+import { ORDER_DISCOUNTS_FIELDS } from '../pricing/index.js';
+/**
+ * Each door its own document: the reason and key arguments exist only on an engine with the
+ * discount-reason layer, so on an older one these calls alone fail validation.
+ */
+export const APPLY_ORDER_LINE_PRICE_OVERRIDES_MUTATION = /* GraphQL */ `
+  mutation ApplyOrderLinePriceOverrides(
+    $orderId: ID!
+    $lines: [OrderLinePriceOverrideInput!]!
+    $reasonCode: String
+    $idempotencyKey: String
+  ) {
+    applyOrderLinePriceOverrides(
+      orderId: $orderId
+      lines: $lines
+      reasonCode: $reasonCode
+      idempotencyKey: $idempotencyKey
+    ) {
+      ${ORDER_DISCOUNTS_FIELDS}
+    }
+  }
+`;
+export const SET_ORDER_PRICE_LIST_DISCOUNTS_MUTATION = /* GraphQL */ `
+  mutation SetOrderPriceListDiscounts(
+    $input: SetOrderPriceListDiscountsInput!
+    $idempotencyKey: String
+  ) {
+    setOrderPriceListDiscounts(input: $input, idempotencyKey: $idempotencyKey) {
+      ${ORDER_DISCOUNTS_FIELDS}
+    }
+  }
+`;
+export function createOrderManualPricingModule(transport) {
+    return {
+        async setLinePrices(orderId, input, options) {
+            const data = await transport.graphql({
+                api: 'admin',
+                query: APPLY_ORDER_LINE_PRICE_OVERRIDES_MUTATION,
+                // The lines go out as given, never normalised: a `unitPriceOverride` left out keeps the
+                // stored price and `null` clears it. `JSON.stringify` drops a key that is `undefined`
+                // and keeps a `null`, so a default here would turn "keep" into "clear". The same holds
+                // for the reason code and the key: absent, they never reach the wire as null.
+                variables: {
+                    orderId,
+                    lines: input.lines,
+                    reasonCode: input.reasonCode,
+                    idempotencyKey: options?.idempotencyKey,
+                },
+            }, options);
+            return data.applyOrderLinePriceOverrides;
+        },
+        async setOneTimeDiscounts(orderId, input, options) {
+            const data = await transport.graphql({
+                api: 'admin',
+                query: SET_ORDER_PRICE_LIST_DISCOUNTS_MUTATION,
+                variables: {
+                    input: {
+                        orderId,
+                        // The engine reads a missing whole-order discount as none, so the request states it:
+                        // the wire then carries the whole desired state, `null` included.
+                        orderDiscount: input.orderDiscount ?? null,
+                        lines: input.lines,
+                        reason: input.reason,
+                        reasonCode: input.reasonCode,
+                    },
+                    idempotencyKey: options?.idempotencyKey,
+                },
+            }, options);
+            return data.setOrderPriceListDiscounts;
+        },
+    };
+}