@final-commerce/common 2.5.0 → 2.5.1-online.2

package/dist/index.mjs

@@ -200,6 +200,7 @@ var OrderPlatform = /* @__PURE__ */ ((OrderPlatform2) => {
   OrderPlatform2["POS"] = "in-store";
   OrderPlatform2["WOO_COMMERCE"] = "woo-commerce";
   OrderPlatform2["PUBLIC_API"] = "public-api";
+  OrderPlatform2["ONLINE_STORE"] = "online-store";
   return OrderPlatform2;
 })(OrderPlatform || {});
 var CustomerPlatform = /* @__PURE__ */ ((CustomerPlatform2) => {
@@ -485,6 +486,50 @@ var ResourceAvailabilityState = /* @__PURE__ */ ((ResourceAvailabilityState2) =>
   return ResourceAvailabilityState2;
 })(ResourceAvailabilityState || {});
 
+// enums/shipping.enum.ts
+var ShippingZoneKind = /* @__PURE__ */ ((ShippingZoneKind2) => {
+  ShippingZoneKind2["COUNTRY"] = "country";
+  ShippingZoneKind2["PROVINCE"] = "province";
+  ShippingZoneKind2["CITY"] = "city";
+  ShippingZoneKind2["EVERYWHERE"] = "everywhere";
+  return ShippingZoneKind2;
+})(ShippingZoneKind || {});
+var ShippingOptionType = /* @__PURE__ */ ((ShippingOptionType2) => {
+  ShippingOptionType2["SHIP"] = "ship";
+  ShippingOptionType2["PICKUP"] = "pickup";
+  return ShippingOptionType2;
+})(ShippingOptionType || {});
+var ShippingRateType = /* @__PURE__ */ ((ShippingRateType2) => {
+  ShippingRateType2["FLAT"] = "flat";
+  return ShippingRateType2;
+})(ShippingRateType || {});
+var ShippingChannel = /* @__PURE__ */ ((ShippingChannel2) => {
+  ShippingChannel2["WEB"] = "web";
+  ShippingChannel2["POS"] = "pos";
+  return ShippingChannel2;
+})(ShippingChannel || {});
+var ShippingNoOptionReason = /* @__PURE__ */ ((ShippingNoOptionReason2) => {
+  ShippingNoOptionReason2["INCOMPLETE"] = "INCOMPLETE";
+  ShippingNoOptionReason2["ADDRESS_MISMATCH"] = "ADDRESS_MISMATCH";
+  ShippingNoOptionReason2["NO_COVERAGE"] = "NO_COVERAGE";
+  ShippingNoOptionReason2["BLOCKED"] = "BLOCKED";
+  ShippingNoOptionReason2["NO_OPTION"] = "NO_OPTION";
+  return ShippingNoOptionReason2;
+})(ShippingNoOptionReason || {});
+var ShippingZoneError = /* @__PURE__ */ ((ShippingZoneError2) => {
+  ShippingZoneError2["NO_PLACES"] = "NO_PLACES";
+  ShippingZoneError2["INVALID_PLACE"] = "INVALID_PLACE";
+  ShippingZoneError2["DUPLICATE_PLACE"] = "DUPLICATE_PLACE";
+  ShippingZoneError2["NO_WEBSITE_OPTION"] = "NO_WEBSITE_OPTION";
+  ShippingZoneError2["INVALID_PRICE"] = "INVALID_PRICE";
+  ShippingZoneError2["INVALID_DAYS"] = "INVALID_DAYS";
+  ShippingZoneError2["INVALID_TIERS"] = "INVALID_TIERS";
+  ShippingZoneError2["NO_CHANNEL"] = "NO_CHANNEL";
+  ShippingZoneError2["PICKUP_WITHOUT_STORE"] = "PICKUP_WITHOUT_STORE";
+  ShippingZoneError2["MISSING_NAME"] = "MISSING_NAME";
+  return ShippingZoneError2;
+})(ShippingZoneError || {});
+
 // utils/currency.util.ts
 var CURRENCY_CONFIG = {
   // Major currencies with 2 decimal places
@@ -3003,7 +3048,9 @@ function buildGrid(rule, timeZone, from, to, now, busy = []) {
     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);
+    return !blocked.some(
+      ({ from: blockFrom, to: blockTo }) => start < blockTo && bufferEndAt.getTime() > blockFrom
+    );
   }).sort((first, second) => +first.startAt - +second.startAt);
 }
 function slotsForWindow(grid, startAt, endAt) {
@@ -3122,7 +3169,14 @@ function buildAvailability({
     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) };
+      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;
@@ -3195,19 +3249,376 @@ function planWindow({ rule, timeZone, presence, startAt, endAt, now, busy = [] }
 }
 var holdExpiresAt = (rule, now) => new Date(now.getTime() + (rule.window.holdMinutes ?? DEFAULT_HOLD_MINUTES) * 6e4);
 
+// shipping/fold-text.ts
+function foldText(value) {
+  return value.normalize("NFD").replace(/[̀-ͯ]/g, "").toLowerCase().replace(/&/g, " and ").replace(/[^a-z0-9]+/g, " ").trim();
+}
+
+// shipping/countries.ts
+var NOT_COUNTRIES = /* @__PURE__ */ new Set(["AC", "CP", "CQ", "DG", "EA", "EU", "EZ", "IC", "QO", "TA", "UN", "XA", "XB", "ZZ"]);
+var ALIASES = {
+  usa: "US",
+  "united states of america": "US",
+  uk: "GB",
+  "great britain": "GB",
+  england: "GB",
+  uae: "AE",
+  can: "CA",
+  mex: "MX",
+  aus: "AU",
+  gbr: "GB"
+};
+var NAME_LOCALES = ["en", "fr"];
+function regionNames(locale) {
+  try {
+    return new Intl.DisplayNames([locale], { type: "region", fallback: "none" });
+  } catch {
+    return null;
+  }
+}
+function canonicalCode(code) {
+  try {
+    return new Intl.Locale(`und-${code}`).maximize().region ?? code;
+  } catch {
+    return code;
+  }
+}
+function allCodes() {
+  const names = regionNames("en");
+  if (!names) return [];
+  const codes2 = [];
+  for (let a = 65; a <= 90; a++) {
+    for (let b = 65; b <= 90; b++) {
+      const code = String.fromCharCode(a, b);
+      if (!NOT_COUNTRIES.has(code) && names.of(code) && canonicalCode(code) === code) codes2.push(code);
+    }
+  }
+  return codes2;
+}
+var lookup = null;
+var codes = null;
+function countryCodes() {
+  codes ??= allCodes();
+  return codes;
+}
+function countryLookup() {
+  if (lookup) return lookup;
+  lookup = new Map(Object.entries(ALIASES));
+  for (const locale of NAME_LOCALES) {
+    const names = regionNames(locale);
+    if (!names) continue;
+    for (const code of countryCodes()) {
+      const name = names.of(code);
+      if (name) lookup.set(foldText(name), code);
+    }
+  }
+  return lookup;
+}
+function normalizeCountry(value) {
+  const text = (value ?? "").trim();
+  if (!text) return void 0;
+  const upper = text.toUpperCase();
+  if (upper.length === 2) {
+    if (NOT_COUNTRIES.has(upper)) return void 0;
+    const code = canonicalCode(upper);
+    if (countryCodes().includes(code)) return code;
+  }
+  return countryLookup().get(foldText(text));
+}
+function listCountries(locale = "en") {
+  const names = regionNames(locale) ?? regionNames("en");
+  return countryCodes().map((code) => ({ code, name: names?.of(code) ?? code })).sort((a, b) => a.name.localeCompare(b.name, locale));
+}
+
+// shipping/provinces.ts
+var CANADA_PROVINCES = [
+  { code: "AB", name: "Alberta", nameFr: "Alberta", postalLetters: ["T"] },
+  { code: "BC", name: "British Columbia", nameFr: "Colombie-Britannique", postalLetters: ["V"] },
+  { code: "MB", name: "Manitoba", nameFr: "Manitoba", postalLetters: ["R"] },
+  { code: "NB", name: "New Brunswick", nameFr: "Nouveau-Brunswick", postalLetters: ["E"] },
+  {
+    code: "NL",
+    name: "Newfoundland and Labrador",
+    nameFr: "Terre-Neuve-et-Labrador",
+    postalLetters: ["A"],
+    aliases: ["NF", "LB", "Newfoundland", "Labrador"]
+  },
+  { code: "NS", name: "Nova Scotia", nameFr: "Nouvelle-\xC9cosse", postalLetters: ["B"] },
+  { code: "NT", name: "Northwest Territories", nameFr: "Territoires du Nord-Ouest", postalLetters: ["X"] },
+  { code: "NU", name: "Nunavut", nameFr: "Nunavut", postalLetters: ["X"] },
+  { code: "ON", name: "Ontario", nameFr: "Ontario", postalLetters: ["K", "L", "M", "N", "P"] },
+  {
+    code: "PE",
+    name: "Prince Edward Island",
+    nameFr: "\xCEle-du-Prince-\xC9douard",
+    postalLetters: ["C"],
+    aliases: ["PEI"]
+  },
+  { code: "QC", name: "Quebec", nameFr: "Qu\xE9bec", postalLetters: ["G", "H", "J"], aliases: ["PQ"] },
+  { code: "SK", name: "Saskatchewan", nameFr: "Saskatchewan", postalLetters: ["S"] },
+  { code: "YT", name: "Yukon", nameFr: "Yukon", postalLetters: ["Y"], aliases: ["YK"] }
+];
+var PROVINCES_BY_COUNTRY = { CA: CANADA_PROVINCES };
+var lookups = /* @__PURE__ */ new Map();
+function provinceLookup(country) {
+  const provinces = PROVINCES_BY_COUNTRY[country];
+  if (!provinces) return void 0;
+  let lookup2 = lookups.get(country);
+  if (!lookup2) {
+    lookup2 = /* @__PURE__ */ new Map();
+    for (const p of provinces) {
+      for (const label of [p.code, p.name, p.nameFr, ...p.aliases ?? []]) lookup2.set(foldText(label), p.code);
+    }
+    lookups.set(country, lookup2);
+  }
+  return lookup2;
+}
+function normalizeProvince(country, value) {
+  if (!country || !value?.trim()) return void 0;
+  return provinceLookup(country)?.get(foldText(value));
+}
+function listProvinces(country) {
+  return PROVINCES_BY_COUNTRY[country] ?? [];
+}
+function provincesForPostCode(country, postCode) {
+  const letter = postCode?.charAt(0);
+  if (!country || !letter) return [];
+  return listProvinces(country).filter((p) => p.postalLetters.includes(letter)).map((p) => p.code);
+}
+
+// shipping/normalize.ts
+var EVERYWHERE_KEY = "*";
+function normalizeCityKey(value) {
+  const words = foldText(value ?? "").split(" ").filter(Boolean).map((word) => word === "saint" ? "st" : word === "sainte" ? "ste" : word);
+  return words.length ? words.join("") : void 0;
+}
+function normalizePostCode(value) {
+  const compact = (value ?? "").replace(/[^0-9a-z]/gi, "").toUpperCase();
+  return compact || void 0;
+}
+function normalizeAddress(address) {
+  if (!address) return {};
+  const country = normalizeCountry(address.country);
+  const postCode = normalizePostCode(address.postCode ?? address.postalCode ?? address.zip);
+  const fromPostCode = provincesForPostCode(country, postCode);
+  const province = normalizeProvince(country, address.state ?? address.province) ?? (fromPostCode.length === 1 ? fromPostCode[0] : void 0);
+  return { country, province, cityKey: normalizeCityKey(address.city), postCode };
+}
+function postCodeMatchesProvince(address) {
+  const candidates = provincesForPostCode(address.country, address.postCode);
+  if (!address.province || candidates.length === 0) return true;
+  return candidates.includes(address.province);
+}
+function placeKey(place) {
+  const country = normalizeCountry(place.country);
+  if (!country) return void 0;
+  if (!place.province) return country;
+  const province = normalizeProvince(country, place.province);
+  if (!province) return void 0;
+  if (!place.city) return `${country}-${province}`;
+  const city = normalizeCityKey(place.city);
+  return city ? `${country}-${province}/${city}` : void 0;
+}
+function addressPlaceKeys(address) {
+  const keys = [];
+  if (address.country && address.province && address.cityKey) {
+    keys.push(`${address.country}-${address.province}/${address.cityKey}`);
+  }
+  if (address.country && address.province) keys.push(`${address.country}-${address.province}`);
+  if (address.country) keys.push(address.country);
+  keys.push(EVERYWHERE_KEY);
+  return keys;
+}
+
+// shipping/resolve.ts
+function resolveShipping({ zones, address, itemsTotal, channel }) {
+  const shipsToCountries = countriesShippedTo(zones);
+  const none = (reason, zone2) => ({
+    zoneId: zone2?.id ?? null,
+    options: [],
+    reason,
+    message: zone2?.message?.trim() || null,
+    shipsToCountries
+  });
+  const normalized = normalizeAddress(address);
+  if (!normalized.country) return none("INCOMPLETE" /* INCOMPLETE */);
+  if (!postCodeMatchesProvince(normalized)) return none("ADDRESS_MISMATCH" /* ADDRESS_MISMATCH */);
+  const zone = findZone(zones, addressPlaceKeys(normalized));
+  if (!zone) return none("NO_COVERAGE" /* NO_COVERAGE */);
+  const offered = zone.options.filter((option) => isOffered(option, zone, channel));
+  if (offered.length === 0) {
+    return none(zone.ships ? "NO_OPTION" /* NO_OPTION */ : "BLOCKED" /* BLOCKED */, zone);
+  }
+  const quotes = offered.map((option) => quote(option, zone.id, itemsTotal));
+  const ship = quotes.filter((q) => q.type === "ship" /* SHIP */).sort((a, b) => a.amount - b.amount);
+  const pickup = quotes.filter((q) => q.type === "pickup" /* PICKUP */).sort((a, b) => a.amount - b.amount);
+  return {
+    zoneId: zone.id,
+    options: [...ship, ...pickup],
+    reason: null,
+    message: zone.ships ? null : zone.message?.trim() || null,
+    shipsToCountries
+  };
+}
+function findZone(zones, keys) {
+  const byKey = /* @__PURE__ */ new Map();
+  for (const zone of zones) {
+    for (const key of zoneKeys(zone)) if (!byKey.has(key)) byKey.set(key, zone);
+  }
+  for (const key of keys) {
+    const zone = byKey.get(key);
+    if (zone) return zone;
+  }
+  return void 0;
+}
+function zoneKeys(zone) {
+  if (zone.kind === "everywhere" /* EVERYWHERE */) return [EVERYWHERE_KEY];
+  return zone.places.map(placeKey).filter((key) => Boolean(key));
+}
+function isOffered(option, zone, channel) {
+  if (!option.channels.some((c) => c === channel)) return false;
+  if (option.type === "pickup" /* PICKUP */) return channel !== "pos" /* POS */;
+  return zone.ships;
+}
+function priceForTotal(option, itemsTotal) {
+  const tiers = [...option.priceByTotal ?? []].sort((a, b) => a.from - b.from);
+  let price = option.price;
+  for (const tier of tiers) if (itemsTotal >= tier.from) price = tier.price;
+  if (option.freeOver != null && itemsTotal >= option.freeOver) return 0;
+  return price;
+}
+function quote(option, zoneId, itemsTotal) {
+  const amount = priceForTotal(option, itemsTotal);
+  const freeOver = option.freeOver ?? null;
+  return {
+    optionId: option.id,
+    zoneId,
+    type: option.type,
+    name: option.name?.trim() || null,
+    amount,
+    amountToFree: freeOver != null && amount > 0 ? freeOver - itemsTotal : null,
+    minDays: option.minDays ?? null,
+    maxDays: option.maxDays ?? null,
+    outletId: option.outletId ?? null
+  };
+}
+function countriesShippedTo(zones) {
+  const countries = /* @__PURE__ */ new Set();
+  for (const zone of zones) {
+    if (!zone.ships) continue;
+    for (const key of zoneKeys(zone)) if (key !== EVERYWHERE_KEY) countries.add(key.slice(0, 2));
+  }
+  return [...countries].sort();
+}
+
+// shipping/validate.ts
+function validateShippingZone(zone) {
+  const problems = [...placeProblems(zone)];
+  for (const option of zone.options) problems.push(...optionProblems(option));
+  const reachesWebsite = zone.options.some((option) => option.channels.includes("web" /* WEB */));
+  if (zone.ships && !reachesWebsite) problems.push({ code: "NO_WEBSITE_OPTION" /* NO_WEBSITE_OPTION */ });
+  return problems;
+}
+function placeProblems(zone) {
+  if (zone.kind === "everywhere" /* EVERYWHERE */) {
+    return zone.places.length ? [{ code: "INVALID_PLACE" /* INVALID_PLACE */ }] : [];
+  }
+  if (zone.places.length === 0) return [{ code: "NO_PLACES" /* NO_PLACES */ }];
+  if (!zone.places.every((place) => fitsKind(place, zone.kind))) return [{ code: "INVALID_PLACE" /* INVALID_PLACE */ }];
+  const keys = zone.places.map(placeKey);
+  if (keys.some((key) => !key)) return [{ code: "INVALID_PLACE" /* INVALID_PLACE */ }];
+  if (new Set(keys).size !== keys.length) return [{ code: "DUPLICATE_PLACE" /* DUPLICATE_PLACE */ }];
+  return [];
+}
+function fitsKind(place, kind) {
+  const hasProvince = Boolean(place.province?.trim());
+  const hasCity = Boolean(place.city?.trim());
+  if (kind === "country" /* COUNTRY */) return !hasProvince && !hasCity;
+  if (kind === "province" /* PROVINCE */) return hasProvince && !hasCity;
+  if (kind === "city" /* CITY */) return hasProvince && hasCity;
+  return false;
+}
+var isAmount = (value) => Number.isInteger(value) && value >= 0;
+var isDays = (value) => value == null || isAmount(value);
+function optionProblems(option) {
+  const problems = [];
+  const isPickup = option.type === "pickup" /* PICKUP */;
+  if (!isAmount(option.price) || option.freeOver != null && !isAmount(option.freeOver)) {
+    problems.push("INVALID_PRICE" /* INVALID_PRICE */);
+  }
+  if (!isPickup && !option.name?.trim()) problems.push("MISSING_NAME" /* MISSING_NAME */);
+  if (!isDays(option.minDays) || !isDays(option.maxDays) || (option.minDays ?? 0) > (option.maxDays ?? Infinity)) {
+    problems.push("INVALID_DAYS" /* INVALID_DAYS */);
+  }
+  if (!tiersAreValid(option)) problems.push("INVALID_TIERS" /* INVALID_TIERS */);
+  if (option.channels.length === 0) problems.push("NO_CHANNEL" /* NO_CHANNEL */);
+  if (isPickup && !option.outletId) problems.push("PICKUP_WITHOUT_STORE" /* PICKUP_WITHOUT_STORE */);
+  return problems.map((code) => ({ code, optionId: option.id }));
+}
+function tiersAreValid(option) {
+  const tiers = option.priceByTotal ?? [];
+  const froms = tiers.map((tier) => tier.from);
+  return tiers.every((tier) => Number.isInteger(tier.from) && tier.from > 0 && isAmount(tier.price)) && new Set(froms).size === froms.length;
+}
+
 // constants/adyen.constants.ts
 var ADYEN_ROLLOUT_COUNTRY_CODES = /* @__PURE__ */ new Set(["CA"]);
 function isAdyenRolloutCountry(alpha2) {
   return ADYEN_ROLLOUT_COUNTRY_CODES.has(alpha2);
 }
+var AFFIRM_PRICE_PLANS = ["core", "standard", "signature"];
+function isAffirmPricePlan(value) {
+  return typeof value === "string" && AFFIRM_PRICE_PLANS.includes(value);
+}
+var AFFIRM_COUNTRY_CODES = /* @__PURE__ */ new Set(["CA"]);
+function isAffirmCountry(alpha2) {
+  return !!alpha2 && AFFIRM_COUNTRY_CODES.has(alpha2.toUpperCase());
+}
+var BNPL_METHOD_STATUS = {
+  ACTIVE: "active",
+  PENDING: "pending",
+  UNAVAILABLE: "unavailable",
+  UNKNOWN: "unknown"
+};
+var BNPL_SKIP_REASON = {
+  PENDING: "pending",
+  NO_SUPPORT_EMAIL: "no_support_email",
+  NO_CURRENCY: "no_currency",
+  NO_BUSINESS_LINE: "no_business_line"
+};
+
+// pos-types/active/ProcessorType.ts
+var ProcessorType = /* @__PURE__ */ ((ProcessorType2) => {
+  ProcessorType2["FINAL_PAY"] = "Terminal";
+  ProcessorType2["TAP_TO_PAY"] = "TapToPay";
+  ProcessorType2["MOTO"] = "Moto";
+  ProcessorType2["CLOUD"] = "Cloud";
+  ProcessorType2["BLUETOOTH"] = "Bluetooth";
+  ProcessorType2["CASH"] = "Cash";
+  ProcessorType2["CUSTOM_PAY"] = "CustomPay";
+  ProcessorType2["VENDARA"] = "Vendara";
+  ProcessorType2["REDEEM"] = "Redeem";
+  ProcessorType2["INTEGRATION"] = "Integration";
+  ProcessorType2["PAYMENT_LINK"] = "PaymentLink";
+  ProcessorType2["ONLINE_PAYMENT"] = "OnlinePayment";
+  return ProcessorType2;
+})(ProcessorType || {});
+
+// constants/payment-channel.constants.ts
+var PAYMENT_CHANNELS = ["inPerson", "online"];
 export {
   ADYEN_ROLLOUT_COUNTRY_CODES,
+  AFFIRM_COUNTRY_CODES,
+  AFFIRM_PRICE_PLANS,
   AttributeType,
+  BNPL_METHOD_STATUS,
+  BNPL_SKIP_REASON,
   BookingRatePeriod,
   BookingResourceKind,
   BookingResourceStatus,
   BookingRulesError,
   BookingType,
+  CANADA_PROVINCES,
   CONDITION_OPERATORS,
   COUNTRY_CURRENCIES,
   CURRENCY_CONFIG,
@@ -3224,6 +3635,7 @@ export {
   DualWriteStrategy,
   EUFixedRates,
   EUROPE,
+  EVERYWHERE_KEY,
   ExtensionCategory,
   FINANCIAL_INVARIANTS,
   FULFILLMENT_STATES,
@@ -3245,6 +3657,7 @@ export {
   OtherFixedRates,
   OwnerType,
   PATH_MODES,
+  PAYMENT_CHANNELS,
   PAYMENT_STATES,
   POS_VALID_INITIAL_STATES,
   PaymentMethod,
@@ -3254,6 +3667,7 @@ export {
   PricingLevel,
   PricingPlanEnum,
   PricingRegionEnum,
+  ProcessorType,
   ProductStatus,
   ProductType,
   PublicationAvailability,
@@ -3272,6 +3686,12 @@ export {
   SYSTEM_FAMILY_IDS,
   SYSTEM_UNITS,
   SYSTEM_UNIT_IDS,
+  ShippingChannel,
+  ShippingNoOptionReason,
+  ShippingOptionType,
+  ShippingRateType,
+  ShippingZoneError,
+  ShippingZoneKind,
   StationStatus,
   StripeCurrencyCode,
   StripeStatus,
@@ -3279,6 +3699,7 @@ export {
   TopMetericsSort,
   UserTypes,
   addAmounts,
+  addressPlaceKeys,
   amountToString,
   assertUnitSane,
   availableIn,
@@ -3330,6 +3751,8 @@ export {
   holdExpiresAt,
   inferStatesFromLegacyStatus,
   isAdyenRolloutCountry,
+  isAffirmCountry,
+  isAffirmPricePlan,
   isConditionOperator,
   isFulfillmentState,
   isPaymentState,
@@ -3337,19 +3760,31 @@ export {
   isSystemFamilyCode,
   isValidQuantity,
   isWhole,
+  listCountries,
+  listProvinces,
   mapToLegacyStatus,
   maxPrecisionFor,
   mergeFragment,
   multiplyAmount,
+  normalizeAddress,
+  normalizeCityKey,
+  normalizeCountry,
   normalizeMongoIdString,
+  normalizePostCode,
+  normalizeProvince,
   occupancyIn,
   parseAmountToMinorUnits,
   parseCurrencyCode,
   parseStripeCurrencyCode,
+  placeKey,
   planWindow,
+  postCodeMatchesProvince,
   presentAt,
+  priceForTotal,
+  provincesForPostCode,
   removeFragment,
   resolveFamily,
+  resolveShipping,
   resolveTemplate,
   resolveUnit,
   roundToPrecision,
@@ -3365,6 +3800,7 @@ export {
   toMinorUnits,
   validateConfig,
   validateFragmentCompatibility,
+  validateShippingZone,
   violatesFinancialInvariant,
   windowEndsAt,
   withinPresence