@sixtyninecommerce/admin 0.8.0 → 0.9.0

package/dist/orders/index.js

@@ -1,4 +1,27 @@
+import { NotFoundError } from '@sixtyninecommerce/core';
+import { createOrderCommitEditModule } from './commit-edit.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';
+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 +90,16 @@ 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),
         async park(orderId, options) {
             const data = await transport.graphql({
                 api: 'admin',
@@ -92,6 +124,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;

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,132 @@
+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;
+}
+export interface DiscountPolicyInput {
+    /** Omitted keeps the stored value. */
+    reasonRequired?: boolean;
+}
+/**
+ * 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    }\n  }\n";
+export declare const UPDATE_DISCOUNT_POLICY_MUTATION = "\n  mutation UpdateDiscountPolicy($input: UpdateDiscountPolicyInput!) {\n    updateDiscountPolicy(input: $input) {\n      reasonRequired\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,95 @@
+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
+    }
+  }
+`;
+export const UPDATE_DISCOUNT_POLICY_MUTATION = /* GraphQL */ `
+  mutation UpdateDiscountPolicy($input: UpdateDiscountPolicyInput!) {
+    updateDiscountPolicy(input: $input) {
+      reasonRequired
+    }
+  }
+`;
+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;
+            },
+        },
+    };
+}