@final-commerce/common 2.4.1-staging2.1 → 2.5.0-staging.1

package/dist/index.js

@@ -19,14 +19,13 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // index.ts
 var index_exports = {};
 __export(index_exports, {
-  ADYEN_JOB_TITLE_ASSOCIATION_TYPES: () => ADYEN_JOB_TITLE_ASSOCIATION_TYPES,
-  ADYEN_LEGAL_ENTITY_STATE_PROVINCE_COUNTRIES: () => ADYEN_LEGAL_ENTITY_STATE_PROVINCE_COUNTRIES,
-  ADYEN_NO_TAX_NUMBER_ABSENT_COUNTRIES: () => ADYEN_NO_TAX_NUMBER_ABSENT_COUNTRIES,
   ADYEN_ROLLOUT_COUNTRY_CODES: () => ADYEN_ROLLOUT_COUNTRY_CODES,
-  ADYEN_STORE_STATE_PROVINCE_COUNTRIES: () => ADYEN_STORE_STATE_PROVINCE_COUNTRIES,
-  ADYEN_TAX_NUMBER_FORMATS: () => ADYEN_TAX_NUMBER_FORMATS,
-  ADYEN_TAX_NUMBER_MIN_LENGTH: () => ADYEN_TAX_NUMBER_MIN_LENGTH,
   AttributeType: () => AttributeType,
+  BookingRatePeriod: () => BookingRatePeriod,
+  BookingResourceKind: () => BookingResourceKind,
+  BookingResourceStatus: () => BookingResourceStatus,
+  BookingRulesError: () => BookingRulesError,
+  BookingType: () => BookingType,
   CONDITION_OPERATORS: () => CONDITION_OPERATORS,
   COUNTRY_CURRENCIES: () => COUNTRY_CURRENCIES,
   CURRENCY_CONFIG: () => CURRENCY_CONFIG,
@@ -37,6 +36,7 @@ __export(index_exports, {
   DEFAULT_CONFIG: () => DEFAULT_CONFIG,
   DEFAULT_CROSS_AXIS_RULES: () => DEFAULT_CROSS_AXIS_RULES,
   DEFAULT_DISPLAY_STATE_MAP: () => DEFAULT_DISPLAY_STATE_MAP,
+  DEFAULT_HOLD_MINUTES: () => DEFAULT_HOLD_MINUTES,
   DEFAULT_RESOLVED_CONFIG: () => DEFAULT_RESOLVED_CONFIG,
   DEFAULT_UNIT_ID: () => DEFAULT_UNIT_ID,
   DualWriteStrategy: () => DualWriteStrategy,
@@ -80,8 +80,10 @@ __export(index_exports, {
   REPORT_NEGATE_PATHS: () => REPORT_NEGATE_PATHS,
   ReceiptSendChannel: () => ReceiptSendChannel,
   ReceiptType: () => ReceiptType,
+  ReservationStatus: () => ReservationStatus,
   ResidualPaymentMethod: () => ResidualPaymentMethod,
   ResidualStatus: () => ResidualStatus,
+  ResourceAvailabilityState: () => ResourceAvailabilityState,
   STATE_SCHEMA: () => STATE_SCHEMA,
   STRIPE_SUPPORTED_COUNTRIES: () => STRIPE_SUPPORTED_COUNTRIES,
   SYSTEM_FAMILIES: () => SYSTEM_FAMILIES,
@@ -95,23 +97,29 @@ __export(index_exports, {
   TopMetericsSort: () => TopMetericsSort,
   UserTypes: () => UserTypes,
   addAmounts: () => addAmounts,
-  adyenLegalEntityRequiresStateOrProvince: () => adyenLegalEntityRequiresStateOrProvince,
-  adyenRequiresJobTitle: () => adyenRequiresJobTitle,
-  adyenStoreRequiresStateOrProvince: () => adyenStoreRequiresStateOrProvince,
-  adyenSupportsTaxNumberAbsent: () => adyenSupportsTaxNumberAbsent,
-  adyenTaxNumberFormat: () => adyenTaxNumberFormat,
   amountToString: () => amountToString,
+  ancestorChain: () => ancestorChain,
   assertUnitSane: () => assertUnitSane,
   availableIn: () => availableIn,
   baseFor: () => baseFor,
   baseFulfillmentDefinitions: () => baseFulfillmentDefinitions,
   baseOf: () => baseOf,
   basePaymentDefinitions: () => basePaymentDefinitions,
+  buildAvailability: () => buildAvailability,
+  buildGrid: () => buildGrid,
   buildOrderContext: () => buildOrderContext,
   buildPosPresetConfig: () => buildPosPresetConfig,
   buildResolvedConfig: () => buildResolvedConfig,
   calculatePercentage: () => calculatePercentage,
   canTransition: () => canTransition,
+  cheapestCompositeItem: () => cheapestCompositeItem,
+  cheapestCompositePrice: () => cheapestCompositePrice,
+  compositeItemCost: () => compositeItemCost,
+  compositeItemUnavailable: () => compositeItemUnavailable,
+  compositeMakeable: () => compositeMakeable,
+  compositeModifierMismatches: () => compositeModifierMismatches,
+  compositeReservationMismatches: () => compositeReservationMismatches,
+  compositeVariantInStock: () => compositeVariantInStock,
   conditionSummary: () => conditionSummary,
   convertFixedFeeToLocalCurrency: () => convertFixedFeeToLocalCurrency,
   createAmount: () => createAmount,
@@ -146,8 +154,11 @@ __export(index_exports, {
   getPricingRegionFromCountry: () => getPricingRegionFromCountry,
   getSettlementTotal: () => getSettlementTotal,
   getTotalCollected: () => getTotalCollected,
+  hasSellableChoice: () => hasSellableChoice,
+  holdExpiresAt: () => holdExpiresAt,
   inferStatesFromLegacyStatus: () => inferStatesFromLegacyStatus,
   isAdyenRolloutCountry: () => isAdyenRolloutCountry,
+  isChoiceAvailableAtOutlet: () => isChoiceAvailableAtOutlet,
   isConditionOperator: () => isConditionOperator,
   isFulfillmentState: () => isFulfillmentState,
   isPaymentState: () => isPaymentState,
@@ -158,26 +169,40 @@ __export(index_exports, {
   mapToLegacyStatus: () => mapToLegacyStatus,
   maxPrecisionFor: () => maxPrecisionFor,
   mergeFragment: () => mergeFragment,
+  modifiersSellable: () => modifiersSellable,
   multiplyAmount: () => multiplyAmount,
   normalizeMongoIdString: () => normalizeMongoIdString,
+  occupancyIn: () => occupancyIn,
   parseAmountToMinorUnits: () => parseAmountToMinorUnits,
   parseCurrencyCode: () => parseCurrencyCode,
   parseStripeCurrencyCode: () => parseStripeCurrencyCode,
+  planWindow: () => planWindow,
+  poolDemand: () => poolDemand,
+  poolOf: () => poolOf,
+  poolShortfall: () => poolShortfall,
+  poolStockAt: () => poolStockAt,
+  presentAt: () => presentAt,
   removeFragment: () => removeFragment,
   resolveFamily: () => resolveFamily,
+  resolveModifiersForProduct: () => resolveModifiersForProduct,
   resolveTemplate: () => resolveTemplate,
   resolveUnit: () => resolveUnit,
   roundToPrecision: () => roundToPrecision,
   sameFamily: () => sameFamily,
   setOrderState: () => setOrderState,
+  shopDayKey: () => shopDayKey,
+  shopDayRange: () => shopDayRange,
   signReportForDisplay: () => signReportForDisplay,
+  slotsForWindow: () => slotsForWindow,
   stringifyMinorUnits: () => stringifyMinorUnits,
   subtractAmounts: () => subtractAmounts,
   toBase: () => toBase,
   toMinorUnits: () => toMinorUnits,
   validateConfig: () => validateConfig,
   validateFragmentCompatibility: () => validateFragmentCompatibility,
-  violatesFinancialInvariant: () => violatesFinancialInvariant
+  violatesFinancialInvariant: () => violatesFinancialInvariant,
+  windowEndsAt: () => windowEndsAt,
+  withinPresence: () => withinPresence
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -605,6 +630,8 @@ var StripeCurrencyCode = /* @__PURE__ */ ((StripeCurrencyCode2) => {
 var ProductType = /* @__PURE__ */ ((ProductType2) => {
   ProductType2["SIMPLE"] = "simple";
   ProductType2["VARIABLE"] = "variable";
+  ProductType2["BOOKING"] = "booking";
+  ProductType2["COMPOSITE"] = "composite";
   return ProductType2;
 })(ProductType || {});
 var ProductStatus = /* @__PURE__ */ ((ProductStatus2) => {
@@ -622,6 +649,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
@@ -1491,6 +1562,309 @@ function normalizeMongoIdString(value) {
   return null;
 }
 
+// utils/composite-price.util.ts
+var compositeItemCost = (item) => item.extraCharge * item.quantity;
+function cheapestCompositeItem(items) {
+  let cheapest;
+  items.forEach((item, index) => {
+    if (!item.available) return;
+    if (cheapest === void 0 || compositeItemCost(item) < compositeItemCost(items[cheapest])) cheapest = index;
+  });
+  return cheapest;
+}
+function cheapestCompositePrice(parts) {
+  let total = 0;
+  for (const part of parts) {
+    if (part.min === 0) continue;
+    const index = cheapestCompositeItem(part.items) ?? cheapestCompositeItem(part.items.map((item) => ({ ...item, available: true })));
+    if (index === void 0) return void 0;
+    total += part.min * compositeItemCost(part.items[index]);
+  }
+  return total;
+}
+
+// utils/modifier-resolution.util.ts
+function ancestorChain(categoryId, categoriesById) {
+  const chain = [];
+  const seen = /* @__PURE__ */ new Set([categoryId]);
+  let current = categoriesById.get(categoryId)?.parentId ?? void 0;
+  while (current && !seen.has(current)) {
+    chain.push(current);
+    seen.add(current);
+    current = categoriesById.get(current)?.parentId ?? void 0;
+  }
+  return chain;
+}
+function clampRule(rule) {
+  if (rule.min != null && rule.max != null && rule.min > rule.max) {
+    return { ...rule, min: rule.max };
+  }
+  return rule;
+}
+function mergeRules(a, b) {
+  const required = a.required || b.required;
+  const min = a.min == null ? b.min : b.min == null ? a.min : Math.max(a.min, b.min);
+  const max = a.max == null ? b.max : b.max == null ? a.max : Math.min(a.max, b.max);
+  return clampRule({ required, min, max, sortOrder: Math.min(a.sortOrder, b.sortOrder) });
+}
+function toRule(row) {
+  const required = row.required ?? false;
+  return clampRule({
+    required,
+    // `required` is the gate: a stale min left on a placement that went optional is
+    // ignored. A cleared min/max stays the explicit null it arrived as — nothing
+    // downstream distinguishes null from absent.
+    min: required ? row.min : void 0,
+    max: row.max,
+    sortOrder: row.sortOrder ?? 0
+  });
+}
+function toResolvedChoices(modifier) {
+  return (modifier.choices ?? []).map((choice, index) => ({
+    _id: String(choice._id),
+    name: choice.name,
+    price: choice.price ?? 0,
+    isDefault: choice.isDefault,
+    defaultQuantity: choice.defaultQuantity,
+    unavailableOutletIds: choice.unavailableOutletIds?.map(String),
+    sortOrder: choice.sortOrder ?? index
+  })).sort((a, b) => a.sortOrder - b.sortOrder);
+}
+function resolveModifiersForProduct(inputs) {
+  const categoriesById = new Map(
+    inputs.categories.filter((category) => !category.isDeleted).map((category) => [String(category._id), category])
+  );
+  const modifiersById = new Map(
+    inputs.modifiers.filter((modifier) => !modifier.isDeleted).map((modifier) => [String(modifier._id), modifier])
+  );
+  const directCategories = new Set(inputs.categoryIds.map(String));
+  const inheritedCategories = /* @__PURE__ */ new Set();
+  for (const categoryId of directCategories) {
+    for (const ancestor of ancestorChain(categoryId, categoriesById)) {
+      if (!directCategories.has(ancestor)) inheritedCategories.add(ancestor);
+    }
+  }
+  const rules = /* @__PURE__ */ new Map();
+  for (const placement of inputs.categoryModifiers) {
+    if (placement.isDeleted) continue;
+    const categoryId = String(placement.categoryId);
+    const precedence = directCategories.has(categoryId) ? 0 : inheritedCategories.has(categoryId) ? 1 : -1;
+    if (precedence === -1) continue;
+    const modifierId = String(placement.modifierId);
+    if (!modifiersById.has(modifierId)) continue;
+    const incoming = toRule(placement);
+    const existing = rules.get(modifierId);
+    if (!existing || precedence < existing.precedence) {
+      rules.set(modifierId, { precedence, rule: incoming });
+    } else if (precedence === existing.precedence) {
+      rules.set(modifierId, { precedence, rule: mergeRules(existing.rule, incoming) });
+    }
+  }
+  const resolved = [];
+  for (const [modifierId, { rule }] of rules) {
+    const modifier = modifiersById.get(modifierId);
+    if (!modifier) continue;
+    const required = rule.required;
+    resolved.push({
+      _id: modifierId,
+      name: modifier.name,
+      selectionType: modifier.selectionType,
+      allowQuantity: modifier.allowQuantity,
+      required,
+      // single-selection is implicitly capped at 1 — min/max are never carried.
+      min: modifier.selectionType === "single" ? void 0 : rule.min,
+      max: modifier.selectionType === "single" ? void 0 : rule.max,
+      sortOrder: rule.sortOrder,
+      choices: toResolvedChoices(modifier)
+    });
+  }
+  return resolved.sort((a, b) => a.sortOrder - b.sortOrder || a.name.localeCompare(b.name));
+}
+function isChoiceAvailableAtOutlet(choice, outletId) {
+  return !(choice.unavailableOutletIds ?? []).includes(outletId);
+}
+function hasSellableChoice(modifier, outletId) {
+  return modifier.choices.some((choice) => isChoiceAvailableAtOutlet(choice, outletId));
+}
+var modifiersSellable = (modifiers, outletId) => modifiers.every((modifier) => !modifier.required || hasSellableChoice(modifier, outletId));
+
+// utils/composite-availability.util.ts
+function poolStockAt(rows, outletId) {
+  if (!rows.some((row) => row.manageStock === true)) return null;
+  return Math.max(0, rows.find((row) => String(row.outletId) === outletId)?.quantity ?? 0);
+}
+function compositeVariantInStock(variantId, quantity, outlet) {
+  const shelf = outlet.shelves.get(variantId);
+  if (!shelf || shelf.unresolved) return false;
+  const onHand = outlet.poolStock.get(shelf.pool);
+  if (onHand === void 0) return false;
+  if (onHand === null || shelf.backorder) return true;
+  return onHand >= (shelf.unit ? toBase(quantity, shelf.unit) : quantity);
+}
+function compositeItemUnavailable(item, rows) {
+  const { outlet } = rows;
+  const sellableHere = (productId2) => !outlet || !outlet.hiddenProductIds.has(productId2) && !outlet.unsellableProductIds.has(productId2);
+  if (item.categoryId) {
+    const variants = rows.categoryVariants.get(String(item.categoryId));
+    if (!variants) return "deleted";
+    const offered = variants.filter((variantId2) => sellableHere(rows.variantProducts.get(variantId2) ?? ""));
+    if (!offered.length) return "empty";
+    if (!outlet) return null;
+    return offered.some((variantId2) => compositeVariantInStock(variantId2, item.quantity, outlet)) ? null : "out_of_stock";
+  }
+  const variantId = String(item.variantId);
+  const productId = rows.variantProducts.get(variantId);
+  if (!productId || !rows.productStatuses.has(productId)) return "deleted";
+  if (rows.productStatuses.get(productId) !== "active" /* ACTIVE */) return "inactive";
+  if (!outlet) return null;
+  if (outlet.hiddenProductIds.has(productId)) return "hidden";
+  if (outlet.unsellableProductIds.has(productId)) return "empty";
+  if (rows.bookableProductIds.has(productId)) {
+    if (!outlet.bookableSeats) return "by_date";
+    return (outlet.bookableSeats.get(productId) ?? 0) >= item.quantity ? null : "fully_booked";
+  }
+  return compositeVariantInStock(variantId, item.quantity, outlet) ? null : "out_of_stock";
+}
+function compositeMakeable(parts, rows) {
+  const { outlet } = rows;
+  if (!outlet) throw new Error("compositeMakeable counts at one outlet: rows.outlet is required");
+  const required = parts.map((part, partIndex) => ({ ...part, partIndex })).filter((part) => part.min > 0);
+  const isBookable = (variantId) => rows.bookableProductIds.has(rows.variantProducts.get(String(variantId)) ?? "");
+  if (required.some((part) => part.items.some((item) => item.variantId && isBookable(item.variantId))))
+    return { byDate: true };
+  const optionsOf = (item) => (item.categoryId ? rows.categoryVariants.get(String(item.categoryId)) ?? [] : [String(item.variantId)]).flatMap(
+    (variantId) => {
+      const reason = compositeItemUnavailable({ variantId, quantity: item.quantity }, rows);
+      const shelf = outlet.shelves.get(variantId);
+      if (reason && reason !== "out_of_stock" || !shelf) return [];
+      const stock = outlet.poolStock.get(shelf.pool);
+      const onHand = shelf.unresolved || stock === void 0 ? 0 : stock === null || shelf.backorder ? null : stock;
+      const perPick = shelf.unit ? toBase(item.quantity, shelf.unit) : item.quantity;
+      return [{ itemId: item.id, pool: shelf.pool, perPick, onHand }];
+    }
+  );
+  const counted = required.map((part) => ({ ...part, options: part.items.flatMap(optionsOf) }));
+  const order = [...counted].sort((a, b) => Number(a.options.length !== 1) - Number(b.options.length !== 1));
+  const picksLeft = (option, reserved) => option.onHand === null ? Infinity : Math.max(0, Math.floor((option.onHand - (reserved.get(option.pool) ?? 0)) / option.perPick));
+  const shortAt = (n) => {
+    const reserved = /* @__PURE__ */ new Map();
+    for (const part of order) {
+      let wanted = part.min * n;
+      const ranked = [...part.options].sort((a, b) => picksLeft(b, reserved) - picksLeft(a, reserved));
+      for (const option of ranked) {
+        if (wanted <= 0) break;
+        const taken = Math.min(wanted, picksLeft(option, reserved));
+        if (option.onHand !== null)
+          reserved.set(option.pool, (reserved.get(option.pool) ?? 0) + taken * option.perPick);
+        wanted -= taken;
+      }
+      if (wanted > 0) return part.partIndex;
+    }
+    return void 0;
+  };
+  const whyRows = [];
+  const rowPools = /* @__PURE__ */ new Map();
+  const makes = (has, uses) => has === null ? null : Math.floor(has / uses);
+  for (const part of counted) {
+    const [option] = part.options;
+    if (part.options.length === 1) {
+      const uses = option.perPick * part.min;
+      const row = whyRows.find((candidate) => rowPools.get(candidate) === option.pool);
+      if (!row) {
+        const created = { itemIds: [option.itemId], uses, has: option.onHand, makes: makes(option.onHand, uses) };
+        rowPools.set(created, option.pool);
+        whyRows.push(created);
+        continue;
+      }
+      row.itemIds.push(option.itemId);
+      row.uses += uses;
+      if (option.onHand === null) row.has = null;
+      row.makes = makes(row.has, row.uses);
+      continue;
+    }
+    const perPool = /* @__PURE__ */ new Map();
+    for (const candidate of part.options)
+      perPool.set(candidate.pool, Math.max(perPool.get(candidate.pool) ?? 0, picksLeft(candidate, /* @__PURE__ */ new Map())));
+    const total = [...perPool.values()].reduce((sum, picks) => sum + picks, 0);
+    const has = total === Infinity ? null : total;
+    whyRows.push({
+      itemIds: part.items.map((item) => item.id),
+      partIndex: part.partIndex,
+      uses: part.min,
+      has,
+      makes: makes(has, part.min)
+    });
+  }
+  if (counted.every((part) => part.options.some((option) => option.onHand === null)))
+    return { count: null, rows: whyRows };
+  const ceiling = Math.min(
+    ...counted.filter((part) => !part.options.some((option) => option.onHand === null)).map(
+      (part) => Math.floor(part.options.reduce((sum, option) => sum + picksLeft(option, /* @__PURE__ */ new Map()), 0) / part.min)
+    )
+  );
+  let [low, high] = [0, ceiling];
+  while (low < high) {
+    const mid = Math.ceil((low + high) / 2);
+    if (shortAt(mid) === void 0) low = mid;
+    else high = mid - 1;
+  }
+  const short = shortAt(low + 1);
+  const shortPart = counted.find((part) => part.partIndex === short);
+  const limitedBy = whyRows.findIndex(
+    (row) => shortPart?.options.length === 1 ? row.partIndex === void 0 && row.itemIds.includes(shortPart.options[0].itemId) : row.partIndex === short
+  );
+  return { count: low, rows: whyRows, ...limitedBy >= 0 ? { limitedBy } : {} };
+}
+var poolOf = (line) => line.stockVariantId || line.variantId;
+function poolDemand(lines) {
+  const demand = /* @__PURE__ */ new Map();
+  const add = (line, times) => demand.set(
+    poolOf(line),
+    (demand.get(poolOf(line)) ?? 0) + (line.unit ? toBase(line.quantity * times, line.unit) : line.quantity * times)
+  );
+  for (const line of lines) {
+    if (line.components) for (const component of line.components) add(component, line.quantity);
+    else add(line, 1);
+  }
+  return demand;
+}
+function poolShortfall(demand, poolStock, backordered = /* @__PURE__ */ new Set()) {
+  for (const [poolId, wanted] of demand) {
+    const available = poolStock.get(poolId);
+    if (available === null || available === void 0 || backordered.has(poolId)) continue;
+    if (wanted > available) return { poolId, available, wanted };
+  }
+  return null;
+}
+
+// utils/composite-reservation.util.ts
+function compositeModifierMismatches(lineItems) {
+  return lineItems.flatMap(
+    (line) => line.components?.length ? (line.modifiers ?? []).flatMap(
+      (modifier) => modifier.componentIndex !== void 0 && line.components[modifier.componentIndex] !== void 0 ? [] : [
+        `Modifier ${modifier.modifierName ?? "?"} on composite line ${line.internalId ?? "?"} names no component (componentIndex ${modifier.componentIndex}) \u2014 a composite has no modifiers of its own`
+      ]
+    ) : []
+  );
+}
+function compositeReservationMismatches(order) {
+  return (order.reservations ?? []).flatMap((reservation) => {
+    if (reservation.lineItemInternalId === void 0) return [];
+    const name = `Booking ${String(reservation.bookingId ?? "?")}`;
+    const line = order.lineItems?.find((candidate) => candidate.internalId === reservation.lineItemInternalId);
+    if (!line) return [`${name} names line ${reservation.lineItemInternalId}, which is not on the order`];
+    const component = reservation.componentIndex === void 0 ? void 0 : line.components?.[reservation.componentIndex];
+    if (!component) return [`${name} names no component ${reservation.componentIndex} of line ${line.internalId}`];
+    if (String(component.productId) !== String(reservation.productId))
+      return [
+        `${name} is for ${String(reservation.productId)}, but that component sold ${String(component.productId)}`
+      ];
+    if (reservation.price !== 0 || reservation.total !== 0)
+      return [`${name} carries money (${reservation.price}/${reservation.total}); its component already does`];
+    return [];
+  });
+}
+
 // units/family-code.ts
 var MAX_SLUG_LENGTH = 32;
 var FALLBACK_SLUG = "family";
@@ -1833,6 +2207,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;
@@ -1840,6 +2223,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;
@@ -1847,13 +2231,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;
@@ -1863,7 +2245,8 @@ function buildOrderContext(order, extras) {
       balance,
       paymentMethods,
       refunds,
-      lineItems
+      lineItems,
+      reservations
     },
     computed: {
       balance,
@@ -2943,44 +3326,409 @@ var ORDER_STATE_EVENTS = {
   configUpdated: "config-updated"
 };
 
-// constants/adyen.constants.ts
-var ADYEN_ROLLOUT_COUNTRY_CODES = /* @__PURE__ */ new Set(["CA"]);
-function isAdyenRolloutCountry(alpha2) {
-  return ADYEN_ROLLOUT_COUNTRY_CODES.has(alpha2);
+// 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);
 }
-var ADYEN_STORE_STATE_PROVINCE_COUNTRIES = /* @__PURE__ */ new Set(["AU", "BR", "CA", "IN", "MX", "NZ", "US"]);
-function adyenStoreRequiresStateOrProvince(alpha2) {
-  return !!alpha2 && ADYEN_STORE_STATE_PROVINCE_COUNTRIES.has(alpha2);
+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
+  };
 }
-var ADYEN_LEGAL_ENTITY_STATE_PROVINCE_COUNTRIES = /* @__PURE__ */ new Set(["AU", "BR", "CA", "IN", "MX", "NZ", "US"]);
-function adyenLegalEntityRequiresStateOrProvince(alpha2) {
-  return !!alpha2 && ADYEN_LEGAL_ENTITY_STATE_PROVINCE_COUNTRIES.has(alpha2);
+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`
+  );
 }
-var ADYEN_NO_TAX_NUMBER_ABSENT_COUNTRIES = /* @__PURE__ */ new Set(["CA"]);
-function adyenSupportsTaxNumberAbsent(alpha2) {
-  return !!alpha2 && !ADYEN_NO_TAX_NUMBER_ABSENT_COUNTRIES.has(alpha2);
+
+// 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 ADYEN_TAX_NUMBER_FORMATS = {
-  CA: { pattern: /^\d{9}$/, length: 9 }
+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 adyenTaxNumberFormat(alpha2) {
-  return alpha2 ? ADYEN_TAX_NUMBER_FORMATS[alpha2] : void 0;
+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 match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(fromDayKey ?? "");
+  if (!match) {
+    throw new BookingRulesError(`Booking rules: "${fromDayKey}" is not a shop day (YYYY-MM-DD)`);
+  }
+  if (!Number.isInteger(count) || count < 1) {
+    throw new BookingRulesError(`Booking rules: "${count}" is not a number of days`);
+  }
+  const [, year, month, day] = match.map(Number);
+  const from = instantFromLocal(year, month, day, 0, timeZone);
+  if (shopDayKey(from, timeZone) !== fromDayKey) {
+    throw new BookingRulesError(`Booking rules: "${fromDayKey}" is not a real day`);
+  }
+  return { from, to: instantFromLocal(year, month, day + 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 ADYEN_TAX_NUMBER_MIN_LENGTH = 5;
-var ADYEN_JOB_TITLE_ASSOCIATION_TYPES = ["signatory", "uboThroughControl"];
-function adyenRequiresJobTitle(associationType) {
-  return ADYEN_JOB_TITLE_ASSOCIATION_TYPES.includes(associationType);
+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) {
+  return ADYEN_ROLLOUT_COUNTRY_CODES.has(alpha2);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  ADYEN_JOB_TITLE_ASSOCIATION_TYPES,
-  ADYEN_LEGAL_ENTITY_STATE_PROVINCE_COUNTRIES,
-  ADYEN_NO_TAX_NUMBER_ABSENT_COUNTRIES,
   ADYEN_ROLLOUT_COUNTRY_CODES,
-  ADYEN_STORE_STATE_PROVINCE_COUNTRIES,
-  ADYEN_TAX_NUMBER_FORMATS,
-  ADYEN_TAX_NUMBER_MIN_LENGTH,
   AttributeType,
+  BookingRatePeriod,
+  BookingResourceKind,
+  BookingResourceStatus,
+  BookingRulesError,
+  BookingType,
   CONDITION_OPERATORS,
   COUNTRY_CURRENCIES,
   CURRENCY_CONFIG,
@@ -2991,6 +3739,7 @@ function adyenRequiresJobTitle(associationType) {
   DEFAULT_CONFIG,
   DEFAULT_CROSS_AXIS_RULES,
   DEFAULT_DISPLAY_STATE_MAP,
+  DEFAULT_HOLD_MINUTES,
   DEFAULT_RESOLVED_CONFIG,
   DEFAULT_UNIT_ID,
   DualWriteStrategy,
@@ -3034,8 +3783,10 @@ function adyenRequiresJobTitle(associationType) {
   REPORT_NEGATE_PATHS,
   ReceiptSendChannel,
   ReceiptType,
+  ReservationStatus,
   ResidualPaymentMethod,
   ResidualStatus,
+  ResourceAvailabilityState,
   STATE_SCHEMA,
   STRIPE_SUPPORTED_COUNTRIES,
   SYSTEM_FAMILIES,
@@ -3049,23 +3800,29 @@ function adyenRequiresJobTitle(associationType) {
   TopMetericsSort,
   UserTypes,
   addAmounts,
-  adyenLegalEntityRequiresStateOrProvince,
-  adyenRequiresJobTitle,
-  adyenStoreRequiresStateOrProvince,
-  adyenSupportsTaxNumberAbsent,
-  adyenTaxNumberFormat,
   amountToString,
+  ancestorChain,
   assertUnitSane,
   availableIn,
   baseFor,
   baseFulfillmentDefinitions,
   baseOf,
   basePaymentDefinitions,
+  buildAvailability,
+  buildGrid,
   buildOrderContext,
   buildPosPresetConfig,
   buildResolvedConfig,
   calculatePercentage,
   canTransition,
+  cheapestCompositeItem,
+  cheapestCompositePrice,
+  compositeItemCost,
+  compositeItemUnavailable,
+  compositeMakeable,
+  compositeModifierMismatches,
+  compositeReservationMismatches,
+  compositeVariantInStock,
   conditionSummary,
   convertFixedFeeToLocalCurrency,
   createAmount,
@@ -3100,8 +3857,11 @@ function adyenRequiresJobTitle(associationType) {
   getPricingRegionFromCountry,
   getSettlementTotal,
   getTotalCollected,
+  hasSellableChoice,
+  holdExpiresAt,
   inferStatesFromLegacyStatus,
   isAdyenRolloutCountry,
+  isChoiceAvailableAtOutlet,
   isConditionOperator,
   isFulfillmentState,
   isPaymentState,
@@ -3112,25 +3872,39 @@ function adyenRequiresJobTitle(associationType) {
   mapToLegacyStatus,
   maxPrecisionFor,
   mergeFragment,
+  modifiersSellable,
   multiplyAmount,
   normalizeMongoIdString,
+  occupancyIn,
   parseAmountToMinorUnits,
   parseCurrencyCode,
   parseStripeCurrencyCode,
+  planWindow,
+  poolDemand,
+  poolOf,
+  poolShortfall,
+  poolStockAt,
+  presentAt,
   removeFragment,
   resolveFamily,
+  resolveModifiersForProduct,
   resolveTemplate,
   resolveUnit,
   roundToPrecision,
   sameFamily,
   setOrderState,
+  shopDayKey,
+  shopDayRange,
   signReportForDisplay,
+  slotsForWindow,
   stringifyMinorUnits,
   subtractAmounts,
   toBase,
   toMinorUnits,
   validateConfig,
   validateFragmentCompatibility,
-  violatesFinancialInvariant
+  violatesFinancialInvariant,
+  windowEndsAt,
+  withinPresence
 });
 //# sourceMappingURL=index.js.map