@sixtyninecommerce/admin 0.10.0 → 0.12.0

package/dist/orders/surcharges.d.ts

@@ -53,6 +53,15 @@ export interface SurchargeRemoveCall extends Call {
      * either (`ORDER_OVERPAYMENT_REFUND_UNRECONCILED`) until it is reconciled.
      */
     overpayment?: OrderOverpaymentChoice;
+    /**
+     * With `ACCOUNT_CREDIT` in a store whose book is store credit (`preview`'s
+     * `accountCredit.book` `STORE_CREDIT`): whether the customer expressly agreed to store credit
+     * instead of a refund to their payment (EU consumer law, CRD art. 13(1)), as staff recorded it.
+     * The move records it on its ledger entries (`StoredValueEntry.customerAgreed`); never a
+     * condition, nothing is refused for it, and it is recorded nowhere else. Sent only when given;
+     * an engine before the field (incentives sprint 8 PR 6a) refuses a call that gives it.
+     */
+    customerAgreed?: boolean;
 }
 /** Options for a surcharge write. */
 export interface SurchargeCall extends SurchargeRemoveCall {
@@ -133,6 +142,13 @@ export interface OverpaymentOption {
     available: boolean;
     code: string | null;
     message: string | null;
+    /**
+     * On an `accountCredit` option: where "credit the customer" lands in this store, its ONE
+     * customer-credit book. `AR` (unapplied cash on the AR ledger), `STORE_CREDIT` (the customer's
+     * store-credit wallet) or `NONE` (neither: the option is closed). Null on the other options and
+     * from an engine before it.
+     */
+    book?: string | null;
 }
 /** What a surcharge change would do to an order's money. Nothing was saved. */
 export interface SurchargeChangePreview {
@@ -190,5 +206,8 @@ export declare const UPDATE_ORDER_SURCHARGE_MUTATION = "\n  mutation UpdateOrder
 export declare const UPDATE_ORDER_SURCHARGE_WITH_OVERPAYMENT_MUTATION = "\n  mutation UpdateOrderSurchargeWithOverpayment(\n    $orderId: ID!\n    $surchargeId: ID!\n    $input: SurchargeInput!\n    $taxClass: String\n    $idempotencyKey: String\n    $overpayment: OrderOverpaymentChoice\n  ) {\n    updateOrderSurcharge(\n      orderId: $orderId\n      surchargeId: $surchargeId\n      input: $input\n      taxClass: $taxClass\n      idempotencyKey: $idempotencyKey\n      overpayment: $overpayment\n    ) {\n      \n  id\n  code\n  currencyCode\n  total\n  totalWithTax\n  surcharges {\n    id\n    description\n    sku\n    price\n    priceWithTax\n    taxRate\n  }\n\n    }\n  }\n";
 export declare const REMOVE_ORDER_SURCHARGE_MUTATION = "\n  mutation RemoveOrderSurcharge($orderId: ID!, $surchargeId: ID!, $idempotencyKey: String) {\n    removeOrderSurcharge(\n      orderId: $orderId\n      surchargeId: $surchargeId\n      idempotencyKey: $idempotencyKey\n    ) {\n      \n  id\n  code\n  currencyCode\n  total\n  totalWithTax\n  surcharges {\n    id\n    description\n    sku\n    price\n    priceWithTax\n    taxRate\n  }\n\n    }\n  }\n";
 export declare const REMOVE_ORDER_SURCHARGE_WITH_OVERPAYMENT_MUTATION = "\n  mutation RemoveOrderSurchargeWithOverpayment(\n    $orderId: ID!\n    $surchargeId: ID!\n    $idempotencyKey: String\n    $overpayment: OrderOverpaymentChoice\n  ) {\n    removeOrderSurcharge(\n      orderId: $orderId\n      surchargeId: $surchargeId\n      idempotencyKey: $idempotencyKey\n      overpayment: $overpayment\n    ) {\n      \n  id\n  code\n  currencyCode\n  total\n  totalWithTax\n  surcharges {\n    id\n    description\n    sku\n    price\n    priceWithTax\n    taxRate\n  }\n\n    }\n  }\n";
-export declare const PREVIEW_ORDER_SURCHARGE_CHANGE_QUERY = "\n  query PreviewOrderSurchargeChange($orderId: ID!, $change: OrderSurchargeChangeInput!) {\n    previewOrderSurchargeChange(orderId: $orderId, change: $change) {\n      currencyCode\n      totalBefore\n      totalAfter\n      overpayment {\n        amount\n        currencyCode\n        refund { available code message }\n        accountCredit { available code message }\n      }\n    }\n  }\n";
+export declare const ADD_ORDER_SURCHARGE_WITH_CONSENT_MUTATION: string;
+export declare const UPDATE_ORDER_SURCHARGE_WITH_CONSENT_MUTATION: string;
+export declare const REMOVE_ORDER_SURCHARGE_WITH_CONSENT_MUTATION: string;
+export declare const PREVIEW_ORDER_SURCHARGE_CHANGE_QUERY = "\n  query PreviewOrderSurchargeChange($orderId: ID!, $change: OrderSurchargeChangeInput!) {\n    previewOrderSurchargeChange(orderId: $orderId, change: $change) {\n      currencyCode\n      totalBefore\n      totalAfter\n      overpayment {\n        amount\n        currencyCode\n        refund { available code message book }\n        accountCredit { available code message book }\n      }\n    }\n  }\n";
 export declare function createSurchargesModule(transport: Transport): SurchargesModule;

package/dist/orders/surcharges.js

@@ -1,3 +1,5 @@
+import { customerAgreedVariable, withCustomerAgreed } from '../payments/customer-consent.js';
+import { storeCreditAware } from '../payments/store-credit-fields.js';
 const SURCHARGED_ORDER_FIELDS = /* GraphQL */ `
   id
   code
@@ -120,7 +122,16 @@ export const REMOVE_ORDER_SURCHARGE_WITH_OVERPAYMENT_MUTATION = /* GraphQL */ `
     }
   }
 `;
-const OVERPAYMENT_OPTION_FIELDS = 'available code message';
+// A third document per write, used only on a call that states the customer's answer to store
+// credit: an engine before the argument still takes every call that does not.
+const CONSENT_ANCHOR = {
+    declaration: '$overpayment: OrderOverpaymentChoice',
+    argument: 'overpayment: $overpayment',
+};
+export const ADD_ORDER_SURCHARGE_WITH_CONSENT_MUTATION = withCustomerAgreed(ADD_ORDER_SURCHARGE_WITH_OVERPAYMENT_MUTATION, CONSENT_ANCHOR);
+export const UPDATE_ORDER_SURCHARGE_WITH_CONSENT_MUTATION = withCustomerAgreed(UPDATE_ORDER_SURCHARGE_WITH_OVERPAYMENT_MUTATION, CONSENT_ANCHOR);
+export const REMOVE_ORDER_SURCHARGE_WITH_CONSENT_MUTATION = withCustomerAgreed(REMOVE_ORDER_SURCHARGE_WITH_OVERPAYMENT_MUTATION, CONSENT_ANCHOR);
+const OVERPAYMENT_OPTION_FIELDS = 'available code message book';
 export const PREVIEW_ORDER_SURCHARGE_CHANGE_QUERY = /* GraphQL */ `
   query PreviewOrderSurchargeChange($orderId: ID!, $change: OrderSurchargeChangeInput!) {
     previewOrderSurchargeChange(orderId: $orderId, change: $change) {
@@ -141,6 +152,12 @@ function overpaymentVariable(options) {
     const value = options?.overpayment;
     return value === 'REFUND' || value === 'ACCOUNT_CREDIT' ? value : undefined;
 }
+/** The document a write sends: the plainest one that declares every argument the call states. */
+function surchargeDocument(options, documents) {
+    if (customerAgreedVariable(options?.customerAgreed) !== undefined)
+        return documents.consent;
+    return overpaymentVariable(options) === undefined ? documents.plain : documents.overpayment;
+}
 /**
  * `undefined` rather than `null` for an absent tax class: a variable explicitly
  * set to null is still a value the engine reads, and this argument's whole
@@ -155,15 +172,18 @@ export function createSurchargesModule(transport) {
         async add(orderId, input, options) {
             const data = await transport.graphql({
                 api: 'admin',
-                query: overpaymentVariable(options) === undefined
-                    ? ADD_ORDER_SURCHARGE_MUTATION
-                    : ADD_ORDER_SURCHARGE_WITH_OVERPAYMENT_MUTATION,
+                query: surchargeDocument(options, {
+                    plain: ADD_ORDER_SURCHARGE_MUTATION,
+                    overpayment: ADD_ORDER_SURCHARGE_WITH_OVERPAYMENT_MUTATION,
+                    consent: ADD_ORDER_SURCHARGE_WITH_CONSENT_MUTATION,
+                }),
                 variables: {
                     orderId,
                     input,
                     taxClass: taxClassVariable(options),
                     idempotencyKey: options?.idempotencyKey,
                     overpayment: overpaymentVariable(options),
+                    customerAgreed: customerAgreedVariable(options?.customerAgreed),
                 },
             }, options);
             return data.addOrderSurcharge;
@@ -171,9 +191,11 @@ export function createSurchargesModule(transport) {
         async update(orderId, surchargeId, input, options) {
             const data = await transport.graphql({
                 api: 'admin',
-                query: overpaymentVariable(options) === undefined
-                    ? UPDATE_ORDER_SURCHARGE_MUTATION
-                    : UPDATE_ORDER_SURCHARGE_WITH_OVERPAYMENT_MUTATION,
+                query: surchargeDocument(options, {
+                    plain: UPDATE_ORDER_SURCHARGE_MUTATION,
+                    overpayment: UPDATE_ORDER_SURCHARGE_WITH_OVERPAYMENT_MUTATION,
+                    consent: UPDATE_ORDER_SURCHARGE_WITH_CONSENT_MUTATION,
+                }),
                 variables: {
                     orderId,
                     surchargeId,
@@ -181,6 +203,7 @@ export function createSurchargesModule(transport) {
                     taxClass: taxClassVariable(options),
                     idempotencyKey: options?.idempotencyKey,
                     overpayment: overpaymentVariable(options),
+                    customerAgreed: customerAgreedVariable(options?.customerAgreed),
                 },
             }, options);
             return data.updateOrderSurcharge;
@@ -188,21 +211,24 @@ export function createSurchargesModule(transport) {
         async remove(orderId, surchargeId, options) {
             const data = await transport.graphql({
                 api: 'admin',
-                query: overpaymentVariable(options) === undefined
-                    ? REMOVE_ORDER_SURCHARGE_MUTATION
-                    : REMOVE_ORDER_SURCHARGE_WITH_OVERPAYMENT_MUTATION,
+                query: surchargeDocument(options, {
+                    plain: REMOVE_ORDER_SURCHARGE_MUTATION,
+                    overpayment: REMOVE_ORDER_SURCHARGE_WITH_OVERPAYMENT_MUTATION,
+                    consent: REMOVE_ORDER_SURCHARGE_WITH_CONSENT_MUTATION,
+                }),
                 variables: {
                     orderId,
                     surchargeId,
                     idempotencyKey: options?.idempotencyKey,
                     overpayment: overpaymentVariable(options),
+                    customerAgreed: customerAgreedVariable(options?.customerAgreed),
                 },
             }, options);
             return data.removeOrderSurcharge;
         },
         async preview(orderId, change, options) {
             const taxClass = taxClassVariable(options);
-            const data = await transport.graphql({
+            const data = await storeCreditAware(transport).graphql({
                 api: 'admin',
                 query: PREVIEW_ORDER_SURCHARGE_CHANGE_QUERY,
                 variables: {

package/dist/payments/account-credit.d.ts

@@ -33,6 +33,19 @@ export interface UnappliedCash {
     /** ISO-8601 with offset. */
     createdAt: string;
 }
+/**
+ * Money of an order's settled payments moved to the customer's store-credit wallet instead of a
+ * refund: one never-expiring ledger entry per payment it came from. Minor units of
+ * `currencyCode`, the order's own currency.
+ */
+export interface StoreCreditMove {
+    /** The customer's store-credit wallet (a stored-value account of kind `store_credit`). */
+    accountId: string;
+    amount: number;
+    currencyCode: string;
+    /** The ledger entries, one per payment the money came from. */
+    entryIds: string[];
+}
 export interface CreditOverpaymentInput {
     orderId: string;
     /**
@@ -43,6 +56,17 @@ export interface CreditOverpaymentInput {
     /** Why, in your own words: shown on the receipt and in the order's history. */
     reason?: string;
 }
+/** Options of {@link AccountCreditModule.creditOverpaymentToStoreCredit}. */
+export interface CreditOverpaymentToStoreCreditCall extends Call {
+    /**
+     * Whether the customer expressly agreed to store credit instead of a refund to their payment
+     * (EU consumer law, CRD art. 13(1)), as staff recorded it: the move records it on its ledger
+     * entries (`StoredValueEntry.customerAgreed`). Never a condition, nothing is refused for it.
+     * Part of the request: a repeat under the same key sends the same answer. Sent only when given;
+     * an engine before the argument (incentives sprint 8 PR 6a) refuses a call that gives it.
+     */
+    customerAgreed?: boolean;
+}
 export interface ApplyUnappliedCashInput {
     unappliedCashId: string;
     /** The AR invoice to pay. Give exactly one of `invoiceId` and `orderId`. */
@@ -123,6 +147,22 @@ export interface AccountCreditModule {
      * account refusals above.
      */
     creditOverpayment(input: CreditOverpaymentInput, options?: Call): Promise<UnappliedCash[]>;
+    /**
+     * The store-credit sibling of {@link creditOverpayment}, for a store whose customer-credit book
+     * is store credit (`storedValue.storeCreditSettings`): what the order holds over its bill moves
+     * to the customer's store-credit wallet, in the order's currency, one ledger entry per payment
+     * it came from. Same bounds and `ACCOUNT_CREDIT_*` refusals; an AR store is refused
+     * `STORE_CREDIT_STORE_KEEPS_ACCOUNTS` (use {@link creditOverpayment} there), a store without
+     * store credit `STORE_CREDIT_NOT_ENABLED` / `_NOT_GRANTED` / `_METHOD_REQUIRED`. A gift card's or
+     * store credit's payment is never moved (`STORE_CREDIT_STORED_VALUE_REFUND_INSTEAD`: refund it),
+     * and the customer must be reachable (`STORE_CREDIT_CUSTOMER_ANONYMOUS`,
+     * `STORED_VALUE_ACCOUNT_BLOCKED`). The overpayment is what the order's payments hold over what
+     * it BILLS, the larger of its total and its live invoices', as a plain refund of an invoiced order
+     * measures it. From then on that money is no longer the order's: `payments.refundPosition` takes
+     * it off `refundable` and `payments.position` no longer reports it as `overpaid`. Needs an
+     * engine with incentives sprint 8 PR 3.
+     */
+    creditOverpaymentToStoreCredit(input: CreditOverpaymentInput, options?: CreditOverpaymentToStoreCreditCall): Promise<StoreCreditMove>;
     /** A customer's unapplied cash in this store, oldest first. */
     list(customerId: string, options?: Call): Promise<UnappliedCash[]>;
     /**
@@ -159,6 +199,12 @@ export interface AccountCreditModule {
     onOrder(orderId: string, options?: Call): Promise<OrderMoneyOnAccount>;
 }
 export declare const CREDIT_ORDER_OVERPAYMENT_MUTATION = "\n  mutation CreditOrderOverpaymentToAccount(\n    $input: CreditOrderOverpaymentInput!\n    $idempotencyKey: String\n  ) {\n    creditOrderOverpaymentToAccount(input: $input, idempotencyKey: $idempotencyKey) {\n      \n  id\n  customerId\n  currencyCode\n  amount\n  applied\n  refunded\n  remaining\n  orderId\n  paymentId\n  receivedOn\n  reference\n  notes\n  createdAt\n\n    }\n  }\n";
+export declare const CREDIT_ORDER_OVERPAYMENT_TO_STORE_CREDIT_MUTATION = "\n  mutation CreditOrderOverpaymentToStoreCredit(\n    $input: CreditOrderOverpaymentInput!\n    $idempotencyKey: String\n  ) {\n    creditOrderOverpaymentToStoreCredit(input: $input, idempotencyKey: $idempotencyKey) {\n      accountId amount currencyCode entryIds\n    }\n  }\n";
+/**
+ * The same, declaring the customer's answer to store credit: sent only by a call that states it,
+ * so an engine before the argument still takes every call that does not.
+ */
+export declare const CREDIT_ORDER_OVERPAYMENT_TO_STORE_CREDIT_WITH_CONSENT_MUTATION = "\n  mutation CreditOrderOverpaymentToStoreCredit(\n    $input: CreditOrderOverpaymentInput!\n    $idempotencyKey: String\n    $customerAgreed: Boolean\n  ) {\n    creditOrderOverpaymentToStoreCredit(\n      input: $input\n      idempotencyKey: $idempotencyKey\n      customerAgreed: $customerAgreed\n    ) {\n      accountId amount currencyCode entryIds\n    }\n  }\n";
 export declare const UNAPPLIED_CASH_QUERY = "\n  query ArUnappliedCash($customerId: ID!) {\n    arUnappliedCash(customerId: $customerId) {\n      \n  id\n  customerId\n  currencyCode\n  amount\n  applied\n  refunded\n  remaining\n  orderId\n  paymentId\n  receivedOn\n  reference\n  notes\n  createdAt\n\n    }\n  }\n";
 export declare const APPLY_UNAPPLIED_CASH_MUTATION = "\n  mutation ApplyArUnappliedCash($input: ApplyArUnappliedCashInput!, $idempotencyKey: String) {\n    applyArUnappliedCash(input: $input, idempotencyKey: $idempotencyKey) {\n      \n  id\n  customerId\n  currencyCode\n  amount\n  applied\n  refunded\n  remaining\n  orderId\n  paymentId\n  receivedOn\n  reference\n  notes\n  createdAt\n\n    }\n  }\n";
 export declare const REFUND_UNAPPLIED_CASH_MUTATION = "\n  mutation RefundArUnappliedCash($input: RefundArUnappliedCashInput!, $idempotencyKey: String) {\n    refundArUnappliedCash(input: $input, idempotencyKey: $idempotencyKey) {\n      id\n      total\n      state\n      method\n      transactionId\n      reason\n    }\n  }\n";

package/dist/payments/account-credit.js

@@ -1,3 +1,5 @@
+import { customerAgreedVariable } from './customer-consent.js';
+import { STORE_CREDIT_MOVE_FIELDS } from './store-credit-fields.js';
 const UNAPPLIED_CASH_FIELDS = /* GraphQL */ `
   id
   customerId
@@ -23,6 +25,35 @@ export const CREDIT_ORDER_OVERPAYMENT_MUTATION = /* GraphQL */ `
     }
   }
 `;
+export const CREDIT_ORDER_OVERPAYMENT_TO_STORE_CREDIT_MUTATION = /* GraphQL */ `
+  mutation CreditOrderOverpaymentToStoreCredit(
+    $input: CreditOrderOverpaymentInput!
+    $idempotencyKey: String
+  ) {
+    creditOrderOverpaymentToStoreCredit(input: $input, idempotencyKey: $idempotencyKey) {
+      ${STORE_CREDIT_MOVE_FIELDS}
+    }
+  }
+`;
+/**
+ * The same, declaring the customer's answer to store credit: sent only by a call that states it,
+ * so an engine before the argument still takes every call that does not.
+ */
+export const CREDIT_ORDER_OVERPAYMENT_TO_STORE_CREDIT_WITH_CONSENT_MUTATION = /* GraphQL */ `
+  mutation CreditOrderOverpaymentToStoreCredit(
+    $input: CreditOrderOverpaymentInput!
+    $idempotencyKey: String
+    $customerAgreed: Boolean
+  ) {
+    creditOrderOverpaymentToStoreCredit(
+      input: $input
+      idempotencyKey: $idempotencyKey
+      customerAgreed: $customerAgreed
+    ) {
+      ${STORE_CREDIT_MOVE_FIELDS}
+    }
+  }
+`;
 export const UNAPPLIED_CASH_QUERY = /* GraphQL */ `
   query ArUnappliedCash($customerId: ID!) {
     arUnappliedCash(customerId: $customerId) {
@@ -79,6 +110,17 @@ export function createAccountCreditModule(transport) {
             }, options);
             return data.creditOrderOverpaymentToAccount;
         },
+        async creditOverpaymentToStoreCredit(input, options) {
+            const customerAgreed = customerAgreedVariable(options?.customerAgreed);
+            const data = await transport.graphql({
+                api: 'admin',
+                query: customerAgreed === undefined
+                    ? CREDIT_ORDER_OVERPAYMENT_TO_STORE_CREDIT_MUTATION
+                    : CREDIT_ORDER_OVERPAYMENT_TO_STORE_CREDIT_WITH_CONSENT_MUTATION,
+                variables: { input, idempotencyKey: options?.idempotencyKey, customerAgreed },
+            }, options);
+            return data.creditOrderOverpaymentToStoreCredit;
+        },
         async list(customerId, options) {
             const data = await transport.graphql({ api: 'admin', query: UNAPPLIED_CASH_QUERY, variables: { customerId } }, options);
             return data.arUnappliedCash;

package/dist/payments/ar.d.ts

@@ -0,0 +1,292 @@
+import { type Page, type Transport } from '@sixtyninecommerce/core';
+import type { Call, ListOptions } from '../types.js';
+/**
+ * Money on the store's accounts-receivable ledger (`admin.payments.ar`, headless W10-30): the
+ * payments customers make against their AR invoices, the ledger itself, prepaid drawdowns, and
+ * collecting an invoice by SEPA direct debit. Unapplied cash (an order's overpayment kept on the
+ * account) is `payments.accountCredit`.
+ *
+ * Every write needs `UpdateOrder` and a store that keeps its AR ledger (else
+ * `AR_LEDGER_NOT_ENABLED`, → `BusinessRuleError`, 422); every read `ReadOrder`. A customer the
+ * store does not hold is `CUSTOMER_NOT_FOUND` (→ `NotFoundError`). Money is in integer minor units
+ * of the currency named beside it.
+ *
+ * **Keys.** `recordPayment`, `recordPrepaidDrawdown` and `directDebit.collectNow` take
+ * `options.idempotencyKey`: a repeat under the same key answers the first call's outcome instead
+ * of moving the money again; another request under the key is `IDEMPOTENCY_CONFLICT`
+ * (→ `ConflictError`, 409), one that arrives while the first still runs
+ * `IDEMPOTENCY_IN_PROGRESS`. **Without a key `recordPayment` is NOT de-duplicated**: a double
+ * submit records two payments. Use a fresh key per intended payment and reuse it only to retry
+ * that payment.
+ */
+/** A customer payment received on the AR ledger, with what it settled. */
+export interface ArPayment {
+    id: string;
+    customerId: string;
+    amount: number;
+    currencyCode: string;
+    /** `bank_transfer`, `cash`, `card`, `direct_debit` or `other`. */
+    method: string;
+    receivedOn: string;
+    reference: string | null;
+    notes: string | null;
+    allocations: Array<{
+        id: string;
+        invoiceId: string;
+        amount: number;
+    }>;
+    createdAt: string;
+}
+export type ArPaymentMethod = 'bank_transfer' | 'cash' | 'card' | 'direct_debit' | 'other';
+export interface RecordArPaymentInput {
+    customerId: string;
+    /** Minor units of `currencyCode`, above zero. */
+    amount: number;
+    method: ArPaymentMethod;
+    /** `YYYY-MM-DD`; defaults to today in the store's zone. */
+    receivedOn?: string;
+    reference?: string;
+    notes?: string;
+    /** One the store sells in; defaults to the account's currency. It settles only invoices in it. */
+    currencyCode?: string;
+    /**
+     * Where the money goes, each at most what the invoice still owes. Omitted, it is allocated
+     * oldest invoice first and the rest stays on the account.
+     */
+    allocations?: Array<{
+        invoiceId: string;
+        amount: number;
+    }>;
+}
+/** One ledger posting. */
+export interface ArLedgerEntry {
+    id: string;
+    /** `invoice_debit`, `payment_credit`, `credit_note_credit`, `prepaid_drawdown`, … */
+    entryType: string;
+    /** Signed minor units of `currencyCode`. */
+    amount: number;
+    currencyCode: string;
+    sourceType: string;
+    sourceId: string | null;
+    occurredOn: string;
+    metadata: Record<string, unknown> | null;
+    createdAt: string;
+}
+/** The drawdown already posted for an order. */
+export interface ArOrderPrepaidDrawdown {
+    entryId: string;
+    orderId: string;
+    amount: number;
+    currencyCode: string;
+    occurredOn: string;
+}
+export interface ArPrepaidDrawdownResult {
+    entryId: string;
+    customerId: string;
+    amount: number;
+    currencyCode: string;
+    occurredOn: string;
+    /** The customer's signed balance after it, in `currencyCode` only. */
+    balanceAfter: number;
+    /** True when the order had been drawn down already: nothing new was posted. */
+    alreadyRecorded: boolean;
+}
+export interface RecordArPrepaidDrawdownInput {
+    orderId: string;
+    /** `YYYY-MM-DD`; defaults to today in the store's zone. */
+    occurredOn?: string;
+}
+/** A customer's SEPA direct debit set-up. */
+export interface ArDirectDebitSettings {
+    customerId: string;
+    enabled: boolean;
+    /** Set: every collection is blocked until a person clears it. */
+    suspendedReason: string | null;
+    hasValidMandate: boolean;
+    mandateId: string | null;
+    providerMandateId: string | null;
+    /** False when the platform has no mandate provider at all. */
+    available: boolean;
+}
+export interface UpdateArDirectDebitSettingsInput {
+    enabled?: boolean;
+    /** Null lifts a suspension. */
+    suspendedReason?: string | null;
+}
+/** One attempt to collect an invoice by direct debit. */
+export interface ArCollectionAttempt {
+    id: string;
+    invoiceId: string;
+    customerId: string;
+    attemptNumber: number;
+    amount: number;
+    currencyCode: string;
+    /** `pending`, `paid`, `failed`, `reversed` or `cancelled`. */
+    status: string;
+    provider: string;
+    providerPaymentId: string | null;
+    /** The SEPA R-code when the provider gave one (`AM04`, `MD06`, …). */
+    failureCode: string | null;
+    failureReason: string | null;
+    settledAt: string | null;
+    reversedAt: string | null;
+    orderSettlementState: string;
+    lastCheckedAt: string | null;
+    createdAt: string;
+}
+/** The recorded pre-notification and the wording the merchant must send the debtor. */
+export interface ArPreNotification {
+    invoiceId: string;
+    /** The first day the collection may be taken. */
+    collectOn: string;
+    amount: number;
+    noticeTitle: string;
+    noticeBody: string;
+}
+/**
+ * What asking to collect an invoice now answered. A refusal is an ANSWER, not an error:
+ * `{ result: 'refused', refusal, message }` says why the invoice cannot be collected now (not
+ * pre-notified, no mandate, suspended, nothing outstanding, …), and nothing was asked of the
+ * bank. `declined`: the provider refused the charge at once. `already-in-flight`: a collection
+ * of the invoice is running; `attempt` is it.
+ */
+export type ArCollectResult = {
+    result: 'charged' | 'declined' | 'already-in-flight';
+    refusal: null;
+    message: null;
+    attempt: ArCollectionAttempt;
+} | {
+    result: 'refused';
+    refusal: string;
+    message: string;
+    attempt: null;
+};
+export interface ArDirectDebitModule {
+    /**
+     * A customer's direct debit settings and mandate state.
+     *
+     * @effect read
+     * @permission ReadOrder
+     */
+    settings(customerId: string, options?: Call): Promise<ArDirectDebitSettings>;
+    /**
+     * Turn direct debit on or off for a customer, or lift a suspension. Turning it on needs a valid
+     * SEPA mandate (`AR_DIRECT_DEBIT_MANDATE_REQUIRED`; an older engine answered
+     * `USER_INPUT_ERROR`). Moves no money.
+     *
+     * @effect write
+     * @permission UpdateOrder
+     */
+    update(customerId: string, input: UpdateArDirectDebitSettingsInput, options?: Call): Promise<ArDirectDebitSettings>;
+    /**
+     * Every collection attempt of one invoice, newest first (the last 50).
+     *
+     * @effect read
+     * @permission ReadOrder
+     */
+    attempts(invoiceId: string, options?: Call): Promise<ArCollectionAttempt[]>;
+    /**
+     * The newest attempt of each invoice named, in one call.
+     *
+     * @effect read
+     * @permission ReadOrder
+     */
+    latestAttempts(invoiceIds: string[], options?: Call): Promise<ArCollectionAttempt[]>;
+    /**
+     * Record that the debtor has been told the invoice will be collected, and get the exact
+     * wording to send them. It sends nothing itself: sending the notice is the merchant's legal
+     * duty, and recording it is what allows the collection. Run it again when the outstanding
+     * amount changes.
+     *
+     * Refused, coded (an older engine answered each `USER_INPUT_ERROR` with the same sentence):
+     * `AR_INVOICE_NOT_FOUND`, `AR_INVOICE_NOT_OPEN` (voided, or nothing outstanding),
+     * `AR_DIRECT_DEBIT_NOT_ENABLED`, `AR_DIRECT_DEBIT_SUSPENDED`, `AR_ACCOUNT_IN_ERP`,
+     * `AR_INVOICE_DIRECT_DEBIT_IN_FLIGHT`.
+     *
+     * @effect money
+     * @permission UpdateOrder
+     */
+    sendPreNotification(invoiceId: string, options?: Call): Promise<ArPreNotification>;
+    /**
+     * Collect a pre-notified invoice now, from the customer's SEPA mandate. A refusal is answered
+     * as `{ result: 'refused', refusal }`, NOT thrown (see {@link ArCollectResult}). Thrown:
+     * `AR_INVOICE_NOT_FOUND`, and `AR_DIRECT_DEBIT_UNAVAILABLE` (a platform fault, 500: the
+     * platform has no webhook address or charge provider for the collection; nothing is reserved).
+     *
+     * Pass `options.idempotencyKey`: a repeat under it answers the first outcome (the attempt as it
+     * is now). Once the provider was asked, a failure spends the key: a repeat answers
+     * `IDEMPOTENCY_OUTCOME_UNKNOWN` (`error.outcomeUnknown`) and asks the bank nothing; read
+     * {@link attempts} for what happened. The engine also keeps one live attempt per invoice
+     * whatever the key does.
+     *
+     * @effect money
+     * @permission UpdateOrder
+     */
+    collectNow(invoiceId: string, options?: Call): Promise<ArCollectResult>;
+}
+export interface ArPaymentsModule {
+    /**
+     * AR payments, newest first, one customer's or the store's, paged (`limit` up to 100).
+     *
+     * @effect read
+     * @permission ReadOrder
+     */
+    payments(options?: ListOptions & {
+        customerId?: string;
+    }): Promise<Page<ArPayment>>;
+    /**
+     * A customer's ledger postings, newest first, paged (`limit` up to 100).
+     *
+     * @effect read
+     * @permission ReadOrder
+     */
+    ledger(customerId: string, options?: ListOptions): Promise<Page<ArLedgerEntry>>;
+    /**
+     * Record a payment a customer made against their AR invoices: the receipt, its allocations and
+     * the ledger credit, in one transaction. **Pass `options.idempotencyKey`**: without one a
+     * repeat (a double click, a retry after a timeout) records a second payment. With one, the
+     * repeat answers the first payment as it is now.
+     *
+     * Refusals: `AR_LEDGER_NOT_ENABLED`, `CUSTOMER_NOT_FOUND`, `CURRENCY_NOT_AVAILABLE` (a currency
+     * the store does not sell in), `AR_CURRENCY_MISMATCH` (an allocation to an invoice in another
+     * currency), `AR_INVOICE_NOT_FOUND` (an allocation to an invoice not this customer's),
+     * `AR_INVOICE_NOT_OPEN` (to a voided one), `AR_ALLOCATION_EXCEEDS_OUTSTANDING` (more than the
+     * invoice still owes) and `AR_ALLOCATION_EXCEEDS_PAYMENT` (more than the payment), each a
+     * `USER_INPUT_ERROR` on an older engine; and a field refusal (`USER_INPUT_ERROR`) for an amount,
+     * a method or an allocation that is not one (a duplicate).
+     *
+     * @effect money
+     * @permission UpdateOrder
+     */
+    recordPayment(input: RecordArPaymentInput, options?: Call): Promise<ArPayment>;
+    /**
+     * The prepaid drawdown already posted for an order, or null.
+     *
+     * @effect read
+     * @permission ReadOrder
+     */
+    prepaidDrawdown(orderId: string, options?: Call): Promise<ArOrderPrepaidDrawdown | null>;
+    /**
+     * Draw a delivered order's gross total off the customer's prepaid credit. Once per order
+     * whatever happens (`alreadyRecorded` on a repeat without a key); with a key, a repeat answers
+     * the first result. Refused `ORDER_NOT_FOUND`, `AR_ORDER_HAS_NO_CUSTOMER` and
+     * `AR_ORDER_STATE_BLOCKS_DRAWDOWN` (each `USER_INPUT_ERROR` on an older engine).
+     *
+     * @effect money
+     * @permission UpdateOrder
+     */
+    recordPrepaidDrawdown(input: RecordArPrepaidDrawdownInput, options?: Call): Promise<ArPrepaidDrawdownResult>;
+    directDebit: ArDirectDebitModule;
+}
+export declare const AR_PAYMENTS_QUERY = "\n  query ArPayments($options: ArListOptions) {\n    arPayments(options: $options) {\n      items { \n  id\n  customerId\n  amount\n  currencyCode\n  method\n  receivedOn\n  reference\n  notes\n  allocations {\n    id\n    invoiceId\n    amount\n  }\n  createdAt\n }\n      totalItems\n    }\n  }\n";
+export declare const AR_LEDGER_QUERY = "\n  query ArLedgerEntries($customerId: ID!, $options: ArListOptions) {\n    arLedgerEntries(customerId: $customerId, options: $options) {\n      items {\n        id\n        entryType\n        amount\n        currencyCode\n        sourceType\n        sourceId\n        occurredOn\n        metadata\n        createdAt\n      }\n      totalItems\n    }\n  }\n";
+export declare const RECORD_AR_PAYMENT_MUTATION = "\n  mutation RecordArPayment($input: RecordArPaymentInput!, $idempotencyKey: String) {\n    recordArPayment(input: $input, idempotencyKey: $idempotencyKey) { \n  id\n  customerId\n  amount\n  currencyCode\n  method\n  receivedOn\n  reference\n  notes\n  allocations {\n    id\n    invoiceId\n    amount\n  }\n  createdAt\n }\n  }\n";
+export declare const AR_ORDER_PREPAID_DRAWDOWN_QUERY = "\n  query ArOrderPrepaidDrawdown($orderId: ID!) {\n    arOrderPrepaidDrawdown(orderId: $orderId) {\n      entryId\n      orderId\n      amount\n      currencyCode\n      occurredOn\n    }\n  }\n";
+export declare const RECORD_AR_PREPAID_DRAWDOWN_MUTATION = "\n  mutation RecordArPrepaidDrawdown($input: RecordArPrepaidDrawdownInput!, $idempotencyKey: String) {\n    recordArPrepaidDrawdown(input: $input, idempotencyKey: $idempotencyKey) {\n      entryId\n      customerId\n      amount\n      currencyCode\n      occurredOn\n      balanceAfter\n      alreadyRecorded\n    }\n  }\n";
+export declare const AR_DIRECT_DEBIT_SETTINGS_QUERY = "\n  query ArDirectDebitSettings($customerId: ID!) {\n    arDirectDebitSettings(customerId: $customerId) { \n  customerId\n  enabled\n  suspendedReason\n  hasValidMandate\n  mandateId\n  providerMandateId\n  available\n }\n  }\n";
+export declare const UPDATE_AR_DIRECT_DEBIT_SETTINGS_MUTATION = "\n  mutation UpdateArDirectDebitSettings($customerId: ID!, $input: UpdateArDirectDebitSettingsInput!) {\n    updateArDirectDebitSettings(customerId: $customerId, input: $input) {\n      \n  customerId\n  enabled\n  suspendedReason\n  hasValidMandate\n  mandateId\n  providerMandateId\n  available\n\n    }\n  }\n";
+export declare const AR_COLLECTION_ATTEMPTS_QUERY = "\n  query ArCollectionAttempts($invoiceId: ID!) {\n    arCollectionAttempts(invoiceId: $invoiceId) { \n  id\n  invoiceId\n  customerId\n  attemptNumber\n  amount\n  currencyCode\n  status\n  provider\n  providerPaymentId\n  failureCode\n  failureReason\n  settledAt\n  reversedAt\n  orderSettlementState\n  lastCheckedAt\n  createdAt\n }\n  }\n";
+export declare const AR_LATEST_COLLECTION_ATTEMPTS_QUERY = "\n  query ArLatestCollectionAttempts($invoiceIds: [ID!]!) {\n    arLatestCollectionAttempts(invoiceIds: $invoiceIds) { \n  id\n  invoiceId\n  customerId\n  attemptNumber\n  amount\n  currencyCode\n  status\n  provider\n  providerPaymentId\n  failureCode\n  failureReason\n  settledAt\n  reversedAt\n  orderSettlementState\n  lastCheckedAt\n  createdAt\n }\n  }\n";
+export declare const SEND_AR_PRE_NOTIFICATION_MUTATION = "\n  mutation SendArDirectDebitPreNotification($invoiceId: ID!) {\n    sendArDirectDebitPreNotification(invoiceId: $invoiceId) {\n      invoiceId\n      collectOn\n      amount\n      noticeTitle\n      noticeBody\n    }\n  }\n";
+export declare const COLLECT_AR_INVOICE_NOW_MUTATION = "\n  mutation CollectArInvoiceNow($invoiceId: ID!, $idempotencyKey: String) {\n    collectArInvoiceNow(invoiceId: $invoiceId, idempotencyKey: $idempotencyKey) {\n      result\n      refusal\n      message\n      attempt { \n  id\n  invoiceId\n  customerId\n  attemptNumber\n  amount\n  currencyCode\n  status\n  provider\n  providerPaymentId\n  failureCode\n  failureReason\n  settledAt\n  reversedAt\n  orderSettlementState\n  lastCheckedAt\n  createdAt\n }\n    }\n  }\n";
+export declare function createArPaymentsModule(transport: Transport): ArPaymentsModule;