@sixtyninecommerce/admin 0.10.0 → 0.12.0

package/dist/payments/index.d.ts

@@ -1,8 +1,12 @@
-import type { Transport } from '@sixtyninecommerce/core';
+import { type Transport } from '@sixtyninecommerce/core';
+import type { InvoiceCorrectionLedger } from '../documents/index.js';
 import type { Call } from '../types.js';
 import { type AccountCreditModule } from './account-credit.js';
+import { type ArPaymentsModule } from './ar.js';
 import { type PaymentMethodsModule } from './methods.js';
+import { type PaymentLinksModule } from './payment-links.js';
 import { type ProvidersModule } from './providers.js';
+import { type PaymentRequestsModule } from './requests.js';
 /**
  * What an order has actually been paid, in minor units of its own currency.
  *
@@ -10,7 +14,11 @@ import { type ProvidersModule } from './providers.js';
  * is a second source of truth that drifts the first time a refund lands.
  */
 export interface OrderPaymentPosition {
-    /** The order's own gross total, carrying the order's rounding rule. */
+    /**
+     * The order's own gross total, carrying the order's rounding rule. 0 for a `Cancelled` order:
+     * a cancelled order bills nothing. A credit note does not change it: see `creditNoted` and
+     * `owed`.
+     */
     total: number;
     /** Settled plus authorized, less refunds: what is accounted for. */
     covered: number;
@@ -24,24 +32,65 @@ export interface OrderPaymentPosition {
      * counted here, though it is taken off `settled` like one.
      */
     refunded: number;
-    /** `total - covered`, floored at zero. */
+    /**
+     * What the order's credit notes took off what it bills: `total` less what its invoices bill net
+     * of their credit notes (a part credited, an invoice voided with no replacement), never more
+     * than `total`; 0 for an order with no invoice. A correction never restates the order, so
+     * `total` keeps reading what it first billed. Taken off `owed` only.
+     *
+     * Read by {@link PaymentsModule.position}, `orders.paymentPosition` and the cancel-with-money
+     * preview and answer. Against an engine that does not serve it those calls resend their document
+     * without it (`creditNotedAware`), so it is absent and reads as zero; absent from a settlement's
+     * position too.
+     */
+    creditNoted?: number;
+    /**
+     * What the customer still owes once the credit notes are counted: `total - creditNoted -
+     * covered`, floored at zero. A refund that went back with a credit note is owed by nobody.
+     * Equals `outstanding` when nothing was credited. Read by the same calls as `creditNoted`; where
+     * it is absent, the customer owes `outstanding`.
+     */
+    owed?: number;
+    /**
+     * What the order's SETTLED money must reach before it counts as paid: `total` less what a live
+     * invoice's credit notes took off it. An order paid down to what its invoice bills net of its
+     * credit notes is paid in full: `orders.settle`, the staff move into `PaymentSettled` and the
+     * platform's own settlement all measure this figure. Equals `total` when nothing was credited,
+     * and also when the order's only invoice was cancelled with nothing in its place (it owes
+     * nothing more, `owed`, but counts as paid only once it is invoiced again or cancelled). Read by
+     * {@link PaymentsModule.position} and `orders.paymentPosition`; against an engine that does not
+     * serve it those calls resend without it, and an absent `payable` reads as `total`.
+     */
+    payable?: number;
+    /**
+     * `total - covered`, floored at zero: what the payments are short of the order's total. On an
+     * order whose credit notes took part of its bill off, `owed` is what the customer still owes,
+     * and what `record` caps a payment at.
+     */
     outstanding: number;
     /**
      * `covered - total`, floored at zero. Over-payment is refused at the door, so
      * this is non-zero only for imported history, rows predating the guard, a
-     * refund that landed after a second payment, or an edit that lowered the
-     * total of a paid order. Money moved to the customer's account
+     * refund that landed after a second payment, an edit that lowered the
+     * total of a paid order, or money kept on a cancelled order (a cancelled
+     * order bills nothing; `orders.cancelWithMoney` with `retain`), which can
+     * still be credited to the account. Money moved to the customer's account
      * (`payments.accountCredit.creditOverpayment`) no longer counts here.
      */
     overpaid: number;
-    /** What a further payment may take. */
+    /**
+     * What a further payment may take: what is still owed once the credit notes are counted
+     * (`owed`; `outstanding` when nothing was credited). An engine before the credit-noted caps
+     * answers `outstanding` here.
+     */
     availableToCharge: number;
 }
 /** Money the merchant HAS, recorded against an order. */
 export interface RecordPaymentInput {
     /**
-     * Minor units of the order's currency. Greater than zero, and at most the
-     * order's `outstanding` — an over-payment is refused rather than accepted,
+     * Minor units of the order's currency. Greater than zero, and at most what the
+     * order still owes (its position's `owed`: `outstanding` less what its credit
+     * notes took off its bill) — an over-payment is refused rather than accepted,
      * and the refusal carries the position so a till can correct itself without a
      * second round trip.
      */
@@ -81,7 +130,10 @@ export interface RefundablePayment {
     /**
      * `amount - refunded`, less what of this payment is on the customer's account
      * (`payments.accountCredit.onOrder`), when this payment took money; floored
-     * at zero, else zero.
+     * at zero, else zero. Less, too, this payment's share of what the gift cards
+     * sold on the order hold: a live card's value, and a voided card's spent (or
+     * expired) value, which stays held for good. How much, and on which payment:
+     * {@link PaymentsModule.refundGiftCardHold}.
      */
     refundable: number;
     /**
@@ -118,11 +170,43 @@ export interface OrderRefundPosition {
      * Money moved to the customer's account as unapplied cash IS deducted: it is
      * paid back from the account (`payments.accountCredit.refund`), never from
      * the order a second time.
+     *
+     * What the gift cards sold on the order hold is deducted too: a live card's
+     * value, and a voided card's spent (or expired) value, which stays held for
+     * good. A refund of it is refused `REFUND_HELD_BY_GIFT_CARD`;
+     * {@link PaymentsModule.refundGiftCardHold} says how much, and on which payment.
      */
     refundable: number;
     /** Every payment on the order, NEWEST FIRST, with its own headroom. */
     perPayment: RefundablePayment[];
 }
+/**
+ * What the gift cards sold on an order hold of its money: why its refund position's `refundable`
+ * is lower than what its payments took ({@link PaymentsModule.refundGiftCardHold}).
+ */
+export interface RefundGiftCardHold {
+    /** The order's currency. Every amount here is in its minor units. */
+    currencyCode: string;
+    /**
+     * What the cards hold: each card its face value less what a void released, and a void releases
+     * at most what the card had not spent, so a card's spent (or expired) value stays held for good.
+     * Already counted out of `refundable`, so `refundable` plus this is what the payments would hand
+     * back with no card. A refund of it is refused `REFUND_HELD_BY_GIFT_CARD`. 0 when no card holds
+     * any.
+     */
+    giftCardHold: number;
+    /**
+     * How many of the cards sold on the order are still live (not voided); null while
+     * `giftCardHold` is 0. Above 0, voiding a card releases what it has not spent; 0 means every
+     * card is voided, and what they hold is spent value that stays with the store.
+     */
+    liveGiftCards: number | null;
+    /** Each payment's share of the hold, NEWEST FIRST, as `refundPosition` lists them. */
+    perPayment: Array<{
+        paymentId: string;
+        giftCardHold: number;
+    }>;
+}
 /**
  * A refund whose outcome is unknown: it reached its payment provider and was
  * never confirmed (a timeout, a dropped connection, a server error), so the
@@ -139,6 +223,30 @@ export interface UnreconciledRefund {
     /** ISO-8601 with offset. */
     createdAt: string | null;
 }
+/**
+ * The invoice a refund of an order must go through, so a credit note says what the money was for
+ * (see {@link PaymentsModule.refundCreditNoteRequirement}).
+ */
+export interface RefundCreditNoteRequirement {
+    /** The live invoice billing the order: plan and commit the correction on it. */
+    invoiceId: string;
+    /** As printed on the invoice. */
+    invoiceNumber: string;
+    /**
+     * The ledger to plan the correction on (`documents.planCorrection({ ledger, invoiceId })`).
+     * `RETAIL` is named first when the order has both: its correction can carry the refund.
+     */
+    ledger: InvoiceCorrectionLedger;
+    /**
+     * Minor units of the order's currency: what its payments hold over what it bills (a duplicate
+     * payment, say), net of every refund. "What it bills" is the larger of the order's total and
+     * what its live invoices bill. {@link PaymentsModule.refund} gives back up to this much
+     * without a credit note, recorded as an overpayment refund (the invoice never billed it); a
+     * larger refund goes through the correction. `0` when the order is not overpaid. Only payments
+     * that took money count, and a refund of unknown outcome stays reserved.
+     */
+    refundableOverpayment: number;
+}
 /** What the payment provider says happened to a refund whose outcome was unknown. */
 export type RefundProviderOutcome = 'MADE' | 'NOT_MADE';
 /** The provider's answer for a refund whose outcome is unknown. */
@@ -202,6 +310,48 @@ export interface PaidOrder {
     total: number;
     totalWithTax: number;
 }
+/** A payment, as {@link PaymentsModule.settle} and {@link PaymentsModule.cancel} answer it. */
+export interface OrderPaymentRecord {
+    id: string;
+    /** Vendure's payment state: `Settled` after a capture, `Cancelled` after a void. */
+    state: string;
+    /** The payment method code. */
+    method: string;
+    /** Minor units of the order's currency. */
+    amount: number;
+    /** The provider's reference for the payment, when it gave one. */
+    transactionId: string | null;
+}
+/** A coded refusal "mark as paid" would answer now ({@link PaymentsModule.settlePreview}). */
+export interface PaymentSettleRefusal {
+    /**
+     * `PAYMENT_CAPTURE_EXCEEDS_BILLED`, `ORDER_CANCELLED_PAYMENT_CONFLICT` or
+     * `PAYMENT_STATE_TRANSITION_ERROR`: the code {@link PaymentsModule.settle} would throw.
+     */
+    code: string;
+    /** The engine's sentence for staff: why, and what to do instead. */
+    message: string;
+}
+/**
+ * What {@link PaymentsModule.settle} would do to an authorized payment as its order stands now
+ * ({@link PaymentsModule.settlePreview}). Nothing was written. Minor units of the order's currency.
+ */
+export interface PaymentSettlePreview {
+    paymentId: string;
+    /** The payment's amount as it stands: what it authorized. */
+    authorized: number;
+    /**
+     * What the capture records now: `authorized`, or less on an order whose credit notes lowered
+     * what it bills (the rest of a promise whose money moves by hand is dropped). 0 when refused.
+     */
+    records: number;
+    /** What the order's credit notes took off what it bills; 0 when the capture is whole. */
+    creditNoted: number;
+    /** The numbers of the credit notes behind `records` or the refusal, oldest first. */
+    creditNotes: string[];
+    /** Null when the capture may run; else the coded refusal it would answer now. */
+    refusal: PaymentSettleRefusal | null;
+}
 /** What a payment app reports happened to a payment it took (`reportAppPayment`). */
 export type AppPaymentReportState = 'Authorized' | 'Settled' | 'Declined' | 'Cancelled';
 /** An app's report on one of its payments. */
@@ -285,11 +435,27 @@ export interface PaymentsModule {
      * to an invoice, pay it back.
      */
     accountCredit: AccountCreditModule;
+    /**
+     * Money on the accounts-receivable ledger: customer payments against AR invoices, the ledger,
+     * prepaid drawdowns and SEPA direct debit collection.
+     */
+    ar: ArPaymentsModule;
     /**
      * 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;
+    /**
+     * Hosted payment requests: ask the customer to pay a chosen amount of a held
+     * order or a committed draft through a stable link that opens the payment
+     * provider's checkout. See {@link PaymentRequestsModule}.
+     */
+    requests: PaymentRequestsModule;
+    /**
+     * The store's payment links (Tikkie): the connection's settings and checks, and the links an
+     * order was sent by invoice e-mail. See {@link PaymentLinksModule}.
+     */
+    paymentLinks: PaymentLinksModule;
     /**
      * Record part (or all) of what an order owes, and return the order.
      *
@@ -297,15 +463,27 @@ export interface PaymentsModule {
      * argument, so a retry under the same key returns the first call's order
      * rather than taking the money twice. Use a fresh key per intended payment.
      *
-     * Refusals: `AMOUNT_EXCEEDS_OUTSTANDING` (over-payment, with the position
-     * attached), `AMOUNT_NOT_POSITIVE`, `ORDER_NOT_RECORDABLE` (the order's state
-     * cannot take a payment), `DEPOSITS_NOT_ENABLED` — a PARTIAL payment on a
-     * store that has not turned deposits on; paying the whole outstanding balance
-     * is not a deposit and always works — `METADATA_KEY_RESERVED`,
+     * Refusals: `AMOUNT_EXCEEDS_OUTSTANDING` (more than the order still owes,
+     * `owed`, with the position attached; its message names the credit notes that
+     * lowered it), `AMOUNT_NOT_POSITIVE`, `ORDER_NOT_RECORDABLE` (the order's state
+     * cannot take a payment), `DEPOSITS_NOT_ENABLED` — a PARTIAL payment (less
+     * than `owed`) on a store that has not turned deposits on; paying all it owes
+     * is not a deposit and always works, and neither is a stored-value payment (a
+     * gift card or store credit) on an order still arranging payment: that part is
+     * taken whatever the deposit policy, and the order is placed only once its
+     * money covers it — `METADATA_KEY_RESERVED`,
      * `PAYMENT_METHOD_NOT_FOUND`, `ORDER_NOT_FOUND`.
+     *
+     * @effect money
      */
     record(orderId: string, input: RecordPaymentInput, options?: Call): Promise<PaidOrder>;
-    /** Read an order's payment position. */
+    /**
+     * Read an order's payment position: what it bills, what was paid and refunded, what its credit
+     * notes took off (`creditNoted`), what the customer still owes after them (`owed`) and what its
+     * settled money must reach before it counts as paid (`payable`).
+     *
+     * @effect read
+     */
     position(orderId: string, options?: Call): Promise<OrderPaymentPosition>;
     /**
      * Hand money back to a customer, never more than the order took.
@@ -379,10 +557,141 @@ export interface PaymentsModule {
      * order has been read carries that order's position in
      * `extensions.refundPosition`, so a till can correct itself without a second
      * round trip.
+     *
+     * **An invoiced order is refunded through its invoice, not here.** While the
+     * order has a live invoice, this refuses `REFUND_REQUIRES_CREDIT_NOTE` (a
+     * `ConflictError`, 409) before anything else: a refund made here issues no
+     * document, and the invoice would stand with no credit note for the money.
+     * Ask {@link refundCreditNoteRequirement} first; it names the invoice, and
+     * `documents.commitCorrection` on it issues the credit note and then refunds.
+     * Not refused: an amount within the order's overpayment
+     * (`refundableOverpayment`, money the invoice never billed), refunded here
+     * and recorded as an overpayment refund; and a customer with a credit
+     * account on a store that keeps the accounts-receivable ledger, whose refund
+     * is documented when it settles: by an AR credit note for what an invoice
+     * billed, and by none for money no invoice billed (a duplicate payment given
+     * back), which is recorded as an overpayment refund. The refusal's `details`
+     * name the invoice and the overpayment still refundable. Needs an engine that knows
+     * the rule (vendure-server deployed first); an older one refunds as before.
+     *
+     * @effect money
      */
     refund(input: RefundPaymentInput, options?: Call): Promise<IssuedRefund>;
+    /**
+     * Capture an authorized payment at its provider ("mark as paid"), and return the payment.
+     *
+     * At most once per payment, whoever asks and however often: the engine keys every capture of a
+     * payment under ONE key of its own (`payment:<id>:capture`), so this method takes no
+     * `idempotencyKey`. A repeat while the payment is `Settled` captures nothing and is refused
+     * `PAYMENT_STATE_TRANSITION_ERROR` ("already settled"); a repeat while the first capture is
+     * still running is refused `IDEMPOTENCY_IN_PROGRESS`. A capture whose answer was lost after it
+     * reached the provider is refused `IDEMPOTENCY_OUTCOME_UNKNOWN` (`error.outcomeUnknown`) on
+     * that call and on every capture for the key's retention (24 hours): check the payment with the
+     * provider before doing anything else with it, and never retry this blind. Once the key is
+     * swept a capture asks the provider again, so an automatic retry after a day can capture a
+     * second time; the provider's own report (`reportAppPayment`) still settles it meanwhile.
+     *
+     * Refusals, as coded errors (the Admin API answers some as a result union; this method throws
+     * every one):
+     * - `PAYMENT_SETTLE_DECLINED` (`BusinessRuleError`, 422): the provider declined the capture.
+     *   The message is the provider's reason. Nothing was captured, and a later capture may be
+     *   tried.
+     * - `PAYMENT_STATE_TRANSITION_ERROR` (422): the payment is not `Authorized` (settled, cancelled
+     *   or declined already). The message says which.
+     * - `ORDER_STATE_TRANSITION_ERROR` (422): the capture went through the provider's gate but the
+     *   order could not move on as it stands.
+     * - `ORDER_CANCELLED_PAYMENT_CONFLICT` (409): the payment's order is cancelled, and a cancelled
+     *   order is never paid. Cancel the payment instead to release it.
+     * - `PAYMENT_CAPTURE_EXCEEDS_BILLED` (422): the order's credit notes lowered what it bills, and
+     *   the payment would take more: its provider can only capture it in full, the order's other
+     *   payments already cover the bill, or its only invoice was cancelled with nothing in its
+     *   place. Nothing was captured; the error's `extensions.leftToPay` is what is left to pay
+     *   without this payment (the bill after its credit notes, less the order's other payments),
+     *   and the message names the credit notes and what to do instead.
+     * - `PAYMENT_SETTLE_CONFLICT` (409): the payment moved while it was being captured. Read it
+     *   again.
+     * - `ENTITY_NOT_FOUND` (404): no payment of an order of this store has that id.
+     *
+     * On such an order, a promise whose money moves by hand (bank transfer, invoice, net terms) is
+     * recorded at what the order still bills: the returned payment's `amount` is that figure, and
+     * the rest of the promise is dropped. {@link settlePreview} says which before you call this.
+     *
+     * Needs `UpdateOrder`.
+     *
+     * @effect money
+     */
+    settle(paymentId: string, options?: Call): Promise<OrderPaymentRecord>;
+    /**
+     * What {@link settle} would do to this authorized payment now, without doing it: the amount it
+     * records, or the coded refusal it would answer (`refusal`). Nothing is written, nothing is
+     * locked and no provider is asked, so {@link settle} still judges again (and the provider may
+     * still decline it).
+     *
+     * Refuses `ENTITY_NOT_FOUND` (404) for a payment of no order of this store. An engine older
+     * than this method answers a GraphQL validation error: treat that as "no preview" and let
+     * {@link settle} judge. Needs `ReadOrder`.
+     *
+     * @effect read
+     */
+    settlePreview(paymentId: string, options?: Call): Promise<PaymentSettlePreview>;
+    /**
+     * Void an authorized payment (release the hold), and return the payment.
+     *
+     * A cancel takes turns with the payment's capture: one that reaches a payment that is no
+     * longer authorized, or one whose capture may have reached its provider with no answer, is
+     * refused `PAYMENT_CANCEL_CONFLICT` (409) and nothing is asked of the provider. A `Settled`
+     * payment is never voided: its money was taken, so it is refunded ({@link refund}).
+     *
+     * Other refusals, as coded errors:
+     * - `PAYMENT_CANCEL_DECLINED` (`BusinessRuleError`, 422): the provider refused the void. The
+     *   message is the provider's reason; the hold may still stand at the provider.
+     * - `PAYMENT_STATE_TRANSITION_ERROR` (422): the payment cannot move to `Cancelled` from where
+     *   it is.
+     * - `ENTITY_NOT_FOUND` (404): no payment of an order of this store has that id.
+     *
+     * Needs `UpdateOrder`.
+     *
+     * @effect money
+     */
+    cancel(paymentId: string, options?: Call): Promise<OrderPaymentRecord>;
+    /**
+     * Whether {@link refund} (and core's `refundOrder`, and the till's refund) is
+     * refused for this order with `REFUND_REQUIRES_CREDIT_NOTE`, and which invoice
+     * the refund goes through instead; `null` when a plain refund may go ahead.
+     *
+     * The order has a live invoice in this store, so a refund needs a credit note
+     * saying what it is for, beyond `refundableOverpayment` (what the order was
+     * paid over what it bills, which {@link refund} still gives back). Plan the
+     * correction with
+     * `documents.planCorrection({ ledger, invoiceId, outcome, refundPaymentId })` and
+     * issue it with `documents.commitCorrection`: the credit note is issued, then
+     * the money refunded. `null` for an order with no live invoice, and for a
+     * customer with a credit account on a store that keeps the
+     * accounts-receivable ledger (their refunds are documented when they settle:
+     * by an AR credit note, except the part no invoice billed, which gets none).
+     * Needs `ReadOrder`.
+     *
+     * Its own query rather than a field of {@link refundPosition}, so a release of
+     * this SDK reading an older engine fails only this call. The answer is read
+     * without a lock: the refund doors judge again when they run.
+     *
+     * @effect read
+     */
+    refundCreditNoteRequirement(orderId: string, options?: Call): Promise<RefundCreditNoteRequirement | null>;
     /** Read what an order may still hand back. */
     refundPosition(orderId: string, options?: Call): Promise<OrderRefundPosition>;
+    /**
+     * What the gift cards sold on an order hold of its money, on the order and per payment, and
+     * how many of them are still live: why {@link refundPosition}'s `refundable` is lower than the
+     * money taken. Needs `ReadOrder`.
+     *
+     * Its own query rather than fields of {@link refundPosition}, so a release of this SDK reading
+     * an older engine fails only this call. Needs an engine that serves
+     * `OrderRefundPosition.giftCardHold`.
+     *
+     * @effect read
+     */
+    refundGiftCardHold(orderId: string, options?: Call): Promise<RefundGiftCardHold>;
     /**
      * The order's refunds whose outcome is unknown, oldest first — the ones
      * {@link reconcileRefund} resolves. Each one's amount is already reserved in
@@ -418,6 +727,8 @@ export interface PaymentsModule {
      *
      * `options.idempotencyKey` is honoured: a repeat under the same key returns
      * the first call's refund.
+     *
+     * @effect money
      */
     reconcileRefund(input: ReconcileRefundInput, options?: Call): Promise<IssuedRefund>;
     /**
@@ -463,14 +774,24 @@ export interface PaymentsModule {
     appPayments(orderId: string, options?: Call): Promise<AppPayment[]>;
 }
 export declare const RECORD_ORDER_PAYMENT_MUTATION = "\n  mutation RecordOrderPayment($orderId: ID!, $input: RecordPaymentInput!, $idempotencyKey: String) {\n    recordOrderPayment(orderId: $orderId, input: $input, idempotencyKey: $idempotencyKey) {\n      \n  id\n  code\n  state\n  currencyCode\n  total\n  totalWithTax\n\n    }\n  }\n";
-export declare const ORDER_PAYMENT_POSITION_QUERY = "\n  query OrderPaymentPosition($orderId: ID!) {\n    orderPaymentPosition(orderId: $orderId) {\n      \n  total\n  covered\n  settled\n  authorized\n  refunded\n  outstanding\n  overpaid\n  availableToCharge\n\n    }\n  }\n";
+export declare const ORDER_PAYMENT_POSITION_QUERY = "\n  query OrderPaymentPosition($orderId: ID!) {\n    orderPaymentPosition(orderId: $orderId) {\n      \n  total\n  covered\n  settled\n  authorized\n  refunded\n  creditNoted\n  owed\n  payable\n  outstanding\n  overpaid\n  availableToCharge\n\n    }\n  }\n";
 export declare const ORDER_REFUND_POSITION_QUERY = "\n  query OrderRefundPosition($orderId: ID!) {\n    orderRefundPosition(orderId: $orderId) {\n      \n  currencyCode\n  refunded\n  refundable\n  perPayment {\n    paymentId\n    state\n    method\n    amount\n    refunded\n    refundable\n    tookMoney\n  }\n\n    }\n  }\n";
 export declare const REFUND_ORDER_PAYMENT_MUTATION = "\n  mutation RefundOrderPayment($input: RefundPaymentInput!, $idempotencyKey: String) {\n    refundOrderPayment(input: $input, idempotencyKey: $idempotencyKey) {\n      id\n      total\n      state\n      method\n      transactionId\n      reason\n    }\n  }\n";
 export declare const UNRECONCILED_REFUNDS_QUERY = "\n  query UnreconciledRefunds($orderId: ID!) {\n    orderRefundPosition(orderId: $orderId) {\n      unreconciled {\n        refundId\n        paymentId\n        amount\n        createdAt\n      }\n    }\n  }\n";
+export declare const REFUND_GIFT_CARD_HOLD_QUERY = "\n  query RefundGiftCardHold($orderId: ID!) {\n    orderRefundPosition(orderId: $orderId) {\n      currencyCode\n      giftCardHold\n      liveGiftCards\n      perPayment {\n        paymentId\n        giftCardHold\n      }\n    }\n  }\n";
+export declare const REFUND_CREDIT_NOTE_REQUIREMENT_QUERY = "\n  query RefundCreditNoteRequirement($orderId: ID!) {\n    orderRefundPosition(orderId: $orderId) {\n      creditNoteRequired {\n        invoiceId\n        invoiceNumber\n        ledger\n        refundableOverpayment\n      }\n    }\n  }\n";
 export declare const RECONCILE_REFUND_OUTCOME_MUTATION = "\n  mutation ReconcileRefundOutcome($input: ReconcileRefundOutcomeInput!, $idempotencyKey: String) {\n    reconcileRefundOutcome(input: $input, idempotencyKey: $idempotencyKey) {\n      id\n      total\n      state\n      method\n      transactionId\n      reason\n    }\n  }\n";
+export declare const SETTLE_PAYMENT_MUTATION = "\n  mutation SettlePayment($id: ID!) {\n    settlePayment(id: $id) {\n      __typename\n      ... on Payment {\n        \n  id\n  state\n  method\n  amount\n  transactionId\n\n      }\n      ... on SettlePaymentError {\n        paymentErrorMessage\n      }\n      ... on PaymentStateTransitionError {\n        transitionError\n      }\n      ... on OrderStateTransitionError {\n        transitionError\n      }\n      ... on ErrorResult {\n        errorCode\n        message\n      }\n    }\n  }\n";
+export declare const CANCEL_PAYMENT_MUTATION = "\n  mutation CancelPayment($id: ID!) {\n    cancelPayment(id: $id) {\n      __typename\n      ... on Payment {\n        \n  id\n  state\n  method\n  amount\n  transactionId\n\n      }\n      ... on CancelPaymentError {\n        paymentErrorMessage\n      }\n      ... on PaymentStateTransitionError {\n        transitionError\n      }\n      ... on ErrorResult {\n        errorCode\n        message\n      }\n    }\n  }\n";
+export declare const SETTLE_PAYMENT_PREVIEW_QUERY = "\n  query SettlePaymentPreview($paymentId: ID!) {\n    settlePaymentPreview(paymentId: $paymentId) {\n      paymentId\n      authorized\n      records\n      creditNoted\n      creditNotes\n      refusal {\n        code\n        message\n      }\n    }\n  }\n";
 export declare const REPORT_APP_PAYMENT_MUTATION = "\n  mutation ReportAppPayment(\n    $paymentId: ID!\n    $input: ReportAppPaymentInput!\n    $idempotencyKey: String!\n  ) {\n    reportAppPayment(paymentId: $paymentId, input: $input, idempotencyKey: $idempotencyKey) {\n      id\n      state\n      amount\n      method\n      transactionId\n    }\n  }\n";
 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';
+export type { AccountCreditModule, ApplyUnappliedCashInput, CreditOverpaymentInput, CreditOverpaymentToStoreCreditCall, OrderMoneyOnAccount, RefundUnappliedCashInput, StoreCreditMove, UnappliedCash, UnappliedCashRefund, } from './account-credit.js';
+export type { ConnectedAccountModule, StripeConnectedAccount, } from './connected-account.js';
+export type { CreatePaymentMethodInput, PaymentMethod, PaymentMethodCredential, PaymentMethodCredentialPath, PaymentMethodsModule, PaymentMethodTranslation, PaymentMethodTranslationInput, UpdatePaymentMethodInput, } from './methods.js';
+export type { MollieDiagnosis, MollieDiagnosisMethod, MollieDiagnosisVerdict, MollieDirectDebitDiagnosis, MollieMethod, MollieMethodList, MollieMethodsModule, MollieProbeError, MollieProbeErrorKind, SetMollieMethodsInput, } from './mollie-methods.js';
+export type { PaymentProviderKey, ProviderKeyProvider, ProviderKeysModule, ProviderKeyTest, SetProviderKeyInput, } from './provider-keys.js';
+export type { PaymentProviderAccount, ProviderConnection, ProviderCredentialPath, ProviderOnboardingStart, ProviderReadiness, ProvidersModule, ProviderTerminal, ProviderTerminalsModule, ProvisionTerminalInput, ReadinessOptions, } from './providers.js';
+export type { CreatePaymentRequestInput, PaymentRequest, PaymentRequestCloseReason, PaymentRequestStatus, PaymentRequestsModule, } from './requests.js';
+export { PAYMENT_REQUEST_CLOSE_REASONS, PAYMENT_REQUEST_DEFAULT_EXPIRY_DAYS, PAYMENT_REQUEST_MAX_EXPIRY_DAYS, PAYMENT_REQUEST_STATUSES, } from './requests.js';