@ticketboothapp/booking 1.2.122 → 1.2.124

package/src/components/booking/useAdminChangeOrderSummaryModel.ts

@@ -0,0 +1,246 @@
+import { useCallback, useMemo } from 'react';
+import {
+  type Availability,
+  type PricingConfig,
+  type Product,
+  type ReturnOption,
+} from '../../lib/booking-api';
+import {
+  changeFlowTicketLineTotalWithReceiptFloor,
+  type ChangeFlowProtectedReceiptPricing,
+} from '../../lib/booking/change-flow-pricing';
+import {
+  computeOrderSummary,
+  computePriceBreakdown,
+  type OrderSummary,
+  type PriceBreakdown as PriceBreakdownData,
+} from '../../lib/booking/pricing';
+import type { Currency } from './CurrencySwitcher';
+import {
+  buildPricingFromAvailability,
+  getAvailabilityOptionId,
+} from './change-booking-flow-helpers';
+import type { AdminChangeLatestQuote } from './useAdminChangeCheckoutController';
+
+type ProductOption = NonNullable<Product['options']>[number];
+type PrecomputedPricesByOption = Parameters<typeof buildPricingFromAvailability>[2];
+
+export interface UseAdminChangeOrderSummaryModelParams {
+  selectedAvailability: Availability | null;
+  activeOptions: ProductOption[];
+  precomputedPricesByOption: PrecomputedPricesByOption;
+  currency: Currency;
+  pricingConfig: PricingConfig | null;
+  isSimplifiedPricingView: boolean;
+  latestChangeQuote: AdminChangeLatestQuote | null;
+  useAdminFeAuthoritativeQuote: boolean;
+  isCustomerSelfServeChange: boolean;
+  quantities: Record<string, number>;
+  returnOptionForOrderSummary: ReturnOption | null;
+  cancellationPolicyId: string | null;
+  changeFlowApplyReceiptPaidFloors: boolean;
+  changeFlowTicketBookedUnitPriceByCategory: Map<string, number>;
+  changeFlowInitialTicketQtyByCategory: Map<string, number>;
+  changeFlowProtectedReceiptPricing: ChangeFlowProtectedReceiptPricing;
+  t: (key: string) => string;
+}
+
+export function useAdminChangeOrderSummaryModel({
+  selectedAvailability,
+  activeOptions,
+  precomputedPricesByOption,
+  currency,
+  pricingConfig,
+  isSimplifiedPricingView,
+  latestChangeQuote,
+  useAdminFeAuthoritativeQuote,
+  isCustomerSelfServeChange,
+  quantities,
+  returnOptionForOrderSummary,
+  cancellationPolicyId,
+  changeFlowApplyReceiptPaidFloors,
+  changeFlowTicketBookedUnitPriceByCategory,
+  changeFlowInitialTicketQtyByCategory,
+  changeFlowProtectedReceiptPricing,
+  t,
+}: UseAdminChangeOrderSummaryModelParams) {
+  const hasFees = useMemo(
+    () =>
+      Boolean(
+        pricingConfig?.fees &&
+          Object.keys(pricingConfig.fees).length > 0 &&
+          Object.values(pricingConfig.fees).some((fee) => (fee?.feePerPerson ?? 0) > 0),
+      ),
+    [pricingConfig?.fees],
+  );
+
+  const pricing = useMemo(
+    () =>
+      buildPricingFromAvailability(
+        selectedAvailability,
+        activeOptions,
+        precomputedPricesByOption,
+        currency,
+        pricingConfig,
+        hasFees,
+        isSimplifiedPricingView,
+      ),
+    [
+      selectedAvailability,
+      currency,
+      hasFees,
+      pricingConfig,
+      precomputedPricesByOption,
+      activeOptions,
+      isSimplifiedPricingView,
+    ],
+  );
+
+  const pricingForTicketSelector = useMemo(() => {
+    const ticketUnitPriceByCategory = latestChangeQuote?.serverPreview?.ticketUnitPriceByCategory;
+    if (
+      useAdminFeAuthoritativeQuote ||
+      !isCustomerSelfServeChange ||
+      !ticketUnitPriceByCategory
+    ) {
+      return pricing;
+    }
+    return pricing.map((rate) => {
+      const unitPrice = ticketUnitPriceByCategory[rate.category.toUpperCase()];
+      if (unitPrice == null || !Number.isFinite(unitPrice)) return rate;
+      return {
+        ...rate,
+        price: unitPrice,
+        priceCAD: unitPrice,
+        baseInDisplayCurrency: unitPrice,
+      };
+    });
+  }, [
+    pricing,
+    latestChangeQuote?.serverPreview?.ticketUnitPriceByCategory,
+    isCustomerSelfServeChange,
+    useAdminFeAuthoritativeQuote,
+  ]);
+
+  const getPriceBreakdown = useCallback(
+    (
+      category: string,
+      priceCAD: number,
+      baseInDisplayCurrency: number | undefined,
+      appliedAdjustments: Array<{
+        type: string;
+        id: string;
+        name: string;
+        changeByCurrency?: Record<string, number>;
+      }> = [],
+    ): PriceBreakdownData | null => {
+      if (!pricingConfig) return null;
+      const selectedOption = activeOptions.find(
+        (option) =>
+          option.optionId ===
+          (selectedAvailability ? getAvailabilityOptionId(selectedAvailability) : ''),
+      );
+      const basePriceCAD = selectedOption?.pricing?.[category.toUpperCase()] ?? 0;
+      return computePriceBreakdown(
+        pricingConfig,
+        currency,
+        priceCAD,
+        basePriceCAD,
+        hasFees,
+        appliedAdjustments,
+        undefined,
+        baseInDisplayCurrency,
+        isSimplifiedPricingView,
+      );
+    },
+    [pricingConfig, currency, hasFees, activeOptions, selectedAvailability, isSimplifiedPricingView],
+  );
+
+  const orderSummary: OrderSummary = useMemo(
+    () =>
+      computeOrderSummary(
+        quantities,
+        pricingForTicketSelector,
+        returnOptionForOrderSummary,
+        pricingConfig ?? null,
+        currency,
+        hasFees,
+        cancellationPolicyId,
+      ),
+    [
+      quantities,
+      pricingForTicketSelector,
+      returnOptionForOrderSummary,
+      pricingConfig,
+      currency,
+      hasFees,
+      cancellationPolicyId,
+    ],
+  );
+
+  const {
+    totalQuantity,
+    subtotal,
+    tax,
+    feeLineItems,
+    returnPriceAdjustment,
+    cancellationPolicyFee,
+    isTaxIncludedInPrice,
+    ticketLineItems,
+  } = orderSummary;
+
+  const changeFlowProtectedTicketSubtotal = useMemo(() => {
+    const currentTicketSubtotal = ticketLineItems.reduce(
+      (sum, line) => sum + Math.max(0, Number(line.itemTotal) || 0),
+      0,
+    );
+    if (!changeFlowApplyReceiptPaidFloors) return currentTicketSubtotal;
+    return ticketLineItems.reduce((sum, line) => {
+      const category = line.category?.trim().toUpperCase();
+      const qty = Math.max(0, Number(line.qty) || 0);
+      if (!category || qty <= 0) return sum;
+      return (
+        sum +
+        changeFlowTicketLineTotalWithReceiptFloor({
+          qty,
+          baselineQtyForCategory: changeFlowInitialTicketQtyByCategory.get(category) ?? 0,
+          receiptUnitFloor: changeFlowTicketBookedUnitPriceByCategory.get(category),
+          liveLineTotal: Number(line.itemTotal) || 0,
+          protectedReceiptPricing: changeFlowProtectedReceiptPricing,
+        })
+      );
+    }, 0);
+  }, [
+    changeFlowApplyReceiptPaidFloors,
+    ticketLineItems,
+    changeFlowTicketBookedUnitPriceByCategory,
+    changeFlowInitialTicketQtyByCategory,
+    changeFlowProtectedReceiptPricing,
+  ]);
+
+  const selectedCancellationPolicy = pricingConfig?.cancellationPolicies?.find(
+    (policy) => policy.id === cancellationPolicyId,
+  );
+  const effectiveCancellationPolicyLabel =
+    selectedCancellationPolicy?.label ??
+    (t('booking.flexibleCancellation') || 'Flexible cancellation');
+
+  return {
+    hasFees,
+    pricing,
+    pricingForTicketSelector,
+    getPriceBreakdown,
+    orderSummary,
+    totalQuantity,
+    subtotal,
+    tax,
+    feeLineItems,
+    returnPriceAdjustment,
+    cancellationPolicyFee,
+    isTaxIncludedInPrice,
+    ticketLineItems,
+    changeFlowProtectedTicketSubtotal,
+    selectedCancellationPolicy,
+    effectiveCancellationPolicyLabel,
+  };
+}

package/src/components/booking/useAdminChangePriceSummary.ts

@@ -0,0 +1,416 @@
+import { useMemo } from 'react';
+import {
+  type AddOn,
+  type Availability,
+  type PricingConfig,
+  type ReturnOption,
+} from '../../lib/booking-api';
+import {
+  resolveChangeFlowNewBookingTotal,
+  type ChangeFlowProtectedReceiptPricing,
+} from '../../lib/booking/change-flow-pricing';
+import type {
+  OrderSummaryFeeLine,
+  OrderSummaryTicketLine,
+  PriceBreakdown as PriceBreakdownData,
+} from '../../lib/booking/pricing';
+import type { ChangeBookingFlowProps } from './booking-flow-types';
+import type { Currency } from './CurrencySwitcher';
+import type { PriceSummaryLine } from './PriceSummary';
+import { useEditableSummaryLines } from './useEditableSummaryLines';
+import {
+  isPromoDiscountGiftCardOrVoucherLine,
+  omitZeroAmountPromoDiscountSummaryLines,
+  type PricingRate,
+} from './change-booking-flow-helpers';
+import { useAdminChangeProtectedPricing } from './useAdminChangeProtectedPricing';
+import { useAdminChangePromoDiscount } from './useAdminChangePromoDiscount';
+
+type AddOnSelection = { addOnId: string; variantId?: string; quantity?: number };
+type AdminCustomReceiptLine = { label: string; amountInput: string; amountSign?: number };
+type ProviderPricingUi = NonNullable<
+  NonNullable<ChangeBookingFlowProps['flowUi']>['providerDashboardChangePricingUi']
+>;
+type ProviderQuotedLine = NonNullable<ProviderPricingUi['quotedLines']>[number];
+type GetPriceBreakdown = (
+  category: string,
+  priceCAD: number,
+  baseInDisplayCurrency: number | undefined,
+  appliedAdjustments?: Array<{ type: string; id: string; name: string; changeByCurrency?: Record<string, number> }>,
+) => PriceBreakdownData | null;
+
+export interface UseAdminChangePriceSummaryParams {
+  selectedAvailability: Availability | null;
+  selectedReturnOption: ReturnOption | null;
+  currency: Currency;
+  totalQuantity: number;
+  returnPriceAdjustment: number;
+  isCustomerSelfServeChange: boolean;
+  effectiveChangeFlowReturnUnitFloorPerPerson: number | null | undefined;
+  changeFlowInitialTicketCount: number;
+  changeFlowReturnPricingRuleA: boolean;
+  changeFlowApplyReceiptPaidFloors: boolean;
+  ticketLineItems: OrderSummaryTicketLine[];
+  changeFlowTicketBookedUnitPriceByCategory: Map<string, number>;
+  changeFlowInitialTicketQtyByCategory: Map<string, number>;
+  changeFlowProtectedReceiptPricing: ChangeFlowProtectedReceiptPricing;
+  subtotal: number;
+  changeFlowProtectedTicketSubtotal: number;
+  feeLineItems: OrderSummaryFeeLine[];
+  changeFlowBookedFeeUnitByNormalizedLabel: Map<string, number>;
+  addOnSelections: AddOnSelection[];
+  addOns: AddOn[];
+  adminCustomReceiptLines: AdminCustomReceiptLine[];
+  quantities: Record<string, number>;
+  flowUi: ChangeBookingFlowProps['flowUi'];
+  isProviderDashboardChange: boolean;
+  isAdmin: boolean;
+  isManualOverrideEligibleLine: (line: { editable: boolean; type?: string; label?: string }) => boolean;
+  pricing: PricingRate[];
+  getPriceBreakdown: GetPriceBreakdown;
+  cancellationPolicyFee: number;
+  hasSelectedCancellationPolicy: boolean;
+  effectiveCancellationPolicyLabel: string;
+  t: (key: string) => string;
+  appliedPromoCode: string | null;
+  productCompanyId?: string | null;
+  envCompanyId?: string | null;
+  productId: string;
+  lockedPromoCode: string | null;
+  originalReceipt: ChangeBookingFlowProps['originalReceipt'];
+  pricingConfig: PricingConfig | null;
+  isTaxIncludedInPrice: boolean;
+  useAdminFeAuthoritativeQuote: boolean;
+  suppressSelfServeCurrencyUi: boolean;
+  selfServePricingConfirmed: boolean;
+  latestServerPriceSummaryLines?: PriceSummaryLine[];
+}
+
+export function useAdminChangePriceSummary({
+  selectedAvailability,
+  selectedReturnOption,
+  currency,
+  totalQuantity,
+  returnPriceAdjustment,
+  isCustomerSelfServeChange,
+  effectiveChangeFlowReturnUnitFloorPerPerson,
+  changeFlowInitialTicketCount,
+  changeFlowReturnPricingRuleA,
+  changeFlowApplyReceiptPaidFloors,
+  ticketLineItems,
+  changeFlowTicketBookedUnitPriceByCategory,
+  changeFlowInitialTicketQtyByCategory,
+  changeFlowProtectedReceiptPricing,
+  subtotal,
+  changeFlowProtectedTicketSubtotal,
+  feeLineItems,
+  changeFlowBookedFeeUnitByNormalizedLabel,
+  addOnSelections,
+  addOns,
+  adminCustomReceiptLines,
+  quantities,
+  flowUi,
+  isProviderDashboardChange,
+  isAdmin,
+  isManualOverrideEligibleLine,
+  pricing,
+  getPriceBreakdown,
+  cancellationPolicyFee,
+  hasSelectedCancellationPolicy,
+  effectiveCancellationPolicyLabel,
+  t,
+  appliedPromoCode,
+  productCompanyId,
+  envCompanyId,
+  productId,
+  lockedPromoCode,
+  originalReceipt,
+  pricingConfig,
+  isTaxIncludedInPrice,
+  useAdminFeAuthoritativeQuote,
+  suppressSelfServeCurrencyUi,
+  selfServePricingConfirmed,
+  latestServerPriceSummaryLines,
+}: UseAdminChangePriceSummaryParams) {
+  const {
+    checkoutReturnLineAmount,
+    ticketLineItemsForChangeFlowDisplay,
+    effectiveSubtotal,
+    adminCustomAdjustmentTotal,
+    effectiveSubtotalForCheckout,
+    feeLineItemsForChangeFlowDisplay,
+    feeLineItemsWithAddOns,
+  } = useAdminChangeProtectedPricing({
+    selectedAvailability,
+    selectedReturnOption,
+    currency,
+    totalQuantity,
+    returnPriceAdjustment,
+    isCustomerSelfServeChange,
+    effectiveChangeFlowReturnUnitFloorPerPerson,
+    changeFlowInitialTicketCount,
+    changeFlowReturnPricingRuleA,
+    changeFlowApplyReceiptPaidFloors,
+    ticketLineItems,
+    changeFlowTicketBookedUnitPriceByCategory,
+    changeFlowInitialTicketQtyByCategory,
+    changeFlowProtectedReceiptPricing,
+    subtotal,
+    changeFlowProtectedTicketSubtotal,
+    feeLineItems,
+    changeFlowBookedFeeUnitByNormalizedLabel,
+    addOnSelections,
+    addOns,
+    adminCustomReceiptLines,
+  });
+
+  const providerPricingUi = flowUi?.providerDashboardChangePricingUi;
+  const providerQuotedLines = useMemo(
+    () => providerPricingUi?.quotedLines ?? [],
+    [providerPricingUi?.quotedLines],
+  );
+  const providerEditableLines = useMemo(
+    () => providerQuotedLines.filter((line) => isManualOverrideEligibleLine(line)),
+    [isManualOverrideEligibleLine, providerQuotedLines],
+  );
+  const showProviderPricingInlineEditor =
+    isProviderDashboardChange &&
+    isAdmin &&
+    (providerPricingUi?.loading || providerPricingUi?.error != null || providerQuotedLines.length > 0);
+
+  const normalizeReceiptLabel = (value: string): string =>
+    value
+      .toLowerCase()
+      .replace(/\([^)]*\)/g, '')
+      .replace(/[^a-z0-9]+/g, '')
+      .trim();
+
+  const providerEditableLineByNormalizedLabel = useMemo(() => {
+    const m = new Map<string, ProviderQuotedLine>();
+    for (const line of providerEditableLines) {
+      const key = normalizeReceiptLabel(line.label ?? '');
+      if (key) m.set(key, line);
+    }
+    return m;
+  }, [providerEditableLines]);
+
+  const checkoutPriceSummaryLines = useMemo((): PriceSummaryLine[] => {
+    if (!selectedAvailability) return [];
+    const returnLineAmount = checkoutReturnLineAmount;
+    const showReturnLine =
+      Boolean(selectedReturnOption) && Math.abs(returnLineAmount) > 0.0005;
+    return [
+      ...ticketLineItemsForChangeFlowDisplay.map((line): PriceSummaryLine => {
+        const rate = pricing.find((r) => r.category === line.category);
+        const breakdown = getPriceBreakdown(
+          line.category,
+          rate?.priceCAD ?? 0,
+          rate?.baseInDisplayCurrency,
+          rate?.appliedAdjustments ?? [],
+        );
+        const normalizedCategory = normalizeReceiptLabel(line.category);
+        return {
+          kind: 'ticket',
+          lineKey: showProviderPricingInlineEditor
+            ? providerEditableLineByNormalizedLabel.get(normalizedCategory)?.lineKey
+            : undefined,
+          editable:
+            showProviderPricingInlineEditor &&
+            providerEditableLineByNormalizedLabel.has(normalizedCategory),
+          category: line.category,
+          qty: line.qty,
+          itemTotal: line.itemTotal,
+          breakdown,
+        };
+      }),
+      ...(showReturnLine
+        ? [
+            {
+              kind: 'line' as const,
+              label: `${t('booking.returnOption')} (${totalQuantity} ${totalQuantity === 1 ? 'person' : 'people'})`,
+              amount: returnLineAmount,
+              type: 'return',
+            },
+          ]
+        : []),
+      ...(cancellationPolicyFee > 0 && hasSelectedCancellationPolicy
+        ? [
+            {
+              kind: 'line' as const,
+              label: effectiveCancellationPolicyLabel,
+              amount: cancellationPolicyFee,
+              type: 'cancellation',
+            },
+          ]
+        : []),
+      ...feeLineItemsWithAddOns.map((fee) => {
+        const isMoraineLakeRoadAccessFee =
+          fee.name.toLowerCase().includes('moraine') &&
+          (fee.name.toLowerCase().includes('access') ||
+            fee.name.toLowerCase().includes('road') ||
+            fee.name.toLowerCase().includes('license'));
+        const isProductFee = feeLineItemsForChangeFlowDisplay.some((f) => f.name === fee.name);
+        const label = isProductFee
+          ? `${fee.name} (${totalQuantity} ${totalQuantity === 1 ? 'person' : 'people'})`
+          : fee.name;
+        const normalizedLabel = normalizeReceiptLabel(label);
+        return {
+          kind: 'line' as const,
+          lineKey: showProviderPricingInlineEditor
+            ? providerEditableLineByNormalizedLabel.get(normalizedLabel)?.lineKey
+            : undefined,
+          editable:
+            showProviderPricingInlineEditor &&
+            providerEditableLineByNormalizedLabel.has(normalizedLabel),
+          label,
+          amount: fee.totalAmount,
+          type: 'fee',
+          tooltip: isMoraineLakeRoadAccessFee
+            ? "Since 2025, Parks Canada charges a per-trip fee for License of Occupation. Based on our capacity, this per-person fee contributes towards Parks Canada's Moraine Lake Road operations."
+            : undefined,
+        };
+      }),
+    ];
+  }, [
+    selectedAvailability,
+    ticketLineItemsForChangeFlowDisplay,
+    pricing,
+    getPriceBreakdown,
+    selectedReturnOption,
+    checkoutReturnLineAmount,
+    totalQuantity,
+    t,
+    cancellationPolicyFee,
+    hasSelectedCancellationPolicy,
+    effectiveCancellationPolicyLabel,
+    feeLineItemsWithAddOns,
+    feeLineItemsForChangeFlowDisplay,
+    showProviderPricingInlineEditor,
+    providerEditableLineByNormalizedLabel,
+  ]);
+
+  const {
+    originalReceiptPromoAdjustment,
+    effectivePromoDiscountAmount,
+    effectivePromoLineType,
+    effectiveTax,
+    totalPrice,
+  } = useAdminChangePromoDiscount({
+    appliedPromoCode,
+    selectedAvailability,
+    totalQuantity,
+    productCompanyId,
+    envCompanyId,
+    productId,
+    currency,
+    quantities,
+    ticketLineItemsForChangeFlowDisplay,
+    feeLineItemsWithAddOns,
+    effectiveSubtotalForCheckout,
+    lockedPromoCode,
+    originalReceipt,
+    isTaxIncludedInPrice,
+    pricingConfig,
+  });
+
+  const checkoutPriceSummaryLinesForCheckout = useMemo(() => {
+    let raw: PriceSummaryLine[];
+    if (!useAdminFeAuthoritativeQuote && suppressSelfServeCurrencyUi && selfServePricingConfirmed) {
+      raw =
+        latestServerPriceSummaryLines && latestServerPriceSummaryLines.length > 0
+          ? latestServerPriceSummaryLines
+          : checkoutPriceSummaryLines;
+    } else {
+      raw = checkoutPriceSummaryLines;
+    }
+    const lines = omitZeroAmountPromoDiscountSummaryLines(raw);
+    const hasPromoSummaryLine = lines.some((line) =>
+      line.kind === 'line' && isPromoDiscountGiftCardOrVoucherLine(line),
+    );
+    if (hasPromoSummaryLine || effectivePromoDiscountAmount < 0.005) return lines;
+    const trimmedPromoCode = appliedPromoCode?.trim() ?? '';
+    const promoLabel =
+      trimmedPromoCode.length > 0
+        ? `Promo: ${trimmedPromoCode}`
+        : originalReceiptPromoAdjustment.label || (t('booking.discount') || 'Discount');
+    return [
+      ...lines,
+      {
+        kind: 'line' as const,
+        label: promoLabel,
+        amount: -effectivePromoDiscountAmount,
+        type: effectivePromoLineType,
+      },
+    ];
+  }, [
+    suppressSelfServeCurrencyUi,
+    selfServePricingConfirmed,
+    useAdminFeAuthoritativeQuote,
+    checkoutPriceSummaryLines,
+    latestServerPriceSummaryLines,
+    effectivePromoDiscountAmount,
+    effectivePromoLineType,
+    appliedPromoCode,
+    originalReceiptPromoAdjustment.label,
+    t,
+  ]);
+
+  const priceSummaryLinesIncludeTaxRow = useMemo(
+    () =>
+      checkoutPriceSummaryLinesForCheckout.some(
+        (line) => line.kind === 'line' && String(line.type ?? '').toUpperCase() === 'TAX',
+      ),
+    [checkoutPriceSummaryLinesForCheckout],
+  );
+
+  const {
+    editableCheckoutPriceSummaryLines,
+    editableSummaryLineAmountInputs,
+    editableSummaryLineLabelInputs,
+    editableSummaryPreSubtotalDelta,
+    editableSummaryPreSubtotalDebugRows,
+    onLineAmountInputChange: handleEditableLineAmountInputChange,
+    onLineAmountInputBlur: handleEditableLineAmountInputBlur,
+    onLineAmountReset: handleEditableLineAmountReset,
+  } = useEditableSummaryLines(checkoutPriceSummaryLinesForCheckout, {
+    enabled: showProviderPricingInlineEditor,
+    onChange: providerPricingUi?.onLineAmountInputChange,
+    onBlur: providerPricingUi?.onLineAmountInputBlur,
+    onReset: providerPricingUi?.onLineAmountReset,
+  });
+
+  const changeFlowNewBookingTotal = resolveChangeFlowNewBookingTotal({
+    cartTotal: totalPrice,
+    originalReceiptTotal: originalReceipt?.total,
+  });
+
+  return {
+    checkoutReturnLineAmount,
+    ticketLineItemsForChangeFlowDisplay,
+    effectiveSubtotal,
+    adminCustomAdjustmentTotal,
+    effectiveSubtotalForCheckout,
+    feeLineItemsForChangeFlowDisplay,
+    feeLineItemsWithAddOns,
+    providerPricingUi,
+    providerQuotedLines,
+    showProviderPricingInlineEditor,
+    checkoutPriceSummaryLines,
+    originalReceiptPromoAdjustment,
+    effectivePromoDiscountAmount,
+    effectivePromoLineType,
+    effectiveTax,
+    totalPrice,
+    checkoutPriceSummaryLinesForCheckout,
+    priceSummaryLinesIncludeTaxRow,
+    editableCheckoutPriceSummaryLines,
+    editableSummaryLineAmountInputs,
+    editableSummaryLineLabelInputs,
+    editableSummaryPreSubtotalDelta,
+    editableSummaryPreSubtotalDebugRows,
+    handleEditableLineAmountInputChange,
+    handleEditableLineAmountInputBlur,
+    handleEditableLineAmountReset,
+    changeFlowNewBookingTotal,
+  };
+}