@bash-app/bash-common 30.432.0 → 30.433.0

package/src/__tests__/promoCartEngine.test.ts

@@ -0,0 +1,201 @@
+import {
+  allocateAcrossTickets,
+  allocateProportionally,
+  resolvePromoForCart,
+  type PromoCartLine,
+} from "../promoCartEngine.js";
+
+const now = new Date("2026-10-14T12:00:00Z");
+
+const earlyBird: PromoCartLine = { ticketTierId: "early", pricing: "USD", quantity: 2, cashSubtotalCents: 2000, pointsSubtotal: 0 };
+const regular: PromoCartLine = { ticketTierId: "regular", pricing: "USD", quantity: 1, cashSubtotalCents: 2500, pointsSubtotal: 0 };
+const vip: PromoCartLine = { ticketTierId: "vip", pricing: "USD", quantity: 1, cashSubtotalCents: 7500, pointsSubtotal: 0 };
+const points: PromoCartLine = { ticketTierId: "points", pricing: "BASHPOINTS", quantity: 2, cashSubtotalCents: 0, pointsSubtotal: 1000 };
+const free: PromoCartLine = { ticketTierId: "free", pricing: "FREE", quantity: 3, cashSubtotalCents: 0, pointsSubtotal: 0 };
+
+describe("allocateProportionally", () => {
+  it("splits by weight, flooring, with leftover to the largest line then tier id", () => {
+    const result = allocateProportionally(1000, [
+      { key: "b", weight: 1000 },
+      { key: "a", weight: 1000 },
+      { key: "c", weight: 1000 },
+    ]);
+    expect([...result.entries()].sort()).toEqual([["a", 334], ["b", 333], ["c", 333]]);
+  });
+
+  it("gives leftover cents to the largest line first", () => {
+    const result = allocateProportionally(1001, [
+      { key: "small", weight: 1000 },
+      { key: "big", weight: 3000 },
+    ]);
+    expect(result.get("big")).toBe(751);
+    expect(result.get("small")).toBe(250);
+  });
+
+  it("never allocates more than the eligible total", () => {
+    const result = allocateProportionally(9999, [{ key: "a", weight: 500 }]);
+    expect(result.get("a")).toBe(500);
+  });
+});
+
+describe("allocateAcrossTickets", () => {
+  it("splits evenly with leftover cents to the lowest ticket ids, summing exactly", () => {
+    const result = allocateAcrossTickets(1001, ["t3", "t1", "t2"]);
+    expect([...result.entries()]).toEqual([["t1", 334], ["t2", 334], ["t3", 333]]);
+    expect([...result.values()].reduce((s, v) => s + v, 0)).toBe(1001);
+  });
+});
+
+describe("resolvePromoForCart", () => {
+  it("attribution-only (NONE) on all tiers counts cash, BashPoints, and free tickets with no discount", () => {
+    const result = resolvePromoForCart({
+      promo: { eligibilityMode: "ALL_TIERS", discountType: "NONE" },
+      cartLines: [earlyBird, points, free],
+      now,
+    });
+    expect(result.status).toBe("applied");
+    expect(result.cashDiscountTotalCents).toBe(0);
+    expect(result.pointsDiscountTotal).toBe(0);
+    expect(result.attributedTicketCount).toBe(7);
+  });
+
+  it("attributes cash, hybrid, BashPoints-only, and free lines, including a tier added later, with a 0 guest discount", () => {
+    const hybrid: PromoCartLine = {
+      ticketTierId: "hybrid",
+      pricing: "USD",
+      quantity: 1,
+      cashSubtotalCents: 3000,
+      pointsSubtotal: 100,
+    };
+    const addedLater: PromoCartLine = {
+      ticketTierId: "tier_added_later",
+      pricing: "USD",
+      quantity: 4,
+      cashSubtotalCents: 4000,
+      pointsSubtotal: 0,
+    };
+    const result = resolvePromoForCart({
+      promo: { eligibilityMode: "ALL_TIERS", discountType: "NONE" },
+      cartLines: [earlyBird, hybrid, points, free, addedLater],
+      now,
+    });
+    expect(result.status).toBe("applied");
+    expect(result.cashDiscountTotalCents).toBe(0);
+    expect(result.pointsDiscountTotal).toBe(0);
+    expect(result.lines.map((line) => [line.ticketTierId, line.eligible, line.attributedTicketCount])).toEqual([
+      ["early", true, 2],
+      ["hybrid", true, 1],
+      ["points", true, 2],
+      ["free", true, 3],
+      ["tier_added_later", true, 4],
+    ]);
+    expect(result.attributedTicketCount).toBe(12);
+  });
+
+  it("percentage on selected tiers discounts only those cash lines", () => {
+    const result = resolvePromoForCart({
+      promo: {
+        eligibilityMode: "SELECTED_TIERS",
+        eligibleTiers: [{ ticketTierId: "regular" }, { ticketTierId: "vip" }],
+        discountType: "PERCENT",
+        discountAmountPercentage: 10,
+      },
+      cartLines: [earlyBird, regular, vip],
+      now,
+    });
+    expect(result.lines.map((l) => [l.ticketTierId, l.cashDiscountCents])).toEqual([
+      ["early", 0],
+      ["regular", 250],
+      ["vip", 750],
+    ]);
+    expect(result.attributedTicketCount).toBe(2);
+  });
+
+  it("percentage leaves BashPoints alone unless the host opts in", () => {
+    const off = resolvePromoForCart({
+      promo: { eligibilityMode: "ALL_TIERS", discountAmountPercentage: 20 },
+      cartLines: [points],
+      now,
+    });
+    expect(off.pointsDiscountTotal).toBe(0);
+    expect(off.attributedTicketCount).toBe(2);
+
+    const on = resolvePromoForCart({
+      promo: { eligibilityMode: "ALL_TIERS", discountAmountPercentage: 20, discountAppliesToBashPoints: true },
+      cartLines: [points],
+      now,
+    });
+    expect(on.pointsDiscountTotal).toBe(200);
+    expect(on.lines[0].finalPoints).toBe(800);
+  });
+
+  it("fixed cash applies once per order across eligible cash lines, never to points", () => {
+    const result = resolvePromoForCart({
+      promo: { eligibilityMode: "ALL_TIERS", discountType: "FIXED_CASH", discountAmountInCents: 1000 },
+      cartLines: [earlyBird, regular, points],
+      now,
+    });
+    expect(result.cashDiscountTotalCents).toBe(1000);
+    expect(result.pointsDiscountTotal).toBe(0);
+    const byTier = Object.fromEntries(result.lines.map((l) => [l.ticketTierId, l.cashDiscountCents]));
+    expect(byTier).toEqual({ early: 444, regular: 556, points: 0 });
+  });
+
+  it("caps a fixed discount at the eligible cash total and floors totals at 0", () => {
+    const result = resolvePromoForCart({
+      promo: { eligibilityMode: "ALL_TIERS", discountAmountInCents: 99999 },
+      cartLines: [regular],
+      now,
+    });
+    expect(result.lines[0].finalCashCents).toBe(0);
+    expect(result.cashDiscountTotalCents).toBe(2500);
+  });
+
+  it("caps a percentage above 100 at the line price", () => {
+    const result = resolvePromoForCart({
+      promo: { ticketTierId: "regular", discountAmountPercentage: 150 },
+      cartLines: [regular],
+      now,
+    });
+    expect(result.lines[0].cashDiscountCents).toBe(2500);
+  });
+
+  it("a legacy single-tier code keeps today's total: whole discount on its one line", () => {
+    const result = resolvePromoForCart({
+      promo: { ticketTierId: "regular", discountAmountInCents: 500 },
+      cartLines: [earlyBird, regular],
+      now,
+    });
+    expect(result.cashDiscountTotalCents).toBe(500);
+    expect(result.lines.find((l) => l.ticketTierId === "regular")?.cashDiscountCents).toBe(500);
+  });
+
+  it("an all-tiers code covers a tier added after the code was created", () => {
+    const result = resolvePromoForCart({
+      promo: { eligibilityMode: "ALL_TIERS", discountAmountPercentage: 10 },
+      cartLines: [{ ...regular, ticketTierId: "added_later" }],
+      now,
+    });
+    expect(result.lines[0].eligible).toBe(true);
+  });
+
+  it("reports not_applicable, expired, and disabled", () => {
+    expect(
+      resolvePromoForCart({ promo: { ticketTierId: "vip" }, cartLines: [regular], now }).status
+    ).toBe("not_applicable");
+    expect(
+      resolvePromoForCart({
+        promo: { eligibilityMode: "ALL_TIERS", redeemBy: new Date("2026-10-01") },
+        cartLines: [regular],
+        now,
+      }).status
+    ).toBe("expired");
+    expect(
+      resolvePromoForCart({
+        promo: { eligibilityMode: "ALL_TIERS", disabledAt: now },
+        cartLines: [regular],
+        now,
+      }).status
+    ).toBe("disabled");
+  });
+});

package/src/__tests__/promoCodeRedemption.test.ts

@@ -0,0 +1,134 @@
+import {
+  evaluatePromoRedeemability,
+  isPromoCodeRejectReason,
+  normalizePromoRedemptionEmail,
+  pickPromoCodeAmongDuplicates,
+  PROMO_CODE_REJECT_MESSAGES,
+  PROMO_CODE_REJECT_REASONS,
+  type PromoCodeDuplicateCandidate,
+} from "../promoCodeRedemption.js";
+
+const now = new Date("2026-10-14T12:00:00Z");
+
+function base(overrides: Partial<Parameters<typeof evaluatePromoRedeemability>[0]> = {}) {
+  return {
+    redeemBy: null,
+    disabledAt: null,
+    maxRedemptions: null,
+    maxUsesPerAccount: null,
+    activeOrderCount: 0,
+    accountOrderCount: 0,
+    now,
+    ...overrides,
+  };
+}
+
+describe("evaluatePromoRedeemability", () => {
+  it("allows a code with no limits", () => {
+    expect(evaluatePromoRedeemability(base())).toBeNull();
+  });
+
+  it("rejects a disabled code before anything else", () => {
+    expect(
+      evaluatePromoRedeemability(
+        base({ disabledAt: now, redeemBy: new Date("2020-01-01"), activeOrderCount: 99, maxRedemptions: 1 })
+      )
+    ).toBe("disabled");
+  });
+
+  it("rejects a code past redeemBy and allows one still before it", () => {
+    expect(evaluatePromoRedeemability(base({ redeemBy: new Date("2026-10-14T11:59:59Z") }))).toBe("expired");
+    expect(evaluatePromoRedeemability(base({ redeemBy: new Date("2026-10-14T12:00:01Z") }))).toBeNull();
+  });
+
+  it("counts orders against maxRedemptions: 8 of 10 used leaves room, 10 of 10 is exhausted", () => {
+    expect(evaluatePromoRedeemability(base({ maxRedemptions: 10, activeOrderCount: 8 }))).toBeNull();
+    expect(evaluatePromoRedeemability(base({ maxRedemptions: 10, activeOrderCount: 10 }))).toBe("exhausted");
+  });
+
+  it("treats maxRedemptions 0 or null as unlimited", () => {
+    expect(evaluatePromoRedeemability(base({ maxRedemptions: 0, activeOrderCount: 50 }))).toBeNull();
+    expect(evaluatePromoRedeemability(base({ maxRedemptions: null, activeOrderCount: 50 }))).toBeNull();
+  });
+
+  it("applies the per-account limit only when set", () => {
+    expect(evaluatePromoRedeemability(base({ maxUsesPerAccount: 1, accountOrderCount: 1 }))).toBe("already_used");
+    expect(evaluatePromoRedeemability(base({ maxUsesPerAccount: 2, accountOrderCount: 1 }))).toBeNull();
+    expect(evaluatePromoRedeemability(base({ maxUsesPerAccount: null, accountOrderCount: 9 }))).toBeNull();
+  });
+});
+
+function row(id: string, overrides: Partial<PromoCodeDuplicateCandidate> = {}): PromoCodeDuplicateCandidate {
+  return {
+    id,
+    ticketTierId: `tier_${id}`,
+    promoterId: "promoter_row",
+    discountAmountInCents: 500,
+    discountAmountPercentage: null,
+    redeemBy: null,
+    maxRedemptions: null,
+    bashPointsRewardPerTicket: null,
+    ...overrides,
+  };
+}
+
+describe("pickPromoCodeAmongDuplicates", () => {
+  it("returns the only row", () => {
+    expect(pickPromoCodeAmongDuplicates([row("b")])).toEqual({ row: row("b") });
+  });
+
+  it("picks the oldest id among identical rows", () => {
+    const result = pickPromoCodeAmongDuplicates([row("c"), row("a"), row("b")]);
+    expect("row" in result && result.row.id).toBe("a");
+  });
+
+  it("prefers an identical row whose tier is in the cart", () => {
+    const result = pickPromoCodeAmongDuplicates([row("a"), row("b")], ["tier_b"]);
+    expect("row" in result && result.row.id).toBe("b");
+  });
+
+  it("falls back to the oldest row when no duplicate tier is in the cart", () => {
+    const result = pickPromoCodeAmongDuplicates([row("b"), row("a")], ["tier_z"]);
+    expect("row" in result && result.row.id).toBe("a");
+  });
+
+  it.each([
+    ["promoter", { promoterId: "someone_else" }],
+    ["discount", { discountAmountInCents: 700 }],
+    ["percentage", { discountAmountPercentage: 10, discountAmountInCents: null }],
+    ["expiry", { redeemBy: new Date("2027-01-01") }],
+    ["limit", { maxRedemptions: 5 }],
+    ["BashPoints reward", { bashPointsRewardPerTicket: 25 }],
+  ])("asks the host to review duplicates that differ on %s", (_label, diff) => {
+    expect(pickPromoCodeAmongDuplicates([row("a"), row("b", diff)])).toEqual({
+      reason: "host_review_required",
+    });
+  });
+
+  it("throws on an empty list", () => {
+    expect(() => pickPromoCodeAmongDuplicates([])).toThrow();
+  });
+});
+
+describe("reason helpers", () => {
+  it("has a guest message for every reason", () => {
+    for (const reason of PROMO_CODE_REJECT_REASONS) {
+      expect(PROMO_CODE_REJECT_MESSAGES[reason].length).toBeGreaterThan(0);
+    }
+    expect(PROMO_CODE_REJECT_MESSAGES.host_review_required).toBe(
+      "This code needs the host to review it."
+    );
+  });
+
+  it("recognizes reason strings", () => {
+    expect(isPromoCodeRejectReason("expired")).toBe(true);
+    expect(isPromoCodeRejectReason("nope")).toBe(false);
+    expect(isPromoCodeRejectReason(3)).toBe(false);
+  });
+
+  it("normalizes emails", () => {
+    expect(normalizePromoRedemptionEmail("  Guest@Example.COM ")).toBe("guest@example.com");
+    expect(normalizePromoRedemptionEmail("   ")).toBeNull();
+    expect(normalizePromoRedemptionEmail(null)).toBeNull();
+  });
+});

package/src/__tests__/promoCodeScope.test.ts

@@ -0,0 +1,106 @@
+import {
+  promoCodeAppliesToTier,
+  promoCodeBashEventId,
+  promoCodeDiscountKind,
+  promoCodeEligibleTierIds,
+  getPromoterShareUrl,
+  promoterCodeInputErrors,
+} from "../promoCodeScope.js";
+
+describe("promoCodeDiscountKind", () => {
+  it("uses the explicit type, else derives it from legacy amounts", () => {
+    expect(promoCodeDiscountKind({ discountType: "NONE", discountAmountPercentage: 10 })).toBe("NONE");
+    expect(promoCodeDiscountKind({ discountAmountPercentage: 10 })).toBe("PERCENT");
+    expect(promoCodeDiscountKind({ discountAmountInCents: 500 })).toBe("FIXED_CASH");
+    expect(promoCodeDiscountKind({})).toBe("NONE");
+  });
+});
+
+describe("promoCodeBashEventId", () => {
+  it("prefers the row's bash, else the legacy tier's bash", () => {
+    expect(promoCodeBashEventId({ bashEventId: "evt_1", ticketTier: { bashEventId: "evt_2" } })).toBe("evt_1");
+    expect(promoCodeBashEventId({ ticketTier: { bashEventId: "evt_2" } })).toBe("evt_2");
+    expect(promoCodeBashEventId({})).toBeNull();
+  });
+});
+
+describe("promoCodeEligibleTierIds", () => {
+  it("returns ALL for an all-tiers code, so tiers added later qualify", () => {
+    const allTiers = { eligibilityMode: "ALL_TIERS" as const, ticketTierId: "ga" };
+    expect(promoCodeEligibleTierIds(allTiers)).toBe("ALL");
+    expect(promoCodeAppliesToTier(allTiers, "tier_added_later")).toBe(true);
+  });
+
+  it("uses selected tiers, else the legacy tier", () => {
+    expect(
+      promoCodeEligibleTierIds({
+        eligibilityMode: "SELECTED_TIERS",
+        eligibleTiers: [{ ticketTierId: "ga" }, { ticketTierId: "vip" }, { ticketTierId: "ga" }],
+      })
+    ).toEqual(["ga", "vip"]);
+    expect(promoCodeEligibleTierIds({ ticketTierId: "ga" })).toEqual(["ga"]);
+    expect(promoCodeEligibleTierIds({})).toEqual([]);
+    expect(promoCodeAppliesToTier({ ticketTierId: "ga" }, "vip")).toBe(false);
+  });
+});
+
+describe("getPromoterShareUrl", () => {
+  it("uses the active vanity path when there is one", () => {
+    expect(
+      getPromoterShareUrl({
+        bashEventId: "evt_1",
+        slug: "summer-bash",
+        vanityPaths: [
+          { segment: "old", status: "Revoked" },
+          { segment: "BashFest", status: "Active" },
+        ],
+        code: " crew 1 ",
+        origin: "https://bash.community/",
+      })
+    ).toBe("https://bash.community/bash/bashfest?promo=CREW%201");
+  });
+
+  it("falls back to the id-slug path, never /bashes/", () => {
+    const url = getPromoterShareUrl({ bashEventId: "evt_1", slug: "summer-bash", code: "vip" });
+    expect(url).toBe("/bash/evt_1-summer-bash?promo=VIP");
+    expect(url).not.toContain("/bashes/");
+  });
+});
+
+describe("promoterCodeInputErrors", () => {
+  const ok = {
+    code: "CREW",
+    discountType: "NONE" as const,
+    eligibilityMode: "ALL_TIERS" as const,
+  };
+  it("accepts an attribution-only all-tiers code", () => {
+    expect(promoterCodeInputErrors(ok, ["ga"])).toEqual([]);
+  });
+  it("validates guest percentage 1-100 separately from promoter commission 0-100", () => {
+    expect(promoterCodeInputErrors({ ...ok, discountType: "PERCENT", discountValue: 0 }, [])).toContain(
+      "Guest discount must be between 1% and 100%."
+    );
+    expect(promoterCodeInputErrors({ ...ok, discountType: "PERCENT", discountValue: 100 }, [])).toEqual([]);
+    expect(promoterCodeInputErrors({ ...ok, promoterCommissionBps: 0 }, [])).toEqual([]);
+    expect(promoterCodeInputErrors({ ...ok, promoterCommissionBps: 10000 }, [])).toEqual([]);
+    expect(promoterCodeInputErrors({ ...ok, promoterCommissionBps: 10001 }, [])).toContain(
+      "Promoter commission must be between 0% and 100%."
+    );
+  });
+  it("requires selected tiers on this bash", () => {
+    expect(promoterCodeInputErrors({ ...ok, eligibilityMode: "SELECTED_TIERS" }, ["ga"])).toContain(
+      "Pick at least one ticket tier."
+    );
+    expect(
+      promoterCodeInputErrors({ ...ok, eligibilityMode: "SELECTED_TIERS", eligibleTierIds: ["other"] }, ["ga"])
+    ).toContain("A selected tier isn't on this bash.");
+  });
+  it("blocks saving a promoter code until the reward is reviewed", () => {
+    expect(promoterCodeInputErrors({ ...ok, promoterEmail: "p@x.com" }, [])).toContain(
+      "Review the promoter reward before saving."
+    );
+    expect(
+      promoterCodeInputErrors({ ...ok, promoterEmail: "p@x.com", promoterRewardReviewed: true }, [])
+    ).toEqual([]);
+  });
+});

package/src/definitions.ts

@@ -1225,6 +1225,8 @@ export enum ApiErrorType {
   EventWaiverNotAccepted,
   /** Bash is not Published/PreSale. Ticket purchase and checkout creation are blocked */
   EventNotAcceptingPurchases,
+  /** Promo code can't be used; `code` carries the PromoCodeRejectReason */
+  PromoCodeRejected,
 }
 
 export type ErrorDataType = Record<RecordKey, unknown>;
@@ -1979,8 +1981,8 @@ const SYNTHETIC_BASH_SECTION_TITLE: Record<string, string> = {
   Popular: "Popular",
   Trending: "Trending",
   CrewGoing: "The crew's going",
-  Local: "Local",
-  State: "Statewide",
+  Local: "City & Community Events",
+  State: "State Events",
   National: "Across the country",
   International: "Worth the flight",
 };

package/src/discoveryScope.ts

@@ -1,6 +1,8 @@
 /**
- * Geographic / importance scope for public discovery.
- * Orthogonal to `BashEventType`. A Fair can be Local or State.
+ * Who puts the event on, for the City & Community and State homepage rows.
+ * Nearby events are a location filter, not a value here.
+ * National and International stay destination rows.
+ * Orthogonal to `BashEventType`.
  */
 
 export const DiscoveryScope = {
@@ -34,8 +36,8 @@ export const DISCOVERY_SCOPE_SECTION_TITLE: Record<
   (typeof DISCOVERY_SCOPE_ROW_KEYS)[number],
   string
 > = {
-  Local: "Local",
-  State: "Statewide",
+  Local: "City & Community Events",
+  State: "State Events",
   National: "Across the country",
   International: "Worth the flight",
 };
@@ -47,18 +49,6 @@ export const HOST_SETTABLE_DISCOVERY_SCOPES: readonly DiscoveryScope[] = [
   DiscoveryScope.State,
 ];
 
-export const HOST_SCOPE_CHIPS: ReadonlyArray<{
-  id: DiscoveryScope;
-  label: string;
-}> = [
-  { id: DiscoveryScope.Unspecified, label: "Not sure yet" },
-  { id: DiscoveryScope.Local, label: "Just the neighborhood / city-wide" },
-  {
-    id: DiscoveryScope.State,
-    label: "People will drive from across the state",
-  },
-];
-
 export function isDiscoveryScope(value: unknown): value is DiscoveryScope {
   return (
     typeof value === "string" &&
@@ -91,11 +81,27 @@ export const NATIONAL_SCOPE_BRAND_PATTERN =
 export const INTERNATIONAL_SCOPE_PATTERN =
   /\b(world tour|world cup|olympics|tomorrowland|glastonbury|primavera sound|oktoberfest|cannes|eurovision|ibiza)\b/i;
 
+/** Organizer is a state agency or an official statewide organization. Sponsorship is not enough. */
 export const STATE_SCOPE_PATTERN =
-  /\b(state fair|statewide|governor'?s? (?:ball|festival)|days of ['’]?47|pioneer day)\b/i;
+  /\b(state fair|state agency|state parks|governor'?s? (?:ball|festival))\b/i;
 
+/** Organizer is a city, municipality, or local community organization. */
 export const LOCAL_SCOPE_PATTERN =
-  /\b(block party|neighborhood|community day|city-sponsored|city festival)\b/i;
+  /\b(city of|municipality|municipal|parks and recreation|community organization|city council)\b/i;
+
+const SPONSORSHIP_ONLY_PATTERN = /\bsponsored by\b/i;
+const ORGANIZER_PATTERN = /\b(organized|hosted|presented|produced) by\b/i;
+
+function matchesOrganizerScope(text: string, pattern: RegExp): boolean {
+  if (!pattern.test(text)) return false;
+  if (
+    SPONSORSHIP_ONLY_PATTERN.test(text) &&
+    !ORGANIZER_PATTERN.test(text)
+  ) {
+    return false;
+  }
+  return true;
+}
 
 export function inferDiscoveryScopeFromText(
   title: string | undefined,
@@ -109,8 +115,12 @@ export function inferDiscoveryScopeFromText(
   if (NATIONAL_SCOPE_BRAND_PATTERN.test(text)) {
     return DiscoveryScope.National;
   }
-  if (STATE_SCOPE_PATTERN.test(text)) return DiscoveryScope.State;
-  if (LOCAL_SCOPE_PATTERN.test(text)) return DiscoveryScope.Local;
+  if (matchesOrganizerScope(text, STATE_SCOPE_PATTERN)) {
+    return DiscoveryScope.State;
+  }
+  if (matchesOrganizerScope(text, LOCAL_SCOPE_PATTERN)) {
+    return DiscoveryScope.Local;
+  }
   return DiscoveryScope.Unspecified;
 }
 

package/src/extendedSchemas.ts

@@ -672,6 +672,7 @@ type BashEventExtBase = Override<
   hideCancellationPolicy?: boolean;
   hideGroupUp?: boolean;
   hideServicesOpenTo?: boolean;
+  hideLiveLocation?: boolean;
   /** GET /event/:id. Tickets sold (non-cancelled), for social proof */
   goingCount?: number;
   /** GET /event/:id. True when at least one Budget line has `showOnBashDetailPage` set. Drives the "View budget" reveal on the public bash page; never carries dollar amounts. */

package/src/index.ts

@@ -50,6 +50,9 @@ export * from "./hostCrmAutomation.js";
 export * from "./relationshipHealth.js";
 export * from "./hostCrmConstants.js";
 export * from "./hostPromoter.js";
+export * from "./promoCodeRedemption.js";
+export * from "./promoCodeScope.js";
+export * from "./promoCartEngine.js";
 export * from "./audienceImport.js";
 export * from "./eventStaffRoles.js";
 export * from "./bashEventCancellationPolicy.js";