@final-commerce/common 2.3.0 → 2.4.0-preprod.2

package/dist/index.mjs

@@ -422,6 +422,7 @@ var StripeCurrencyCode = /* @__PURE__ */ ((StripeCurrencyCode2) => {
 var ProductType = /* @__PURE__ */ ((ProductType2) => {
   ProductType2["SIMPLE"] = "simple";
   ProductType2["VARIABLE"] = "variable";
+  ProductType2["BOOKING"] = "booking";
   return ProductType2;
 })(ProductType || {});
 var ProductStatus = /* @__PURE__ */ ((ProductStatus2) => {
@@ -439,6 +440,50 @@ var PaymentProcessor = /* @__PURE__ */ ((PaymentProcessor2) => {
   return PaymentProcessor2;
 })(PaymentProcessor || {});
 
+// enums/booking.enum.ts
+var BookingType = /* @__PURE__ */ ((BookingType3) => {
+  BookingType3["RENTAL"] = "rental";
+  BookingType3["APPOINTMENT"] = "appointment";
+  BookingType3["OVERNIGHT"] = "overnight";
+  BookingType3["GROUP"] = "group";
+  return BookingType3;
+})(BookingType || {});
+var BookingRatePeriod = /* @__PURE__ */ ((BookingRatePeriod2) => {
+  BookingRatePeriod2["SLOT"] = "slot";
+  BookingRatePeriod2["DAY"] = "day";
+  BookingRatePeriod2["NIGHT"] = "night";
+  BookingRatePeriod2["WEEK"] = "week";
+  BookingRatePeriod2["MONTH"] = "month";
+  return BookingRatePeriod2;
+})(BookingRatePeriod || {});
+var BookingResourceKind = /* @__PURE__ */ ((BookingResourceKind2) => {
+  BookingResourceKind2["ASSET"] = "asset";
+  BookingResourceKind2["ROOM"] = "room";
+  BookingResourceKind2["PROPERTY"] = "property";
+  BookingResourceKind2["SPACE"] = "space";
+  BookingResourceKind2["STAFF"] = "staff";
+  BookingResourceKind2["TABLE"] = "table";
+  return BookingResourceKind2;
+})(BookingResourceKind || {});
+var ReservationStatus = /* @__PURE__ */ ((ReservationStatus2) => {
+  ReservationStatus2["HELD"] = "held";
+  ReservationStatus2["CONFIRMED"] = "confirmed";
+  ReservationStatus2["CANCELLED"] = "cancelled";
+  ReservationStatus2["EXPIRED"] = "expired";
+  return ReservationStatus2;
+})(ReservationStatus || {});
+var BookingResourceStatus = /* @__PURE__ */ ((BookingResourceStatus2) => {
+  BookingResourceStatus2["ACTIVE"] = "active";
+  BookingResourceStatus2["INACTIVE"] = "inactive";
+  return BookingResourceStatus2;
+})(BookingResourceStatus || {});
+var ResourceAvailabilityState = /* @__PURE__ */ ((ResourceAvailabilityState2) => {
+  ResourceAvailabilityState2["AVAILABLE"] = "available";
+  ResourceAvailabilityState2["FULLY_BOOKED"] = "fullyBooked";
+  ResourceAvailabilityState2["NO_HOURS_IN_RANGE"] = "noHoursInRange";
+  return ResourceAvailabilityState2;
+})(ResourceAvailabilityState || {});
+
 // utils/currency.util.ts
 var CURRENCY_CONFIG = {
   // Major currencies with 2 decimal places
@@ -1650,6 +1695,15 @@ function sumRefundQuantities(refunds) {
   }
   return t;
 }
+var asCount = (value) => typeof value === "number" && Number.isFinite(value) ? Math.max(0, value) : 0;
+function countsOf(row) {
+  const quantity = asCount(row.quantity);
+  return {
+    quantity,
+    fulfilled: Math.min(asCount(row.fulfilledQuantity), quantity),
+    returned: Math.min(asCount(row.returnedQuantity), quantity)
+  };
+}
 function buildOrderContext(order, extras) {
   const o = order ?? {};
   const total = typeof o.total === "number" && Number.isFinite(o.total) ? o.total : 0;
@@ -1657,6 +1711,7 @@ function buildOrderContext(order, extras) {
   const paymentMethods = o.paymentMethods ?? [];
   const refunds = o.refunds ?? o.refund ?? [];
   const lineItems = o.lineItems ?? [];
+  const reservations = o.reservations ?? [];
   const totalPaid = sumNumbers(paymentMethods);
   const totalRefunded = sumRefundQuantities(refunds);
   const isFullyPaid = total > 0 ? balance <= 0 : totalPaid > 0 && balance <= 0;
@@ -1664,13 +1719,11 @@ function buildOrderContext(order, extras) {
   let itemCount = 0;
   let fulfilledItemCount = 0;
   let returnedItemCount = 0;
-  for (const li of lineItems) {
-    const q = typeof li.quantity === "number" && Number.isFinite(li.quantity) ? Math.max(0, li.quantity) : 0;
-    itemCount += q;
-    const fq = typeof li.fulfilledQuantity === "number" && Number.isFinite(li.fulfilledQuantity) ? Math.max(0, li.fulfilledQuantity) : 0;
-    fulfilledItemCount += Math.min(fq, q);
-    const rq = typeof li.returnedQuantity === "number" && Number.isFinite(li.returnedQuantity) ? Math.max(0, li.returnedQuantity) : 0;
-    returnedItemCount += Math.min(rq, q);
+  for (const row of [...lineItems, ...reservations]) {
+    const { quantity, fulfilled, returned } = countsOf(row);
+    itemCount += quantity;
+    fulfilledItemCount += fulfilled;
+    returnedItemCount += returned;
   }
   const isFullyReturned = itemCount > 0 ? returnedItemCount >= itemCount : returnedItemCount > 0;
   const hasPartialReturns = returnedItemCount > 0 && !isFullyReturned;
@@ -1680,7 +1733,8 @@ function buildOrderContext(order, extras) {
       balance,
       paymentMethods,
       refunds,
-      lineItems
+      lineItems,
+      reservations
     },
     computed: {
       balance,
@@ -2760,6 +2814,378 @@ var ORDER_STATE_EVENTS = {
   configUpdated: "config-updated"
 };
 
+// booking/types.ts
+var BookingRulesError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "BookingRulesError";
+  }
+};
+
+// booking/zoned-time.ts
+var MINUTE = 6e4;
+var formatters = /* @__PURE__ */ new Map();
+var formatterFor = (timeZone) => {
+  const existing = formatters.get(timeZone);
+  if (existing) return existing;
+  let created;
+  try {
+    created = new Intl.DateTimeFormat("en-US", {
+      timeZone,
+      hour12: false,
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit",
+      hour: "2-digit",
+      minute: "2-digit",
+      second: "2-digit",
+      weekday: "short"
+    });
+  } catch {
+    throw new BookingRulesError(`Booking rules: "${timeZone}" is not a known time zone`);
+  }
+  formatters.set(timeZone, created);
+  return created;
+};
+var WEEKDAYS = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+function zonedParts(instant, timeZone) {
+  const parts = {};
+  for (const { type, value } of formatterFor(timeZone).formatToParts(instant)) parts[type] = value;
+  const hour = Number(parts.hour) % 24;
+  return {
+    year: Number(parts.year),
+    month: Number(parts.month),
+    day: Number(parts.day),
+    hour,
+    minute: Number(parts.minute),
+    second: Number(parts.second),
+    weekday: WEEKDAYS.indexOf(parts.weekday)
+  };
+}
+function offsetAt(instant, timeZone) {
+  const { year, month, day, hour, minute, second } = zonedParts(instant, timeZone);
+  return Date.UTC(year, month - 1, day, hour, minute, second) - Math.floor(instant.getTime() / 1e3) * 1e3;
+}
+function instantFromLocal(year, month, day, minutes, timeZone) {
+  const naive = Date.UTC(year, month - 1, day) + minutes * MINUTE;
+  const firstGuess = naive - offsetAt(new Date(naive), timeZone);
+  return new Date(naive - offsetAt(new Date(firstGuess), timeZone));
+}
+function startOfZonedDay(instant, timeZone) {
+  const { year, month, day } = zonedParts(instant, timeZone);
+  return instantFromLocal(year, month, day, 0, timeZone);
+}
+function nextZonedDay(dayStart, timeZone) {
+  const { year, month, day } = zonedParts(dayStart, timeZone);
+  return instantFromLocal(year, month, day + 1, 0, timeZone);
+}
+function atZonedMinute(dayStart, minutes, timeZone) {
+  const { year, month, day } = zonedParts(dayStart, timeZone);
+  return instantFromLocal(year, month, day, minutes, timeZone);
+}
+
+// booking/grid.ts
+var MINUTE2 = 6e4;
+var MAX_RANGE_DAYS = 366;
+var asTime = (value, field) => {
+  if (value == null) return void 0;
+  const time = new Date(value).getTime();
+  if (Number.isNaN(time)) throw new BookingRulesError(`Booking rules: ${field} is not a date, got "${String(value)}"`);
+  return time;
+};
+function parseHhMm(value, field) {
+  const [hours, minutes] = value.split(":").map(Number);
+  if (!Number.isInteger(hours) || !Number.isInteger(minutes)) {
+    throw new BookingRulesError(`Booking rules: ${field} must be "HH:mm", got "${value}"`);
+  }
+  return hours * 60 + minutes;
+}
+function windowEndsAt(rule, now) {
+  const { maxAdvanceDays, bookableTo } = rule.window;
+  const ends = Math.min(
+    maxAdvanceDays ? now.getTime() + maxAdvanceDays * 1440 * MINUTE2 : Number.POSITIVE_INFINITY,
+    asTime(bookableTo, "window.bookableTo") ?? Number.POSITIVE_INFINITY
+  );
+  return Number.isFinite(ends) ? new Date(ends) : null;
+}
+function periodSlot(dayStart, timeZone, rule, openMinute, closeMinute) {
+  const { ratePeriod, slot, checkInTime, checkOutTime } = rule;
+  const at = (minutes) => atZonedMinute(dayStart, minutes, timeZone);
+  if (ratePeriod === "night" /* NIGHT */) {
+    if (!checkInTime || !checkOutTime) {
+      throw new BookingRulesError("Overnight booking rules need both checkInTime and checkOutTime");
+    }
+    const checkIn = parseHhMm(checkInTime, "checkInTime");
+    const checkOut = parseHhMm(checkOutTime, "checkOutTime");
+    return {
+      startAt: at(checkIn),
+      endAt: at(1440 + checkOut),
+      // Housekeeping sits between check-out and the next check-in: it costs no night.
+      bufferEndAt: at(1440 + checkIn),
+      canStart: true
+    };
+  }
+  const from = ratePeriod === "day" /* DAY */ ? openMinute ?? 0 : 0;
+  const to = ratePeriod === "day" /* DAY */ ? closeMinute ?? 1440 : 1440;
+  return {
+    startAt: at(from),
+    endAt: at(to),
+    bufferEndAt: at(to + (slot.bufferMinutes ?? 0)),
+    canStart: true
+  };
+}
+function freeGaps(openAt, closeAt, busy) {
+  const inside = busy.map(({ startAt, bufferEndAt }) => ({ from: +startAt, to: +bufferEndAt })).filter(({ from, to }) => to > openAt && from < closeAt).sort((first, second) => first.from - second.from);
+  const gaps = [];
+  let cursor = openAt;
+  for (const { from, to } of inside) {
+    if (from > cursor) gaps.push({ from: cursor, to: from, endsAtBooking: true });
+    cursor = Math.max(cursor, to);
+    if (cursor >= closeAt) break;
+  }
+  if (cursor < closeAt) gaps.push({ from: cursor, to: closeAt, endsAtBooking: false });
+  return gaps;
+}
+function buildGrid(rule, timeZone, from, to, now, busy = []) {
+  if (to.getTime() - from.getTime() > MAX_RANGE_DAYS * 1440 * MINUTE2) {
+    throw new BookingRulesError(`A booking range may span at most ${MAX_RANGE_DAYS} days`);
+  }
+  const { availability, slot, window, ratePeriod } = rule;
+  const periodMode = ratePeriod !== "slot" /* SLOT */;
+  const weeklyHours = availability.weeklyHours ?? [];
+  const notBefore = Math.max(
+    now.getTime() + (window.minNoticeMinutes ?? 0) * MINUTE2,
+    asTime(window.bookableFrom, "window.bookableFrom") ?? 0,
+    asTime(availability.availableFrom, "availability.availableFrom") ?? 0
+  );
+  const notAfter = windowEndsAt(rule, now)?.getTime() ?? Number.POSITIVE_INFINITY;
+  const blocked = (availability.offMarket ?? []).map(({ from: blockFrom, to: blockTo }) => ({
+    from: asTime(blockFrom, "availability.offMarket.from"),
+    to: asTime(blockTo, "availability.offMarket.to")
+  }));
+  const arrivalDays = availability.arrivalDays;
+  const step = slot.lengthMinutes + (slot.bufferMinutes ?? 0);
+  const slots = [];
+  const lastDay = startOfZonedDay(to, timeZone).getTime();
+  let dayStart = startOfZonedDay(from, timeZone);
+  while (dayStart.getTime() <= lastDay) {
+    const weekday = zonedParts(dayStart, timeZone).weekday;
+    const rows = weeklyHours.filter((entry) => entry.weekday === weekday);
+    if (periodMode) {
+      const openToday = weeklyHours.length === 0 || rows.length > 0;
+      if (openToday) {
+        const built = periodSlot(dayStart, timeZone, rule, rows[0]?.openMinute, rows[0]?.closeMinute);
+        slots.push({ ...built, canStart: !arrivalDays?.length || arrivalDays.includes(weekday) });
+      }
+    } else {
+      for (const row of rows) {
+        const openAt = +atZonedMinute(dayStart, row.openMinute, timeZone);
+        const closeAt = +atZonedMinute(dayStart, row.closeMinute, timeZone);
+        for (const gap of freeGaps(openAt, closeAt, busy)) {
+          const mustFit = (gap.endsAtBooking ? step : slot.lengthMinutes) * MINUTE2;
+          for (let start = gap.from; start + mustFit <= gap.to; start += step * MINUTE2) {
+            slots.push({
+              startAt: new Date(start),
+              endAt: new Date(start + slot.lengthMinutes * MINUTE2),
+              bufferEndAt: new Date(start + step * MINUTE2),
+              canStart: true
+            });
+          }
+        }
+      }
+    }
+    dayStart = nextZonedDay(dayStart, timeZone);
+  }
+  const askedFrom = from.getTime();
+  const askedTo = to.getTime();
+  return slots.filter(({ startAt, bufferEndAt }) => {
+    const start = startAt.getTime();
+    if (start < askedFrom || start >= askedTo) return false;
+    if (start < notBefore || start > notAfter) return false;
+    return !blocked.some(({ from: blockFrom, to: blockTo }) => start < blockTo && bufferEndAt.getTime() > blockFrom);
+  }).sort((first, second) => +first.startAt - +second.startAt);
+}
+function slotsForWindow(grid, startAt, endAt) {
+  const startIndex = grid.findIndex((entry) => entry.startAt.getTime() === startAt.getTime());
+  if (startIndex < 0) {
+    throw new BookingRulesError(`${startAt.toISOString()} is not a bookable slot start for these rules`);
+  }
+  if (!grid[startIndex].canStart) {
+    throw new BookingRulesError(`${startAt.toISOString()} is not an arrival day for these rules`);
+  }
+  const covered = [];
+  for (let index = startIndex; index < grid.length; index++) {
+    const entry = grid[index];
+    const previous = covered[covered.length - 1];
+    if (previous && entry.startAt.getTime() !== previous.bufferEndAt.getTime()) break;
+    covered.push(entry);
+    if (entry.endAt.getTime() === endAt.getTime()) return covered;
+    if (entry.endAt.getTime() > endAt.getTime()) break;
+  }
+  throw new BookingRulesError(
+    `${startAt.toISOString()} \u2192 ${endAt.toISOString()} does not line up with the bookable grid`
+  );
+}
+
+// booking/availability.ts
+var withinPresence = (slot, timeZone, presence) => {
+  if (!presence?.length) return true;
+  const dayStart = startOfZonedDay(slot.startAt, timeZone);
+  const weekday = zonedParts(dayStart, timeZone).weekday;
+  return presence.some(
+    (shift) => shift.weekday === weekday && slot.startAt.getTime() >= atZonedMinute(dayStart, shift.openMinute, timeZone).getTime() && slot.endAt.getTime() <= atZonedMinute(dayStart, shift.closeMinute, timeZone).getTime()
+  );
+};
+var overlaps = (entry, startAt, bufferEndAt) => entry.startAt.getTime() < bufferEndAt.getTime() && entry.bufferEndAt.getTime() > startAt.getTime();
+function occupancyIn(occupied, productId, startAt, bufferEndAt, shared) {
+  const clashing = occupied.filter((entry) => overlaps(entry, startAt, bufferEndAt));
+  const foreign = shared ? void 0 : clashing.find((entry) => entry.productId !== productId);
+  return {
+    taken: clashing.filter((entry) => shared || entry.productId === productId).reduce((sum, entry) => sum + entry.qty, 0),
+    foreignProductId: foreign?.productId
+  };
+}
+var stateFor = (hasShift, offerable, free) => {
+  if (offerable === 0) {
+    return hasShift() ? "fullyBooked" /* FULLY_BOOKED */ : "noHoursInRange" /* NO_HOURS_IN_RANGE */;
+  }
+  return free === 0 ? "fullyBooked" /* FULLY_BOOKED */ : "available" /* AVAILABLE */;
+};
+function shopDayKey(instant, timeZone) {
+  const { year, month, day } = zonedParts(instant, timeZone);
+  const pad = (value) => String(value).padStart(2, "0");
+  return `${year}-${pad(month)}-${pad(day)}`;
+}
+function shopDayRange(fromDayKey, count, timeZone) {
+  const [year, month, day] = fromDayKey.split("-").map(Number);
+  return {
+    from: instantFromLocal(year, month, day, 0, timeZone),
+    to: instantFromLocal(year, month, day + Math.max(1, count), 0, timeZone)
+  };
+}
+function buildAvailability({
+  productId,
+  bookingRulesId,
+  bookingType,
+  rule,
+  resources,
+  occupied,
+  from,
+  to,
+  now
+}) {
+  const shared = rule.slot.sharedAcrossProducts ?? false;
+  const bookableUntil = windowEndsAt(rule, now);
+  const header = {
+    productId,
+    bookingRulesId,
+    bookingType,
+    ratePeriod: rule.ratePeriod,
+    // Passed through for the UI to label: a group slot under minimumToRun may not run.
+    minimumToRun: rule.slot.minimumToRun,
+    minStay: rule.slot.minStay,
+    maxStay: rule.slot.maxStay,
+    // Why a day can come back empty. Past this instant the rule refuses everything, so the UI
+    // can say "beyond the booking window" where it would otherwise claim "nothing free".
+    bookableUntil,
+    // The comparison itself, not just the boundary: deciding whether a day lies past the
+    // window is a rule, and a UI that re-derives it owns a copy of that rule — which is how
+    // the same empty grid ends up explained one way on the till and another in a flow.
+    beyondWindow: !!bookableUntil && from.getTime() > bookableUntil.getTime()
+  };
+  const byResource = /* @__PURE__ */ new Map();
+  for (const entry of occupied) {
+    byResource.set(entry.resourceId, [...byResource.get(entry.resourceId) ?? [], entry]);
+  }
+  const grids = resources.map((resource) => {
+    const mine = byResource.get(resource.id) ?? [];
+    const busy = (resource.seats ?? 1) === 1 ? mine : [];
+    const slots2 = buildGrid(rule, resource.timeZone, from, to, now, busy).filter(
+      (slot) => withinPresence(slot, resource.timeZone, resource.presence)
+    );
+    return { resource, slots: slots2 };
+  });
+  const byInstant = /* @__PURE__ */ new Map();
+  const freeSlotsPerResource = /* @__PURE__ */ new Map();
+  for (const { resource, slots: slots2 } of grids) {
+    const capacity = resource.seats ?? 1;
+    const mine = byResource.get(resource.id) ?? [];
+    for (const slot of slots2) {
+      const { taken, foreignProductId } = occupancyIn(mine, productId, slot.startAt, slot.bufferEndAt, shared);
+      const free = foreignProductId ? 0 : Math.max(capacity - taken, 0);
+      const entry = byInstant.get(+slot.startAt) ?? { ...slot, capacity: 0, booked: 0, free: 0, resources: [], dayKey: shopDayKey(slot.startAt, resource.timeZone) };
+      entry.capacity += capacity;
+      entry.booked += foreignProductId ? capacity : taken;
+      entry.free += free;
+      entry.canStart = entry.canStart || slot.canStart;
+      entry.resources.push({ resourceId: resource.id, name: resource.name, capacity, booked: taken, free });
+      if (free > 0) freeSlotsPerResource.set(resource.id, (freeSlotsPerResource.get(resource.id) ?? 0) + 1);
+      byInstant.set(+slot.startAt, entry);
+    }
+  }
+  const inWindow = grids.map(({ resource, slots: slots2 }) => {
+    const free = freeSlotsPerResource.get(resource.id) ?? 0;
+    return {
+      resourceId: resource.id,
+      name: resource.name,
+      slots: slots2.length,
+      free,
+      // Lazily: the shift grid is a second walk, and only an empty answer needs it.
+      state: stateFor(
+        () => buildGrid(rule, resource.timeZone, from, to, now).filter(
+          (slot) => withinPresence(slot, resource.timeZone, resource.presence)
+        ).length > 0,
+        slots2.length,
+        free
+      )
+    };
+  });
+  const slots = [...byInstant.values()].sort((first, second) => +first.startAt - +second.startAt);
+  return {
+    ...header,
+    resources: inWindow,
+    slots,
+    /**
+     * The clock every instant above reads on. Returned rather than assumed: without it a caller
+     * has to fetch the zone from somewhere else and hope it is the same one the grid used.
+     */
+    timeZone: resources[0]?.timeZone ?? null,
+    /** The shop days this answer covers, in order — what a day picker lists. */
+    days: [...new Set(slots.map((slot) => slot.dayKey))]
+  };
+}
+function presentAt(resources, rows, outletId) {
+  const byResource = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    byResource.set(row.resourceId, [...byResource.get(row.resourceId) ?? [], row]);
+  }
+  return resources.flatMap((resource) => {
+    const own = byResource.get(resource.id) ?? [];
+    if (own.length === 0 || !outletId) return [{ resource }];
+    const here = own.find((row) => row.outletId === outletId);
+    return here ? [{ resource, presence: here.weeklyHours }] : [];
+  });
+}
+
+// booking/plan.ts
+var DEFAULT_HOLD_MINUTES = 10;
+function planWindow({ rule, timeZone, presence, startAt, endAt, now, busy = [] }) {
+  const grid = buildGrid(rule, timeZone, startAt, endAt, now, busy).filter(
+    (slot) => withinPresence(slot, timeZone, presence)
+  );
+  const slots = slotsForWindow(grid, startAt, endAt);
+  const { minStay, maxStay } = rule.slot;
+  if (minStay && slots.length < minStay) {
+    throw new BookingRulesError(`These rules ask for at least ${minStay} period(s), got ${slots.length}`);
+  }
+  if (maxStay && slots.length > maxStay) {
+    throw new BookingRulesError(`These rules allow at most ${maxStay} period(s), got ${slots.length}`);
+  }
+  const last = slots[slots.length - 1];
+  return { slots, endAt: last.endAt, bufferEndAt: last.bufferEndAt };
+}
+var holdExpiresAt = (rule, now) => new Date(now.getTime() + (rule.window.holdMinutes ?? DEFAULT_HOLD_MINUTES) * 6e4);
+
 // constants/adyen.constants.ts
 var ADYEN_ROLLOUT_COUNTRY_CODES = /* @__PURE__ */ new Set(["CA"]);
 function isAdyenRolloutCountry(alpha2) {
@@ -2768,6 +3194,11 @@ function isAdyenRolloutCountry(alpha2) {
 export {
   ADYEN_ROLLOUT_COUNTRY_CODES,
   AttributeType,
+  BookingRatePeriod,
+  BookingResourceKind,
+  BookingResourceStatus,
+  BookingRulesError,
+  BookingType,
   CONDITION_OPERATORS,
   COUNTRY_CURRENCIES,
   CURRENCY_CONFIG,
@@ -2778,6 +3209,7 @@ export {
   DEFAULT_CONFIG,
   DEFAULT_CROSS_AXIS_RULES,
   DEFAULT_DISPLAY_STATE_MAP,
+  DEFAULT_HOLD_MINUTES,
   DEFAULT_RESOLVED_CONFIG,
   DEFAULT_UNIT_ID,
   DualWriteStrategy,
@@ -2821,8 +3253,10 @@ export {
   REPORT_NEGATE_PATHS,
   ReceiptSendChannel,
   ReceiptType,
+  ReservationStatus,
   ResidualPaymentMethod,
   ResidualStatus,
+  ResourceAvailabilityState,
   STATE_SCHEMA,
   STRIPE_SUPPORTED_COUNTRIES,
   SYSTEM_FAMILIES,
@@ -2843,6 +3277,8 @@ export {
   baseFulfillmentDefinitions,
   baseOf,
   basePaymentDefinitions,
+  buildAvailability,
+  buildGrid,
   buildOrderContext,
   buildPosPresetConfig,
   buildResolvedConfig,
@@ -2882,6 +3318,7 @@ export {
   getPricingRegionFromCountry,
   getSettlementTotal,
   getTotalCollected,
+  holdExpiresAt,
   inferStatesFromLegacyStatus,
   isAdyenRolloutCountry,
   isConditionOperator,
@@ -2896,9 +3333,12 @@ export {
   mergeFragment,
   multiplyAmount,
   normalizeMongoIdString,
+  occupancyIn,
   parseAmountToMinorUnits,
   parseCurrencyCode,
   parseStripeCurrencyCode,
+  planWindow,
+  presentAt,
   removeFragment,
   resolveFamily,
   resolveTemplate,
@@ -2906,13 +3346,18 @@ export {
   roundToPrecision,
   sameFamily,
   setOrderState,
+  shopDayKey,
+  shopDayRange,
   signReportForDisplay,
+  slotsForWindow,
   stringifyMinorUnits,
   subtractAmounts,
   toBase,
   toMinorUnits,
   validateConfig,
   validateFragmentCompatibility,
-  violatesFinancialInvariant
+  violatesFinancialInvariant,
+  windowEndsAt,
+  withinPresence
 };
 //# sourceMappingURL=index.mjs.map