@bash-app/bash-common 30.235.0 → 30.237.0

package/src/utils/service/offerAllowListUtils.ts

@@ -0,0 +1,81 @@
+/**
+ * Phase 4 of the unified-pricing roadmap — host-side pricing-model allow-list
+ * validation.
+ *
+ * Each vertical request entity (`VendorBookingRequest`,
+ * `ExhibitorBookingRequest`, `SponsorBookingRequest`) carries an optional
+ * `pricingModelAllowList String[]`. When empty, the host hasn't restricted
+ * anything and providers may bid in any of their supported models. When
+ * non-empty, providers can only bid in models that appear in the list.
+ *
+ * Pure function so the wizard, api validators, and offer-suggestion AI all
+ * share one rule.
+ */
+import type { PricingModel } from "@prisma/client";
+
+export type AllowListValidation =
+  | { ok: true }
+  | {
+      ok: false;
+      reason: string;
+      offered: PricingModel | string;
+      allowList: ReadonlyArray<string>;
+    };
+
+/**
+ * Returns `{ ok: true }` if either:
+ *   - the allow-list is empty / null (host has no restriction), or
+ *   - the offered model appears in the allow-list.
+ *
+ * Otherwise returns `{ ok: false }` with a friendly reason suitable for
+ * surfacing in the SendOfferSheet error region.
+ */
+export function validateOfferAgainstAllowList(args: {
+  offered: PricingModel | string | null | undefined;
+  allowList: ReadonlyArray<string> | null | undefined;
+}): AllowListValidation {
+  if (!args.offered) {
+    return {
+      ok: false,
+      reason: "Offer is missing a pricing model.",
+      offered: "",
+      allowList: args.allowList ?? [],
+    };
+  }
+  const list = args.allowList ?? [];
+  if (list.length === 0) {
+    return { ok: true };
+  }
+  if (list.includes(args.offered)) {
+    return { ok: true };
+  }
+  return {
+    ok: false,
+    reason: `Host accepts bids priced as ${list.join(
+      ", "
+    )}. ${args.offered} is not on the list.`,
+    offered: args.offered,
+    allowList: list,
+  };
+}
+
+/**
+ * Per-vertical sensible defaults for what a wizard should pre-check in the
+ * "I'll consider bids priced as…" group when the host hasn't customized.
+ * Used by Phase 4 wizard sections; safe to share with the AI service so its
+ * suggestions match the wizard's defaults.
+ */
+export const DEFAULT_PRICING_MODEL_ALLOW_LIST_BY_SERVICE_TYPE: Record<
+  string,
+  ReadonlyArray<PricingModel>
+> = {
+  // Strings match the Prisma `ServiceTypes` enum values (see schema.prisma).
+  Vendors: ["FLAT_FEE", "PRODUCT_SALES_PERCENTAGE"],
+  Exhibitors: ["FLAT_FEE"],
+  Sponsors: ["TIERED", "FLAT_FEE"],
+  Venues: ["FLAT_FEE", "TICKET_REVENUE_PERCENTAGE"],
+  EntertainmentServices: ["HOURLY", "FLAT_FEE"],
+  EventServices: ["FLAT_FEE", "PER_ATTENDEE"],
+  Volunteers: ["FLAT_FEE"],
+  Organizations: ["FLAT_FEE"],
+};

package/src/utils/service/offerComparisonUtils.ts

@@ -0,0 +1,197 @@
+/**
+ * Phase 5 of the unified-pricing roadmap — pure projection of a `ServiceBookingOffer`
+ * candidate into expected / worst-case / best-case totals (in cents).
+ *
+ * Used by:
+ *   - the offer-suggestion AI to return one suggestion per allowed model with
+ *     bands the host can compare side-by-side,
+ *   - the SendOfferSheet preview row that renders the same bands,
+ *   - the api validator that double-checks an accepted offer against the
+ *     host's expected attendees and any host-side caps.
+ *
+ * Heuristics for `worstCaseCents` / `bestCaseCents`:
+ *   - `FLAT_FEE` / `HOURLY` / `PER_DAY` / `CUSTOM` — all three bands equal the
+ *     expected total (no variability).
+ *   - `PER_ATTENDEE` / `PER_PAID_ATTENDEE` — worst case = floor (minimumQuantity
+ *     * baseRateCents, capped by minimumChargeCents); best case = capped to
+ *     `maxBillableCents` when present, else `expectedAttendees * 1.5`.
+ *   - `PER_BASHPOINTS_ATTENDEE` — same shape but in BashPoints, so we surface
+ *     `expectedTotalBp` and the USD bands return null.
+ *   - `TICKET_REVENUE_PERCENTAGE` / `PRODUCT_SALES_PERCENTAGE` — caller passes
+ *     an `expectedBasisCents` (usually the bash's projected ticket revenue or
+ *     vendor gross sales). Worst case = 0 if pre-sale, best case = basis * pct.
+ *   - `TIERED` — worst case = lowest tier price, best case = highest tier
+ *     price; expected resolves via the supplied `tieredExpectedTierCents`.
+ */
+import type { PricingModel } from "@prisma/client";
+
+export interface OfferComparisonInput {
+  pricingModel: PricingModel | string;
+  baseRateCents?: number | null;
+  baseRateBashPoints?: number | null;
+  minimumChargeCents?: number | null;
+  minimumQuantity?: number | null;
+  maxBillableCents?: number | null;
+  /** Bash's expectedAttendees at offer time. */
+  expectedAttendees?: number | null;
+  /** Optional expected basis for revenue-share models. */
+  expectedBasisCents?: number | null;
+  /** Percentage (0..100) for revenue-share models. */
+  percentage?: number | null;
+  /** Pre-resolved expected total for TIERED (already chosen tier). */
+  tieredExpectedTierCents?: number | null;
+  tieredLowestTierCents?: number | null;
+  tieredHighestTierCents?: number | null;
+  /** Optional flat amount the caller already computed (e.g. from priceToBook). */
+  flatRateCents?: number | null;
+}
+
+export interface OfferComparisonResult {
+  /** Most-likely total in USD cents. `null` for BashPoints-only models. */
+  expectedTotalCents: number | null;
+  /** Worst case in USD cents the host could end up owing (or null for BP). */
+  worstCaseCents: number | null;
+  /** Best case for the host (cheapest plausible total). */
+  bestCaseCents: number | null;
+  /** Same triple in BashPoints when the model settles in BP. */
+  expectedTotalBp: number | null;
+  worstCaseBp: number | null;
+  bestCaseBp: number | null;
+  /**
+   * Plain-English tradeoff sentence to surface next to the bands. AI may
+   * override with its own copy; this is a deterministic fallback.
+   */
+  reasoning: string;
+}
+
+function nn(v: number | null | undefined): number {
+  return v == null || !Number.isFinite(v) || v <= 0 ? 0 : Math.round(v);
+}
+
+function fmt(cents: number): string {
+  return `$${(cents / 100).toFixed(0)}`;
+}
+
+/**
+ * Project an offer candidate into expected / worst / best totals.
+ * Returns sensible-but-defensive defaults if the input model is unknown.
+ */
+export function computeOfferComparisonBands(
+  input: OfferComparisonInput
+): OfferComparisonResult {
+  const expected = nn(input.expectedAttendees);
+  const minQty = nn(input.minimumQuantity);
+
+  switch (input.pricingModel) {
+    case "FLAT_FEE":
+    case "HOURLY":
+    case "PER_DAY":
+    case "CUSTOM": {
+      const total =
+        nn(input.flatRateCents) || nn(input.baseRateCents) || 0;
+      return {
+        expectedTotalCents: total,
+        worstCaseCents: total,
+        bestCaseCents: total,
+        expectedTotalBp: null,
+        worstCaseBp: null,
+        bestCaseBp: null,
+        reasoning:
+          total > 0
+            ? `Fixed price: you pay ${fmt(total)} regardless of turnout.`
+            : "Fixed price — provider has not set a rate.",
+      };
+    }
+
+    case "PER_ATTENDEE":
+    case "PER_PAID_ATTENDEE": {
+      const rate = nn(input.baseRateCents);
+      const expectedTotal = expected * rate;
+      const floor = Math.max(
+        nn(input.minimumChargeCents),
+        minQty * rate
+      );
+      const worst = Math.max(expectedTotal, floor);
+      const ceiling =
+        nn(input.maxBillableCents) ||
+        Math.max(expectedTotal, Math.round(expected * rate * 1.5));
+      const best = Math.max(floor, 0);
+      return {
+        expectedTotalCents: expectedTotal,
+        worstCaseCents: ceiling,
+        bestCaseCents: best,
+        expectedTotalBp: null,
+        worstCaseBp: null,
+        bestCaseBp: null,
+        reasoning: `Per-${input.pricingModel === "PER_PAID_ATTENDEE" ? "paid-" : ""}attendee: expected ${fmt(
+          expectedTotal
+        )} at ${expected} guests, with a floor of ${fmt(floor)} and a host cap of ${fmt(ceiling)}.`,
+      };
+    }
+
+    case "PER_BASHPOINTS_ATTENDEE": {
+      const rate = nn(input.baseRateBashPoints);
+      const expectedTotalBp = expected * rate;
+      const floorBp = minQty * rate;
+      const worstBp = Math.max(expectedTotalBp, floorBp);
+      const bestBp = Math.max(floorBp, 0);
+      return {
+        expectedTotalCents: null,
+        worstCaseCents: null,
+        bestCaseCents: null,
+        expectedTotalBp,
+        worstCaseBp: worstBp,
+        bestCaseBp: bestBp,
+        reasoning: `Per-attendee BashPoints: expected ${expectedTotalBp} BP at ${expected} guests, floor ${floorBp} BP.`,
+      };
+    }
+
+    case "TICKET_REVENUE_PERCENTAGE":
+    case "PRODUCT_SALES_PERCENTAGE": {
+      const basis = nn(input.expectedBasisCents);
+      const pct = Math.max(0, Math.min(100, input.percentage ?? 0));
+      const expectedTotal = Math.round((basis * pct) / 100);
+      return {
+        expectedTotalCents: expectedTotal,
+        worstCaseCents: 0,
+        bestCaseCents: expectedTotal,
+        expectedTotalBp: null,
+        worstCaseBp: null,
+        bestCaseBp: null,
+        reasoning: `Revenue share: provider takes ${pct}% of ${fmt(
+          basis
+        )} projected. Worst case for you (slow night, no revenue): $0.`,
+      };
+    }
+
+    case "TIERED": {
+      const exp = nn(input.tieredExpectedTierCents);
+      const low = nn(input.tieredLowestTierCents);
+      const high = nn(input.tieredHighestTierCents);
+      return {
+        expectedTotalCents: exp || low || high || 0,
+        worstCaseCents: high || exp || low,
+        bestCaseCents: low || exp || high,
+        expectedTotalBp: null,
+        worstCaseBp: null,
+        bestCaseBp: null,
+        reasoning: `Tiered: from ${fmt(low)} to ${fmt(
+          high
+        )} depending on the tier you pick.`,
+      };
+    }
+
+    default: {
+      const fallback = nn(input.flatRateCents) || nn(input.baseRateCents);
+      return {
+        expectedTotalCents: fallback,
+        worstCaseCents: fallback,
+        bestCaseCents: fallback,
+        expectedTotalBp: null,
+        worstCaseBp: null,
+        bestCaseBp: null,
+        reasoning: `Unrecognized pricing model "${input.pricingModel}" — treated as flat.`,
+      };
+    }
+  }
+}

package/src/utils/service/serviceBookingExposureUtils.ts

@@ -0,0 +1,218 @@
+/**
+ * Phase 0 adoption guardrails — aggregate cost exposure for a bash's service
+ * bookings. Pure functions so the api endpoint (Prisma query, then this util)
+ * and bash-app (display) share one source of truth.
+ *
+ * Each booking resolves to:
+ *   - `expectedCents` — the most-likely total at expected attendance.
+ *   - `worstCaseCents` — the dollar ceiling if the host's caps trip. For flat
+ *     models this equals `expectedCents` (no variance). For variable models it
+ *     equals `maxBillableCents` if set; otherwise `1.5x expected` (matches the
+ *     `defaultMaxBillableCents` heuristic in `billingCapUtils.ts`).
+ *
+ * Forward-looking: the input shape uses the unified pricing block fields
+ * (`pricingModel`, `baseRateCents`, etc.). Phase 1 adds them to every subtype;
+ * Phase 0 callers passing in `pricingModel: null` for legacy bookings still get
+ * a sensible flat-fee fallback.
+ */
+
+import {
+  DEFAULT_MAX_BILLABLE_MULTIPLIER,
+  isFlatPricingModel,
+} from "./billingCapUtils";
+
+/**
+ * Pricing-model strings recognized by the exposure util. Stays a string
+ * literal (not the Prisma enum) so this util compiles for the browser bundle.
+ */
+export const KNOWN_VARIABLE_PRICING_MODELS = [
+  "PER_ATTENDEE",
+  "PER_PAID_ATTENDEE",
+  "PER_BASHPOINTS_ATTENDEE",
+  "TICKET_REVENUE_PERCENTAGE",
+  "PRODUCT_SALES_PERCENTAGE",
+  "TIERED",
+  "CUSTOM",
+] as const;
+
+export interface ServiceBookingExposureInput {
+  bookingId: string;
+  /** Display label (e.g. service name). Echoed back for UI. */
+  label: string;
+  /**
+   * The pricing model from the booked service's subtype, if known. Phase 0
+   * bookings that predate the unified block pass `null` — exposure falls
+   * back to flat-rate math.
+   */
+  pricingModel?: string | null;
+  /**
+   * Per-unit rate the booking is priced at. Cents-per-attendee for
+   * PER_ATTENDEE; cents-per-hour for HOURLY; etc. Optional fallback.
+   */
+  baseRateCents?: number | null;
+  /**
+   * Expected attendance at booking time (snapshot from
+   * `bashEvent.expectedAttendees`).
+   */
+  expectedAttendeesAtBooking?: number | null;
+  /** Host-set ceiling on billable check-ins for PER_ATTENDEE bookings. */
+  maxAttendeesAttributable?: number | null;
+  /**
+   * Phase 0 soft cap: host-set per-booking dollar ceiling. Overrides the
+   * 1.5x worst-case heuristic when set.
+   */
+  maxBillableCents?: number | null;
+  /**
+   * The booking's grand total (cents) when it was confirmed — used as the
+   * fallback "expected" amount for non-variable bookings whose pricing model
+   * isn't yet tracked. Mirrors `ServiceBooking.totalATBCents`.
+   */
+  totalATBCents?: number | null;
+  /**
+   * Optional flat-rate snapshot (`ServiceBooking.flatRateCents`). Used as a
+   * narrow fallback when both `pricingModel` and `totalATBCents` are missing.
+   */
+  flatRateCents?: number | null;
+}
+
+export interface ServiceBookingExposure {
+  bookingId: string;
+  label: string;
+  pricingModel: string | null;
+  isVariable: boolean;
+  /** Most likely total (cents). */
+  expectedCents: number;
+  /** Worst-case total (cents) the host might owe if the cap trips. */
+  worstCaseCents: number;
+}
+
+export interface AggregateExposureSummary {
+  /** Sum of `expectedCents` across all bookings (cents). */
+  projectedTotalCents: number;
+  /** Sum of `worstCaseCents` across all bookings (cents). */
+  worstCaseTotalCents: number;
+  /**
+   * Per-booking breakdown — preserves input order so callers can render rows
+   * alongside the booking list without re-sorting.
+   */
+  byBooking: ServiceBookingExposure[];
+}
+
+/**
+ * Returns `true` for any pricing model whose total depends on event-day
+ * variables (attendance, revenue, etc.).
+ */
+export function isVariablePricingModel(
+  model: string | null | undefined
+): boolean {
+  if (!model) return false;
+  if (isFlatPricingModel(model)) return false;
+  return (KNOWN_VARIABLE_PRICING_MODELS as readonly string[]).includes(model);
+}
+
+/**
+ * Resolve one booking's exposure (expected + worst case). Pure.
+ *
+ * Decision matrix:
+ * - PER_ATTENDEE / PER_PAID_ATTENDEE:
+ *     expected = expectedAttendees * baseRateCents
+ *     worst    = maxBillableCents ?? maxAttendeesAttributable * baseRateCents
+ *                 ?? expected * 1.5
+ * - PER_BASHPOINTS_ATTENDEE: same shape but reported in cents-of-BP-equivalent.
+ *     Caller should treat this booking's contribution as informational only;
+ *     `expectedCents`/`worstCaseCents` reflect BP units, not dollars.
+ * - TICKET_REVENUE_PERCENTAGE / PRODUCT_SALES_PERCENTAGE / TIERED / CUSTOM:
+ *     expected = totalATBCents ?? 0
+ *     worst    = maxBillableCents ?? expected * 1.5 (variance unknown without
+ *                 settlement basis math — see Phase 2 for venue rev-share).
+ * - FLAT_FEE / HOURLY / PER_DAY (or null pricingModel): flat → expected = worst.
+ */
+export function computeServiceBookingExposure(
+  input: ServiceBookingExposureInput
+): ServiceBookingExposure {
+  const flatFallback =
+    input.totalATBCents ?? input.flatRateCents ?? 0;
+
+  const variable = isVariablePricingModel(input.pricingModel);
+
+  if (!variable) {
+    return {
+      bookingId: input.bookingId,
+      label: input.label,
+      pricingModel: input.pricingModel ?? null,
+      isVariable: false,
+      expectedCents: Math.max(0, flatFallback),
+      worstCaseCents: Math.max(0, flatFallback),
+    };
+  }
+
+  const expectedAttendees = Math.max(
+    0,
+    Math.floor(input.expectedAttendeesAtBooking ?? 0)
+  );
+  const baseRate = Math.max(0, Math.floor(input.baseRateCents ?? 0));
+
+  // For attendee-driven models, expected = N * rate.
+  const isAttendeeDriven =
+    input.pricingModel === "PER_ATTENDEE" ||
+    input.pricingModel === "PER_PAID_ATTENDEE" ||
+    input.pricingModel === "PER_BASHPOINTS_ATTENDEE";
+
+  let expected: number;
+  if (isAttendeeDriven) {
+    expected = expectedAttendees * baseRate;
+  } else {
+    // Revenue-share / tiered / custom — totalATBCents is the most we know.
+    expected = Math.max(0, flatFallback);
+  }
+
+  // Worst case prefers the explicit `maxBillableCents` snapshot, then the
+  // attendee ceiling math, then a 1.5x fallback.
+  let worst: number;
+  if (input.maxBillableCents != null && input.maxBillableCents > 0) {
+    worst = input.maxBillableCents;
+  } else if (
+    isAttendeeDriven &&
+    input.maxAttendeesAttributable != null &&
+    input.maxAttendeesAttributable > 0
+  ) {
+    worst = input.maxAttendeesAttributable * baseRate;
+  } else if (expected > 0) {
+    worst = Math.ceil(expected * DEFAULT_MAX_BILLABLE_MULTIPLIER);
+  } else {
+    worst = 0;
+  }
+
+  // Sanity: worst should never be below expected.
+  worst = Math.max(worst, expected);
+
+  return {
+    bookingId: input.bookingId,
+    label: input.label,
+    pricingModel: input.pricingModel ?? null,
+    isVariable: true,
+    expectedCents: expected,
+    worstCaseCents: worst,
+  };
+}
+
+/**
+ * Sum a list of booking exposures into the host-facing summary used by
+ * the budget step's projected-cost and worst-case lines.
+ */
+export function summarizeServiceBookingExposures(
+  inputs: ServiceBookingExposureInput[]
+): AggregateExposureSummary {
+  const byBooking = inputs.map(computeServiceBookingExposure);
+  let projected = 0;
+  let worstCase = 0;
+  for (const row of byBooking) {
+    projected += row.expectedCents;
+    worstCase += row.worstCaseCents;
+  }
+  return {
+    projectedTotalCents: projected,
+    worstCaseTotalCents: worstCase,
+    byBooking,
+  };
+}

package/src/utils/service/serviceBookingTypes.ts

@@ -63,6 +63,10 @@ export type ServiceBookingRequiredData = MakeNullablePropsOptional<
     | "creatorId"
     | "creator"
     | "checkout"
+    // Event Promoter settlement fields — DB applies defaults at creation,
+    // so callers building a new booking shape may omit them.
+    | "settlementStatus"
+    | "settlementAttempts"
   >
 >;
 

package/src/utils/service/serviceUtils.ts

@@ -1,9 +1,6 @@
-import {
-  Service,
-  ServiceCancellationPolicy as ServiceCancellationPolicyOption,
-  ServiceSubscriptionStatus,
-  ServiceTypes,
-} from "@prisma/client";
+import { Service, ServiceSubscriptionStatus, ServiceTypes } from "@prisma/client";
+import type { ServiceCancellationPolicy as ServiceCancellationPolicyOption } from "@prisma/client";
+import { ServiceCancellationPolicy } from "../../mirroredPrismaEnums.js";
 import {
   ServiceExt,
   ServiceExtNoIds,
@@ -27,12 +24,12 @@ export type ServiceCancellationPolicyMap = {
 };
 
 export const SERVICE_CANCELLATION_POLICY_DATA: ServiceCancellationPolicyMap = {
-  [ServiceCancellationPolicyOption.None]: {
+  [ServiceCancellationPolicy.None]: {
     name: "None",
     refundPolicy: [],
     description: "No cancellation policy.",
   },
-  [ServiceCancellationPolicyOption.VeryFlexible]: {
+  [ServiceCancellationPolicy.VeryFlexible]: {
     name: "Very Flexible",
     refundPolicy: [
       {
@@ -41,7 +38,7 @@ export const SERVICE_CANCELLATION_POLICY_DATA: ServiceCancellationPolicyMap = {
       },
     ],
   },
-  [ServiceCancellationPolicyOption.Flexible]: {
+  [ServiceCancellationPolicy.Flexible]: {
     name: "Flexible",
     refundPolicy: [
       {
@@ -54,7 +51,7 @@ export const SERVICE_CANCELLATION_POLICY_DATA: ServiceCancellationPolicyMap = {
       },
     ],
   },
-  [ServiceCancellationPolicyOption.Standard30Day]: {
+  [ServiceCancellationPolicy.Standard30Day]: {
     name: "Standard 30 Day",
     refundPolicy: [
       {
@@ -67,7 +64,7 @@ export const SERVICE_CANCELLATION_POLICY_DATA: ServiceCancellationPolicyMap = {
       },
     ],
   },
-  [ServiceCancellationPolicyOption.Standard90Day]: {
+  [ServiceCancellationPolicy.Standard90Day]: {
     name: "Standard 90 Day",
     refundPolicy: [
       {
@@ -81,7 +78,7 @@ export const SERVICE_CANCELLATION_POLICY_DATA: ServiceCancellationPolicyMap = {
     ],
   },
   // Vendor-specific policies (vendor pays host, different language needed)
-  [ServiceCancellationPolicyOption.VendorFlexible]: {
+  [ServiceCancellationPolicy.VendorFlexible]: {
     name: "Vendor Flexible",
     refundPolicy: [
       {
@@ -95,7 +92,7 @@ export const SERVICE_CANCELLATION_POLICY_DATA: ServiceCancellationPolicyMap = {
     ],
     description: "Flexible policy for vendor bookings",
   },
-  [ServiceCancellationPolicyOption.VendorStandard]: {
+  [ServiceCancellationPolicy.VendorStandard]: {
     name: "Vendor Standard",
     refundPolicy: [
       {
@@ -109,7 +106,7 @@ export const SERVICE_CANCELLATION_POLICY_DATA: ServiceCancellationPolicyMap = {
     ],
     description: "Standard policy for vendor bookings",
   },
-  [ServiceCancellationPolicyOption.VendorStrict]: {
+  [ServiceCancellationPolicy.VendorStrict]: {
     name: "Vendor Strict",
     refundPolicy: [
       {
@@ -124,7 +121,7 @@ export const SERVICE_CANCELLATION_POLICY_DATA: ServiceCancellationPolicyMap = {
     description: "Strict policy for vendor bookings with longer notice periods",
   },
   // Exhibitor / Sponsor: same tier math as vendor; separate enum + copy for role clarity
-  [ServiceCancellationPolicyOption.ExhibitorFlexible]: {
+  [ServiceCancellationPolicy.ExhibitorFlexible]: {
     name: "Exhibitor Flexible",
     refundPolicy: [
       {
@@ -138,7 +135,7 @@ export const SERVICE_CANCELLATION_POLICY_DATA: ServiceCancellationPolicyMap = {
     ],
     description: "Flexible policy for exhibitor bookings",
   },
-  [ServiceCancellationPolicyOption.ExhibitorStandard]: {
+  [ServiceCancellationPolicy.ExhibitorStandard]: {
     name: "Exhibitor Standard",
     refundPolicy: [
       {
@@ -152,7 +149,7 @@ export const SERVICE_CANCELLATION_POLICY_DATA: ServiceCancellationPolicyMap = {
     ],
     description: "Standard policy for exhibitor bookings",
   },
-  [ServiceCancellationPolicyOption.ExhibitorStrict]: {
+  [ServiceCancellationPolicy.ExhibitorStrict]: {
     name: "Exhibitor Strict",
     refundPolicy: [
       {
@@ -166,7 +163,7 @@ export const SERVICE_CANCELLATION_POLICY_DATA: ServiceCancellationPolicyMap = {
     ],
     description: "Strict policy for exhibitor bookings",
   },
-  [ServiceCancellationPolicyOption.SponsorFlexible]: {
+  [ServiceCancellationPolicy.SponsorFlexible]: {
     name: "Sponsor Flexible",
     refundPolicy: [
       {
@@ -180,7 +177,7 @@ export const SERVICE_CANCELLATION_POLICY_DATA: ServiceCancellationPolicyMap = {
     ],
     description: "Flexible policy for sponsorship bookings",
   },
-  [ServiceCancellationPolicyOption.SponsorStandard]: {
+  [ServiceCancellationPolicy.SponsorStandard]: {
     name: "Sponsor Standard",
     refundPolicy: [
       {
@@ -194,7 +191,7 @@ export const SERVICE_CANCELLATION_POLICY_DATA: ServiceCancellationPolicyMap = {
     ],
     description: "Standard policy for sponsorship bookings",
   },
-  [ServiceCancellationPolicyOption.SponsorStrict]: {
+  [ServiceCancellationPolicy.SponsorStrict]: {
     name: "Sponsor Strict",
     refundPolicy: [
       {
@@ -376,7 +373,7 @@ Object.keys(SERVICE_CANCELLATION_POLICY_DATA)
   .filter(
     (policyKey) =>
       (policyKey as ServiceCancellationPolicyOption) !=
-      ServiceCancellationPolicyOption.None
+      ServiceCancellationPolicy.None
   )
   .forEach((policyKey) => {
     const policy =