@final-commerce/command-frame 0.4.0-preprod.1 → 0.4.1-preprod.2

package/README.md

@@ -10,13 +10,13 @@ Command Frame provides a structured way to build integrations that run inside Fi
 
 The library provides three main capabilities:
 
-| Capability                | Purpose                                                                                         | Scope                                          |
-| ------------------------- | ----------------------------------------------------------------------------------------------- | ---------------------------------------------- |
-| **Commands**              | Call host functions from the iframe (e.g. get products, open cash drawer)                       | Request/response per call                      |
-| **Pub/Sub**               | Subscribe to real-time events from the host (e.g. cart changes, payments)                       | Page-scoped (while iframe is mounted)          |
-| **Hooks**                 | Register business-logic callbacks that persist across all pages                                 | Session-scoped (survives page navigation)      |
-| **Interceptors**          | Gate POS flows (approve / modify / block) at named points                                       | Blocking; host waits for your response         |
-| **Host → iframe refunds** | Render asks the extension to reverse redeem / gift-card payments before completing a POS refund | Parent `postMessage` + `requestId` (see below) |
+| Capability          | Purpose                                                                   | Scope                                     |
+| ------------------- | ------------------------------------------------------------------------- | ----------------------------------------- |
+| **Commands**        | Call host functions from the iframe (e.g. get products, open cash drawer) | Request/response per call                 |
+| **Pub/Sub**         | Subscribe to real-time events from the host (e.g. cart changes, payments) | Page-scoped (while iframe is mounted)     |
+| **Hooks**           | Register business-logic callbacks that persist across all pages           | Session-scoped (survives page navigation) |
+| **Interceptors**    | Gate POS flows (approve / modify / block) at named points                 | Blocking; host waits for your response    |
+| **Refund commands** | Refund payments to gift cards or redeem tenders via `redeemRefund`, or mixed-destination legs on `processPartialRefund`; query engine capacity with `getRefundPlan` | Request/response per call                 |
 
 Domain models (orders, cart, customers, products, and related types) are documented in **[Types reference](./src/types/README.md)**.
 
@@ -158,40 +158,29 @@ interceptors.register(
 );
 ```
 
-## Host-initiated extension refunds (redeem / gift card)
+## Refunding redeem / extension payments
 
-**Extensions that accept redeem / extension payments must implement a refund listener.** When staff refund an order paid with `paymentType: "redeem"`, Render (host) `postMessage`s into your iframe **before** it records the refund locally. If your app does not handle this message, redeem refunds will time out or fail.
+When staff refund an order that was paid with `paymentType: "redeem"` (via `redeemPayment` or `extensionPayment`), use the **`redeemRefund`** command to refund the amount onto a gift card or redeem tender.
 
-### What you should do
-
-1. **Recommended:** call **`installExtensionRefundListener`** once when your extension boots (e.g. next to your `RenderClient` setup). Pass an `async` handler that calls your provider (gift card API, wallet, etc.) and returns an **`ExtensionRefundResponse`** (`success`, optional `error`, optional `extensionTransactionId` for receipts / support).
-2. The helper validates `event.source === window.top`, parses params, and replies with the same **`PostMessageResponse`** envelope as the rest of Command Frame (`requestId`, `success`, `data` / `error`).
-3. **Alternative:** implement a `window` `message` listener yourself using the same contract (action name: **`extensionRefundRequest`**, or import **`EXTENSION_REFUND_REQUEST_ACTION`** from this package).
-
-Exported APIs: `installExtensionRefundListener`, `EXTENSION_REFUND_REQUEST_ACTION`, types **`ExtensionRefundParams`** / **`ExtensionRefundResponse`**.
+**Key point:** Plain refunds on redeem sources still fail by design (`REDEEM_REFUND_UNSUPPORTED`). Use `redeemRefund` to refund onto a gift card when your extension credits the card first.
 
 ```typescript
-import {
-  installExtensionRefundListener,
-  type ExtensionRefundParams,
-  type ExtensionRefundResponse,
-} from '@final-commerce/command-frame';
-
-const unsubscribe = installExtensionRefundListener(
-  async (params: ExtensionRefundParams): Promise<ExtensionRefundResponse> => {
-    // params.paymentType === "redeem", params.amount in major currency units, params.saleId, params.processor, etc.
-    const ok = await myGiftCardProvider.refund(params);
-    return ok
-      ? { success: true, extensionTransactionId: ok.providerRefundId }
-      : { success: false, error: 'Refund declined' };
-  },
-);
-
-// on teardown (optional)
-// unsubscribe();
+import { command } from '@final-commerce/command-frame';
+
+// Refund a redeem order back onto a gift card
+const result = await command.redeemRefund({
+  orderId: 'order_123',
+  amount: 2500, // $25.00
+  referenceId: 'GIFTCARD-456', // destination card
+  processor: 'giftCard',
+  label: 'Gift Card Refund',
+  reason: 'Customer requested return',
+});
 ```
 
-**Full protocol, edge cases, and manual handling:** **[Extension refund documentation](./src/actions/extension-refund/README.md)**.
+**Full documentation:** **[redeemRefund](./src/actions/redeem-refund/README.md)**.
+
+Before prompting the cashier for an amount, query **[getRefundPlan](./src/actions/get-refund-plan/README.md)** (read-only) for the order's own per-source caps (`maxRefundable`, `cardNumber` for same-card prefill) and order-level `remainingRefundable` — don't recompute this client-side, and always handle a `REFUND_AMOUNT_EXCEEDS_CAPACITY` rejection from the mutating call since the plan is only an advisory snapshot.
 
 ## Development & Testing
 

package/dist/actions/get-refund-plan/action.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Get refund plan action
+ * Calls the getRefundPlan action on the parent window
+ */
+import type { GetRefundPlan } from './types';
+export declare const getRefundPlan: GetRefundPlan;

package/dist/actions/get-refund-plan/action.js

@@ -0,0 +1,8 @@
+/**
+ * Get refund plan action
+ * Calls the getRefundPlan action on the parent window
+ */
+import { commandFrameClient } from '../../client';
+export const getRefundPlan = async (params) => {
+    return await commandFrameClient.call('getRefundPlan', params);
+};

package/dist/actions/get-refund-plan/mock.d.ts

@@ -0,0 +1,14 @@
+import { GetRefundPlan } from './types';
+/**
+ * Demo derivation of the runtime `getRefundPlan`. Builds the per-source rows
+ * from the mock order's `paymentMethods`, mirroring the runtime's capacity
+ * definition (principal + captured tip).
+ *
+ * HONEST INERTNESS: the demo DB records no prior-refund ledger and no `emv`
+ * blocks on its mock captures, so this mock reports `refundedAmount: 0` /
+ * `totalRefunded: 0` and `cardNumber: undefined` for every source, and treats
+ * `maxRefundable` as the full captured amount. Against real kaching those
+ * numbers come from `order.refund[]` and the capture's `emv` JSON. Use this
+ * only to shape UI in local/standalone mode — never to assert real capacity.
+ */
+export declare const mockGetRefundPlan: GetRefundPlan;

package/dist/actions/get-refund-plan/mock.js

@@ -0,0 +1,59 @@
+import { MOCK_ORDERS } from '../../demo/database';
+/**
+ * Demo derivation of the runtime `getRefundPlan`. Builds the per-source rows
+ * from the mock order's `paymentMethods`, mirroring the runtime's capacity
+ * definition (principal + captured tip).
+ *
+ * HONEST INERTNESS: the demo DB records no prior-refund ledger and no `emv`
+ * blocks on its mock captures, so this mock reports `refundedAmount: 0` /
+ * `totalRefunded: 0` and `cardNumber: undefined` for every source, and treats
+ * `maxRefundable` as the full captured amount. Against real kaching those
+ * numbers come from `order.refund[]` and the capture's `emv` JSON. Use this
+ * only to shape UI in local/standalone mode — never to assert real capacity.
+ */
+export const mockGetRefundPlan = async (params) => {
+    console.log('[Mock] getRefundPlan called', params);
+    const order = params?.orderId ? MOCK_ORDERS.find((o) => o._id === params.orderId) : MOCK_ORDERS[0];
+    if (!order) {
+        throw new Error(`Order with ID ${params?.orderId} not found`);
+    }
+    const capturedOf = (pm) => Math.round(pm.amount ?? 0) + Math.round(pm.tip?.amount ?? 0);
+    const sources = (order.paymentMethods ?? []).map((pm) => {
+        const captured = capturedOf(pm);
+        let cardNumber;
+        // Demo captures carry no emv, so this is always undefined here; kept to
+        // document the runtime's redeem-source card-number extraction.
+        if (pm.paymentType === 'redeem' && pm.emv) {
+            try {
+                cardNumber = JSON.parse(pm.emv)['Card Number'];
+            }
+            catch {
+                cardNumber = undefined;
+            }
+        }
+        return {
+            transactionId: pm.transactionId,
+            paymentType: pm.paymentType,
+            processor: pm.processor ?? undefined,
+            capturedAmount: captured,
+            // Demo DB has no refund ledger — nothing has been refunded yet here.
+            refundedAmount: 0,
+            maxRefundable: captured,
+            refundableToSource: pm.paymentType !== 'redeem',
+            cardNumber,
+        };
+    });
+    const totalCaptured = sources.reduce((sum, s) => sum + s.capturedAmount, 0);
+    const nonRefundableLiability = order.summary?.nonRevenueTotal ?? 0;
+    return {
+        success: true,
+        orderId: order._id,
+        sources,
+        // Demo: no prior refunds, so remaining = captured minus the non-revenue load.
+        remainingRefundable: Math.max(0, totalCaptured - nonRefundableLiability),
+        nonRefundableLiability,
+        totalCaptured,
+        totalRefunded: 0,
+        timestamp: new Date().toISOString(),
+    };
+};

package/dist/actions/get-refund-plan/types.d.ts

@@ -0,0 +1,32 @@
+export interface GetRefundPlanParams {
+    /** Order to inspect; defaults to the active order. */
+    orderId?: string;
+}
+export interface RefundPlanSource {
+    transactionId: string;
+    paymentType: string;
+    processor?: string;
+    /** Captured on this payment (minor units). */
+    capturedAmount: number;
+    /** Already refunded against this source (minor units). */
+    refundedAmount: number;
+    /** Remaining refundable on this source (minor units) — the engine's own per-source cap. */
+    maxRefundable: number;
+    /** False for sources the engine cannot refund to directly (redeem without a gift-card destination). */
+    refundableToSource: boolean;
+    /** For redeem sources: the card number from the payment entry's emv, when present. */
+    cardNumber?: string;
+}
+export interface GetRefundPlanResponse {
+    success: boolean;
+    orderId: string;
+    sources: RefundPlanSource[];
+    /** Order-level remaining refundable (minor units) — non-revenue liability already excluded. */
+    remainingRefundable: number;
+    /** Non-refundable liability (gift-card loads etc., minor units). */
+    nonRefundableLiability: number;
+    totalCaptured: number;
+    totalRefunded: number;
+    timestamp: string;
+}
+export type GetRefundPlan = (params?: GetRefundPlanParams) => Promise<GetRefundPlanResponse>;

package/dist/actions/get-refund-plan/types.js

@@ -0,0 +1,7 @@
+// Get Refund Plan Types
+//
+// READ-ONLY capacity query. Exposes the refund engine's OWN per-source and
+// order-level math so flows can PRESENT accurate refund options without
+// re-deriving the numbers client-side (the mutating commands —
+// `processPartialRefund` / `redeemRefund` — re-validate at submit time).
+export {};

package/dist/actions/process-partial-refund/mock.js

@@ -1,5 +1,13 @@
 export const mockProcessPartialRefund = async (params) => {
-    console.log("[Mock] processPartialRefund called", params);
+    // The mock has no split-payment modal or order engine, so `openUI` (default
+    // true on the real command), `legs` (the headless per-tender allocation) and
+    // any per-leg `giftCard` destination (mixed returns) are inert here — the
+    // shape is accepted and echoed, nothing else. No gift card is credited.
+    console.log("[Mock] processPartialRefund called", {
+        ...params,
+        openUI: params?.openUI ?? true,
+        legs: params?.legs ?? null,
+    });
     return {
         success: true,
         refundId: 'mock_refund_' + Date.now(),

package/dist/actions/process-partial-refund/types.d.ts

@@ -1,15 +1,113 @@
 import type { CFTransitionResult } from "../../common-types/order-state";
 export interface ProcessPartialRefundParams {
-    /** Optional refund reason. */
+    /**
+     * Optional refund reason.
+     *
+     * KNOWN LIMITATION: not currently persisted on the `Refund` doc or the
+     * state-event audit row via this command — the runtime falls back to a
+     * fixed 'partial-refund' label instead. Unlike `redeemRefund`, whose
+     * `reason` IS recorded. See the README's "Known limitation" section.
+     */
     reason?: string;
     /** Optional: specify which order to refund (sets it as active). */
     orderId?: string;
+    /**
+     * Controls the refund UI for a MULTI-TENDER order (one paid across more
+     * than one payment method). Defaults to `true`.
+     *
+     * - `true` (default, back-compat): the POS raises its split-payment refund
+     *   modal so the cashier allocates the refund across the original payment
+     *   sources; `processPartialRefund` returns without committing and the
+     *   modal drives the commit.
+     * - `false`: no modal is raised — the refund is committed headlessly
+     *   against the planner's default proportional allocation across those
+     *   sources (all cash-rounding invariants preserved). Use this when your
+     *   flow renders its own refund UI and needs a fully headless multi-tender
+     *   partial refund.
+     *
+     * Has no effect on single-tender orders (already headless — there is
+     * nothing to allocate).
+     */
+    openUI?: boolean;
+    /**
+     * Explicit per-tender allocation for the refund — the headless replacement
+     * for choosing, in the split-payment refund modal, WHICH original payment
+     * each refunded dollar returns to. Each entry names an original payment by
+     * its `transactionId` and the amount, **in minor units** (cents), to return
+     * to that source.
+     *
+     * Requires `openUI: false` — with the modal path (`openUI` omitted/`true`)
+     * the modal owns allocation and `legs` are ignored. Validation:
+     * - Σ of all `amount`s **must equal the allocatable refund budget** —
+     *   `min(the refund total computed from the selected items, Σ of each
+     *   source's remaining refundable capacity)`; on a full selection this is
+     *   the captured total and the cash-rounding gap is auto-stamped (a
+     *   mismatch throws; nothing is committed);
+     * - the amounts **aggregated per source** must be ≤ that source's remaining
+     *   refundable capacity (over-cap throws, naming the source);
+     * - a **zero** `amount` entry is IGNORED — dropped like an omitted row,
+     *   matching the modal (which let a cashier leave a tender at 0 and filtered
+     *   it at commit) — while a **negative** `amount` is rejected;
+     * - an unknown `transactionId` throws, naming it.
+     *
+     * MIXED RETURNS — set `giftCard` on a leg to land that leg's amount on a
+     * gift-card / store-credit tender instead of returning it to the source. A
+     * single `legs` array may freely mix source-return legs and `giftCard` legs
+     * (some money back to the original tenders, the rest onto a card). An
+     * all-`giftCard` staging is the `redeemRefund` equivalent through this path.
+     * **Credit-first:** the flow must credit the card for the sum of all
+     * `giftCard` legs BEFORE calling; on any throw nothing was recorded — reverse
+     * the credit.
+     *
+     * Omit `legs` to keep the default proportional allocation across sources.
+     * See "Choosing which payments to refund to" and "Mixed returns" in the README.
+     */
+    legs?: {
+        /** `transactionId` of the original payment this leg draws from. */
+        transactionId: string;
+        /** Amount for this leg, in minor units (cents). `0` is ignored (dropped
+         *  like an omitted row); a negative value is rejected. */
+        amount: number;
+        /**
+         * When set, this leg's amount lands on the gift-card / store-credit
+         * ("redeem") tender instead of returning to the source. The leg still
+         * draws from `transactionId` for capacity/audit — only the landing
+         * tender changes.
+         *
+         * CREDIT-FIRST: the flow must have already credited the card for the sum
+         * of all `giftCard` legs before calling; on any throw nothing was
+         * recorded and the caller must reverse that credit. `referenceId` is
+         * required when `giftCard` is present.
+         */
+        giftCard?: {
+            /** Card/account id the flow already credited (stored raw). */
+            referenceId: string;
+            /** Provider/program name. Defaults to `giftCard`. */
+            processor?: string;
+            /** Human label for the destination tender. */
+            label?: string;
+        };
+    }[];
     /** Optional items to refund. */
     items?: {
         /** internalId or variantId or customSaleId. */
         itemKey: string;
         quantity: number;
         type?: 'product' | 'customSale' | 'fee' | 'tip';
+        /**
+         * Per-item stock disposition for a refunded **product** line — the
+         * headless equivalent of the old refund popup's per-row restock/damaged
+         * dropdown. Recorded on the persisted refund line so hub-side inventory
+         * ingest knows whether the returned units go back on the shelf.
+         *
+         * - `'RESTOCK'` (default when omitted): units return to sellable stock
+         *   — the popup's default first option.
+         * - `'REFUND_DAMAGE'`: units are written off as damaged, not restocked.
+         *
+         * Ignored for non-`product` items (custom sales / fees / tips carry no
+         * stock action, exactly as the popup only offered it on line items).
+         */
+        stockAction?: 'RESTOCK' | 'REFUND_DAMAGE';
     }[];
 }
 export interface ProcessPartialRefundResponse {

package/dist/actions/redeem-refund/action.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Redeem refund action
+ * Calls the redeemRefund action on the parent window
+ */
+import type { RedeemRefund } from './types';
+export declare const redeemRefund: RedeemRefund;

package/dist/actions/redeem-refund/action.js

@@ -0,0 +1,8 @@
+/**
+ * Redeem refund action
+ * Calls the redeemRefund action on the parent window
+ */
+import { commandFrameClient } from '../../client';
+export const redeemRefund = async (params) => {
+    return await commandFrameClient.call('redeemRefund', params);
+};

package/dist/actions/redeem-refund/mock.d.ts

@@ -0,0 +1,2 @@
+import { RedeemRefund } from './types';
+export declare const mockRedeemRefund: RedeemRefund;

package/dist/actions/redeem-refund/mock.js

@@ -0,0 +1,55 @@
+import { MOCK_ORDERS, mockPublishEvent } from '../../demo/database';
+// Track refunded amounts per order to enforce remaining capacity gate
+const mockRefundedAmounts = {};
+export const mockRedeemRefund = async (params) => {
+    console.log('[Mock] redeemRefund called', params);
+    // Validate required params
+    if (!params.amount || params.amount <= 0) {
+        throw new Error('Amount must be greater than 0');
+    }
+    if (!params.referenceId) {
+        throw new Error('referenceId is required');
+    }
+    // Find order
+    const order = params.orderId ? MOCK_ORDERS.find((o) => o._id === params.orderId) : MOCK_ORDERS[0];
+    if (!order) {
+        throw new Error(`Order with ID ${params.orderId} not found`);
+    }
+    const orderId = order._id;
+    // NO payment-state gate — the runtime has none (partially_paid orders are
+    // refundable too); mirroring it here would teach devs a phantom error class.
+    // Track refunded amounts and check remaining capacity
+    const refundedSoFar = mockRefundedAmounts[orderId] || 0;
+    const remainingCapacity = order.summary.total - refundedSoFar;
+    if (params.amount > remainingCapacity) {
+        throw new Error(`REFUND_AMOUNT_EXCEEDS_CAPACITY: Refund amount ${params.amount} exceeds remaining refundable capacity ${remainingCapacity}`);
+    }
+    // Update refunded amount tracking
+    const refundedAfter = refundedSoFar + params.amount;
+    mockRefundedAmounts[orderId] = refundedAfter;
+    // Update order state based on remaining capacity after this refund
+    const remainingAfterRefund = order.summary.total - refundedAfter;
+    if (remainingAfterRefund > 0) {
+        order.paymentState = 'partially_refunded';
+    }
+    else {
+        order.paymentState = 'refunded';
+    }
+    // Publish refund event
+    mockPublishEvent('refunds', 'refund-created', {
+        orderId,
+        amount: params.amount,
+        referenceId: params.referenceId,
+        processor: params.processor || 'giftCard',
+        label: params.label,
+        reason: params.reason,
+    });
+    return {
+        success: true,
+        orderId,
+        amount: params.amount,
+        referenceId: params.referenceId,
+        legCount: 1,
+        timestamp: new Date().toISOString(),
+    };
+};

package/dist/actions/redeem-refund/types.d.ts

@@ -0,0 +1,39 @@
+export interface RedeemRefundParams {
+    /** Order to refund; defaults to the active order. */
+    orderId?: string;
+    /**
+     * Amount to refund onto the redeem tender, integer MINOR currency units
+     * (1575 = $15.75). Required; must be > 0 and within the order's remaining
+     * refundable capacity (tip-inclusive, across all source payments).
+     */
+    amount: number;
+    /**
+     * Destination card/account identifier the funds were credited to
+     * (e.g. the gift-card number). Recorded in the emv block (`'Card Number'`)
+     * of every refund payment entry on the order, and in paymentData on the
+     * local transaction rows, for the audit trail. Required.
+     */
+    referenceId: string;
+    /** Destination provider label; defaults to "giftCard" (matches redeemPayment). */
+    processor?: string;
+    /** Human-readable label for receipts/reporting. */
+    label?: string;
+    /** Extension identity, recorded on the legs when provided. */
+    extensionId?: string;
+    /** Opaque extension payload, recorded on the legs when provided. */
+    metadata?: Record<string, unknown>;
+    /** Cashier-facing reason, recorded on the refund + state-event audit rows. */
+    reason?: string;
+}
+export interface RedeemRefundResponse {
+    success: boolean;
+    orderId: string;
+    /** Total refunded onto the redeem tender (minor units). */
+    amount: number;
+    /** Echo of the destination identifier the legs were recorded against. */
+    referenceId: string;
+    /** Number of source payments the amount was drawn from. */
+    legCount: number;
+    timestamp: string;
+}
+export type RedeemRefund = (params: RedeemRefundParams) => Promise<RedeemRefundResponse>;

package/dist/actions/redeem-refund/types.js

@@ -0,0 +1,2 @@
+// Redeem Refund Types
+export {};

package/dist/index.d.ts

@@ -80,6 +80,8 @@ export declare const command: {
     readonly calculateRefundTotal: import(".").CalculateRefundTotal;
     readonly getRemainingRefundableQuantities: import(".").GetRemainingRefundableQuantities;
     readonly processPartialRefund: import(".").ProcessPartialRefund;
+    readonly redeemRefund: import(".").RedeemRefund;
+    readonly getRefundPlan: import(".").GetRefundPlan;
     readonly addProduct: import(".").AddProduct;
     readonly editProduct: import(".").EditProduct;
     readonly editProductVariants: import(".").EditProductVariants;
@@ -138,6 +140,8 @@ export type { ResetRefundDetails, ResetRefundDetailsResponse } from './actions/r
 export type { CalculateRefundTotal, CalculateRefundTotalParams, CalculateRefundTotalResponse, } from './actions/calculate-refund-total/types';
 export type { GetRemainingRefundableQuantities, GetRemainingRefundableQuantitiesParams, GetRemainingRefundableQuantitiesResponse, } from './actions/get-remaining-refundable-quantities/types';
 export type { ProcessPartialRefund, ProcessPartialRefundParams, ProcessPartialRefundResponse, } from './actions/process-partial-refund/types';
+export type { RedeemRefund, RedeemRefundParams, RedeemRefundResponse } from './actions/redeem-refund/types';
+export type { GetRefundPlan, GetRefundPlanParams, GetRefundPlanResponse, RefundPlanSource, } from './actions/get-refund-plan/types';
 export type { InitiateRefund, InitiateRefundParams, InitiateRefundResponse } from './actions/initiate-refund/types';
 export type { OpenExtensionOverlay, OpenExtensionOverlayParams, OpenExtensionOverlayResponse, } from './actions/open-extension-overlay/types';
 export type { ResolveExtensionOverlay, ResolveExtensionOverlayParams, ResolveExtensionOverlayResponse, } from './actions/resolve-extension-overlay/types';

package/dist/index.js

@@ -87,6 +87,8 @@ import { resetRefundDetails } from './actions/reset-refund-details/action';
 import { calculateRefundTotal } from './actions/calculate-refund-total/action';
 import { getRemainingRefundableQuantities } from './actions/get-remaining-refundable-quantities/action';
 import { processPartialRefund } from './actions/process-partial-refund/action';
+import { redeemRefund } from './actions/redeem-refund/action';
+import { getRefundPlan } from './actions/get-refund-plan/action';
 // Custom Tables Actions
 import { getCustomTables } from './actions/get-custom-tables/action';
 import { getCustomTableFields } from './actions/get-custom-table-fields/action';
@@ -217,6 +219,8 @@ export const command = {
     calculateRefundTotal,
     getRemainingRefundableQuantities,
     processPartialRefund,
+    redeemRefund,
+    getRefundPlan,
     // Product CRUD Actions
     addProduct,
     editProduct,

package/dist/projects/render/mocks.js

@@ -50,6 +50,8 @@ import { mockOpenCashDrawer } from '../../actions/open-cash-drawer/mock';
 import { mockParkOrder } from '../../actions/park-order/mock';
 import { mockPartialPayment } from '../../actions/partial-payment/mock';
 import { mockProcessPartialRefund } from '../../actions/process-partial-refund/mock';
+import { mockRedeemRefund } from '../../actions/redeem-refund/mock';
+import { mockGetRefundPlan } from '../../actions/get-refund-plan/mock';
 import { mockRemoveCustomerFromCart } from '../../actions/remove-customer-from-cart/mock';
 import { mockResetRefundDetails } from '../../actions/reset-refund-details/mock';
 import { mockResumeParkedOrder } from '../../actions/resume-parked-order/mock';
@@ -144,6 +146,8 @@ export const RENDER_MOCKS = {
     parkOrder: mockParkOrder,
     partialPayment: mockPartialPayment,
     processPartialRefund: mockProcessPartialRefund,
+    redeemRefund: mockRedeemRefund,
+    getRefundPlan: mockGetRefundPlan,
     removeCustomerFromCart: mockRemoveCustomerFromCart,
     removeCartDiscount: mockRemoveCartDiscount,
     resetRefundDetails: mockResetRefundDetails,

package/dist/projects/render/types.d.ts

@@ -1,4 +1,4 @@
-import type { ExampleFunction, GetProducts, AddCustomSale, EditCustomSale, GetCustomers, AssignCustomer, AddCustomer, EditCustomer, GetCategories, GetOrders, GetRefunds, GetTaxTables, AddProductDiscount, AddProductToCart, RemoveProductFromCart, UpdateCartItemQuantity, AddCartDiscount, GetContext, GetFinalContext, AddProductNote, AddProductFee, SetActiveProductFee, SetActiveProductDiscount, GetActiveProduct, SetActiveProduct, AdjustInventory, AddOrderNote, AddCartFee, ClearCart, ParkOrder, ResumeParkedOrder, DeleteParkedOrder, VoidOrder, InitiateRefund, CashPayment, GetCashRoundingAmount, TapToPayPayment, TerminalPayment, VendaraPayment, ExtensionPayment, RedeemPayment, AddNonRevenueItem, AddCustomerNote, RemoveCustomerNote, RemoveCustomerFromCart, GoToStationHome, OpenCashDrawer, ShowNotification, ShowConfirmation, AuthenticateUser, PartialPayment, SwitchUser, SetRefundStockAction, SelectAllRefundItems, ResetRefundDetails, CalculateRefundTotal, GetRemainingRefundableQuantities, ProcessPartialRefund, GetCurrentCart, Print, SetActiveOrder, GetCustomTables, GetCustomTableData, UpsertCustomTableData, DeleteCustomTableData, GetCustomExtensions, GetCurrentCompanyCustomExtensions, GetCustomExtensionCustomTables, GetCustomTableFields, GetSecretsKeys, GetSecretVal, SetSecretVal, GetUsers, GetRoles, RemoveCartDiscount, GetActiveOrder, GetActiveCustomer, SetActiveCustomer, GetActiveOutlet, GetActiveStation, GetActiveSession, GetActiveUser, SetActiveUser, SetActiveRefund, RemoveProductDiscount, RemoveProductFee, RemoveProductNote, RemoveCartFee, RemoveOrderNote, RemoveCustomSale, RemoveNonRevenueItem, CanTransition, GetAvailableTransitions, ApplyTransition, IntegrationPayment, GetSmartGridLayout, SaveSmartGridLayout, SendEmail, SendSms } from '../../index';
+import type { ExampleFunction, GetProducts, AddCustomSale, EditCustomSale, GetCustomers, AssignCustomer, AddCustomer, EditCustomer, GetCategories, GetOrders, GetRefunds, GetTaxTables, AddProductDiscount, AddProductToCart, RemoveProductFromCart, UpdateCartItemQuantity, AddCartDiscount, GetContext, GetFinalContext, AddProductNote, AddProductFee, SetActiveProductFee, SetActiveProductDiscount, GetActiveProduct, SetActiveProduct, AdjustInventory, AddOrderNote, AddCartFee, ClearCart, ParkOrder, ResumeParkedOrder, DeleteParkedOrder, VoidOrder, InitiateRefund, CashPayment, GetCashRoundingAmount, TapToPayPayment, TerminalPayment, VendaraPayment, ExtensionPayment, RedeemPayment, AddNonRevenueItem, AddCustomerNote, RemoveCustomerNote, RemoveCustomerFromCart, GoToStationHome, OpenCashDrawer, ShowNotification, ShowConfirmation, AuthenticateUser, PartialPayment, SwitchUser, SetRefundStockAction, SelectAllRefundItems, ResetRefundDetails, CalculateRefundTotal, GetRemainingRefundableQuantities, ProcessPartialRefund, RedeemRefund, GetRefundPlan, GetCurrentCart, Print, SetActiveOrder, GetCustomTables, GetCustomTableData, UpsertCustomTableData, DeleteCustomTableData, GetCustomExtensions, GetCurrentCompanyCustomExtensions, GetCustomExtensionCustomTables, GetCustomTableFields, GetSecretsKeys, GetSecretVal, SetSecretVal, GetUsers, GetRoles, RemoveCartDiscount, GetActiveOrder, GetActiveCustomer, SetActiveCustomer, GetActiveOutlet, GetActiveStation, GetActiveSession, GetActiveUser, SetActiveUser, SetActiveRefund, RemoveProductDiscount, RemoveProductFee, RemoveProductNote, RemoveCartFee, RemoveOrderNote, RemoveCustomSale, RemoveNonRevenueItem, CanTransition, GetAvailableTransitions, ApplyTransition, IntegrationPayment, GetSmartGridLayout, SaveSmartGridLayout, SendEmail, SendSms } from '../../index';
 import type { OpenExtensionOverlay } from '../../actions/open-extension-overlay/types';
 import type { ResolveExtensionOverlay } from '../../actions/resolve-extension-overlay/types';
 export interface RenderProviderActions {
@@ -64,6 +64,8 @@ export interface RenderProviderActions {
     calculateRefundTotal: CalculateRefundTotal;
     getRemainingRefundableQuantities: GetRemainingRefundableQuantities;
     processPartialRefund: ProcessPartialRefund;
+    redeemRefund: RedeemRefund;
+    getRefundPlan: GetRefundPlan;
     getCurrentCart: GetCurrentCart;
     print: Print;
     setActiveOrder: SetActiveOrder;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@final-commerce/command-frame",
-  "version": "0.4.0-preprod.1",
+  "version": "0.4.1-preprod.2",
   "description": "Commands Frame library",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",