@final-commerce/command-frame 0.1.63 → 0.2.0-beta.6

package/README.md

@@ -10,11 +10,11 @@ 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) |
+| 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)      |
 | **Host → iframe refunds** | Render asks the extension to reverse redeem / gift-card payments before completing a POS refund | Parent `postMessage` + `requestId` (see below) |
 
 Domain models (orders, cart, customers, products, and related types) are documented in **[Types reference](./src/types/README.md)**.
@@ -54,7 +54,7 @@ For building applications that run inside the Render Point of Sale interface.
 - **Features:** Order management, Product catalog, Customer management, Payments, Hardware integration (Cash drawer, Printer), Custom tables, Secrets storage.
 
 ```typescript
-import { RenderClient } from '@final-commerce/command-frame';
+import { RenderClient } from "@final-commerce/command-frame";
 
 const client = new RenderClient();
 const products = await client.getProducts();
@@ -68,7 +68,7 @@ For building applications that run inside the Final Commerce Management Dashboar
 - **Features:** Context, catalog, entities, custom tables, secrets, and optional host-specific commands (navigation, media, tax, branding, notifications) when the dashboard implements them.
 
 ```typescript
-import { ManageClient } from '@final-commerce/command-frame';
+import { ManageClient } from "@final-commerce/command-frame";
 
 const client = new ManageClient();
 const context = await client.getContext();
@@ -82,14 +82,14 @@ The pub/sub system allows iframe extensions to subscribe to topics and receive r
 - **Topics:** Cart (16), Customers (8), Orders (4), Payments (2), Products (4), Refunds (4), Print (3), Custom Tables (3), Outlet (2), Station (2), Session (2), Users (2).
 
 ```typescript
-import { topics } from '@final-commerce/command-frame';
+import { topics } from "@final-commerce/command-frame";
 
-const subscriptionId = topics.subscribe('cart', (event) => {
-    console.log('Cart event:', event.type, event.data);
+const subscriptionId = topics.subscribe("cart", event => {
+    console.log("Cart event:", event.type, event.data);
 });
 
 // Unsubscribe when done
-topics.unsubscribe('cart', subscriptionId);
+topics.unsubscribe("cart", subscriptionId);
 ```
 
 ## Hooks
@@ -101,17 +101,21 @@ Hooks are **session-scoped** event callbacks that run in the host (Render) conte
 - A stable `hookId` is required for deduplication (safe on iframe reload).
 
 ```typescript
-import { hooks } from '@final-commerce/command-frame';
-
-hooks.register('cart', async (event, hostCommands) => {
-    await hostCommands.upsertCustomTableData({
-        tableName: 'cart-events-log',
-        data: { eventType: event.type, payload: event.data, timestamp: event.timestamp },
-    });
-}, { hookId: 'my-extension:cart-log' });
+import { hooks } from "@final-commerce/command-frame";
+
+hooks.register(
+    "cart",
+    async (event, hostCommands) => {
+        await hostCommands.upsertCustomTableData({
+            tableName: "cart-events-log",
+            data: { eventType: event.type, payload: event.data, timestamp: event.timestamp }
+        });
+    },
+    { hookId: "my-extension:cart-log" }
+);
 
 // Unregister when no longer needed
-hooks.unregister('my-extension:cart-log');
+hooks.unregister("my-extension:cart-log");
 ```
 
 ## Host-initiated extension refunds (redeem / gift card)
@@ -127,18 +131,12 @@ hooks.unregister('my-extension:cart-log');
 Exported APIs: `installExtensionRefundListener`, `EXTENSION_REFUND_REQUEST_ACTION`, types **`ExtensionRefundParams`** / **`ExtensionRefundResponse`**.
 
 ```typescript
-import {
-    installExtensionRefundListener,
-    type ExtensionRefundParams,
-    type ExtensionRefundResponse
-} from '@final-commerce/command-frame';
+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' };
+    return ok ? { success: true, extensionTransactionId: ok.providerRefundId } : { success: false, error: "Refund declined" };
 });
 
 // on teardown (optional)

package/dist/CommonTypes.d.ts

@@ -60,8 +60,7 @@ export declare enum CFUserTypes {
     CASHIER = "cashier",
     RESELLER = "reseller"
 }
-export interface CFActiveEntity {
-}
+export type CFActiveEntity = Record<string, unknown>;
 export interface CFDiscount {
     value: number;
     label?: string;
@@ -97,8 +96,26 @@ export interface CFTax {
     amount: number;
     taxTableName: string;
     taxTableId: string;
+    /** Whether this tax compounds on top of others. */
+    compounding?: boolean;
+    /** Application order; lower numbers apply first. */
+    priority?: number;
+}
+/** Per-rate tax entry on a cart fee (gst, hst, etc.). Same shape as `CFTax`; declared
+ *  separately to match the host's distinct `CartFeeTaxEntry` type. */
+export interface CFCartFeeTaxEntry {
+    id: string;
+    name: string;
+    percentage: number;
+    amount: number;
+    taxTableId: string;
+    taxTableName: string;
+    compounding?: boolean;
+    priority?: number;
 }
 export interface CFInventory {
+    /** Warehouse identifier the stock is held at. */
+    warehouse: string;
     outletId: string;
     stock?: number | null;
     _id?: string;
@@ -116,6 +133,29 @@ export interface CFOrderNote {
     addedByUser?: string;
     dateCreated?: string;
 }
+export interface CFAttributeOption {
+    name: string;
+    order?: number;
+}
+export interface CFAttribute {
+    _id: string;
+    companyId?: string;
+    optionName: string;
+    sortingOrder: number;
+    options: CFAttributeOption[];
+}
+export interface CFTransaction {
+    _id: string;
+    companyId?: string;
+    orderId?: string;
+    amount: number;
+    currency?: string;
+    status?: string;
+    paymentMethod?: string;
+    createdAt?: string;
+    updatedAt?: string;
+    [key: string]: unknown;
+}
 export interface CFCategory {
     _id: string;
     companyId: string;
@@ -132,7 +172,8 @@ export interface CFProductVariant {
     barcode?: string;
     costPrice?: number;
     manageStock: boolean;
-    externalId?: string;
+    /** External variant identifier — required by host. */
+    externalId: string;
     inventory?: CFInventory[];
     allowBackorder?: boolean;
     images?: string[];
@@ -145,11 +186,15 @@ export interface CFProductVariant {
         value: string;
     }[];
     _id: string;
+    isDeleted?: boolean;
+    currency?: CurrencyCode;
+    minorUnits?: number;
 }
 export interface CFProduct {
     _id: string;
     companyId?: string;
-    externalId?: string;
+    /** External product identifier — required by host. */
+    externalId: string;
     taxTable: string;
     name: string;
     description?: string;
@@ -169,8 +214,12 @@ export interface CFProduct {
     minorUnits: number;
     minPrice?: number;
     maxPrice?: number;
+    /** Catalog-level price (rare; usually only on simple products). */
+    price?: number;
     status?: string;
     isDeleted?: boolean;
+    createdAt?: string;
+    updatedAt?: string;
 }
 export interface CFActiveProduct extends CFActiveEntity {
     id: string;
@@ -196,10 +245,17 @@ export interface CFActiveProduct extends CFActiveEntity {
     isUnlimited?: boolean;
     attributes?: string;
     localQuantity?: number;
+    /** Mongo-style id when the active product retains the catalog `_id`. */
+    _id?: string;
+    productType?: CFProductType;
+    /** Currency code for the line price. */
+    currency?: CurrencyCode;
+    /** Number of minor units (decimal places) for the line currency. */
+    minorUnits?: number;
 }
 export interface CFCustomer {
     _id: string;
-    companyId: any;
+    companyId: string;
     externalId?: string;
     email: string;
     firstName: string;
@@ -246,6 +302,8 @@ export interface CFCartFeeItem {
     taxTableId?: string;
     tax?: number;
     taxName: string;
+    /** Per-rate breakdown so summary/refund views can show correct amounts per rate. */
+    taxes?: CFCartFeeTaxEntry[];
 }
 export interface CFTipPayment {
     amount: number;
@@ -269,6 +327,8 @@ export interface CFPaymentMethod {
     tip?: CFTipPayment | null;
     cashRounding?: number;
     emv?: string | null;
+    /** Processor fee charged on this payment. */
+    processorFee?: number | null;
 }
 export interface CFPosDataItem {
     outlet: string;
@@ -358,8 +418,7 @@ export interface CFRefundedLineItem {
     images?: string[];
     fee: CFFeeLineItem;
 }
-export interface CFRefundedCustomSale extends CFCustomSale {
-}
+export type CFRefundedCustomSale = CFCustomSale;
 export interface CFRefundItem {
     lineItems: CFRefundedLineItem[];
     customSales: CFRefundedCustomSale[];
@@ -382,6 +441,12 @@ export interface CFOrder {
     companyId: string;
     externalId: string | null;
     status: string;
+    /** Financial state (state machine). Undefined on legacy orders pre-backfill. */
+    paymentState?: string;
+    /** Operational state (state machine). Undefined on legacy orders pre-backfill. */
+    fulfillmentState?: string;
+    /** Computed display label from paymentState + fulfillmentState matrix. */
+    displayState?: string;
     customer: Partial<CFActiveCustomer | null>;
     customerNote?: string;
     summary: CFSummary;
@@ -404,6 +469,10 @@ export interface CFOrder {
     refund?: CFRefundItem[];
     balance: number;
     signature?: string | null;
+    /** ISO timestamp at which a parked order's stock reservation expires. */
+    parkExpiryDate?: string;
+    /** Park stock-reduction policy (host-defined string flag). */
+    parkReduceStock?: string;
 }
 export interface CFActiveUserRole {
     id?: string;
@@ -435,7 +504,7 @@ export interface CFActiveUser extends CFActiveEntity {
         _id: string;
     }[];
     type?: CFUserTypes;
-    companies?: any;
+    companies?: unknown;
 }
 export interface CFActiveOutlet extends CFActiveEntity {
     address: string;
@@ -465,6 +534,12 @@ export interface CFActiveStation {
     createdAt?: string;
     updatedAt?: string;
     stripeTerminalId?: string;
+    /** Stripe serial-reader identifier when paired. */
+    serialReaderId?: string;
+    /** User id of whoever enrolled the station. */
+    enrolledBy?: string;
+    /** Whether the station is virtual (no physical terminal). */
+    isVirtual?: boolean;
 }
 /** Cash register session (station session), aligned with Render `Session`. */
 export interface CFSession {
@@ -515,8 +590,8 @@ export interface CFActiveCustomSales {
     taxTableId?: string;
     quantity: number;
     price: number;
-    discount?: any;
-    fee?: any;
+    discount?: Record<string, unknown>;
+    fee?: Record<string, unknown>;
 }
 /** Non-revenue cart line (e.g. gift card load) — aligned with Render `NonRevenueItem.externalId` (order line id). */
 export interface CFNonRevenueItem {
@@ -530,6 +605,8 @@ export interface CFNonRevenueItem {
 }
 export interface CFActiveCart extends CFActiveEntity {
     tax?: number;
+    /** Per-rate tax breakdown for the cart. Same shape as line item taxes. */
+    taxes?: CFTax[];
     total: number;
     subtotal: number;
     discount?: CFDiscount;
@@ -545,12 +622,28 @@ export interface CFActiveCart extends CFActiveEntity {
     cartTotal?: number;
     orderTotal?: number;
     orderId?: string;
+    /** Currency code for amounts on this cart. */
+    currency?: CurrencyCode;
+    /** Number of minor units (decimal places) for the cart's currency. */
+    minorUnits?: number;
+}
+/** A parked order. Extends `CFActiveCart` with parking-specific fields. */
+export interface CFActivePark extends CFActiveCart {
+    /** Required on parked orders (overrides the optional `orderId` on the parent). */
+    orderId: string;
+    receiptId: string;
+    servedBy: string | {
+        _id?: string;
+        firstName: string;
+        lastName: string;
+    } | undefined;
+    createdAt: string | number;
 }
 export interface CFActiveCompany extends CFActiveEntity {
     id?: string;
     name?: string;
     logo?: string;
-    settings?: any;
+    settings?: Record<string, unknown>;
 }
 export type CFProjectName = "Render" | "Manage";
 export interface CFContextRender {
@@ -568,10 +661,16 @@ export interface CFContextRender {
     buildSourceId: string | null;
     buildIsPremium: boolean;
     isOffline: boolean;
-    user: Record<string, any> | null;
-    company: Omit<Record<string, any>, 'settings'> | null;
-    station: Record<string, any> | null;
-    outlet: Record<string, any> | null;
+    currency: string | null;
+    currencySymbol: string | null;
+    currencyPrefix: string | null;
+    currencySuffix: string | null;
+    thousandSeparator: string | null;
+    decimalSeparator: string | null;
+    user: Record<string, unknown> | null;
+    company: Omit<Record<string, unknown>, "settings"> | null;
+    station: Record<string, unknown> | null;
+    outlet: Record<string, unknown> | null;
     timestamp: string;
 }
 export interface CFOutletInfo {
@@ -591,11 +690,11 @@ export interface CFOutletInfo {
     country?: string;
 }
 export interface CFContextManage {
-    user: any;
-    company: any;
-    menuItem?: any;
+    user: unknown;
+    company: unknown;
+    menuItem?: unknown;
     extensionId: string;
-    outlets?: any[];
+    outlets?: unknown[];
     timestamp: string;
 }
 export type CFContext = CFContextRender;

package/dist/actions/add-customer-note/mock.js

@@ -1,23 +1,32 @@
-import { MOCK_CUSTOMERS } from "../../demo/database";
-export const mockAddCustomerNote = async (params) => {
+import { MOCK_CUSTOMERS, mockPublishEvent } from "../../demo/database";
+function generateNoteId() {
+    return `mock_note_${Date.now()}_${Math.random().toString(36).slice(2, 11)}`;
+}
+export const mockAddCustomerNote = (params) => {
     console.log("[Mock] addCustomerNote called", params);
-    if (params?.customerId && params.note) {
-        const customer = MOCK_CUSTOMERS.find(c => c._id === params.customerId);
-        if (customer) {
-            if (!customer.notes) {
-                customer.notes = [];
-            }
-            customer.notes.push({
-                _id: `mock_note_${Date.now()}_${Math.random().toString(36).slice(2, 11)}`,
-                message: params.note,
-                createdAt: new Date().toISOString()
-            });
-        }
+    if (!params?.note) {
+        throw new Error("addCustomerNote: note is required");
     }
-    return {
+    const target = params.customerId ? MOCK_CUSTOMERS.find(c => c._id === params.customerId) : MOCK_CUSTOMERS[0];
+    if (!target) {
+        throw new Error("addCustomerNote: no target customer (provide customerId or seed at least one mock customer)");
+    }
+    const noteId = generateNoteId();
+    const note = {
+        _id: noteId,
+        message: params.note,
+        createdAt: new Date().toISOString()
+    };
+    target.notes = [...(target.notes || []), note];
+    mockPublishEvent("customers", "customer-note-added", {
+        customer: target,
+        note
+    });
+    return Promise.resolve({
         success: true,
-        customerId: params?.customerId || "",
-        note: params?.note || "",
+        customerId: target._id,
+        noteId,
+        note: params.note,
         timestamp: new Date().toISOString()
-    };
+    });
 };

package/dist/actions/add-customer-note/types.d.ts

@@ -1,11 +1,12 @@
 export interface AddCustomerNoteParams {
-    customerId: string;
     note: string;
+    customerId?: string;
 }
 export interface AddCustomerNoteResponse {
     success: boolean;
     customerId: string;
+    noteId: string;
     note: string;
     timestamp: string;
 }
-export type AddCustomerNote = (params?: AddCustomerNoteParams) => Promise<AddCustomerNoteResponse>;
+export type AddCustomerNote = (params: AddCustomerNoteParams) => Promise<AddCustomerNoteResponse>;

package/dist/actions/add-product/mock.js

@@ -1,10 +1,13 @@
 import { CFProductType, CurrencyCode } from "../../CommonTypes";
+// eslint-disable-next-line @typescript-eslint/require-await
 export const mockAddProduct = async (params) => {
     console.log("[Mock] addProduct called", params);
     const hasVariants = params.variants && params.variants.length > 0;
+    const productId = "mock_product_" + Date.now();
     return {
         product: {
-            _id: "mock_product_" + Date.now(),
+            _id: productId,
+            externalId: `ext_${productId}`,
             currency: CurrencyCode.USD,
             minorUnits: 2,
             name: params.name,
@@ -20,16 +23,19 @@ export const mockAddProduct = async (params) => {
             maxPrice: params.price || 0,
             variants: hasVariants
                 ? params.variants.map((v, i) => ({ ...v, _id: `mock_variant_${Date.now()}_${i}` }))
-                : [{
+                : [
+                    {
                         _id: `mock_variant_${Date.now()}_0`,
+                        externalId: `ext_variant_${Date.now()}_0`,
                         sku: params.sku || "",
                         price: params.price || 0,
                         salePrice: 0,
                         isOnSale: false,
                         manageStock: params.manageStock || false,
-                        attributes: [],
-                    }],
+                        attributes: []
+                    }
+                ]
         },
-        timestamp: new Date().toISOString(),
+        timestamp: new Date().toISOString()
     };
 };

package/dist/actions/can-transition/action.d.ts

@@ -0,0 +1,2 @@
+import type { CanTransition } from "./types";
+export declare const canTransition: CanTransition;

package/dist/actions/can-transition/action.js

@@ -0,0 +1,4 @@
+import { commandFrameClient } from "../../client";
+export const canTransition = async (params) => {
+    return await commandFrameClient.call("canTransition", params);
+};

package/dist/actions/can-transition/mock.d.ts

@@ -0,0 +1,6 @@
+import type { CanTransitionParams, CanTransitionResponse } from "./types";
+/**
+ * Mock implementation: allows all transitions except a few known-invalid ones
+ * so the demo app can show both allowed and blocked responses.
+ */
+export declare const canTransitionMock: (params: CanTransitionParams) => Promise<CanTransitionResponse>;

package/dist/actions/can-transition/mock.js

@@ -0,0 +1,28 @@
+/**
+ * Mock implementation: allows all transitions except a few known-invalid ones
+ * so the demo app can show both allowed and blocked responses.
+ */
+export const canTransitionMock = async (params) => {
+    const to = params.to;
+    if (to.payment === "refunded" && to.fulfillment === "draft") {
+        return {
+            result: {
+                allowed: false,
+                blockedBy: "financial_invariant",
+                guard: "no-refund-in-draft",
+                reason: "Cannot refund an order that is still in draft",
+            },
+        };
+    }
+    if (to.payment === "paid" && to.fulfillment === "cancelled") {
+        return {
+            result: {
+                allowed: false,
+                blockedBy: "cross_axis_rule",
+                guard: "no-pay-cancelled",
+                reason: "Cannot mark a cancelled order as paid",
+            },
+        };
+    }
+    return { result: { allowed: true } };
+};

package/dist/actions/can-transition/types.d.ts

@@ -0,0 +1,11 @@
+import type { CFStatePair, CFTransitionResult } from "../../common-types/order-state";
+export interface CanTransitionParams {
+    /** Order to evaluate. If omitted, evaluates against a new order (from = null). */
+    orderId?: string;
+    /** Target state pair to transition to. */
+    to: CFStatePair;
+}
+export interface CanTransitionResponse {
+    result: CFTransitionResult;
+}
+export type CanTransition = (params: CanTransitionParams) => Promise<CanTransitionResponse>;

package/dist/actions/can-transition/types.js

@@ -0,0 +1 @@
+export {};

package/dist/actions/cash-payment/types.d.ts

@@ -1,9 +1,12 @@
 import { CFOrder } from "../../CommonTypes";
+import type { CFTransitionResult } from "../../common-types/order-state";
 export interface CashPaymentParams {
     /** If not provided, uses the cart total. */
     amount?: number;
     /** Defaults to false. */
     openChangeCalculator?: boolean;
+    /** Override the fulfillment state after full payment. Render resolves the cascade. */
+    checkoutFulfillmentTarget?: string;
 }
 export interface CashPaymentResponse {
     success: boolean;
@@ -12,5 +15,7 @@ export interface CashPaymentResponse {
     paymentType: string;
     order: CFOrder | null;
     timestamp: string;
+    /** Present when the state machine blocked or forced the transition. */
+    transitionResult?: CFTransitionResult;
 }
 export type CashPayment = (params?: CashPaymentParams) => Promise<CashPaymentResponse>;

package/dist/actions/delete-parked-order/types.d.ts

@@ -1,3 +1,4 @@
+import type { CFTransitionResult } from "../../common-types/order-state";
 export interface DeleteParkedOrderParams {
     orderId: string;
 }
@@ -5,5 +6,7 @@ export interface DeleteParkedOrderResponse {
     success: boolean;
     orderId: string;
     timestamp: string;
+    /** Present when the state machine blocked or forced the transition. */
+    transitionResult?: CFTransitionResult;
 }
 export type DeleteParkedOrder = (params?: DeleteParkedOrderParams) => Promise<DeleteParkedOrderResponse>;

package/dist/actions/edit-product/mock.js

@@ -1,9 +1,11 @@
 import { CFProductType, CurrencyCode } from "../../CommonTypes";
+// eslint-disable-next-line @typescript-eslint/require-await
 export const mockEditProduct = async (params) => {
     console.log("[Mock] editProduct called", params);
     return {
         product: {
             _id: params.productId,
+            externalId: `ext_${params.productId}`,
             currency: CurrencyCode.USD,
             minorUnits: 2,
             name: params.changes.name || "Updated Product",
@@ -14,8 +16,8 @@ export const mockEditProduct = async (params) => {
             status: params.changes.status || "active",
             productType: CFProductType.SIMPLE,
             attributes: [],
-            variants: [],
+            variants: []
         },
-        timestamp: new Date().toISOString(),
+        timestamp: new Date().toISOString()
     };
 };

package/dist/actions/extension-payment/types.d.ts

@@ -1,4 +1,5 @@
 import { CFOrder } from "../../CommonTypes";
+import type { CFTransitionResult } from "../../common-types/order-state";
 /** Params for extension-initiated payments; host routes by `paymentType`. */
 export interface ExtensionPaymentParams {
     paymentType: string;
@@ -8,6 +9,8 @@ export interface ExtensionPaymentParams {
     referenceId?: string;
     extensionId?: string;
     metadata?: Record<string, unknown>;
+    /** Override the fulfillment state after full payment. Render resolves the cascade. */
+    checkoutFulfillmentTarget?: string;
 }
 export interface ExtensionPaymentResponse {
     success: boolean;
@@ -15,5 +18,7 @@ export interface ExtensionPaymentResponse {
     paymentType: string;
     order: CFOrder | null;
     timestamp: string;
+    /** Present when the state machine blocked or forced the transition. */
+    transitionResult?: CFTransitionResult;
 }
 export type ExtensionPayment = (params?: ExtensionPaymentParams) => Promise<ExtensionPaymentResponse>;

package/dist/actions/get-available-transitions/action.d.ts

@@ -0,0 +1,2 @@
+import type { GetAvailableTransitions } from "./types";
+export declare const getAvailableTransitions: GetAvailableTransitions;

package/dist/actions/get-available-transitions/action.js

@@ -0,0 +1,4 @@
+import { commandFrameClient } from "../../client";
+export const getAvailableTransitions = async (params) => {
+    return await commandFrameClient.call("getAvailableTransitions", params);
+};

package/dist/actions/get-available-transitions/mock.d.ts

@@ -0,0 +1,6 @@
+import type { GetAvailableTransitionsParams, GetAvailableTransitionsResponse } from "./types";
+/**
+ * Mock implementation: returns a fixed set of plausible transitions
+ * so the demo app has data to render.
+ */
+export declare const getAvailableTransitionsMock: (_params: GetAvailableTransitionsParams) => Promise<GetAvailableTransitionsResponse>;