@sixtyninecommerce/admin 0.8.0 → 0.10.0

package/dist/pos/index.js

@@ -0,0 +1,205 @@
+import { createPage } from '@sixtyninecommerce/core';
+const REGISTER_FIELDS = 'id stockLocationId name status createdAt updatedAt';
+const TOTALS = 'cash card other refunds net saleCount';
+const SESSION_FIELDS = `id registerId deviceId openedByStaffId openingFloat status expectedCash countedCash cashOverShort totals openedAt closedAt`;
+const CART_FIELDS = `id code state currencyCode total totalWithTax couponCodes
+  lines { id quantity productVariant { id } linePriceWithTax }
+  surcharges { description sku price priceWithTax taxRate }`;
+const TENDER_FIELDS = 'orderId paymentId covered outstanding change';
+const DEVICE_FIELDS = 'id stockLocationId registerId label status paired lastSeenAt';
+export const POS_REGISTERS_QUERY = `query PosRegisters { posRegisters { ${REGISTER_FIELDS} } }`;
+export const POS_REGISTER_QUERY = `query PosRegister($id: ID!) { posRegister(id: $id) { ${REGISTER_FIELDS} } }`;
+export const CREATE_POS_REGISTER_MUTATION = `mutation CreatePosRegister($input: CreatePosRegisterInput!) { createPosRegister(input: $input) { ${REGISTER_FIELDS} } }`;
+export const UPDATE_POS_REGISTER_MUTATION = `mutation UpdatePosRegister($id: ID!, $input: UpdatePosRegisterInput!) { updatePosRegister(id: $id, input: $input) { ${REGISTER_FIELDS} } }`;
+export const OPEN_POS_SESSION_MUTATION = `mutation OpenPosRegisterSession($input: OpenPosRegisterSessionInput!, $staffToken: String) { openPosRegisterSession(input: $input, staffToken: $staffToken) { ${SESSION_FIELDS} } }`;
+export const CLOSE_POS_SESSION_MUTATION = `mutation ClosePosRegisterSession($input: ClosePosRegisterSessionInput!, $staffToken: String) { closePosRegisterSession(input: $input, staffToken: $staffToken) { ${SESSION_FIELDS} } }`;
+export const POS_X_REPORT_QUERY = `query PosXReport($sessionId: ID!) { posXReport(sessionId: $sessionId) { sessionId openingFloat expectedCash movementCount totals { ${TOTALS} } } }`;
+export const POS_SESSION_QUERY = `query PosRegisterSession($id: ID!) { posRegisterSession(id: $id) { ${SESSION_FIELDS} } }`;
+export const RECORD_POS_CASH_MOVEMENT_MUTATION = `mutation RecordPosCashMovement($input: RecordPosCashMovementInput!, $staffToken: String) { recordPosCashMovement(input: $input, staffToken: $staffToken) { id sessionId type amount reason orderId createdAt } }`;
+export const POS_CREATE_CART_MUTATION = `mutation PosCreateCart($registerId: ID) { posCreateCart(registerId: $registerId) { ${CART_FIELDS} } }`;
+export const POS_ADD_ITEM_MUTATION = `mutation PosAddItem($input: PosAddItemInput!) { posAddItem(input: $input) { ${CART_FIELDS} } }`;
+export const POS_APPLY_DISCOUNT_MUTATION = `mutation PosApplyDiscount($input: PosApplyDiscountInput!, $staffToken: String) { posApplyDiscount(input: $input, staffToken: $staffToken) { ${CART_FIELDS} } }`;
+export const POS_APPLY_COUPON_CODE_MUTATION = `mutation PosApplyCouponCode($input: PosCouponCodeInput!) { posApplyCouponCode(input: $input) { ${CART_FIELDS} } }`;
+export const POS_REMOVE_COUPON_CODE_MUTATION = `mutation PosRemoveCouponCode($input: PosCouponCodeInput!) { posRemoveCouponCode(input: $input) { ${CART_FIELDS} } }`;
+export const POS_COMPLETE_SALE_MUTATION = `mutation PosCompleteSale($input: PosCompleteSaleInput!, $staffToken: String) { posCompleteSale(input: $input, staffToken: $staffToken) { orderId orderCode receiptNumber state } }`;
+export const POS_TENDER_CASH_MUTATION = `mutation PosTenderCash($input: PosTenderCashInput!, $staffToken: String) { posTenderCash(input: $input, staffToken: $staffToken) { ${TENDER_FIELDS} } }`;
+export const POS_TENDER_CARD_MUTATION = `mutation PosTenderCard($input: PosTenderCardInput!, $staffToken: String) { posTenderCard(input: $input, staffToken: $staffToken) { ${TENDER_FIELDS} } }`;
+export const POS_TENDER_STORED_VALUE_MUTATION = `mutation PosTenderStoredValue($input: PosTenderStoredValueInput!, $staffToken: String) { posTenderStoredValue(input: $input, staffToken: $staffToken) { ${TENDER_FIELDS} } }`;
+export const POS_TENDER_MANUAL_MUTATION = `mutation PosTenderManual($input: PosTenderManualInput!, $staffToken: String) { posTenderManual(input: $input, staffToken: $staffToken) { ${TENDER_FIELDS} } }`;
+export const POS_REFUND_MUTATION = `mutation PosRefund($input: PosRefundInput!, $staffToken: String) { posRefund(input: $input, staffToken: $staffToken) { orderId refundId state } }`;
+export const POS_DEVICES_QUERY = `query PosDevices { posDevices { ${DEVICE_FIELDS} } }`;
+export const POS_DEVICE_QUERY = `query PosDevice($id: ID!) { posDevice(id: $id) { lastSeenAt } }`;
+export const POS_PAIRING_CODE_MUTATION = `mutation GeneratePosPairingCode($deviceId: ID!) { generatePosPairingCode(deviceId: $deviceId) { code expiresAt } }`;
+export const REVOKE_POS_DEVICE_MUTATION = `mutation RevokePosDevice($deviceId: ID!) { revokePosDevice(deviceId: $deviceId) { ${DEVICE_FIELDS} } }`;
+export const POS_RECEIPT_NUMBERING_QUERY = `query PosReceiptNumberingConfig { posReceiptNumberingConfig { prefix suffix digits } }`;
+export const UPDATE_POS_RECEIPT_NUMBERING_MUTATION = `mutation UpdatePosReceiptNumberingConfig($input: UpdatePosReceiptNumberingConfigInput!) { updatePosReceiptNumberingConfig(input: $input) { prefix suffix digits } }`;
+function toCart(raw) {
+    return {
+        ...raw,
+        lines: raw.lines.map((line) => ({
+            id: line.id,
+            quantity: line.quantity,
+            productVariantId: line.productVariant.id,
+            linePriceWithTax: line.linePriceWithTax,
+        })),
+    };
+}
+/**
+ * The wire answers `""` rather than null for a session a machine principal
+ * opened (the fields shipped `ID!`, and relaxing an output field breaks older
+ * consumers); this module's type says what that means.
+ */
+function toSession(raw) {
+    return { ...raw, deviceId: raw.deviceId || null, openedByStaffId: raw.openedByStaffId || null };
+}
+function wholeList(items) {
+    return createPage(items, { nextCursor: null, hasNext: false, total: items.length }, () => {
+        throw new Error('this list is returned whole; there is no next page');
+    });
+}
+/**
+ * The key is a REQUIRED `String!` on the server; an empty one would be a
+ * GraphQL validation error that names no field a caller recognises, so it is
+ * refused here with the name of the option that was missing.
+ */
+function requireKey(options) {
+    const key = options?.idempotencyKey;
+    if (typeof key !== 'string' || key.trim() === '') {
+        throw new TypeError('A POS money call needs options.idempotencyKey (a fresh UUIDv7 per operation).');
+    }
+    return key;
+}
+export function createPosModule(transport) {
+    const gql = async (query, variables, options) => transport.graphql({ api: 'admin', query, variables }, options);
+    return {
+        registers: {
+            async list(options) {
+                const data = await gql(POS_REGISTERS_QUERY, {}, options);
+                return wholeList(data.posRegisters);
+            },
+            async get(id, options) {
+                const data = await gql(POS_REGISTER_QUERY, { id }, options);
+                return data.posRegister;
+            },
+            async create(input, options) {
+                const data = await gql(CREATE_POS_REGISTER_MUTATION, { input }, options);
+                return data.createPosRegister;
+            },
+            async update(id, input, options) {
+                const data = await gql(UPDATE_POS_REGISTER_MUTATION, { id, input }, options);
+                return data.updatePosRegister;
+            },
+        },
+        sessions: {
+            async open(input, options) {
+                const data = await gql(OPEN_POS_SESSION_MUTATION, { input, staffToken: options?.staffToken }, options);
+                return toSession(data.openPosRegisterSession);
+            },
+            async close(input, options) {
+                const data = await gql(CLOSE_POS_SESSION_MUTATION, { input, staffToken: options?.staffToken }, options);
+                return toSession(data.closePosRegisterSession);
+            },
+            async xReport(sessionId, options) {
+                const data = await gql(POS_X_REPORT_QUERY, { sessionId }, options);
+                return data.posXReport;
+            },
+            async zReport(sessionId, options) {
+                const data = await gql(POS_SESSION_QUERY, { id: sessionId }, options);
+                return data.posRegisterSession && toSession(data.posRegisterSession);
+            },
+        },
+        cash: {
+            async record(input, options) {
+                const data = await gql(RECORD_POS_CASH_MOVEMENT_MUTATION, { input, staffToken: options?.staffToken }, options);
+                return data.recordPosCashMovement;
+            },
+        },
+        sale: {
+            async createCart(input, options) {
+                const data = await gql(POS_CREATE_CART_MUTATION, { registerId: input?.registerId }, options);
+                return toCart(data.posCreateCart);
+            },
+            async addItem(input, options) {
+                const data = await gql(POS_ADD_ITEM_MUTATION, { input }, options);
+                return toCart(data.posAddItem);
+            },
+            async applyDiscount(input, options) {
+                const data = await gql(POS_APPLY_DISCOUNT_MUTATION, {
+                    input: { ...input, idempotencyKey: options?.idempotencyKey },
+                    staffToken: options?.staffToken,
+                }, options);
+                return toCart(data.posApplyDiscount);
+            },
+            async applyCouponCode(input, options) {
+                const data = await gql(POS_APPLY_COUPON_CODE_MUTATION, { input: { ...input, idempotencyKey: options?.idempotencyKey } }, options);
+                return toCart(data.posApplyCouponCode);
+            },
+            async removeCouponCode(input, options) {
+                const data = await gql(POS_REMOVE_COUPON_CODE_MUTATION, { input: { ...input, idempotencyKey: options?.idempotencyKey } }, options);
+                return toCart(data.posRemoveCouponCode);
+            },
+            async complete(orderId, options) {
+                const idempotencyKey = requireKey(options);
+                const data = await gql(POS_COMPLETE_SALE_MUTATION, { input: { orderId, idempotencyKey }, staffToken: options.staffToken }, options);
+                return data.posCompleteSale;
+            },
+        },
+        tenders: {
+            async cash(input, options) {
+                const idempotencyKey = requireKey(options);
+                const data = await gql(POS_TENDER_CASH_MUTATION, { input: { ...input, idempotencyKey }, staffToken: options.staffToken }, options);
+                return data.posTenderCash;
+            },
+            async card(input, options) {
+                const idempotencyKey = requireKey(options);
+                const data = await gql(POS_TENDER_CARD_MUTATION, { input: { ...input, idempotencyKey }, staffToken: options.staffToken }, options);
+                return data.posTenderCard;
+            },
+            async manual(input, options) {
+                const idempotencyKey = requireKey(options);
+                const data = await gql(POS_TENDER_MANUAL_MUTATION, { input: { ...input, idempotencyKey }, staffToken: options.staffToken }, options);
+                return data.posTenderManual;
+            },
+            async storedValue(input, options) {
+                const idempotencyKey = requireKey(options);
+                const data = await gql(POS_TENDER_STORED_VALUE_MUTATION, { input: { ...input, idempotencyKey }, staffToken: options.staffToken }, options);
+                return data.posTenderStoredValue;
+            },
+        },
+        refunds: {
+            async create(input, options) {
+                const idempotencyKey = requireKey(options);
+                const data = await gql(POS_REFUND_MUTATION, { input: { ...input, idempotencyKey }, staffToken: options.staffToken }, options);
+                return data.posRefund;
+            },
+        },
+        devices: {
+            async list(options) {
+                const data = await gql(POS_DEVICES_QUERY, {}, options);
+                return wholeList(data.posDevices);
+            },
+            async pair(deviceId, options) {
+                const data = await gql(POS_PAIRING_CODE_MUTATION, { deviceId }, options);
+                return data.generatePosPairingCode;
+            },
+            async revoke(deviceId, options) {
+                const data = await gql(REVOKE_POS_DEVICE_MUTATION, { deviceId }, options);
+                return data.revokePosDevice;
+            },
+            async heartbeat(deviceId, options) {
+                const data = await gql(POS_DEVICE_QUERY, { id: deviceId }, options);
+                return data.posDevice;
+            },
+        },
+        receiptNumbering: {
+            async get(options) {
+                const data = await gql(POS_RECEIPT_NUMBERING_QUERY, {}, options);
+                return data.posReceiptNumberingConfig;
+            },
+            async set(input, options) {
+                const data = await gql(UPDATE_POS_RECEIPT_NUMBERING_MUTATION, { input }, options);
+                return data.updatePosReceiptNumberingConfig;
+            },
+        },
+    };
+}

package/dist/pricing/index.d.ts

@@ -0,0 +1,408 @@
+import { type Page, type Transport } from '@sixtyninecommerce/core';
+import type { ConfigurableOperation, ConfigurableOperationInput, LanguageCode } from '../catalog/types.js';
+import type { Call } from '../types.js';
+import { type PricingVouchersModule } from './vouchers.js';
+/**
+ * Promotions at the register (headless spec §9.2 `pricing`; incentives spec §5,
+ * sprint 1): which promotions a register can offer, coupons on the order it is
+ * entering, and what each discount did to each line.
+ *
+ * Money is integer MINOR UNITS of the order's currency; times are ISO-8601 UTC.
+ *
+ * **Coded refusals** of the coupon methods, delivered as GraphQL errors with
+ * `extensions.code` (`BusinessRuleError`, 422, unless noted). Branch on the
+ * code, never on the class:
+ * - `COUPON_INVALID` (`ValidationError`, 400, by its `_INVALID` suffix) — no
+ *   coupon of this store carries the code: unknown, mistyped, deactivated, its
+ *   promotion disabled, or another store's code (the same answer, so no store
+ *   learns of another's codes);
+ * - `COUPON_EXPIRED` — its promotion has ended;
+ * - `COUPON_NOT_YET_VALID` — its promotion has not started;
+ * - `COUPON_USAGE_EXHAUSTED` — used up: the promotion's limit, its per-customer
+ *   limit for the order's customer, or a unique code's own limits
+ *   (`extensions.details.limit`);
+ * - `COUPON_NOT_APPLICABLE` — valid, but its promotion does not apply to the
+ *   order as it stands (a condition is not met, or the promotion is already on
+ *   the order through another of its unique codes);
+ * - `EXTERNAL_LINE_PROMOTION_UNSUPPORTED` — it would discount a line whose price
+ *   the caller stated (`orders.createOrRecover` external lines);
+ * - `ORDER_NOT_DRAFT` — the order is not a Draft; change a placed order through
+ *   an order modification.
+ * A refused call leaves the order unchanged. Another store's order is
+ * `ENTITY_NOT_FOUND` (`NotFoundError`), as one that does not exist.
+ */
+export interface PricingModule {
+    promotions: PricingPromotionsModule;
+    coupons: PricingCouponsModule;
+    /** Personal vouchers: templates, issuing, a customer's vouchers (`./vouchers.ts`). */
+    vouchers: PricingVouchersModule;
+    /**
+     * The order's discounts as they stand: its coupon codes, the order-level
+     * discounts, and each line's discounts, every one naming the promotion it came
+     * from. Needs `ReadOrder`. `NotFoundError` (`ORDER_NOT_FOUND`) when this store
+     * has no such order.
+     */
+    discounts(orderId: string, options?: Call): Promise<OrderDiscounts>;
+}
+export interface PricingPromotionsModule {
+    /**
+     * The store's promotions that can apply right now: enabled, inside their date
+     * window, not used up, and — with `customerId` — open to that customer (a
+     * customer-group condition naming a group they are in). With no customer a
+     * customer-group promotion is left out: an anonymous sale is in no group.
+     * Conditions on the basket (amounts, products, the payment method) are not
+     * judged here, they are summarised. Ordered as the engine applies them.
+     *
+     * The targeting conditions are judged for a sale here and now:
+     * `selling_location` against `locationId`, else the request's `x-location`
+     * (with neither, such a promotion is left out); `time_window` on that
+     * location's clock, else the store's; `first_order` for `customerId` (left out
+     * without one, and for the till's walk-in). `locationId` must be a stock
+     * location of this store that the credential may act at
+     * (`LOCATION_NOT_IN_CHANNEL` / `LOCATION_NOT_ALLOWED`).
+     *
+     * Needs `ReadPromotion`, `CreateOrder` or `OperatePos`. A `Page` because every
+     * list in this SDK is one; the engine answers the whole list, so it is always
+     * the last page.
+     */
+    active(filter?: ActivePromotionsFilter, options?: Call): Promise<Page<ActivePromotion>>;
+    /**
+     * Create a promotion of this store. Build targeting conditions with
+     * {@link promotionConditions}; core's conditions and actions take their
+     * `ConfigurableOperationInput` as stored. The stacking guard the dashboard
+     * puts on every promotion it saves (`promotion_stacking_guard`) is added when
+     * the input does not carry it, so a promotion made here stacks like one made
+     * there. Needs `CreatePromotion`.
+     *
+     * **An empty `conditions` list creates a promotion that applies to every
+     * order** (with no coupon code: automatically), exactly as the dashboard's "No
+     * conditions means the promotion applies to all orders". The guard counts as
+     * a condition, so core's "no condition and no coupon code" refusal never
+     * fires for a promotion saved here: build at least one condition, or set
+     * `couponCode` or `enabled: false`, unless a store-wide promotion is meant.
+     *
+     * Refusals: `PROMOTION_CONDITION_INVALID` (`ValidationError`, 400: a
+     * targeting or set argument the engine cannot read, a second set condition or
+     * a set action without its condition (`argument: "conditions"`), or a set
+     * condition without its action or a second copy of a set action
+     * (`argument: "actions"`), judged on `update` for the pair the update leaves; `extensions.details` names the condition and
+     * argument), `LOCATION_NOT_IN_CHANNEL` (a location of another store, or not
+     * an id), `LOCATION_NOT_ALLOWED` (outside the credential's location
+     * restriction), `FACET_VALUE_NOT_FOUND` / `COLLECTION_NOT_FOUND`
+     * (`NotFoundError`, 404: a set component names a facet value or collection
+     * this store does not have; another store's answers the same).
+     */
+    create(input: CreatePromotionInput, options?: Call): Promise<PricingPromotion>;
+    /**
+     * Update a promotion of this store. `conditions` and `actions`, when sent,
+     * replace the whole list (the guard is kept as on create). Needs
+     * `UpdatePromotion`.
+     *
+     * Refusals: those of {@link PricingPromotionsModule.create}, and
+     * `MISSING_CONDITIONS_ERROR` (`BusinessRuleError`, 422) for one case: the input
+     * does not name `conditions`, the STORED promotion has none (an imported
+     * coupon, a seed: no guard was ever added), and the result would have no coupon
+     * code (`couponCode: ''` clears it, or none is stored). Core judges omitted
+     * conditions from the stored ones, and the guard is added only to conditions
+     * the input sends: send `conditions` (even `[]`) to keep such a promotion
+     * without a code.
+     */
+    update(input: UpdatePromotionInput, options?: Call): Promise<PricingPromotion>;
+}
+/** A day of the week as the `time_window` condition stores it (Monday first). */
+export type Weekday = 'mon' | 'tue' | 'wed' | 'thu' | 'fri' | 'sat' | 'sun';
+/** `HH:mm`, 24-hour, local time. */
+export type LocalTime = `${number}${number}:${number}${number}`;
+/**
+ * The targeting conditions (incentives sprint 2), encoded as the engine stores
+ * them — every argument a string, lists JSON-encoded. Their argument names and
+ * shapes are a stored contract.
+ */
+export declare const promotionConditions: {
+    /**
+     * `selling_location`: the order is sold from one of these stock locations of
+     * the store — a till there, an order `orders.createOrRecover` recorded for it
+     * (`location`), or a register sending it as `x-location` on the Admin API. A
+     * web order has no location and never matches.
+     */
+    readonly sellingLocation: (locationIds: readonly string[]) => ConfigurableOperationInput;
+    /**
+     * `time_window`: on one of `days`, from `from` (included) to `until`
+     * (excluded), local time — the selling location's profile zone, else the
+     * store's. An `until` not after `from` runs into the next day and belongs to
+     * the day it opened (`fri 22:00–02:00`); equal times are 24 hours
+     * (`00:00`–`00:00`: all day). Judged on the wall clock, so a window in the
+     * hour clocks repeat in autumn is open twice, one in the hour they skip in
+     * spring never opens. A placed order keeps a window it was placed with.
+     */
+    readonly timeWindow: (window: {
+        days: readonly Weekday[];
+        from: LocalTime | string;
+        until: LocalTime | string;
+    }) => ConfigurableOperationInput;
+    /**
+     * `first_order`: the customer has no earlier placed order in this store. An
+     * order with no customer, or the till's walk-in, never matches.
+     */
+    readonly firstOrder: () => ConfigurableOperationInput;
+    /**
+     * `bundle_fixed_price` (incentives sprint 4): each complete set of
+     * `components` costs `price` — minor units of the store's DEFAULT currency, in
+     * the store's tax basis (as its catalogue prices are entered), converted into
+     * an order's currency at the checkout's rate. The discount is spread over the
+     * set's lines by value; a set worth `price` or less stays at list price. Pair
+     * it with {@link promotionActions}`.bundleFixedPrice()`.
+     *
+     * `price` is required and must be a whole amount above 0: anything else throws
+     * `ValidationError` (`PROMOTION_CONDITION_INVALID`) before a request is sent,
+     * as the engine would refuse it. To give sets away use
+     * {@link promotionConditions}`.nthSetPercentage` with `discount: 100`.
+     */
+    readonly bundleFixedPrice: (set: {
+        components: readonly SetComponent[];
+        price: number;
+    }) => ConfigurableOperationInput;
+    /**
+     * `nth_set_percentage`: of every `nth` complete sets, the cheapest is
+     * `discount`% off ("second pair at 50%" is `nth: 2, discount: 50`; `nth: 1`
+     * discounts every set). Pair it with {@link promotionActions}`.nthSetPercentage()`.
+     */
+    readonly nthSetPercentage: (set: {
+        components: readonly SetComponent[];
+        nth: number;
+        discount: number;
+    }) => ConfigurableOperationInput;
+    /**
+     * `mix_and_match`: any `quantity` units matching the selector (all of
+     * `facetValueIds`, any of `collectionIds`) for `price`, per complete group;
+     * leftover units stay at list price. `price` as in `bundleFixedPrice`
+     * (required, above 0, refused before sending otherwise). Pair it with
+     * {@link promotionActions}`.mixAndMatch()`.
+     */
+    readonly mixAndMatch: (group: {
+        facetValueIds?: readonly string[];
+        collectionIds?: readonly string[];
+        quantity: number;
+        price: number;
+    }) => ConfigurableOperationInput;
+};
+/**
+ * One component of a set: `quantity` units, each carrying ALL of
+ * `facetValueIds` and sitting in ANY of `collectionIds` (at least one of the
+ * two lists). A unit that a caller priced (an external, imported, quoted or
+ * till-priced line) or that staff priced by hand never joins a set.
+ */
+export interface SetComponent {
+    facetValueIds?: readonly string[];
+    collectionIds?: readonly string[];
+    quantity: number;
+}
+/**
+ * The set actions (incentives sprint 4). Each takes no arguments and applies
+ * what its same-code condition computed, so it goes on the promotion together
+ * with that condition: the engine refuses one without the other.
+ */
+export declare const promotionActions: {
+    readonly bundleFixedPrice: () => ConfigurableOperationInput;
+    readonly nthSetPercentage: () => ConfigurableOperationInput;
+    readonly mixAndMatch: () => ConfigurableOperationInput;
+};
+export interface PromotionTranslationInput {
+    languageCode: LanguageCode;
+    name: string;
+    description?: string;
+}
+export interface CreatePromotionInput {
+    translations: PromotionTranslationInput[];
+    enabled: boolean;
+    /** ISO-8601; null or absent for an open end. */
+    startsAt?: string | null;
+    endsAt?: string | null;
+    couponCode?: string | null;
+    perCustomerUsageLimit?: number | null;
+    usageLimit?: number | null;
+    conditions: ConfigurableOperationInput[];
+    actions: ConfigurableOperationInput[];
+    /** Applies to customers on a price list too (the stacking guard's B2B rule). */
+    combineWithB2b?: boolean;
+    /** Stacks with other promotions instead of taking the exclusive slot. */
+    combineWithOtherPromotions?: boolean;
+    /** Higher is tested first and wins the exclusive slot. */
+    priority?: number;
+}
+export interface UpdatePromotionInput extends Partial<Omit<CreatePromotionInput, 'translations'>> {
+    id: string;
+    translations?: Array<PromotionTranslationInput & {
+        id?: string;
+    }>;
+}
+/** A promotion as `create` / `update` answer it. The coupon code is the caller's own input. */
+export interface PricingPromotion {
+    id: string;
+    name: string;
+    description: string;
+    enabled: boolean;
+    couponCode: string | null;
+    startsAt: string | null;
+    endsAt: string | null;
+    usageLimit: number | null;
+    perCustomerUsageLimit: number | null;
+    conditions: ConfigurableOperation[];
+    actions: ConfigurableOperation[];
+    customFields: {
+        combineWithB2b: boolean | null;
+        combineWithOtherPromotions: boolean | null;
+        priority: number | null;
+    };
+}
+export interface PricingCouponsModule {
+    /**
+     * Apply a coupon code — a promotion's own code or a unique code generated for
+     * it — to a DRAFT order of this store: a back-office draft, or an order
+     * `orders.createOrRecover` composed and left as a Draft. Answers the re-priced
+     * order. Surcharges are left as they are. A code already on the order answers
+     * the order unchanged. Needs `CreateOrder`.
+     *
+     * Takes `options.idempotencyKey`: the same key with the same arguments replays
+     * the first answer, a refusal included; a different request under the same key
+     * is `IDEMPOTENCY_CONFLICT`. A till cart takes its coupons through
+     * `pos.sale.applyCouponCode`.
+     */
+    apply(orderId: string, couponCode: string, options?: Call): Promise<OrderDiscounts>;
+    /**
+     * Take a coupon code off a DRAFT order of this store — the code as applied (a
+     * unique code frees its use) or as `couponCodes` shows it. A code that is not
+     * on the order answers the order unchanged. Needs `CreateOrder`; takes
+     * `options.idempotencyKey` as {@link PricingCouponsModule.apply} does.
+     */
+    remove(orderId: string, couponCode: string, options?: Call): Promise<OrderDiscounts>;
+}
+export interface ActivePromotionsFilter {
+    locationId?: string;
+    customerId?: string;
+}
+/** A promotion's stored condition or action, and the sentence its definition makes of it. */
+export interface PromotionOperationSummary {
+    code: string;
+    args: Array<{
+        name: string;
+        value: string;
+    }>;
+    /**
+     * The registered definition's description with the stored values filled in,
+     * in the request's language — `"If order total is greater than 50.00 EUR"`.
+     * Money reads in the store's default currency; a list argument as a count.
+     */
+    summary: string;
+}
+export interface ActivePromotion {
+    id: string;
+    name: string;
+    description: string;
+    startsAt: string | null;
+    endsAt: string | null;
+    /** Whether a coupon code must be applied for it to count. The code itself is never answered. */
+    requiresCouponCode: boolean;
+    usageLimit: number | null;
+    perCustomerUsageLimit: number | null;
+    conditions: PromotionOperationSummary[];
+    actions: PromotionOperationSummary[];
+    /** Conditions joined with "and", then what it gives. */
+    summary: string;
+}
+/** One discount, on the order or on a line. Amounts are negative minor units. */
+export interface OrderDiscount {
+    /** The promotion it came from; null for a discount from anything else. */
+    promotionId: string | null;
+    /** `PROMOTION:<id>` for a promotion. */
+    adjustmentSource: string;
+    /** `PROMOTION` or `DISTRIBUTED_ORDER_PROMOTION` (an order-level discount's share of a line). */
+    type: string;
+    description: string;
+    amount: number;
+    amountWithTax: number;
+}
+export interface DiscountedOrderLine {
+    id: string;
+    quantity: number;
+    productVariant: {
+        id: string;
+        sku: string;
+        name: string;
+    };
+    unitPrice: number;
+    unitPriceWithTax: number;
+    /** Before any discount. */
+    linePrice: number;
+    linePriceWithTax: number;
+    /** After the line's own promotions. */
+    discountedLinePrice: number;
+    discountedLinePriceWithTax: number;
+    /** After the line's own promotions AND its share of the order-level ones: what it costs. */
+    proratedLinePrice: number;
+    proratedLinePriceWithTax: number;
+    discounts: OrderDiscount[];
+}
+/**
+ * Lines a set promotion priced together (`bundle_fixed_price`,
+ * `nth_set_percentage`, `mix_and_match`), read from the order's own lines and
+ * discounts: a placed order keeps the packages it was priced with.
+ */
+export interface OrderPackage {
+    promotionId: string;
+    /** The promotion's name, as the order recorded it when it was priced. */
+    label: string;
+    /** What the package's units cost after its discount, excluding tax. */
+    price: number;
+    priceWithTax: number;
+    /** In the order's line order; a line belongs to one package at most. */
+    lineIds: string[];
+    /** Complete sets (groups) in the package. */
+    quantity: number;
+}
+export interface OrderDiscounts {
+    id: string;
+    code: string;
+    state: string;
+    currencyCode: string;
+    /**
+     * The codes on the order. A unique code is redeemed by standing in for its
+     * promotion's own code, so it shows here as THAT code.
+     */
+    couponCodes: string[];
+    subTotal: number;
+    subTotalWithTax: number;
+    shipping: number;
+    shippingWithTax: number;
+    total: number;
+    totalWithTax: number;
+    /** The order's discounts, one per promotion (a line's share is on the line). */
+    discounts: OrderDiscount[];
+    /** The promotions that apply to the order now. */
+    promotions: Array<{
+        id: string;
+        name: string;
+    }>;
+    lines: DiscountedOrderLine[];
+    /** The sets its set promotions priced together; empty when none applies. */
+    packages: OrderPackage[];
+    /** Untouched by coupons; listed so a register can show the whole bill. */
+    surcharges: Array<{
+        id: string;
+        description: string;
+        sku: string | null;
+        price: number;
+        priceWithTax: number;
+    }>;
+}
+/** An order's pricing readout; the manual pricing doors (`orders.setLinePrices`, …) answer it too. */
+export declare const ORDER_DISCOUNTS_FIELDS = "\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";
+export declare const ACTIVE_PROMOTIONS_QUERY = "\n  query ActivePromotions($locationId: ID, $customerId: ID) {\n    activePromotions(locationId: $locationId, customerId: $customerId) {\n      id\n      name\n      description\n      startsAt\n      endsAt\n      requiresCouponCode\n      usageLimit\n      perCustomerUsageLimit\n      conditions { code args { name value } summary }\n      actions { code args { name value } summary }\n      summary\n    }\n  }\n";
+export declare const CREATE_PROMOTION_MUTATION = "\n  mutation CreatePromotion($input: CreatePromotionInput!) {\n    createPromotion(input: $input) {\n      ... on Promotion { \n  id\n  name\n  description\n  enabled\n  couponCode\n  startsAt\n  endsAt\n  usageLimit\n  perCustomerUsageLimit\n  conditions { code args { name value } }\n  actions { code args { name value } }\n  customFields { combineWithB2b combineWithOtherPromotions priority }\n }\n      ... on ErrorResult { errorCode message }\n    }\n  }\n";
+export declare const UPDATE_PROMOTION_MUTATION = "\n  mutation UpdatePromotion($input: UpdatePromotionInput!) {\n    updatePromotion(input: $input) {\n      ... on Promotion { \n  id\n  name\n  description\n  enabled\n  couponCode\n  startsAt\n  endsAt\n  usageLimit\n  perCustomerUsageLimit\n  conditions { code args { name value } }\n  actions { code args { name value } }\n  customFields { combineWithB2b combineWithOtherPromotions priority }\n }\n      ... on ErrorResult { errorCode message }\n    }\n  }\n";
+/** The condition the dashboard and the admin app put on every promotion they save. */
+export declare const STACKING_GUARD_CONDITION = "promotion_stacking_guard";
+export declare const APPLY_COUPON_CODE_TO_ORDER_MUTATION = "\n  mutation ApplyCouponCodeToOrder($orderId: ID!, $couponCode: String!, $idempotencyKey: String) {\n    applyCouponCodeToOrder(\n      orderId: $orderId\n      couponCode: $couponCode\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 REMOVE_COUPON_CODE_FROM_ORDER_MUTATION = "\n  mutation RemoveCouponCodeFromOrder($orderId: ID!, $couponCode: String!, $idempotencyKey: String) {\n    removeCouponCodeFromOrder(\n      orderId: $orderId\n      couponCode: $couponCode\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 ORDER_DISCOUNTS_QUERY = "\n  query OrderDiscounts($id: ID!) {\n    order(id: $id) {\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 createPricingModule(transport: Transport): PricingModule;