@final-commerce/command-frame 0.8.0-online.4 → 0.8.0-preprod.1

package/dist/CommonTypes.d.ts

@@ -1,5 +1,5 @@
 export * from './common-types';
-import type { Tax, Tip, Address, MetadataItem, PosDataItem, CartFeeTaxEntry, CartFeeItem, CartDiscountItem, OrderNote, NonRevenueItem, DiscountDetail, FeeDetail, DiscountLineItem, FeeLineItem, LineItem, TipPayment, RefundedTipPayment, PaymentMethod, Discount, CustomFee, Summary, CustomSale, RefundedCustomSale, RefundItem, RefundedLineItem, ActiveStation, ActiveSession, ActiveOutlet, ActiveUser, ActiveUserRole, ActiveOrder, ActiveCart, ActivePark, ActiveCompany, ActiveCustomSales, ActiveProduct, ActiveCustomer, FullProduct, ProductVariant, Inventory, ResolvedModifier, ResolvedModifierChoice, ModifierSelectionType, ModifierSelection, ModifierChoiceSelection, CartLineModifier, ProdModifierBreakdown, OrderLineItemModifier, CustomerNote, Attribute, AttributeOption, Category, Transaction, ActiveSplitPayment } from '@final-commerce/common/pos-types';
+import type { Tax, Tip, Address, MetadataItem, PosDataItem, CartFeeTaxEntry, CartFeeItem, CartDiscountItem, OrderNote, NonRevenueItem, DiscountDetail, FeeDetail, DiscountLineItem, FeeLineItem, LineItem, TipPayment, RefundedTipPayment, PaymentMethod, Discount, CustomFee, Summary, CustomSale, RefundedCustomSale, RefundItem, RefundedLineItem, ActiveStation, ActiveSession, ActiveOutlet, ActiveUser, ActiveUserRole, ActiveOrder, ActiveCart, ActivePark, ActiveCompany, ActiveCustomSales, ActiveProduct, ActiveCustomer, FullProduct, ProductVariant, Inventory, ResolvedModifier, ResolvedModifierChoice, ModifierSelectionType, ModifierSelection, ModifierChoiceSelection, CartLineModifier, ProdModifierBreakdown, OrderLineItemModifier, CustomerNote, Attribute, AttributeOption, Category, Transaction, ActiveSplitPayment, BookingAvailability, BookingSlot, BookingSlotResource, BookingResource, Booking, CartReservation, OrderReservation } from '@final-commerce/common/pos-types';
 export { CurrencyCode, ProductType as CFProductType, UserTypes as CFUserTypes } from '@final-commerce/common';
 /** Open record used as a base for active entities. */
 export type CFActiveEntity = Record<string, unknown>;
@@ -18,6 +18,16 @@ export type CFTransaction = Transaction;
 export type CFCategory = Category;
 export type CFProductVariant = ProductVariant;
 export type CFProduct = FullProduct;
+export type CFBookingAvailability = BookingAvailability;
+export type CFBookingSlot = BookingSlot;
+export type CFBookingSlotResource = BookingSlotResource;
+export type CFBookingResource = BookingResource;
+export type CFBooking = Booking;
+/** A service sitting in the cart, and the same sale once it is on an order. A flow that draws a
+ *  cart or a receipt needs both by name — reaching into the package's dist for them is not an
+ *  interface. */
+export type CFCartReservation = CartReservation;
+export type CFOrderReservation = OrderReservation;
 /** Modifier (the till question) resolved onto a product — `CFProduct.modifiers`. */
 export type CFResolvedModifier = ResolvedModifier;
 export type CFResolvedModifierChoice = ResolvedModifierChoice;
@@ -119,6 +129,21 @@ export interface CFContextRender {
     stationName: string | null;
     outletId: string | null;
     outletName: string | null;
+    /**
+     * IANA zone the SHOP keeps, resolved as the outlet's own zone, else the
+     * company's — never the device's. A booking is stored as an instant, so which
+     * hour and which DAY it reads as is decided entirely by the zone it is printed
+     * in, and the screen's own machine is the one zone that is certainly wrong: a
+     * 17:00 Monday appointment in Vancouver is 21:30 for a till in St John's, and
+     * for some viewers it lands on Tuesday. Without this an app cannot label a
+     * slot or an appointment honestly — it can only guess, and it guesses wrong
+     * for every business that does not sit in the same zone as its screen.
+     *
+     * `null` when neither the outlet nor the company has one configured. Say so
+     * rather than falling back to the device: a missing timezone is a setup
+     * problem, and printing the machine's clock hides it.
+     */
+    timeZone: string | null;
     buildId: string | null;
     buildName: string | null;
     buildVersion: string | null;

package/dist/actions/add-booking-to-cart/action.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Add booking to cart action
+ * Calls the addBookingToCart action on the parent window
+ */
+import type { AddBookingToCart } from './types';
+export declare const addBookingToCart: AddBookingToCart;

package/dist/actions/add-booking-to-cart/action.js

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

package/dist/actions/add-booking-to-cart/mock.d.ts

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

package/dist/actions/add-booking-to-cart/mock.js

@@ -0,0 +1,66 @@
+import { MOCK_CART, MOCK_PRODUCTS, mockPublishEvent } from '../../demo/database';
+import { mockHoldBooking } from '../hold-booking/mock';
+export const mockAddBookingToCart = async (params) => {
+    console.log('[Mock] addBookingToCart called', params);
+    // One call, two effects — the window is claimed AND the service is in the cart. The claim goes
+    // first and its refusal propagates: a cart line for a window somebody else took is worse than
+    // no line at all.
+    const held = await mockHoldBooking(params);
+    if (!held.success || !held.booking) {
+        return { success: false, reason: held.reason, timestamp: new Date().toISOString() };
+    }
+    const booking = held.booking;
+    // An unknown product used to be sold as "Booking" at zero. The host refuses it, and a mock that
+    // quietly sells something no catalogue contains teaches a screen a case that cannot happen.
+    const product = MOCK_PRODUCTS.find(({ _id }) => _id === params.productId);
+    if (!product) {
+        return { success: false, reason: `No product ${params.productId}`, timestamp: new Date().toISOString() };
+    }
+    // A named variant is honoured or refused, never substituted — the host does the same.
+    const variant = params.variantId
+        ? product.variants?.find(({ _id }) => _id === params.variantId)
+        : product.variants?.[0];
+    if (params.variantId && !variant) {
+        return {
+            success: false,
+            reason: `${product.name} has no variant ${params.variantId}`,
+            timestamp: new Date().toISOString(),
+        };
+    }
+    const price = variant?.price ?? product.minPrice ?? 0;
+    const reservation = {
+        internalId: `res_${booking.id}`,
+        bookingId: booking.id,
+        productId: params.productId,
+        variantId: variant?._id ?? null,
+        resourceId: params.resourceId,
+        name: product.name,
+        resourceName: booking.resourceName,
+        price,
+        quantity: 1,
+        total: price,
+        taxTableId: product.taxTable,
+        startAt: booking.startAt,
+        endAt: booking.endAt,
+        bufferEndAt: booking.bufferEndAt,
+        expiresAt: booking.expiresAt,
+    };
+    if (!MOCK_CART.reservations)
+        MOCK_CART.reservations = [];
+    MOCK_CART.reservations.push(reservation);
+    MOCK_CART.subtotal += price;
+    MOCK_CART.total += price;
+    MOCK_CART.amountToBeCharged = MOCK_CART.total;
+    MOCK_CART.remainingBalance = MOCK_CART.total;
+    // The cart topic, not the bookings one: a screen that only watches bookings still has to
+    // repaint its cart, and every other cart mutation announces itself the same way.
+    // `cart-created`, as the host publishes: the cart topic carries the whole cart, and a screen
+    // written against the host's event was not listening for a name only the mock used.
+    mockPublishEvent('cart', 'cart-created', { cart: MOCK_CART });
+    return {
+        success: true,
+        booking,
+        reservationInternalId: reservation.internalId,
+        timestamp: new Date().toISOString(),
+    };
+};

package/dist/actions/add-booking-to-cart/types.d.ts

@@ -0,0 +1,27 @@
+import { CFBooking } from '../../CommonTypes';
+export interface AddBookingToCartParams {
+    /** The bookable product (`productType: 'booking'`). */
+    productId: string;
+    /** Which resource serves it: a member of staff, a room, a scooter. */
+    resourceId: string;
+    /** Must be the START of a slot getBookingAvailability offered, ISO 8601. */
+    startAt: string;
+    /** End of the window — the slot's own `endAt`, or the last slot's for a stay. */
+    endAt: string;
+    /** The variant being sold. Defaults to the product's only variant. */
+    variantId?: string;
+    /** Whom the booking is for. Omit for a walk-in. */
+    customerId?: string;
+}
+export interface AddBookingToCartResponse {
+    /** False when the command was refused — a taken window, a rule, a booking that is not yours. */
+    success: boolean;
+    /** Why it was refused, in words a cashier can act on. Absent on success. */
+    reason?: string;
+    /** The claim the cart now stands on: `id` cancels or releases it, `expiresAt` is your clock. */
+    booking?: CFBooking;
+    /** Identity of the reservation inside the cart and, later, the order. */
+    reservationInternalId?: string;
+    timestamp: string;
+}
+export type AddBookingToCart = (params: AddBookingToCartParams) => Promise<AddBookingToCartResponse>;

package/dist/actions/cancel-booking/action.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Cancel booking action
+ * Calls the cancelBooking action on the parent window
+ */
+import type { CancelBooking } from './types';
+export declare const cancelBooking: CancelBooking;

package/dist/actions/cancel-booking/action.js

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

package/dist/actions/cancel-booking/mock.d.ts

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

package/dist/actions/cancel-booking/mock.js

@@ -0,0 +1,31 @@
+import { MOCK_BOOKINGS, MOCK_CART, mockPublishEvent } from '../../demo/database';
+import { ReservationStatus } from '@final-commerce/common';
+export const mockCancelBooking = async (params) => {
+    console.log('[Mock] cancelBooking called', params);
+    const booking = MOCK_BOOKINGS.find(({ id }) => id === params.bookingId);
+    if (!booking) {
+        return { success: false, reason: `No booking ${params.bookingId}`, timestamp: new Date().toISOString() };
+    }
+    // A paid booking is not cancellable: the window would be freed while the money stays taken.
+    if (booking.status === ReservationStatus.CONFIRMED && booking.orderId) {
+        return {
+            success: false,
+            reason: `That booking is paid for on order ${booking.orderId} — refund the service instead`,
+            timestamp: new Date().toISOString(),
+        };
+    }
+    booking.status = ReservationStatus.CANCELLED;
+    // A window given away may be the one an open cart is selling, so the cart follows — the host
+    // does this, and a mock that left the line behind sold time that had just been released.
+    const index = (MOCK_CART.reservations ?? []).findIndex((entry) => entry.bookingId === params.bookingId);
+    if (index >= 0) {
+        const [removed] = MOCK_CART.reservations.splice(index, 1);
+        const line = removed.total || removed.price * (removed.quantity ?? 1);
+        MOCK_CART.subtotal -= line;
+        MOCK_CART.total -= line;
+        MOCK_CART.amountToBeCharged = MOCK_CART.total;
+        MOCK_CART.remainingBalance = MOCK_CART.total;
+        mockPublishEvent('cart', 'cart-created', { cart: MOCK_CART });
+    }
+    return { success: true, booking, timestamp: new Date().toISOString() };
+};

package/dist/actions/cancel-booking/types.d.ts

@@ -0,0 +1,14 @@
+import { CFBooking } from '../../CommonTypes';
+export interface CancelBookingParams {
+    /** `id` of the booking returned by holdBooking or getBookings. */
+    bookingId: string;
+}
+export interface CancelBookingResponse {
+    /** False when the command was refused — a taken window, a rule, a booking that is not yours. */
+    success: boolean;
+    /** Why it was refused, in words a cashier can act on. Absent on success. */
+    reason?: string;
+    booking?: CFBooking;
+    timestamp: string;
+}
+export type CancelBooking = (params: CancelBookingParams) => Promise<CancelBookingResponse>;

package/dist/actions/get-booking-availability/action.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Get booking availability action
+ * Calls the getBookingAvailability action on the parent window
+ */
+import type { GetBookingAvailability } from './types';
+export declare const getBookingAvailability: GetBookingAvailability;

package/dist/actions/get-booking-availability/action.js

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

package/dist/actions/get-booking-availability/mock.d.ts

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

package/dist/actions/get-booking-availability/mock.js

@@ -0,0 +1,12 @@
+import { mockBookingAvailability } from '../../demo/database';
+export const mockGetBookingAvailability = async (params) => {
+    console.log('[Mock] getBookingAvailability called', params);
+    // `fromDay` + `days` is the shape a calendar actually asks in; the mock resolves it on the
+    // machine's clock, which is the only one it has.
+    const start = params.fromDay ? new Date(`${params.fromDay}T00:00:00`) : params.from ? new Date(params.from) : new Date();
+    const end = params.to
+        ? new Date(params.to)
+        : new Date(start.getFullYear(), start.getMonth(), start.getDate() + Math.max(1, params.days ?? 1));
+    const availability = mockBookingAvailability(params.productId, start, end, params.resourceId);
+    return { success: true, availability, timestamp: new Date().toISOString() };
+};

package/dist/actions/get-booking-availability/types.d.ts

@@ -0,0 +1,37 @@
+import { CFBookingAvailability } from '../../CommonTypes';
+export interface GetBookingAvailabilityParams {
+    /** The bookable product (`productType: 'booking'`) whose calendar you are drawing. */
+    productId: string;
+    /**
+     * Range start, ISO 8601. Optional when `fromDay` is given.
+     *
+     * Prefer `fromDay`: a calendar asks about DAYS, and turning "this day at this shop" into two
+     * instants needs the shop's zone — which the host has and the caller has to go and find. A
+     * caller that widened the range by a day at each end and filtered the answer afterwards was
+     * working around the absence of `fromDay`.
+     */
+    from?: string;
+    /** Range end, ISO 8601. Optional when `fromDay` is given. */
+    to?: string;
+    /**
+     * First shop day to cover, `YYYY-MM-DD`. Resolved to local midnight in the shop's own zone,
+     * so a day that is 23 or 25 hours long because the clocks moved is still exactly one day.
+     * Omit both this and `from`/`to` to get today at the shop.
+     */
+    fromDay?: string;
+    /** How many shop days from `fromDay`. Default 1. */
+    days?: number;
+    /** Narrow the answer to one resource — "only Marco", "only room 4". */
+    resourceId?: string;
+    /** Narrow to the resources standing at one outlet. */
+    outletId?: string;
+}
+export interface GetBookingAvailabilityResponse {
+    /** False when the command was refused — a taken window, a rule, a booking that is not yours. */
+    success: boolean;
+    /** Why it was refused, in words a cashier can act on. Absent on success. */
+    reason?: string;
+    availability?: CFBookingAvailability;
+    timestamp: string;
+}
+export type GetBookingAvailability = (params: GetBookingAvailabilityParams) => Promise<GetBookingAvailabilityResponse>;

package/dist/actions/get-booking-resources/action.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Get booking resources action
+ * Calls the getBookingResources action on the parent window
+ */
+import type { GetBookingResources } from './types';
+export declare const getBookingResources: GetBookingResources;

package/dist/actions/get-booking-resources/action.js

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

package/dist/actions/get-booking-resources/mock.d.ts

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

package/dist/actions/get-booking-resources/mock.js

@@ -0,0 +1,7 @@
+import { MOCK_BOOKING_RESOURCES } from '../../demo/database';
+export const mockGetBookingResources = async (params) => {
+    console.log('[Mock] getBookingResources called', params);
+    // A resource knows nothing about outlets — where it works lives in its own records, which the
+    // host reads. The mock has no such records, so `outletId` narrows nothing here.
+    return { success: true, resources: MOCK_BOOKING_RESOURCES, timestamp: new Date().toISOString() };
+};

package/dist/actions/get-booking-resources/types.d.ts

@@ -0,0 +1,16 @@
+import { CFBookingResource } from '../../CommonTypes';
+export interface GetBookingResourcesParams {
+    /** Only the resources that serve this bookable product. Omit for the whole company. */
+    productId?: string;
+    /** Only resources standing at this outlet (a resource with no outlet serves all of them). */
+    outletId?: string;
+}
+export interface GetBookingResourcesResponse {
+    /** False when the command was refused — a taken window, a rule, a booking that is not yours. */
+    success: boolean;
+    /** Why it was refused, in words a cashier can act on. Absent on success. */
+    reason?: string;
+    resources?: CFBookingResource[];
+    timestamp: string;
+}
+export type GetBookingResources = (params?: GetBookingResourcesParams) => Promise<GetBookingResourcesResponse>;

package/dist/actions/get-booking-resources/types.js

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

package/dist/actions/get-bookings/action.d.ts

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

package/dist/actions/get-bookings/action.js

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

package/dist/actions/get-bookings/mock.d.ts

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

package/dist/actions/get-bookings/mock.js

@@ -0,0 +1,20 @@
+import { MOCK_BOOKINGS, mockLiveBookings } from '../../demo/database';
+export const mockGetBookings = async (params) => {
+    console.log('[Mock] getBookings called', params);
+    let bookings = params?.includeExpired ? MOCK_BOOKINGS : mockLiveBookings();
+    if (params?.resourceId)
+        bookings = bookings.filter((entry) => entry.resourceId === params.resourceId);
+    if (params?.productId)
+        bookings = bookings.filter((entry) => entry.productId === params.productId);
+    if (params?.customerId)
+        bookings = bookings.filter((entry) => entry.customerId === params.customerId);
+    if (params?.from) {
+        const from = new Date(params.from);
+        bookings = bookings.filter((entry) => new Date(entry.bufferEndAt) > from);
+    }
+    if (params?.to) {
+        const to = new Date(params.to);
+        bookings = bookings.filter((entry) => new Date(entry.startAt) < to);
+    }
+    return { success: true, bookings, timestamp: new Date().toISOString() };
+};

package/dist/actions/get-bookings/types.d.ts

@@ -0,0 +1,22 @@
+import { CFBooking } from '../../CommonTypes';
+export interface GetBookingsParams {
+    /** Everything taking this resource's time — the one query a day view needs. */
+    resourceId?: string;
+    productId?: string;
+    /** This customer's appointments. */
+    customerId?: string;
+    /** Bookings whose window overlaps this range, ISO 8601. */
+    from?: string;
+    to?: string;
+    /** Defaults to live bookings only (confirmed, plus holds that have not expired). */
+    includeExpired?: boolean;
+}
+export interface GetBookingsResponse {
+    /** False when the command was refused — a taken window, a rule, a booking that is not yours. */
+    success: boolean;
+    /** Why it was refused, in words a cashier can act on. Absent on success. */
+    reason?: string;
+    bookings?: CFBooking[];
+    timestamp: string;
+}
+export type GetBookings = (params?: GetBookingsParams) => Promise<GetBookingsResponse>;

package/dist/actions/get-bookings/types.js

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

package/dist/actions/get-context/mock.js

@@ -11,6 +11,10 @@ export const mockGetContext = () => {
         stationName: MOCK_STATION.name,
         outletId: MOCK_OUTLET.id,
         outletName: MOCK_OUTLET.name || null,
+        // Deliberately NOT the developer's own zone: an app that quietly formats with
+        // the machine's clock looks correct in preview and is wrong on every till that
+        // sits in a different city. Here it cannot look correct by accident.
+        timeZone: "America/Vancouver",
         buildId: "mock_build_id",
         buildName: "Mock Build",
         buildVersion: "1.0.0-mock",

package/dist/actions/get-product-modifier-selections/action.d.ts

@@ -2,5 +2,5 @@
  * Get product modifier selections action (read-only)
  * Calls the getProductModifierSelections action on the parent window
  */
-import type { GetProductModifierSelections } from "./types";
+import type { GetProductModifierSelections } from './types';
 export declare const getProductModifierSelections: GetProductModifierSelections;

package/dist/actions/get-product-modifier-selections/action.js

@@ -2,7 +2,7 @@
  * Get product modifier selections action (read-only)
  * Calls the getProductModifierSelections action on the parent window
  */
-import { commandFrameClient } from "../../client";
+import { commandFrameClient } from '../../client';
 export const getProductModifierSelections = async (params) => {
-    return await commandFrameClient.call("getProductModifierSelections", params);
+    return await commandFrameClient.call('getProductModifierSelections', params);
 };

package/dist/actions/get-product-modifier-selections/mock.d.ts

@@ -1,2 +1,2 @@
-import { GetProductModifierSelections } from "./types";
+import { GetProductModifierSelections } from './types';
 export declare const mockGetProductModifierSelections: GetProductModifierSelections;

package/dist/actions/get-product-modifier-selections/mock.js

@@ -1,6 +1,6 @@
-import { MOCK_CART, buildModifierRows } from "../../demo/database";
+import { MOCK_CART, buildModifierRows } from '../../demo/database';
 export const mockGetProductModifierSelections = async (params) => {
-    console.log("[Mock] getProductModifierSelections called", params);
+    console.log('[Mock] getProductModifierSelections called', params);
     // Read the line's stored selections from the mock cart (last line when no internalId).
     const line = params?.internalId
         ? MOCK_CART.products.find((p) => p.internalId === params.internalId)
@@ -8,12 +8,12 @@ export const mockGetProductModifierSelections = async (params) => {
     if (!line) {
         return {
             success: false,
-            reason: "No matching cart line",
+            reason: 'No matching cart line',
             internalId: params?.internalId,
             selections: [],
             rows: [],
             modifiersTotal: 0,
-            timestamp: new Date().toISOString()
+            timestamp: new Date().toISOString(),
         };
     }
     // The priced rows already sit on the line; extending them by the line quantity is
@@ -25,6 +25,6 @@ export const mockGetProductModifierSelections = async (params) => {
         selections: line.modifierSelections ?? [],
         rows,
         modifiersTotal,
-        timestamp: new Date().toISOString()
+        timestamp: new Date().toISOString(),
     };
 };

package/dist/actions/get-product-modifier-selections/types.d.ts

@@ -1,4 +1,4 @@
-import type { CFModifierSelection, CFModifierChoiceSelection, CFProdModifierBreakdown } from "../../CommonTypes";
+import type { CFModifierSelection, CFModifierChoiceSelection, CFProdModifierBreakdown } from '../../CommonTypes';
 /** Alias of common's — `quantity` is units PER LINE-ITEM UNIT. */
 export type ModifierChoiceSelection = CFModifierChoiceSelection;
 /** Alias of common's — the cashier's answer to one modifier. */

package/dist/actions/get-products/mock.js

@@ -5,6 +5,12 @@ export const mockGetProducts = async (params) => {
     // Simple filter simulation
     let products = MOCK_PRODUCTS;
     const query = params?.query || {};
+    // Same rule as the real host: a bookable service is not catalogue stock and is left out unless
+    // the query names `productType`. Mirrored here on purpose — a mock that hands back services the
+    // device withholds is how a flow gets built around a grid that cannot exist.
+    if (!JSON.stringify(query).includes('productType')) {
+        products = products.filter((p) => p.productType !== 'booking');
+    }
     if (query.searchValue) {
         const search = String(query.searchValue).toLowerCase();
         products = products.filter((p) => p.name.toLowerCase().includes(search) || p.sku?.toLowerCase().includes(search));

package/dist/actions/get-products/types.d.ts

@@ -1,6 +1,21 @@
-import { CFProduct } from "../../CommonTypes";
+import { CFProduct } from '../../CommonTypes';
 export interface GetProductsParams {
-    /** MongoDB-like query object. */
+    /**
+     * MongoDB-like query object.
+     *
+     * BOOKABLE SERVICES ARE EXCLUDED unless this query mentions `productType`. A service is not
+     * catalogue stock: it is sold by claiming a time with `addBookingToCart`, and
+     * `addProductToCart` refuses it. Returned by default it appeared in ordinary product grids,
+     * where the obvious gesture took the money and reserved nothing.
+     *
+     * Ask for them explicitly when the user actually wants services — a "Book" tab, a services
+     * screen, a search across everything:
+     *
+     *   getProducts({ query: { productType: 'booking' } })   // services only
+     *   getProducts({ query: { productType: { $in: ['simple', 'variable', 'booking'] } } })  // both
+     *
+     * Any query naming `productType` is used exactly as written.
+     */
     query?: {
         name?: string | {
             $regex?: string;
@@ -11,7 +26,14 @@ export interface GetProductsParams {
             $options?: string;
         };
         status?: string;
-        productType?: string;
+        /**
+         * `simple` | `variable` | `booking`. Naming it at all switches OFF the default exclusion
+         * of bookable services — including `{ $ne: 'booking' }`, which then means what it says.
+         */
+        productType?: string | {
+            $in?: string[];
+            $ne?: string;
+        };
         categories?: string | {
             $in?: string[];
         };

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

@@ -18,11 +18,14 @@ export interface GetRefundPlanParams {
      * nothing staged, no `allocation` comes back.
      */
     items?: {
-        /** `internalId` / `variantId` for a product, `customSaleId`, cart-fee id, or tip `transactionId`. */
+        /**
+         * `internalId` / `variantId` for a product, `customSaleId`, cart-fee id, tip
+         * `transactionId`, or a booking's own `internalId` on `order.reservations[]`.
+         */
         itemKey: string;
         quantity: number;
         /** Optional hint; inferred from the order when omitted. */
-        type?: 'product' | 'customSale' | 'fee' | 'tip';
+        type?: 'product' | 'customSale' | 'fee' | 'tip' | 'reservation';
     }[];
 }
 export interface RefundPlanSource {

package/dist/actions/get-remaining-refundable-quantities/mock.js

@@ -6,6 +6,7 @@ export const mockGetRemainingRefundableQuantities = async (_params) => {
         customSales: {},
         cartFees: {},
         tips: {},
+        reservations: {},
         timestamp: new Date().toISOString(),
     };
 };

package/dist/actions/get-remaining-refundable-quantities/types.d.ts

@@ -18,6 +18,14 @@ export interface GetRemainingRefundableQuantitiesResponse {
      * 0/1 semantics: `1` = still refundable, `0` = already refunded.
      */
     tips: Record<string, number>;
+    /**
+     * Remaining refundable bookings, keyed by `order.reservations[].internalId` —
+     * the same key `processPartialRefund` takes for `type: 'reservation'` items.
+     * A service is sold as a reservation rather than a line item, so without this
+     * map a refund screen can show everything on the order EXCEPT the appointment.
+     * 0/1 semantics: `1` = still refundable, `0` = already refunded.
+     */
+    reservations: Record<string, number>;
     timestamp: string;
 }
 export type GetRemainingRefundableQuantities = (params?: GetRemainingRefundableQuantitiesParams) => Promise<GetRemainingRefundableQuantitiesResponse>;

package/dist/actions/hold-booking/action.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Hold booking action
+ * Calls the holdBooking action on the parent window
+ */
+import type { HoldBooking } from './types';
+export declare const holdBooking: HoldBooking;

package/dist/actions/hold-booking/action.js

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

package/dist/actions/hold-booking/mock.d.ts

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