@sixtyninecommerce/admin 0.9.0 → 0.10.0

package/dist/orders/deposit-policy.d.ts

@@ -0,0 +1,103 @@
+import { type Transport } from '@sixtyninecommerce/core';
+import type { Call } from '../types.js';
+/** The fewest days `autoCancelAfterDays` may be; `null` means never. */
+export declare const DEPOSIT_POLICY_AUTO_CANCEL_DAYS_MIN = 1;
+/** The largest `storefront.minimumPercent`: a whole percentage of the order total. */
+export declare const DEPOSIT_POLICY_MINIMUM_PERCENT_MAX = 100;
+/** The most payment method codes `storefront.methods` may name. */
+export declare const DEPOSIT_POLICY_STOREFRONT_METHODS_MAX = 50;
+/** Deposits a SHOPPER pays online at checkout. Applies only while `enabled` is on as well. */
+export interface StorefrontDepositPolicy {
+    /** The online switch. */
+    enabled: boolean;
+    /**
+     * Payment method CODES a shopper may pay a deposit with: offline methods and
+     * Mollie. Empty: none, so no shopper can pay a deposit online.
+     */
+    methods: string[];
+    /**
+     * The least an online deposit may be, as a whole percentage (0–100) of the
+     * order's total, judged in the order's currency. Beside `minimum`, not instead
+     * of it: the larger of the two applies.
+     */
+    minimumPercent: number;
+}
+/**
+ * The store's deposit policy (`Channel.customFields.orderDepositPolicy`): whether
+ * staff may take a deposit and park an order (`orders.park`), and whether a
+ * shopper may pay one at checkout. Every field present: this is what the engine
+ * APPLIES, absent and malformed fields read as their defaults.
+ */
+export interface OrderDepositPolicy {
+    /**
+     * The store-wide switch. Off: a payment must cover the whole outstanding
+     * amount (`payments.record` refuses a part payment `DEPOSITS_NOT_ENABLED`) and
+     * no order can be parked.
+     */
+    enabled: boolean;
+    /**
+     * The least a deposit must be before an order can be parked, in minor units of
+     * the store's DEFAULT currency; 0 means any deposit will do. An order in another
+     * currency is held to it converted at the rate checkout charges with.
+     */
+    minimum: number;
+    /** Whether an order may be parked with nothing paid at all. */
+    allowZeroDepositPark: boolean;
+    /**
+     * Whether the storefront shows a parked order's reason to the shopper. Off by
+     * default: staff write that reason for staff.
+     */
+    showParkReasonToCustomer: boolean;
+    /**
+     * RESERVED: days after which a parked order is cancelled. Saved and read back,
+     * but nothing cancels a parked order automatically yet. `null`: never.
+     */
+    autoCancelAfterDays: number | null;
+    storefront: StorefrontDepositPolicy;
+}
+/**
+ * The policy of a store that never set one, and of every field that cannot be
+ * read: deposits off, no minimum, no zero-deposit park, the reason kept from the
+ * shopper, never auto-cancelled, no online deposits.
+ */
+export declare const DEFAULT_ORDER_DEPOSIT_POLICY: Readonly<OrderDepositPolicy>;
+/**
+ * The ACTIVE store's deposit policy (`admin.orders.depositPolicy`), stored as a
+ * Channel custom field and written through core `updateChannel`.
+ *
+ * Reading needs an authenticated administrator on the store; writing needs
+ * `UpdateChannel`.
+ */
+export interface OrderDepositPolicyModule {
+    /**
+     * The policy the engine applies, read as tolerantly as the engine reads it: a
+     * store that never set one, a malformed column and a field of the wrong type
+     * all answer their defaults ({@link DEFAULT_ORDER_DEPOSIT_POLICY}), so this is
+     * what `orders.park` and `payments.record` will hold an order to.
+     */
+    get(options?: Call): Promise<OrderDepositPolicy>;
+    /**
+     * Replace the whole policy, and answer it as the engine now applies it.
+     *
+     * Every field is required: read it with {@link get}, change what you mean to,
+     * and send it back. Only the schema's fields are stored (anything else on the
+     * object is left out), and the method codes are stored as given.
+     *
+     * Refused before any request with `DEPOSIT_POLICY_INVALID` ({@link ValidationError},
+     * one `details[]` entry per failing field, named by its path such as
+     * `storefront.minimumPercent`): a non-boolean switch, a `minimum` that is not a
+     * whole number of 0 or more, an `autoCancelAfterDays` that is neither `null` nor
+     * a whole number of 1 or more, a `minimumPercent` outside 0–100, a blank or
+     * repeated method code, or more than 50 of them. The engine itself stores any
+     * JSON in the column and reads what it cannot use as the default, so this check
+     * is what keeps a bad value from silently turning deposits off.
+     *
+     * Absent and "set to the defaults" mean the same thing to the engine, and a
+     * store's column is never backfilled: write the policy when a merchant changed
+     * it, not as a side effect of saving something else.
+     */
+    set(policy: OrderDepositPolicy, options?: Call): Promise<OrderDepositPolicy>;
+}
+export declare const ORDER_DEPOSIT_POLICY_QUERY = "\n  query OrderDepositPolicy {\n    activeChannel { \n  id\n  customFields {\n    orderDepositPolicy\n  }\n }\n  }\n";
+export declare const SET_ORDER_DEPOSIT_POLICY_MUTATION = "\n  mutation SetOrderDepositPolicy($input: UpdateChannelInput!) {\n    updateChannel(input: $input) {\n      ... on Channel { \n  id\n  customFields {\n    orderDepositPolicy\n  }\n }\n      ... on ErrorResult { errorCode message }\n    }\n  }\n";
+export declare function createOrderDepositPolicyModule(transport: Transport): OrderDepositPolicyModule;

package/dist/orders/deposit-policy.js

@@ -0,0 +1,202 @@
+import { errorFromErrorResult, isErrorResult, ValidationError, } from '@sixtyninecommerce/core';
+// The bounds of the meta catalog's `order_deposit_policy` schema
+// (`packages/shared/src/meta-catalog/settings-schemas.ts`), which the spec reads
+// back from that schema. Nothing on the engine validates the column on write, so
+// these are the only check a value gets before the engine reads it.
+/** The fewest days `autoCancelAfterDays` may be; `null` means never. */
+export const DEPOSIT_POLICY_AUTO_CANCEL_DAYS_MIN = 1;
+/** The largest `storefront.minimumPercent`: a whole percentage of the order total. */
+export const DEPOSIT_POLICY_MINIMUM_PERCENT_MAX = 100;
+/** The most payment method codes `storefront.methods` may name. */
+export const DEPOSIT_POLICY_STOREFRONT_METHODS_MAX = 50;
+/**
+ * The policy of a store that never set one, and of every field that cannot be
+ * read: deposits off, no minimum, no zero-deposit park, the reason kept from the
+ * shopper, never auto-cancelled, no online deposits.
+ */
+export const DEFAULT_ORDER_DEPOSIT_POLICY = Object.freeze({
+    enabled: false,
+    minimum: 0,
+    allowZeroDepositPark: false,
+    showParkReasonToCustomer: false,
+    autoCancelAfterDays: null,
+    storefront: Object.freeze({ enabled: false, methods: [], minimumPercent: 0 }),
+});
+const POLICY_FIELDS = /* GraphQL */ `
+  id
+  customFields {
+    orderDepositPolicy
+  }
+`;
+export const ORDER_DEPOSIT_POLICY_QUERY = /* GraphQL */ `
+  query OrderDepositPolicy {
+    activeChannel { ${POLICY_FIELDS} }
+  }
+`;
+export const SET_ORDER_DEPOSIT_POLICY_MUTATION = /* GraphQL */ `
+  mutation SetOrderDepositPolicy($input: UpdateChannelInput!) {
+    updateChannel(input: $input) {
+      ... on Channel { ${POLICY_FIELDS} }
+      ... on ErrorResult { errorCode message }
+    }
+  }
+`;
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+const isWhole = (value) => typeof value === 'number' && Number.isSafeInteger(value);
+/**
+ * The column, read as the engine reads it (`resolveDepositPolicy` in
+ * `services/vendure/src/payment/deposit-policy.ts`): anything unreadable is its
+ * default.
+ */
+function readOrderDepositPolicy(raw) {
+    let parsed = raw;
+    if (typeof raw === 'string') {
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch {
+            parsed = null;
+        }
+    }
+    if (!isRecord(parsed))
+        return copyOf(DEFAULT_ORDER_DEPOSIT_POLICY);
+    return {
+        enabled: parsed.enabled === true,
+        minimum: isWhole(parsed.minimum) && parsed.minimum >= 0 ? parsed.minimum : 0,
+        allowZeroDepositPark: parsed.allowZeroDepositPark === true,
+        showParkReasonToCustomer: parsed.showParkReasonToCustomer === true,
+        autoCancelAfterDays: isWhole(parsed.autoCancelAfterDays) &&
+            parsed.autoCancelAfterDays >= DEPOSIT_POLICY_AUTO_CANCEL_DAYS_MIN
+            ? parsed.autoCancelAfterDays
+            : null,
+        storefront: readStorefront(parsed.storefront),
+    };
+}
+function readStorefront(raw) {
+    if (!isRecord(raw))
+        return { enabled: false, methods: [], minimumPercent: 0 };
+    // Only non-blank string codes, once each and at most 50: a stray `null` or a
+    // number must not allow a method nobody named.
+    const methods = Array.isArray(raw.methods)
+        ? [
+            ...new Set(raw.methods.filter((code) => typeof code === 'string' && code.trim() !== '')),
+        ].slice(0, DEPOSIT_POLICY_STOREFRONT_METHODS_MAX)
+        : [];
+    const percent = raw.minimumPercent;
+    return {
+        enabled: raw.enabled === true,
+        methods,
+        minimumPercent: isWhole(percent) && percent >= 0 && percent <= DEPOSIT_POLICY_MINIMUM_PERCENT_MAX
+            ? percent
+            : 0,
+    };
+}
+function copyOf(policy) {
+    return {
+        ...policy,
+        storefront: { ...policy.storefront, methods: [...policy.storefront.methods] },
+    };
+}
+/** Every way `policy` breaks the schema, one entry per field. */
+function problemsOf(policy) {
+    const problems = [];
+    const add = (field, message) => problems.push({ field, code: 'DEPOSIT_POLICY_INVALID', message });
+    if (!isRecord(policy)) {
+        add('policy', 'Pass the whole policy as an object: read it with get(), change it, send it back.');
+        return problems;
+    }
+    for (const field of ['enabled', 'allowZeroDepositPark', 'showParkReasonToCustomer']) {
+        if (typeof policy[field] !== 'boolean')
+            add(field, `${field} must be true or false.`);
+    }
+    if (!(isWhole(policy.minimum) && policy.minimum >= 0)) {
+        add('minimum', 'minimum must be a whole number of minor units, 0 or more.');
+    }
+    const days = policy.autoCancelAfterDays;
+    if (days !== null && !(isWhole(days) && days >= DEPOSIT_POLICY_AUTO_CANCEL_DAYS_MIN)) {
+        add('autoCancelAfterDays', 'autoCancelAfterDays must be null (never) or a whole number of days, 1 or more.');
+    }
+    const storefront = policy.storefront;
+    if (!isRecord(storefront)) {
+        add('storefront', 'storefront must be an object: { enabled, methods, minimumPercent }.');
+        return problems;
+    }
+    if (typeof storefront.enabled !== 'boolean') {
+        add('storefront.enabled', 'storefront.enabled must be true or false.');
+    }
+    const methods = storefront.methods;
+    if (!Array.isArray(methods)) {
+        add('storefront.methods', 'storefront.methods must be an array of payment method codes.');
+    }
+    else if (methods.some((code) => typeof code !== 'string' || code.trim() === '')) {
+        add('storefront.methods', 'storefront.methods may hold only non-blank payment method codes.');
+    }
+    else if (new Set(methods).size !== methods.length) {
+        add('storefront.methods', 'storefront.methods names a payment method code more than once.');
+    }
+    else if (methods.length > DEPOSIT_POLICY_STOREFRONT_METHODS_MAX) {
+        add('storefront.methods', `storefront.methods may name at most ${String(DEPOSIT_POLICY_STOREFRONT_METHODS_MAX)} payment methods.`);
+    }
+    const percent = storefront.minimumPercent;
+    if (!(isWhole(percent) && percent >= 0 && percent <= DEPOSIT_POLICY_MINIMUM_PERCENT_MAX)) {
+        add('storefront.minimumPercent', 'storefront.minimumPercent must be a whole percentage from 0 to 100.');
+    }
+    return problems;
+}
+/** Exactly the schema's fields, in its order: what the column stores. */
+function storedOf(policy) {
+    return {
+        enabled: policy.enabled,
+        minimum: policy.minimum,
+        allowZeroDepositPark: policy.allowZeroDepositPark,
+        showParkReasonToCustomer: policy.showParkReasonToCustomer,
+        autoCancelAfterDays: policy.autoCancelAfterDays,
+        storefront: {
+            enabled: policy.storefront.enabled,
+            methods: [...policy.storefront.methods],
+            minimumPercent: policy.storefront.minimumPercent,
+        },
+    };
+}
+export function createOrderDepositPolicyModule(transport) {
+    const read = async (options) => {
+        const data = await transport.graphql({ api: 'admin', query: ORDER_DEPOSIT_POLICY_QUERY }, options);
+        return data.activeChannel;
+    };
+    return {
+        async get(options) {
+            const channel = await read(options);
+            return readOrderDepositPolicy(channel.customFields?.orderDepositPolicy ?? null);
+        },
+        async set(policy, options) {
+            const problems = problemsOf(policy);
+            if (problems.length > 0) {
+                throw new ValidationError({
+                    code: 'DEPOSIT_POLICY_INVALID',
+                    message: problems.map((problem) => problem.message).join(' '),
+                    status: 400,
+                    service: 'vendure',
+                    details: problems,
+                });
+            }
+            // `updateChannel` needs the id, and the active channel is the one the
+            // client is scoped to — read it with the SAME call options, so a per-call
+            // tenant writes its own channel rather than the client's.
+            const { id } = await read(options);
+            const data = await transport.graphql({
+                api: 'admin',
+                query: SET_ORDER_DEPOSIT_POLICY_MUTATION,
+                variables: {
+                    // The column is `text` holding JSON (the schema describes the
+                    // DECODED value), so it is sent as a string.
+                    input: { id, customFields: { orderDepositPolicy: JSON.stringify(storedOf(policy)) } },
+                },
+            }, options);
+            if (isErrorResult(data.updateChannel))
+                throw errorFromErrorResult(data.updateChannel);
+            return readOrderDepositPolicy(data.updateChannel.customFields?.orderDepositPolicy ?? null);
+        },
+    };
+}

package/dist/orders/index.d.ts

@@ -1,7 +1,10 @@
 import { type Transport } from '@sixtyninecommerce/core';
+import type { JobHandle } from '../jobs/index.js';
 import type { OrderPaymentPosition, PaidOrder } from '../payments/index.js';
 import type { Call } from '../types.js';
+import { type OrderBulkInput, type OrderBulkRun } from './bulk.js';
 import { type OrderCommitEditModule } from './commit-edit.js';
+import { type OrderDepositPolicyModule } from './deposit-policy.js';
 import { type OrderGetModule } from './get.js';
 import { type OrderLinePricePreviewModule } from './line-price-preview.js';
 import { type ManualDiscountsModule } from './manual-discounts.js';
@@ -12,6 +15,9 @@ import { type OrderPlanEditModule } from './plan-edit.js';
 import { type OrderStatusModule } from './status.js';
 import { type SurchargesModule } from './surcharges.js';
 export type { PaidOrder } from '../payments/index.js';
+export type { OrderBulkAction, OrderBulkCapture, OrderBulkInput, OrderBulkItem, OrderBulkRun, } from './bulk.js';
+export { MAX_BULK_ORDERS, ORDER_BULK_ACTIONS, ORDER_BULK_TRANSITION_REFUSED } from './bulk.js';
+export type { OrderDepositPolicy, OrderDepositPolicyModule, StorefrontDepositPolicy, } from './deposit-policy.js';
 export type { DiscountPolicy, DiscountPolicyInput, DiscountPolicyModule, DiscountReason, DiscountReasonInput, DiscountReasonsModule, ManualDiscountsModule, OrderManualDiscount, } from './manual-discounts.js';
 export type { ExternalLinePriceBasis, ExternalOrder, ExternalOrderAddressInput, ExternalOrderCall, ExternalOrderCatalogLine, ExternalOrderExternalLine, ExternalOrderFulfilment, ExternalOrderInput, ExternalOrderLine, ExternalOrderLineInput, ExternalOrderSurcharge, ExternalOrderSurchargeInput, ExternalOrderTargetState, ExternalOrderTaxLine, } from './order-entry.js';
 /** An app provider an order is running without (`admin.orders.providerFallbacks`). */
@@ -73,6 +79,80 @@ export interface OrdersModule extends OrderEntryModule, OrderGetModule, OrderPar
      * `setOneTimeDiscounts` on this module.
      */
     manualDiscounts: ManualDiscountsModule;
+    /**
+     * Move, cancel, delete or mark paid up to `MAX_BULK_ORDERS` (50) orders of the store in ONE
+     * call (headless spec §7 `orders.bulk`; rulings G19, G28).
+     *
+     * **The run is a job.** The call answers a receipt (`runId`) once the run is queued;
+     * `handle.wait()` polls it until it ends and resolves with the run, whatever the ending.
+     * `bulkRun(runId)` reads it again later, from any process. Each order's outcome is in
+     * `run.items`, in the order the ids were named.
+     *
+     * **Each order is judged as on its own page, and succeeds or fails alone.** First by its own
+     * status (`orders.status`): an action the order's status does not offer, or a TRANSITION target
+     * outside the order's own `nextStates`, answers `ORDER_ACTION_UNAVAILABLE` with `reasonCode`
+     * (that read's vocabulary), before anything is written. Then by its single door, under the
+     * door's own lock, with the door's own code: `ORDER_STATE_TRANSITION_ERROR` (and core's other
+     * order codes), `ORDER_CART_NOT_CANCELLABLE`, `ORDER_UNITS_SHIPPED`,
+     * `ORDER_HAS_ACTIVE_FULFILLMENT`, `ORDER_INVOICE_LOCKED`, `ORDER_HAS_RECORDS`,
+     * `ORDER_NOT_DELETED`. Another store's order answers `ENTITY_NOT_FOUND` on its item. A
+     * `SUCCEEDED` run can hold `FAILED` items: read them.
+     *
+     * - `TRANSITION` (`toState` required): as `transitionOrderToState`. Never `Cancelled` (use
+     *   `CANCEL`), `PaymentSettled` (use `MARK_PAID`), `Modifying` or `AddingItems`.
+     * - `CANCEL` (`reason` optional): the whole order, shipping included, as `cancelOrder`. **It
+     *   moves no money:** a paid order keeps its payment, to be refunded through `payments.refund`.
+     * - `DELETE`: a draft or a cart holding no payment or stock movement, as `deleteOrder`.
+     * - `MARK_PAID`: **captures** each payment of the order that is `Authorized` when the run reaches
+     *   it, read by the engine (never your list's copy), each as `settlePayment` and on its own
+     *   (ruling G19). Each order's `captured` lists every payment acted on. **A decline is a result,
+     *   not a retry:** the order answers `SETTLE_PAYMENT_ERROR`, the payment keeps the state the
+     *   provider left, and the run never asks again. **An unknown provider answer must be
+     *   reconciled, never retried blind:** `IDEMPOTENCY_OUTCOME_UNKNOWN` means the provider was asked
+     *   and its answer was lost; check the payment with the provider. `IDEMPOTENCY_IN_PROGRESS` means
+     *   a capture under the same request may still be running. An order with no authorized payment
+     *   answers `NOTHING_TO_CAPTURE`: it is never marked paid without money (ruling G28).
+     *
+     * **Idempotency.** `options.idempotencyKey` (minted when omitted): the same key with the same
+     * input answers the SAME run, so a resubmit never captures twice; another input under the key is
+     * `IDEMPOTENCY_CONFLICT` (409 `ConflictError`). Each order, and each capture, is keyed within the
+     * run, so a run the platform processes again (a worker restart) answers what it already did from
+     * that record and never asks a provider twice.
+     *
+     * **No dry run.** The refusals that matter are the doors' own, made under their locks, so a
+     * rehearsal could answer "ok" for an order the real run refuses.
+     *
+     * Needs `UpdateOrder` (`DeleteOrder` for `DELETE`); reading the run needs `ReadOrder`. Refusals
+     * of the call itself (nothing is queued): `BULK_ACTION_INPUT_INVALID` (`ValidationError`, 400:
+     * no orders, more than 50, one named twice, an unknown action, a missing or refused `toState`,
+     * an option the action takes none of; refused before sending too), `BULK_ACTION_NOT_ALLOWED`
+     * (`PermissionDeniedError`, 403), `IDEMPOTENCY_CONFLICT`.
+     *
+     * Platform releases before this method do not have the mutation and refuse it as
+     * `ValidationError` `GRAPHQL_VALIDATION_FAILED` (400): deploy the engine first.
+     */
+    bulk(input: OrderBulkInput, options?: Call): Promise<JobHandle<OrderBulkRun>>;
+    /**
+     * One read of a bulk order run, by the `runId` `bulk()` answered. A run of another store, or one
+     * that does not exist, is `BULK_ACTION_RUN_NOT_FOUND` (`NotFoundError`, 404).
+     */
+    bulkRun(runId: string, options?: Call): Promise<OrderBulkRun>;
+    /**
+     * Delete ONE order: a draft or a cart (`AddingItems`) holding no payment and no stock movement,
+     * as the order page's Delete (ruling G29). Needs `DeleteOrder`. Anything else is kept:
+     * `ORDER_INVOICE_LOCKED` (an invoiced order, for every caller), `ORDER_HAS_RECORDS` (cancel it
+     * instead: `orders.bulk` with `CANCEL`), or `ORDER_NOT_DELETED` (`ConflictError`, 409, as every `*_NOT_DELETED` of this SDK) with
+     * the engine's own reason for an order in another state, or one this store does not have.
+     * Placed orders are cancelled, never deleted.
+     */
+    delete(orderId: string, options?: Call): Promise<void>;
+    /**
+     * The store's deposit policy (`orderDepositPolicy`): whether staff may take a
+     * deposit and {@link OrdersModule.park} an order, the minimum a deposit must be,
+     * and whether a shopper may pay one at checkout. `get` answers what the engine
+     * applies; `set` replaces it, validated against the schema's bounds first.
+     */
+    depositPolicy: OrderDepositPolicyModule;
     /**
      * Hold a placed order while the rest of its money is arranged. Needs
      * `UpdateOrder`.

package/dist/orders/index.js

@@ -1,5 +1,7 @@
 import { NotFoundError } from '@sixtyninecommerce/core';
+import { bulkOrders, deleteOrder, readOrderBulkRun, } from './bulk.js';
 import { createOrderCommitEditModule } from './commit-edit.js';
+import { createOrderDepositPolicyModule } from './deposit-policy.js';
 import { createOrderGetModule } from './get.js';
 import { createOrderLinePricePreviewModule, } from './line-price-preview.js';
 import { createManualDiscountsModule } from './manual-discounts.js';
@@ -9,6 +11,7 @@ import { createOrderParcelChargeModule } from './parcel-charge.js';
 import { createOrderPlanEditModule } from './plan-edit.js';
 import { createOrderStatusModule } from './status.js';
 import { createSurchargesModule } from './surcharges.js';
+export { MAX_BULK_ORDERS, ORDER_BULK_ACTIONS, ORDER_BULK_TRANSITION_REFUSED } from './bulk.js';
 const ORDER_PROVIDER_FALLBACKS_QUERY = /* GraphQL */ `
   query OrderProviderFallbacks($id: ID!) {
     order(id: $id) {
@@ -100,6 +103,16 @@ export function createOrdersModule(transport) {
         ...createOrderStatusModule(transport),
         surcharges: createSurchargesModule(transport),
         manualDiscounts: createManualDiscountsModule(transport),
+        depositPolicy: createOrderDepositPolicyModule(transport),
+        bulk(input, options) {
+            return bulkOrders(transport, input, options);
+        },
+        bulkRun(runId, options) {
+            return readOrderBulkRun(transport, runId, options);
+        },
+        delete(orderId, options) {
+            return deleteOrder(transport, orderId, options);
+        },
         async park(orderId, options) {
             const data = await transport.graphql({
                 api: 'admin',

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

@@ -37,10 +37,19 @@ export interface DiscountPolicy {
      * 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
@@ -126,7 +135,7 @@ export interface ManualDiscountsModule {
 }
 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 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

@@ -44,6 +44,7 @@ export const DISCOUNT_POLICY_QUERY = /* GraphQL */ `
   query DiscountPolicy {
     discountPolicy {
       reasonRequired
+      maxDiscountBps
     }
   }
 `;
@@ -51,6 +52,7 @@ export const UPDATE_DISCOUNT_POLICY_MUTATION = /* GraphQL */ `
   mutation UpdateDiscountPolicy($input: UpdateDiscountPolicyInput!) {
     updateDiscountPolicy(input: $input) {
       reasonRequired
+      maxDiscountBps
     }
   }
 `;

package/dist/payments/index.d.ts

@@ -1,6 +1,7 @@
 import type { Transport } from '@sixtyninecommerce/core';
 import type { Call } from '../types.js';
 import { type AccountCreditModule } from './account-credit.js';
+import { type PaymentMethodsModule } from './methods.js';
 import { type ProvidersModule } from './providers.js';
 /**
  * What an order has actually been paid, in minor units of its own currency.
@@ -284,6 +285,11 @@ export interface PaymentsModule {
      * to an invoice, pay it back.
      */
     accountCredit: AccountCreditModule;
+    /**
+     * The store's payment methods, as staff choose one: the `method` code
+     * {@link PaymentsModule.record} takes, and the codes a deposit policy names.
+     */
+    methods: PaymentMethodsModule;
     /**
      * Record part (or all) of what an order owes, and return the order.
      *
@@ -466,4 +472,5 @@ export declare const REPORT_APP_PAYMENT_MUTATION = "\n  mutation ReportAppPaymen
 export declare const APP_PAYMENTS_QUERY = "\n  query AppPayments($orderId: ID!) {\n    appPayments(orderId: $orderId) {\n      id\n      orderId\n      orderCode\n      state\n      amount\n      currencyCode\n      providerReference\n      methodCode\n      outcomeUnknown\n      createdAt\n    }\n  }\n";
 export declare function createPaymentsModule(transport: Transport): PaymentsModule;
 export type { AccountCreditModule, ApplyUnappliedCashInput, CreditOverpaymentInput, OrderMoneyOnAccount, RefundUnappliedCashInput, UnappliedCash, UnappliedCashRefund, } from './account-credit.js';
+export type { PaymentMethod, PaymentMethodsModule } from './methods.js';
 export type { ProviderConnection, ProviderCredentialPath, ProviderOnboardingStart, ProviderReadiness, ProvidersModule, ProviderTerminal, ProviderTerminalsModule, ProvisionTerminalInput, ReadinessOptions, } from './providers.js';

package/dist/payments/index.js

@@ -1,4 +1,5 @@
 import { createAccountCreditModule } from './account-credit.js';
+import { createPaymentMethodsModule } from './methods.js';
 import { createProvidersModule } from './providers.js';
 const PAID_ORDER_FIELDS = /* GraphQL */ `
   id
@@ -124,6 +125,7 @@ export function createPaymentsModule(transport) {
     return {
         providers: createProvidersModule(transport),
         accountCredit: createAccountCreditModule(transport),
+        methods: createPaymentMethodsModule(transport),
         async record(orderId, input, options) {
             const data = await transport.graphql({
                 api: 'admin',

package/dist/payments/methods.d.ts

@@ -0,0 +1,37 @@
+import type { Page, Transport } from '@sixtyninecommerce/core';
+import type { ListOptions } from '../types.js';
+/** One payment method of the store, as staff choose one. */
+export interface PaymentMethod {
+    id: string;
+    /**
+     * The method's code: what `payments.record` takes as `method`, and what a
+     * deposit policy names in `storefront.methods`.
+     */
+    code: string;
+    name: string;
+    /** A disabled method takes no new payments; it still names the ones it took. */
+    enabled: boolean;
+    /**
+     * The code of the handler that takes the money (`manual-payment`, `mollie`, a
+     * payment app's handler, …): what kind of method this is.
+     */
+    handlerCode: string;
+}
+/**
+ * The store's payment methods (`admin.payments.methods`): what staff record a
+ * payment with, and what a deposit policy names.
+ *
+ * Needs `ReadSettings` or `ReadPaymentMethod`. Scoped to the channel the client
+ * is on: another store's methods are not listed.
+ */
+export interface PaymentMethodsModule {
+    /**
+     * Every method of the store, enabled or not, in the engine's order. Paged
+     * (`options.limit`, default 100, at most 1,000 or `INVALID_PAGE_SIZE`; and
+     * `options.after` from a previous page); `for await (const method of page)`
+     * walks them all.
+     */
+    list(options?: ListOptions): Promise<Page<PaymentMethod>>;
+}
+export declare const PAYMENT_METHODS_QUERY = "\n  query StorePaymentMethods($options: PaymentMethodListOptions) {\n    paymentMethods(options: $options) {\n      items {\n        id\n        code\n        name\n        enabled\n        handler {\n          code\n        }\n      }\n      totalItems\n    }\n  }\n";
+export declare function createPaymentMethodsModule(transport: Transport): PaymentMethodsModule;

package/dist/payments/methods.js

@@ -0,0 +1,33 @@
+import { vendureListPage } from '../catalog/types.js';
+/** A store has a handful; one page holds them. */
+const DEFAULT_PAGE_SIZE = 100;
+export const PAYMENT_METHODS_QUERY = /* GraphQL */ `
+  query StorePaymentMethods($options: PaymentMethodListOptions) {
+    paymentMethods(options: $options) {
+      items {
+        id
+        code
+        name
+        enabled
+        handler {
+          code
+        }
+      }
+      totalItems
+    }
+  }
+`;
+const toMethod = (method) => ({
+    id: method.id,
+    code: method.code,
+    name: method.name,
+    enabled: method.enabled,
+    handlerCode: method.handler.code,
+});
+export function createPaymentMethodsModule(transport) {
+    return {
+        list(options) {
+            return vendureListPage(transport, PAYMENT_METHODS_QUERY, 'paymentMethods', (skip, take) => ({ options: { skip, take } }), { ...options, limit: options?.limit ?? DEFAULT_PAGE_SIZE }, toMethod);
+        },
+    };
+}

package/dist/pricing/index.d.ts

@@ -1,6 +1,7 @@
 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
@@ -33,6 +34,8 @@ import type { Call } from '../types.js';
 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

package/dist/pricing/index.js

@@ -1,4 +1,5 @@
 import { createPage, errorFromErrorResult, isErrorResult, NotFoundError, ValidationError, } from '@sixtyninecommerce/core';
+import { createPricingVouchersModule } from './vouchers.js';
 /**
  * The targeting conditions (incentives sprint 2), encoded as the engine stores
  * them — every argument a string, lists JSON-encoded. Their argument names and
@@ -317,6 +318,7 @@ export function createPricingModule(transport) {
                 return data.updatePromotion;
             },
         },
+        vouchers: createPricingVouchersModule(transport),
         coupons: {
             async apply(orderId, couponCode, options) {
                 const data = await transport.graphql({