@final-commerce/common 1.1.4-beta.4

package/dist/index.js

@@ -0,0 +1,2702 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// index.ts
+var index_exports = {};
+__export(index_exports, {
+  AttributeType: () => AttributeType,
+  CONDITION_OPERATORS: () => CONDITION_OPERATORS,
+  COUNTRY_CURRENCIES: () => COUNTRY_CURRENCIES,
+  CURRENCY_CONFIG: () => CURRENCY_CONFIG,
+  CompanyType: () => CompanyType,
+  CurrencyCode: () => CurrencyCode,
+  CustomTableAvailability: () => CustomTableAvailability,
+  CustomerPlatform: () => CustomerPlatform,
+  DEFAULT_CONFIG: () => DEFAULT_CONFIG,
+  DEFAULT_CROSS_AXIS_RULES: () => DEFAULT_CROSS_AXIS_RULES,
+  DEFAULT_DISPLAY_STATE_MAP: () => DEFAULT_DISPLAY_STATE_MAP,
+  DEFAULT_RESOLVED_CONFIG: () => DEFAULT_RESOLVED_CONFIG,
+  EUFixedRates: () => EUFixedRates,
+  EUROPE: () => EUROPE,
+  ExtensionCategory: () => ExtensionCategory,
+  FINANCIAL_INVARIANTS: () => FINANCIAL_INVARIANTS,
+  FULFILLMENT_STATES: () => FULFILLMENT_STATES,
+  FeesCustomBillingStatus: () => FeesCustomBillingStatus,
+  InventoryBaseActionEnum: () => InventoryBaseActionEnum,
+  InventorySpecificActionType: () => InventorySpecificActionType,
+  InvoiceStatus: () => InvoiceStatus,
+  LibraryItemType: () => LibraryItemType,
+  MenuProject: () => MenuProject,
+  NAFixedRates: () => NAFixedRates,
+  NORTH_AMERICA: () => NORTH_AMERICA,
+  NonRevenueItemType: () => NonRevenueItemType,
+  ORDER_STATE_ACTIONS: () => ORDER_STATE_ACTIONS,
+  ORDER_STATE_EVENTS: () => ORDER_STATE_EVENTS,
+  ORDER_STATE_TOPIC: () => ORDER_STATE_TOPIC,
+  OrderPlatform: () => OrderPlatform,
+  OtherFixedRates: () => OtherFixedRates,
+  OwnerType: () => OwnerType,
+  PATH_MODES: () => PATH_MODES,
+  PAYMENT_STATES: () => PAYMENT_STATES,
+  POS_CROSS_AXIS_RULES: () => POS_CROSS_AXIS_RULES,
+  POS_VALID_INITIAL_STATES: () => POS_VALID_INITIAL_STATES,
+  PaymentMethod: () => PaymentMethod,
+  Platform: () => Platform,
+  PreviewImageMode: () => PreviewImageMode,
+  PricingLevel: () => PricingLevel,
+  PricingPlanEnum: () => PricingPlanEnum,
+  PricingRegionEnum: () => PricingRegionEnum,
+  ProductStatus: () => ProductStatus,
+  ProductType: () => ProductType,
+  PublicationAvailability: () => PublicationAvailability,
+  PublicationStatus: () => PublicationStatus,
+  REGION_MAPPING: () => REGION_MAPPING,
+  REPORT_NEGATE_PATHS: () => REPORT_NEGATE_PATHS,
+  ReceiptSendChannel: () => ReceiptSendChannel,
+  ReceiptType: () => ReceiptType,
+  ResidualPaymentMethod: () => ResidualPaymentMethod,
+  ResidualStatus: () => ResidualStatus,
+  STATE_SCHEMA: () => STATE_SCHEMA,
+  STRIPE_SUPPORTED_COUNTRIES: () => STRIPE_SUPPORTED_COUNTRIES,
+  StationStatus: () => StationStatus,
+  StripeCurrencyCode: () => StripeCurrencyCode,
+  StripeStatus: () => StripeStatus,
+  TimePeriod: () => TimePeriod,
+  TopMetericsSort: () => TopMetericsSort,
+  UserTypes: () => UserTypes,
+  addAmounts: () => addAmounts,
+  amountToString: () => amountToString,
+  baseFulfillmentDefinitions: () => baseFulfillmentDefinitions,
+  basePaymentDefinitions: () => basePaymentDefinitions,
+  buildOrderContext: () => buildOrderContext,
+  buildPosPresetConfig: () => buildPosPresetConfig,
+  buildResolvedConfig: () => buildResolvedConfig,
+  calculatePercentage: () => calculatePercentage,
+  canTransition: () => canTransition,
+  conditionSummary: () => conditionSummary,
+  convertFixedFeeToLocalCurrency: () => convertFixedFeeToLocalCurrency,
+  createAmount: () => createAmount,
+  crossAxisRuleApplies: () => crossAxisRuleApplies,
+  deriveDisplayState: () => deriveDisplayState,
+  displayRuleMatchesPair: () => displayRuleMatchesPair,
+  divideAmount: () => divideAmount,
+  evaluateCondition: () => evaluateCondition,
+  evaluateConditionSet: () => evaluateConditionSet,
+  formatCurrency: () => formatCurrency,
+  formatMinorUnitsToString: () => formatMinorUnitsToString,
+  fromMinorUnits: () => fromMinorUnits,
+  generateMongoID: () => generateMongoID,
+  getAvailableTransitions: () => getAvailableTransitions,
+  getCountriesByRegion: () => getCountriesByRegion,
+  getCurrencyConfig: () => getCurrencyConfig,
+  getCurrentISODate: () => getCurrentISODate,
+  getFinancialInvariantViolations: () => getFinancialInvariantViolations,
+  getMinorUnitMultiplier: () => getMinorUnitMultiplier,
+  getMinorUnits: () => getMinorUnits,
+  getPricingRegionFromCountry: () => getPricingRegionFromCountry,
+  inferStatesFromLegacyStatus: () => inferStatesFromLegacyStatus,
+  isConditionOperator: () => isConditionOperator,
+  isFulfillmentState: () => isFulfillmentState,
+  isPaymentState: () => isPaymentState,
+  isSupportedCurrency: () => isSupportedCurrency,
+  mapToLegacyStatus: () => mapToLegacyStatus,
+  mergeFragment: () => mergeFragment,
+  multiplyAmount: () => multiplyAmount,
+  normalizeMongoIdString: () => normalizeMongoIdString,
+  parseAmountToMinorUnits: () => parseAmountToMinorUnits,
+  parseCurrencyCode: () => parseCurrencyCode,
+  parseStripeCurrencyCode: () => parseStripeCurrencyCode,
+  removeFragment: () => removeFragment,
+  resolveTemplate: () => resolveTemplate,
+  setOrderState: () => setOrderState,
+  signReportForDisplay: () => signReportForDisplay,
+  stringifyMinorUnits: () => stringifyMinorUnits,
+  subtractAmounts: () => subtractAmounts,
+  toMinorUnits: () => toMinorUnits,
+  validateConfig: () => validateConfig,
+  validateFragmentCompatibility: () => validateFragmentCompatibility,
+  violatesFinancialInvariant: () => violatesFinancialInvariant
+});
+module.exports = __toCommonJS(index_exports);
+
+// enums/currency.enum.ts
+var CurrencyCode = /* @__PURE__ */ ((CurrencyCode2) => {
+  CurrencyCode2["USD"] = "USD";
+  CurrencyCode2["EUR"] = "EUR";
+  CurrencyCode2["GBP"] = "GBP";
+  CurrencyCode2["CAD"] = "CAD";
+  CurrencyCode2["AUD"] = "AUD";
+  CurrencyCode2["NZD"] = "NZD";
+  CurrencyCode2["CHF"] = "CHF";
+  CurrencyCode2["CNY"] = "CNY";
+  CurrencyCode2["INR"] = "INR";
+  CurrencyCode2["MXN"] = "MXN";
+  CurrencyCode2["BRL"] = "BRL";
+  CurrencyCode2["ZAR"] = "ZAR";
+  CurrencyCode2["SGD"] = "SGD";
+  CurrencyCode2["HKD"] = "HKD";
+  CurrencyCode2["SEK"] = "SEK";
+  CurrencyCode2["NOK"] = "NOK";
+  CurrencyCode2["DKK"] = "DKK";
+  CurrencyCode2["PLN"] = "PLN";
+  CurrencyCode2["THB"] = "THB";
+  CurrencyCode2["MYR"] = "MYR";
+  CurrencyCode2["PHP"] = "PHP";
+  CurrencyCode2["IDR"] = "IDR";
+  CurrencyCode2["AED"] = "AED";
+  CurrencyCode2["SAR"] = "SAR";
+  CurrencyCode2["ILS"] = "ILS";
+  CurrencyCode2["TRY"] = "TRY";
+  CurrencyCode2["RUB"] = "RUB";
+  CurrencyCode2["HTG"] = "HTG";
+  CurrencyCode2["BND"] = "BND";
+  CurrencyCode2["CRC"] = "CRC";
+  CurrencyCode2["BDT"] = "BDT";
+  CurrencyCode2["UAH"] = "UAH";
+  CurrencyCode2["NGN"] = "NGN";
+  CurrencyCode2["AFN"] = "AFN";
+  CurrencyCode2["ALL"] = "ALL";
+  CurrencyCode2["AMD"] = "AMD";
+  CurrencyCode2["ANG"] = "ANG";
+  CurrencyCode2["AOA"] = "AOA";
+  CurrencyCode2["ARS"] = "ARS";
+  CurrencyCode2["AWG"] = "AWG";
+  CurrencyCode2["AZN"] = "AZN";
+  CurrencyCode2["BAM"] = "BAM";
+  CurrencyCode2["BBD"] = "BBD";
+  CurrencyCode2["BGN"] = "BGN";
+  CurrencyCode2["BMD"] = "BMD";
+  CurrencyCode2["BOB"] = "BOB";
+  CurrencyCode2["BSD"] = "BSD";
+  CurrencyCode2["BTN"] = "BTN";
+  CurrencyCode2["BWP"] = "BWP";
+  CurrencyCode2["BYN"] = "BYN";
+  CurrencyCode2["BZD"] = "BZD";
+  CurrencyCode2["COP"] = "COP";
+  CurrencyCode2["CZK"] = "CZK";
+  CurrencyCode2["DOP"] = "DOP";
+  CurrencyCode2["DZD"] = "DZD";
+  CurrencyCode2["EGP"] = "EGP";
+  CurrencyCode2["ETB"] = "ETB";
+  CurrencyCode2["FJD"] = "FJD";
+  CurrencyCode2["GEL"] = "GEL";
+  CurrencyCode2["GHS"] = "GHS";
+  CurrencyCode2["GTQ"] = "GTQ";
+  CurrencyCode2["GYD"] = "GYD";
+  CurrencyCode2["HNL"] = "HNL";
+  CurrencyCode2["IRR"] = "IRR";
+  CurrencyCode2["JMD"] = "JMD";
+  CurrencyCode2["KES"] = "KES";
+  CurrencyCode2["KGS"] = "KGS";
+  CurrencyCode2["KHR"] = "KHR";
+  CurrencyCode2["KYD"] = "KYD";
+  CurrencyCode2["KZT"] = "KZT";
+  CurrencyCode2["LAK"] = "LAK";
+  CurrencyCode2["LBP"] = "LBP";
+  CurrencyCode2["LKR"] = "LKR";
+  CurrencyCode2["MAD"] = "MAD";
+  CurrencyCode2["MDL"] = "MDL";
+  CurrencyCode2["MKD"] = "MKD";
+  CurrencyCode2["MMK"] = "MMK";
+  CurrencyCode2["MNT"] = "MNT";
+  CurrencyCode2["MOP"] = "MOP";
+  CurrencyCode2["MUR"] = "MUR";
+  CurrencyCode2["MVR"] = "MVR";
+  CurrencyCode2["MZN"] = "MZN";
+  CurrencyCode2["NAD"] = "NAD";
+  CurrencyCode2["NIO"] = "NIO";
+  CurrencyCode2["NPR"] = "NPR";
+  CurrencyCode2["PAB"] = "PAB";
+  CurrencyCode2["PEN"] = "PEN";
+  CurrencyCode2["PGK"] = "PGK";
+  CurrencyCode2["PKR"] = "PKR";
+  CurrencyCode2["QAR"] = "QAR";
+  CurrencyCode2["RON"] = "RON";
+  CurrencyCode2["RSD"] = "RSD";
+  CurrencyCode2["SBD"] = "SBD";
+  CurrencyCode2["SRD"] = "SRD";
+  CurrencyCode2["SYP"] = "SYP";
+  CurrencyCode2["TJS"] = "TJS";
+  CurrencyCode2["TMT"] = "TMT";
+  CurrencyCode2["TOP"] = "TOP";
+  CurrencyCode2["TTD"] = "TTD";
+  CurrencyCode2["TZS"] = "TZS";
+  CurrencyCode2["UYU"] = "UYU";
+  CurrencyCode2["UZS"] = "UZS";
+  CurrencyCode2["VES"] = "VES";
+  CurrencyCode2["WST"] = "WST";
+  CurrencyCode2["XCD"] = "XCD";
+  CurrencyCode2["YER"] = "YER";
+  CurrencyCode2["ZMW"] = "ZMW";
+  CurrencyCode2["CDF"] = "CDF";
+  CurrencyCode2["CUP"] = "CUP";
+  CurrencyCode2["ERN"] = "ERN";
+  CurrencyCode2["FKP"] = "FKP";
+  CurrencyCode2["GIP"] = "GIP";
+  CurrencyCode2["GMD"] = "GMD";
+  CurrencyCode2["KPW"] = "KPW";
+  CurrencyCode2["LRD"] = "LRD";
+  CurrencyCode2["LSL"] = "LSL";
+  CurrencyCode2["MGA"] = "MGA";
+  CurrencyCode2["MWK"] = "MWK";
+  CurrencyCode2["SCR"] = "SCR";
+  CurrencyCode2["SDG"] = "SDG";
+  CurrencyCode2["SHP"] = "SHP";
+  CurrencyCode2["SLE"] = "SLE";
+  CurrencyCode2["SOS"] = "SOS";
+  CurrencyCode2["SSP"] = "SSP";
+  CurrencyCode2["STN"] = "STN";
+  CurrencyCode2["SZL"] = "SZL";
+  CurrencyCode2["VED"] = "VED";
+  CurrencyCode2["XCG"] = "XCG";
+  CurrencyCode2["JPY"] = "JPY";
+  CurrencyCode2["KRW"] = "KRW";
+  CurrencyCode2["VND"] = "VND";
+  CurrencyCode2["CLP"] = "CLP";
+  CurrencyCode2["ISK"] = "ISK";
+  CurrencyCode2["HUF"] = "HUF";
+  CurrencyCode2["TWD"] = "TWD";
+  CurrencyCode2["GNF"] = "GNF";
+  CurrencyCode2["BIF"] = "BIF";
+  CurrencyCode2["DJF"] = "DJF";
+  CurrencyCode2["KMF"] = "KMF";
+  CurrencyCode2["PYG"] = "PYG";
+  CurrencyCode2["RWF"] = "RWF";
+  CurrencyCode2["UGX"] = "UGX";
+  CurrencyCode2["VUV"] = "VUV";
+  CurrencyCode2["XAF"] = "XAF";
+  CurrencyCode2["XOF"] = "XOF";
+  CurrencyCode2["XPF"] = "XPF";
+  CurrencyCode2["KWD"] = "KWD";
+  CurrencyCode2["BHD"] = "BHD";
+  CurrencyCode2["OMR"] = "OMR";
+  CurrencyCode2["JOD"] = "JOD";
+  CurrencyCode2["TND"] = "TND";
+  CurrencyCode2["LYD"] = "LYD";
+  CurrencyCode2["IQD"] = "IQD";
+  return CurrencyCode2;
+})(CurrencyCode || {});
+
+// enums/core.enum.ts
+var TimePeriod = /* @__PURE__ */ ((TimePeriod2) => {
+  TimePeriod2["TODAY"] = "today";
+  TimePeriod2["THIS_WEEK"] = "this week";
+  TimePeriod2["THIS_MONTH"] = "this month";
+  TimePeriod2["THIS_YEAR"] = "this year";
+  TimePeriod2["All_TIME"] = "all_time";
+  return TimePeriod2;
+})(TimePeriod || {});
+var TopMetericsSort = /* @__PURE__ */ ((TopMetericsSort2) => {
+  TopMetericsSort2["TOTAL_PAYMENT_VOLUME"] = "totalPaymentVolume";
+  TopMetericsSort2["TOTAL_TRANSACTION"] = "totalTransaction";
+  return TopMetericsSort2;
+})(TopMetericsSort || {});
+var CompanyType = /* @__PURE__ */ ((CompanyType2) => {
+  CompanyType2["COMPANY"] = "company";
+  CompanyType2["ROOT"] = "root";
+  CompanyType2["ORGANIZATION"] = "organization";
+  return CompanyType2;
+})(CompanyType || {});
+var CustomTableAvailability = /* @__PURE__ */ ((CustomTableAvailability2) => {
+  CustomTableAvailability2["PUBLIC"] = "public";
+  CustomTableAvailability2["ORGANIZATION"] = "organization";
+  return CustomTableAvailability2;
+})(CustomTableAvailability || {});
+var AttributeType = /* @__PURE__ */ ((AttributeType2) => {
+  AttributeType2["STRING"] = "string";
+  AttributeType2["NUMBER"] = "number";
+  AttributeType2["BOOLEAN"] = "boolean";
+  AttributeType2["DATE"] = "date";
+  AttributeType2["JSON_STRING"] = "json-string";
+  return AttributeType2;
+})(AttributeType || {});
+var Platform = /* @__PURE__ */ ((Platform2) => {
+  Platform2["WOO_COMMERCE"] = "woo-commerce";
+  Platform2["SHOPIFY"] = "shopify";
+  Platform2["OLIVER"] = "oliver";
+  Platform2["STANDALONE"] = "standalone";
+  return Platform2;
+})(Platform || {});
+var OrderPlatform = /* @__PURE__ */ ((OrderPlatform2) => {
+  OrderPlatform2["POS"] = "in-store";
+  OrderPlatform2["WOO_COMMERCE"] = "woo-commerce";
+  return OrderPlatform2;
+})(OrderPlatform || {});
+var CustomerPlatform = /* @__PURE__ */ ((CustomerPlatform2) => {
+  CustomerPlatform2["POS"] = "in-store";
+  CustomerPlatform2["WOO_COMMERCE"] = "woo-commerce";
+  return CustomerPlatform2;
+})(CustomerPlatform || {});
+var StationStatus = /* @__PURE__ */ ((StationStatus2) => {
+  StationStatus2["IN_USE"] = "IN_USE";
+  StationStatus2["AVAILABLE"] = "AVAILABLE";
+  return StationStatus2;
+})(StationStatus || {});
+var InventoryBaseActionEnum = /* @__PURE__ */ ((InventoryBaseActionEnum2) => {
+  InventoryBaseActionEnum2["ADD"] = "ADD";
+  InventoryBaseActionEnum2["REMOVE"] = "REMOVE";
+  InventoryBaseActionEnum2["RECOUNT"] = "RECOUNT";
+  InventoryBaseActionEnum2["SKIP"] = "SKIP";
+  return InventoryBaseActionEnum2;
+})(InventoryBaseActionEnum || {});
+var InventorySpecificActionType = /* @__PURE__ */ ((InventorySpecificActionType2) => {
+  InventorySpecificActionType2["STOCK_RECEIVED"] = "STOCK_RECEIVED";
+  InventorySpecificActionType2["INVENTORY_RECOUNT"] = "INVENTORY_RECOUNT";
+  InventorySpecificActionType2["DAMAGE"] = "DAMAGE";
+  InventorySpecificActionType2["THEFT"] = "THEFT";
+  InventorySpecificActionType2["LOSS"] = "LOSS";
+  InventorySpecificActionType2["RESTOCK_RETURN"] = "RESTOCK_RETURN";
+  InventorySpecificActionType2["REFUND_RESTOCK_RETURN"] = "REFUND_RESTOCK_RETURN";
+  InventorySpecificActionType2["REFUND_DAMAGE"] = "REFUND_DAMAGE";
+  InventorySpecificActionType2["SALE"] = "SALE";
+  InventorySpecificActionType2["TRANSFER"] = "TRANSFER";
+  InventorySpecificActionType2["BULK_RECOUNT"] = "BULK_RECOUNT";
+  InventorySpecificActionType2["APPLIED_FROM_WOO"] = "APPLIED_FROM_WOO";
+  return InventorySpecificActionType2;
+})(InventorySpecificActionType || {});
+var ExtensionCategory = /* @__PURE__ */ ((ExtensionCategory2) => {
+  ExtensionCategory2["SYNC"] = "sync";
+  ExtensionCategory2["PAYMENT"] = "payment";
+  ExtensionCategory2["HUB"] = "hub";
+  ExtensionCategory2["BUILDER"] = "builder";
+  return ExtensionCategory2;
+})(ExtensionCategory || {});
+var FeesCustomBillingStatus = /* @__PURE__ */ ((FeesCustomBillingStatus2) => {
+  FeesCustomBillingStatus2["UNPAID"] = "unpaid";
+  FeesCustomBillingStatus2["PAID"] = "paid";
+  FeesCustomBillingStatus2["OPEN"] = "open";
+  return FeesCustomBillingStatus2;
+})(FeesCustomBillingStatus || {});
+var PricingPlanEnum = /* @__PURE__ */ ((PricingPlanEnum2) => {
+  PricingPlanEnum2["DEFAULT"] = "default";
+  PricingPlanEnum2["MINIMUM"] = "minimum";
+  PricingPlanEnum2["ORGANIZATION"] = "organization";
+  PricingPlanEnum2["PLAN"] = "plan";
+  PricingPlanEnum2["COMPANY"] = "company";
+  return PricingPlanEnum2;
+})(PricingPlanEnum || {});
+var PricingLevel = /* @__PURE__ */ ((PricingLevel2) => {
+  PricingLevel2["ORG"] = "org";
+  PricingLevel2["PLAN"] = "plan";
+  PricingLevel2["DEFAULT"] = "default";
+  PricingLevel2["MINIMUM"] = "minimum";
+  return PricingLevel2;
+})(PricingLevel || {});
+var PricingRegionEnum = /* @__PURE__ */ ((PricingRegionEnum2) => {
+  PricingRegionEnum2["EUROPE"] = "europe";
+  PricingRegionEnum2["OTHER"] = "others";
+  PricingRegionEnum2["NORTH_AMERICA"] = "northAmerica";
+  return PricingRegionEnum2;
+})(PricingRegionEnum || {});
+var MenuProject = /* @__PURE__ */ ((MenuProject2) => {
+  MenuProject2["MANAGE"] = "Manage";
+  MenuProject2["SCALE"] = "Scale";
+  MenuProject2["BUILD"] = "Build";
+  MenuProject2["PAY"] = "Pay";
+  MenuProject2["RUN"] = "Run";
+  return MenuProject2;
+})(MenuProject || {});
+var UserTypes = /* @__PURE__ */ ((UserTypes2) => {
+  UserTypes2["COMPANY_OWNER"] = "owner";
+  UserTypes2["ORG_USER"] = "organization_user";
+  UserTypes2["ORG_OWNER"] = "organization_owner";
+  UserTypes2["FINAL_USER"] = "final_user";
+  UserTypes2["FINAL_OWNER"] = "final_owner";
+  UserTypes2["EMPLOYEE"] = "employee";
+  UserTypes2["SUPER_ADMIN"] = "super_admin";
+  UserTypes2["MANAGER"] = "manager";
+  UserTypes2["ADMIN"] = "admin";
+  UserTypes2["ASSISTANT_MANAGER"] = "assistant";
+  UserTypes2["CASHIER"] = "cashier";
+  UserTypes2["RESELLER"] = "reseller";
+  return UserTypes2;
+})(UserTypes || {});
+var OwnerType = /* @__PURE__ */ ((OwnerType2) => {
+  OwnerType2["API_KEY"] = "api-key";
+  OwnerType2["ORGANIZATION"] = "organization";
+  OwnerType2["COMPANY"] = "company";
+  return OwnerType2;
+})(OwnerType || {});
+var PublicationAvailability = /* @__PURE__ */ ((PublicationAvailability2) => {
+  PublicationAvailability2["GLOBAL"] = "global";
+  PublicationAvailability2["PRIVATE"] = "private";
+  return PublicationAvailability2;
+})(PublicationAvailability || {});
+var PublicationStatus = /* @__PURE__ */ ((PublicationStatus2) => {
+  PublicationStatus2["APPROVED"] = "approved";
+  PublicationStatus2["REJECTED"] = "rejected";
+  PublicationStatus2["PENDING"] = "pending";
+  PublicationStatus2["NOT_APPLICABLE"] = "not_applicable";
+  return PublicationStatus2;
+})(PublicationStatus || {});
+var ResidualStatus = /* @__PURE__ */ ((ResidualStatus2) => {
+  ResidualStatus2["PAID"] = "paid";
+  ResidualStatus2["DUE"] = "due";
+  ResidualStatus2["ACCRUING"] = "accruing";
+  return ResidualStatus2;
+})(ResidualStatus || {});
+var PreviewImageMode = /* @__PURE__ */ ((PreviewImageMode2) => {
+  PreviewImageMode2["STATIC"] = "static";
+  PreviewImageMode2["DYNAMIC"] = "dynamic";
+  return PreviewImageMode2;
+})(PreviewImageMode || {});
+var LibraryItemType = /* @__PURE__ */ ((LibraryItemType2) => {
+  LibraryItemType2["FLOW"] = "flow";
+  LibraryItemType2["PAGE"] = "page";
+  LibraryItemType2["COMPOSITION"] = "composition";
+  LibraryItemType2["LAYOUT"] = "layout";
+  return LibraryItemType2;
+})(LibraryItemType || {});
+var ResidualPaymentMethod = /* @__PURE__ */ ((ResidualPaymentMethod2) => {
+  ResidualPaymentMethod2["CHEQUE"] = "cheque";
+  return ResidualPaymentMethod2;
+})(ResidualPaymentMethod || {});
+var PaymentMethod = /* @__PURE__ */ ((PaymentMethod2) => {
+  PaymentMethod2["CUSTOM"] = "Custom";
+  PaymentMethod2["CASH"] = "Cash";
+  PaymentMethod2["TERMINAL"] = "Terminal";
+  PaymentMethod2["CLOUD"] = "Cloud";
+  PaymentMethod2["BLUETOOTH"] = "Bluetooth";
+  return PaymentMethod2;
+})(PaymentMethod || {});
+var NonRevenueItemType = /* @__PURE__ */ ((NonRevenueItemType2) => {
+  NonRevenueItemType2["GIFT_CARD"] = "gift-card";
+  return NonRevenueItemType2;
+})(NonRevenueItemType || {});
+var ReceiptSendChannel = /* @__PURE__ */ ((ReceiptSendChannel2) => {
+  ReceiptSendChannel2["EMAIL"] = "email";
+  ReceiptSendChannel2["TEXT"] = "text";
+  return ReceiptSendChannel2;
+})(ReceiptSendChannel || {});
+var ReceiptType = /* @__PURE__ */ ((ReceiptType2) => {
+  ReceiptType2["ORDER"] = "order";
+  ReceiptType2["REFUND"] = "refund";
+  return ReceiptType2;
+})(ReceiptType || {});
+var StripeStatus = /* @__PURE__ */ ((StripeStatus2) => {
+  StripeStatus2["ACTIVE"] = "active";
+  StripeStatus2["INACTIVE"] = "inactive";
+  StripeStatus2["PAYMENT_METHOD_REQUIRED"] = "payment_method_required";
+  StripeStatus2["PAYMENT_METHOD_ADDED"] = "payment_method_added";
+  return StripeStatus2;
+})(StripeStatus || {});
+var InvoiceStatus = /* @__PURE__ */ ((InvoiceStatus2) => {
+  InvoiceStatus2["PAID"] = "paid";
+  InvoiceStatus2["PENDING"] = "pending";
+  InvoiceStatus2["EXPIRED"] = "expired";
+  return InvoiceStatus2;
+})(InvoiceStatus || {});
+
+// enums/stripe-currencies.enum.ts
+var StripeCurrencyCode = /* @__PURE__ */ ((StripeCurrencyCode2) => {
+  StripeCurrencyCode2["USD"] = "USD";
+  StripeCurrencyCode2["EUR"] = "EUR";
+  StripeCurrencyCode2["GBP"] = "GBP";
+  StripeCurrencyCode2["CAD"] = "CAD";
+  StripeCurrencyCode2["AUD"] = "AUD";
+  StripeCurrencyCode2["NZD"] = "NZD";
+  StripeCurrencyCode2["CHF"] = "CHF";
+  StripeCurrencyCode2["CNY"] = "CNY";
+  StripeCurrencyCode2["INR"] = "INR";
+  StripeCurrencyCode2["MXN"] = "MXN";
+  StripeCurrencyCode2["BRL"] = "BRL";
+  StripeCurrencyCode2["ZAR"] = "ZAR";
+  StripeCurrencyCode2["SGD"] = "SGD";
+  StripeCurrencyCode2["HKD"] = "HKD";
+  StripeCurrencyCode2["SEK"] = "SEK";
+  StripeCurrencyCode2["NOK"] = "NOK";
+  StripeCurrencyCode2["DKK"] = "DKK";
+  StripeCurrencyCode2["PLN"] = "PLN";
+  StripeCurrencyCode2["THB"] = "THB";
+  StripeCurrencyCode2["MYR"] = "MYR";
+  StripeCurrencyCode2["PHP"] = "PHP";
+  StripeCurrencyCode2["IDR"] = "IDR";
+  StripeCurrencyCode2["AED"] = "AED";
+  StripeCurrencyCode2["SAR"] = "SAR";
+  StripeCurrencyCode2["ILS"] = "ILS";
+  StripeCurrencyCode2["TRY"] = "TRY";
+  StripeCurrencyCode2["RUB"] = "RUB";
+  StripeCurrencyCode2["JPY"] = "JPY";
+  StripeCurrencyCode2["KRW"] = "KRW";
+  StripeCurrencyCode2["VND"] = "VND";
+  StripeCurrencyCode2["CLP"] = "CLP";
+  StripeCurrencyCode2["ISK"] = "ISK";
+  StripeCurrencyCode2["HUF"] = "HUF";
+  StripeCurrencyCode2["TWD"] = "TWD";
+  StripeCurrencyCode2["KWD"] = "KWD";
+  StripeCurrencyCode2["BHD"] = "BHD";
+  StripeCurrencyCode2["OMR"] = "OMR";
+  StripeCurrencyCode2["JOD"] = "JOD";
+  StripeCurrencyCode2["TND"] = "TND";
+  StripeCurrencyCode2["LYD"] = "LYD";
+  StripeCurrencyCode2["IQD"] = "IQD";
+  return StripeCurrencyCode2;
+})(StripeCurrencyCode || {});
+
+// enums/product.enum.ts
+var ProductType = /* @__PURE__ */ ((ProductType2) => {
+  ProductType2["SIMPLE"] = "simple";
+  ProductType2["VARIABLE"] = "variable";
+  return ProductType2;
+})(ProductType || {});
+var ProductStatus = /* @__PURE__ */ ((ProductStatus2) => {
+  ProductStatus2["ACTIVE"] = "active";
+  ProductStatus2["INACTIVE"] = "inactive";
+  ProductStatus2["DRAFT"] = "draft";
+  return ProductStatus2;
+})(ProductStatus || {});
+
+// utils/currency.util.ts
+var CURRENCY_CONFIG = {
+  // Major currencies with 2 decimal places
+  ["USD" /* USD */]: { minorUnits: 2, symbol: "$", symbolPosition: "prefix" },
+  ["EUR" /* EUR */]: { minorUnits: 2, symbol: "\u20AC", symbolPosition: "prefix" },
+  ["GBP" /* GBP */]: { minorUnits: 2, symbol: "\xA3", symbolPosition: "prefix" },
+  ["CAD" /* CAD */]: { minorUnits: 2, symbol: "CA$", symbolPosition: "prefix" },
+  ["AUD" /* AUD */]: { minorUnits: 2, symbol: "A$", symbolPosition: "prefix" },
+  ["NZD" /* NZD */]: { minorUnits: 2, symbol: "NZ$", symbolPosition: "prefix" },
+  ["CHF" /* CHF */]: { minorUnits: 2, symbol: "CHF", symbolPosition: "prefix" },
+  ["CNY" /* CNY */]: { minorUnits: 2, symbol: "\xA5", symbolPosition: "prefix" },
+  ["INR" /* INR */]: { minorUnits: 2, symbol: "\u20B9", symbolPosition: "prefix" },
+  ["MXN" /* MXN */]: { minorUnits: 2, symbol: "MX$", symbolPosition: "prefix" },
+  ["BRL" /* BRL */]: { minorUnits: 2, symbol: "R$", symbolPosition: "prefix" },
+  ["ZAR" /* ZAR */]: { minorUnits: 2, symbol: "R", symbolPosition: "prefix" },
+  ["SGD" /* SGD */]: { minorUnits: 2, symbol: "S$", symbolPosition: "prefix" },
+  ["HKD" /* HKD */]: { minorUnits: 2, symbol: "HK$", symbolPosition: "prefix" },
+  ["SEK" /* SEK */]: { minorUnits: 2, symbol: "kr", symbolPosition: "suffix" },
+  ["NOK" /* NOK */]: { minorUnits: 2, symbol: "kr", symbolPosition: "suffix" },
+  ["DKK" /* DKK */]: { minorUnits: 2, symbol: "kr", symbolPosition: "suffix" },
+  ["PLN" /* PLN */]: { minorUnits: 2, symbol: "z\u0142", symbolPosition: "suffix" },
+  ["THB" /* THB */]: { minorUnits: 2, symbol: "\u0E3F", symbolPosition: "prefix" },
+  ["MYR" /* MYR */]: { minorUnits: 2, symbol: "RM", symbolPosition: "prefix" },
+  ["PHP" /* PHP */]: { minorUnits: 2, symbol: "\u20B1", symbolPosition: "prefix" },
+  ["IDR" /* IDR */]: { minorUnits: 2, symbol: "Rp", symbolPosition: "prefix" },
+  ["AED" /* AED */]: { minorUnits: 2, symbol: "\u062F.\u0625", symbolPosition: "prefix" },
+  ["SAR" /* SAR */]: { minorUnits: 2, symbol: "\uFDFC", symbolPosition: "prefix" },
+  ["ILS" /* ILS */]: { minorUnits: 2, symbol: "\u20AA", symbolPosition: "prefix" },
+  ["TRY" /* TRY */]: { minorUnits: 2, symbol: "\u20BA", symbolPosition: "prefix" },
+  ["RUB" /* RUB */]: { minorUnits: 2, symbol: "\u20BD", symbolPosition: "suffix" },
+  ["HTG" /* HTG */]: { minorUnits: 2, symbol: "HTG", symbolPosition: "prefix" },
+  // New Currencies with 2 decimal places
+  ["BND" /* BND */]: { minorUnits: 2, symbol: "BND", symbolPosition: "prefix" },
+  ["CRC" /* CRC */]: { minorUnits: 2, symbol: "CRC", symbolPosition: "prefix" },
+  ["BDT" /* BDT */]: { minorUnits: 2, symbol: "BDT", symbolPosition: "prefix" },
+  ["UAH" /* UAH */]: { minorUnits: 2, symbol: "UAH", symbolPosition: "prefix" },
+  ["NGN" /* NGN */]: { minorUnits: 2, symbol: "\u20A6", symbolPosition: "prefix" },
+  ["AFN" /* AFN */]: { minorUnits: 2, symbol: "\u060B", symbolPosition: "prefix" },
+  ["ALL" /* ALL */]: { minorUnits: 2, symbol: "L", symbolPosition: "suffix" },
+  ["AMD" /* AMD */]: { minorUnits: 2, symbol: "\u058F", symbolPosition: "suffix" },
+  ["ANG" /* ANG */]: { minorUnits: 2, symbol: "\u0192", symbolPosition: "prefix" },
+  ["AOA" /* AOA */]: { minorUnits: 2, symbol: "Kz", symbolPosition: "prefix" },
+  ["ARS" /* ARS */]: { minorUnits: 2, symbol: "AR$", symbolPosition: "prefix" },
+  ["AWG" /* AWG */]: { minorUnits: 2, symbol: "Afl.", symbolPosition: "prefix" },
+  ["AZN" /* AZN */]: { minorUnits: 2, symbol: "\u20BC", symbolPosition: "prefix" },
+  ["BAM" /* BAM */]: { minorUnits: 2, symbol: "KM", symbolPosition: "suffix" },
+  ["BBD" /* BBD */]: { minorUnits: 2, symbol: "Bds$", symbolPosition: "prefix" },
+  ["BGN" /* BGN */]: { minorUnits: 2, symbol: "\u043B\u0432", symbolPosition: "suffix" },
+  ["BMD" /* BMD */]: { minorUnits: 2, symbol: "BD$", symbolPosition: "prefix" },
+  ["BOB" /* BOB */]: { minorUnits: 2, symbol: "Bs.", symbolPosition: "prefix" },
+  ["BSD" /* BSD */]: { minorUnits: 2, symbol: "B$", symbolPosition: "prefix" },
+  ["BTN" /* BTN */]: { minorUnits: 2, symbol: "Nu.", symbolPosition: "prefix" },
+  ["BWP" /* BWP */]: { minorUnits: 2, symbol: "P", symbolPosition: "prefix" },
+  ["BYN" /* BYN */]: { minorUnits: 2, symbol: "Br", symbolPosition: "suffix" },
+  ["BZD" /* BZD */]: { minorUnits: 2, symbol: "BZ$", symbolPosition: "prefix" },
+  ["COP" /* COP */]: { minorUnits: 2, symbol: "COL$", symbolPosition: "prefix" },
+  ["CZK" /* CZK */]: { minorUnits: 2, symbol: "K\u010D", symbolPosition: "suffix" },
+  ["DOP" /* DOP */]: { minorUnits: 2, symbol: "RD$", symbolPosition: "prefix" },
+  ["DZD" /* DZD */]: { minorUnits: 2, symbol: "DA", symbolPosition: "prefix" },
+  ["EGP" /* EGP */]: { minorUnits: 2, symbol: "E\xA3", symbolPosition: "prefix" },
+  ["ETB" /* ETB */]: { minorUnits: 2, symbol: "Br", symbolPosition: "prefix" },
+  ["FJD" /* FJD */]: { minorUnits: 2, symbol: "FJ$", symbolPosition: "prefix" },
+  ["GEL" /* GEL */]: { minorUnits: 2, symbol: "\u20BE", symbolPosition: "prefix" },
+  ["GHS" /* GHS */]: { minorUnits: 2, symbol: "\u20B5", symbolPosition: "prefix" },
+  ["GTQ" /* GTQ */]: { minorUnits: 2, symbol: "Q", symbolPosition: "prefix" },
+  ["GYD" /* GYD */]: { minorUnits: 2, symbol: "G$", symbolPosition: "prefix" },
+  ["HNL" /* HNL */]: { minorUnits: 2, symbol: "L", symbolPosition: "prefix" },
+  ["IRR" /* IRR */]: { minorUnits: 2, symbol: "\uFDFC", symbolPosition: "prefix" },
+  ["JMD" /* JMD */]: { minorUnits: 2, symbol: "J$", symbolPosition: "prefix" },
+  ["KES" /* KES */]: { minorUnits: 2, symbol: "KSh", symbolPosition: "prefix" },
+  ["KGS" /* KGS */]: { minorUnits: 2, symbol: "\u0441", symbolPosition: "suffix" },
+  ["KHR" /* KHR */]: { minorUnits: 2, symbol: "\u17DB", symbolPosition: "prefix" },
+  ["KYD" /* KYD */]: { minorUnits: 2, symbol: "CI$", symbolPosition: "prefix" },
+  ["KZT" /* KZT */]: { minorUnits: 2, symbol: "\u20B8", symbolPosition: "prefix" },
+  ["LAK" /* LAK */]: { minorUnits: 2, symbol: "\u20AD", symbolPosition: "prefix" },
+  ["LBP" /* LBP */]: { minorUnits: 2, symbol: "L\xA3", symbolPosition: "prefix" },
+  ["LKR" /* LKR */]: { minorUnits: 2, symbol: "Rs", symbolPosition: "prefix" },
+  ["MAD" /* MAD */]: { minorUnits: 2, symbol: "DH", symbolPosition: "prefix" },
+  ["MDL" /* MDL */]: { minorUnits: 2, symbol: "L", symbolPosition: "suffix" },
+  ["MKD" /* MKD */]: { minorUnits: 2, symbol: "\u0434\u0435\u043D", symbolPosition: "suffix" },
+  ["MMK" /* MMK */]: { minorUnits: 2, symbol: "K", symbolPosition: "prefix" },
+  ["MNT" /* MNT */]: { minorUnits: 2, symbol: "\u20AE", symbolPosition: "prefix" },
+  ["MOP" /* MOP */]: { minorUnits: 2, symbol: "MOP$", symbolPosition: "prefix" },
+  ["MUR" /* MUR */]: { minorUnits: 2, symbol: "Rs", symbolPosition: "prefix" },
+  ["MVR" /* MVR */]: { minorUnits: 2, symbol: "Rf", symbolPosition: "prefix" },
+  ["MZN" /* MZN */]: { minorUnits: 2, symbol: "MT", symbolPosition: "prefix" },
+  ["NAD" /* NAD */]: { minorUnits: 2, symbol: "N$", symbolPosition: "prefix" },
+  ["NIO" /* NIO */]: { minorUnits: 2, symbol: "C$", symbolPosition: "prefix" },
+  ["NPR" /* NPR */]: { minorUnits: 2, symbol: "Rs", symbolPosition: "prefix" },
+  ["PAB" /* PAB */]: { minorUnits: 2, symbol: "B/.", symbolPosition: "prefix" },
+  ["PEN" /* PEN */]: { minorUnits: 2, symbol: "S/", symbolPosition: "prefix" },
+  ["PGK" /* PGK */]: { minorUnits: 2, symbol: "K", symbolPosition: "prefix" },
+  ["PKR" /* PKR */]: { minorUnits: 2, symbol: "\u20A8", symbolPosition: "prefix" },
+  ["QAR" /* QAR */]: { minorUnits: 2, symbol: "QR", symbolPosition: "prefix" },
+  ["RON" /* RON */]: { minorUnits: 2, symbol: "lei", symbolPosition: "suffix" },
+  ["RSD" /* RSD */]: { minorUnits: 2, symbol: "\u0434\u0438\u043D.", symbolPosition: "suffix" },
+  ["SBD" /* SBD */]: { minorUnits: 2, symbol: "SI$", symbolPosition: "prefix" },
+  ["SRD" /* SRD */]: { minorUnits: 2, symbol: "Sr$", symbolPosition: "prefix" },
+  ["SYP" /* SYP */]: { minorUnits: 2, symbol: "\xA3S", symbolPosition: "prefix" },
+  ["TJS" /* TJS */]: { minorUnits: 2, symbol: "SM", symbolPosition: "prefix" },
+  ["TMT" /* TMT */]: { minorUnits: 2, symbol: "m.", symbolPosition: "prefix" },
+  ["TOP" /* TOP */]: { minorUnits: 2, symbol: "T$", symbolPosition: "prefix" },
+  ["TTD" /* TTD */]: { minorUnits: 2, symbol: "TT$", symbolPosition: "prefix" },
+  ["TZS" /* TZS */]: { minorUnits: 2, symbol: "TSh", symbolPosition: "prefix" },
+  ["UYU" /* UYU */]: { minorUnits: 2, symbol: "$U", symbolPosition: "prefix" },
+  ["UZS" /* UZS */]: { minorUnits: 2, symbol: "\u0441\u045E\u043C", symbolPosition: "suffix" },
+  ["VES" /* VES */]: { minorUnits: 2, symbol: "Bs.", symbolPosition: "prefix" },
+  ["WST" /* WST */]: { minorUnits: 2, symbol: "WS$", symbolPosition: "prefix" },
+  ["XCD" /* XCD */]: { minorUnits: 2, symbol: "EC$", symbolPosition: "prefix" },
+  ["YER" /* YER */]: { minorUnits: 2, symbol: "\uFDFC", symbolPosition: "prefix" },
+  ["ZMW" /* ZMW */]: { minorUnits: 2, symbol: "ZK", symbolPosition: "prefix" },
+  ["CDF" /* CDF */]: { minorUnits: 2, symbol: "FC", symbolPosition: "prefix" },
+  ["CUP" /* CUP */]: { minorUnits: 2, symbol: "$MN", symbolPosition: "prefix" },
+  ["ERN" /* ERN */]: { minorUnits: 2, symbol: "Nfk", symbolPosition: "prefix" },
+  ["FKP" /* FKP */]: { minorUnits: 2, symbol: "FK\xA3", symbolPosition: "prefix" },
+  ["GIP" /* GIP */]: { minorUnits: 2, symbol: "GI\xA3", symbolPosition: "prefix" },
+  ["GMD" /* GMD */]: { minorUnits: 2, symbol: "D", symbolPosition: "prefix" },
+  ["KPW" /* KPW */]: { minorUnits: 2, symbol: "KPW", symbolPosition: "prefix" },
+  ["LRD" /* LRD */]: { minorUnits: 2, symbol: "L$", symbolPosition: "prefix" },
+  ["LSL" /* LSL */]: { minorUnits: 2, symbol: "M", symbolPosition: "prefix" },
+  ["MGA" /* MGA */]: { minorUnits: 2, symbol: "Ar", symbolPosition: "prefix" },
+  ["MWK" /* MWK */]: { minorUnits: 2, symbol: "MK", symbolPosition: "prefix" },
+  ["SCR" /* SCR */]: { minorUnits: 2, symbol: "SR", symbolPosition: "prefix" },
+  ["SDG" /* SDG */]: { minorUnits: 2, symbol: "SDG", symbolPosition: "prefix" },
+  ["SHP" /* SHP */]: { minorUnits: 2, symbol: "SH\xA3", symbolPosition: "prefix" },
+  ["SLE" /* SLE */]: { minorUnits: 2, symbol: "Le", symbolPosition: "prefix" },
+  ["SOS" /* SOS */]: { minorUnits: 2, symbol: "SSh", symbolPosition: "prefix" },
+  ["SSP" /* SSP */]: { minorUnits: 2, symbol: "SSP", symbolPosition: "prefix" },
+  ["STN" /* STN */]: { minorUnits: 2, symbol: "Db", symbolPosition: "prefix" },
+  ["SZL" /* SZL */]: { minorUnits: 2, symbol: "E", symbolPosition: "prefix" },
+  ["VED" /* VED */]: { minorUnits: 2, symbol: "Bs.D", symbolPosition: "prefix" },
+  ["XCG" /* XCG */]: { minorUnits: 2, symbol: "Cg", symbolPosition: "prefix" },
+  // Zero decimal currencies
+  ["JPY" /* JPY */]: { minorUnits: 0, symbol: "\xA5", symbolPosition: "prefix" },
+  ["KRW" /* KRW */]: { minorUnits: 0, symbol: "\u20A9", symbolPosition: "prefix" },
+  ["VND" /* VND */]: { minorUnits: 0, symbol: "\u20AB", symbolPosition: "suffix" },
+  ["CLP" /* CLP */]: { minorUnits: 0, symbol: "CLP$", symbolPosition: "prefix" },
+  ["ISK" /* ISK */]: { minorUnits: 0, symbol: "kr", symbolPosition: "suffix" },
+  ["HUF" /* HUF */]: { minorUnits: 0, symbol: "Ft", symbolPosition: "suffix" },
+  ["TWD" /* TWD */]: { minorUnits: 0, symbol: "NT$", symbolPosition: "prefix" },
+  // New Currencies with 0 decimal places
+  ["GNF" /* GNF */]: { minorUnits: 0, symbol: "GNF", symbolPosition: "prefix" },
+  ["BIF" /* BIF */]: { minorUnits: 0, symbol: "FBu", symbolPosition: "prefix" },
+  ["DJF" /* DJF */]: { minorUnits: 0, symbol: "Fdj", symbolPosition: "prefix" },
+  ["KMF" /* KMF */]: { minorUnits: 0, symbol: "CF", symbolPosition: "prefix" },
+  ["PYG" /* PYG */]: { minorUnits: 0, symbol: "\u20B2", symbolPosition: "prefix" },
+  ["RWF" /* RWF */]: { minorUnits: 0, symbol: "FRw", symbolPosition: "prefix" },
+  ["UGX" /* UGX */]: { minorUnits: 0, symbol: "USh", symbolPosition: "prefix" },
+  ["VUV" /* VUV */]: { minorUnits: 0, symbol: "VT", symbolPosition: "prefix" },
+  ["XAF" /* XAF */]: { minorUnits: 0, symbol: "FCFA", symbolPosition: "suffix" },
+  ["XOF" /* XOF */]: { minorUnits: 0, symbol: "CFA", symbolPosition: "suffix" },
+  ["XPF" /* XPF */]: { minorUnits: 0, symbol: "\u20A3", symbolPosition: "suffix" },
+  // Three decimal currencies
+  ["KWD" /* KWD */]: { minorUnits: 3, symbol: "KD", symbolPosition: "prefix" },
+  ["BHD" /* BHD */]: { minorUnits: 3, symbol: "BD", symbolPosition: "prefix" },
+  ["OMR" /* OMR */]: { minorUnits: 3, symbol: "OMR", symbolPosition: "prefix" },
+  ["JOD" /* JOD */]: { minorUnits: 3, symbol: "JD", symbolPosition: "prefix" },
+  ["TND" /* TND */]: { minorUnits: 3, symbol: "DT", symbolPosition: "prefix" },
+  ["LYD" /* LYD */]: { minorUnits: 3, symbol: "LD", symbolPosition: "prefix" },
+  ["IQD" /* IQD */]: { minorUnits: 3, symbol: "IQD", symbolPosition: "prefix" }
+};
+var DEFAULT_CURRENCY_CONFIG = {
+  minorUnits: 2,
+  symbol: "",
+  symbolPosition: "prefix"
+};
+function getCurrencyConfig(currency) {
+  const upperCurrency = currency.toUpperCase();
+  return CURRENCY_CONFIG[upperCurrency] || DEFAULT_CURRENCY_CONFIG;
+}
+function getMinorUnitMultiplier(currency) {
+  const config = getCurrencyConfig(currency);
+  return Math.pow(10, config.minorUnits);
+}
+function toMinorUnits(amount, currency) {
+  const multiplier = getMinorUnitMultiplier(currency);
+  return Math.round(amount * multiplier);
+}
+function fromMinorUnits(minorAmount, currency) {
+  const multiplier = getMinorUnitMultiplier(currency);
+  return minorAmount / multiplier;
+}
+function formatCurrency(minorAmount, currency, options = {}) {
+  const { includeSymbol = true, useGrouping = true } = options;
+  const config = getCurrencyConfig(currency);
+  const majorAmount = fromMinorUnits(minorAmount, currency);
+  const formattedNumber = majorAmount.toLocaleString("en-US", {
+    minimumFractionDigits: config.minorUnits,
+    maximumFractionDigits: config.minorUnits,
+    useGrouping
+  });
+  if (!includeSymbol || !config.symbol) {
+    return formattedNumber;
+  }
+  if (config.symbolPosition === "suffix") {
+    return `${formattedNumber}${config.symbol}`;
+  }
+  return `${config.symbol}${formattedNumber}`;
+}
+function addAmounts(a, b) {
+  return Math.round(a + b);
+}
+function subtractAmounts(a, b) {
+  return Math.round(a - b);
+}
+function multiplyAmount(amount, multiplier) {
+  return Math.round(amount * multiplier);
+}
+function divideAmount(amount, divisor) {
+  if (divisor === 0) {
+    throw new Error("Cannot divide by zero");
+  }
+  return Math.round(amount / divisor);
+}
+function calculatePercentage(amount, percentage) {
+  return Math.round(amount * percentage / 100);
+}
+function parseAmountToMinorUnits(amountString, currency) {
+  const parsed = parseFloat(amountString);
+  if (isNaN(parsed)) {
+    return null;
+  }
+  return toMinorUnits(parsed, currency);
+}
+function isSupportedCurrency(currency) {
+  return currency.toUpperCase() in CURRENCY_CONFIG;
+}
+function parseCurrencyCode(value) {
+  if (!value || typeof value !== "string") {
+    throw new Error(`Currency value is missing or invalid`);
+  }
+  const validCodes = Object.values(CurrencyCode);
+  if (!validCodes.includes(value)) {
+    throw new Error(`"${value}" is not a supported CurrencyCode. Supported codes: ${validCodes.join(", ")}`);
+  }
+  return value;
+}
+function parseStripeCurrencyCode(value) {
+  if (!value || typeof value !== "string") {
+    throw new Error(`Currency value is missing or invalid`);
+  }
+  const validCodes = Object.values(StripeCurrencyCode);
+  if (!validCodes.includes(value)) {
+    throw new Error(`"${value}" is not a supported Stripe CurrencyCode. Supported codes: ${validCodes.join(", ")}`);
+  }
+  return value;
+}
+function stringifyMinorUnits(minorAmount, minorUnits) {
+  const multiplier = Math.pow(10, minorUnits);
+  return minorAmount / multiplier;
+}
+function formatMinorUnitsToString(minorAmount, minorUnits) {
+  const majorAmount = stringifyMinorUnits(minorAmount, minorUnits);
+  return majorAmount.toString();
+}
+function getMinorUnits(currency) {
+  return getCurrencyConfig(currency).minorUnits;
+}
+function createAmount(value, currency) {
+  if (value === null || value === void 0 || value === "") {
+    return void 0;
+  }
+  const numericValue = typeof value === "string" ? parseFloat(value) : value;
+  if (isNaN(numericValue)) {
+    return void 0;
+  }
+  const minorUnits = getMinorUnits(currency);
+  const multiplier = Math.pow(10, minorUnits);
+  return {
+    amount: Math.round(numericValue * multiplier),
+    currency,
+    minorUnits
+  };
+}
+function amountToString(amount) {
+  if (!amount) {
+    return "";
+  }
+  const divisor = Math.pow(10, amount.minorUnits);
+  const majorValue = amount.amount / divisor;
+  return majorValue.toFixed(amount.minorUnits);
+}
+
+// constants/pricing.constants.ts
+var REGION_MAPPING = {
+  // North America
+  US: "northAmerica" /* NORTH_AMERICA */,
+  CA: "northAmerica" /* NORTH_AMERICA */,
+  MX: "northAmerica" /* NORTH_AMERICA */,
+  // Europe
+  AT: "europe" /* EUROPE */,
+  BE: "europe" /* EUROPE */,
+  BG: "europe" /* EUROPE */,
+  CH: "europe" /* EUROPE */,
+  CY: "europe" /* EUROPE */,
+  CZ: "europe" /* EUROPE */,
+  DE: "europe" /* EUROPE */,
+  DK: "europe" /* EUROPE */,
+  EE: "europe" /* EUROPE */,
+  ES: "europe" /* EUROPE */,
+  FI: "europe" /* EUROPE */,
+  FR: "europe" /* EUROPE */,
+  GB: "europe" /* EUROPE */,
+  // Stripe uses 'GB' (not 'UK')
+  GR: "europe" /* EUROPE */,
+  HR: "europe" /* EUROPE */,
+  HU: "europe" /* EUROPE */,
+  IE: "europe" /* EUROPE */,
+  IT: "europe" /* EUROPE */,
+  LI: "europe" /* EUROPE */,
+  LT: "europe" /* EUROPE */,
+  LU: "europe" /* EUROPE */,
+  LV: "europe" /* EUROPE */,
+  MT: "europe" /* EUROPE */,
+  NL: "europe" /* EUROPE */,
+  NO: "europe" /* EUROPE */,
+  PL: "europe" /* EUROPE */,
+  PT: "europe" /* EUROPE */,
+  RO: "europe" /* EUROPE */,
+  SE: "europe" /* EUROPE */,
+  SI: "europe" /* EUROPE */,
+  SK: "europe" /* EUROPE */,
+  GI: "europe" /* EUROPE */,
+  // Gibraltar (NEW)
+  // Others (Asia-Pacific, Middle East, South America, etc.)
+  AE: "others" /* OTHER */,
+  // United Arab Emirates
+  AU: "others" /* OTHER */,
+  // Australia
+  BR: "others" /* OTHER */,
+  // Brazil (NEW)
+  HK: "others" /* OTHER */,
+  // Hong Kong
+  IN: "others" /* OTHER */,
+  // India (NEW)
+  JP: "others" /* OTHER */,
+  // Japan
+  MY: "others" /* OTHER */,
+  // Malaysia
+  NZ: "others" /* OTHER */,
+  // New Zealand
+  SG: "others" /* OTHER */,
+  // Singapore
+  TH: "others" /* OTHER */
+  // Thailand
+};
+var STRIPE_SUPPORTED_COUNTRIES = /* @__PURE__ */ new Set([
+  // North America
+  "US",
+  "CA",
+  "MX",
+  // Europe
+  "AT",
+  "BE",
+  "BG",
+  "CH",
+  "CY",
+  "CZ",
+  "DE",
+  "DK",
+  "EE",
+  "ES",
+  "FI",
+  "FR",
+  "GB",
+  "GR",
+  "HR",
+  "HU",
+  "IE",
+  "IT",
+  "LI",
+  "LT",
+  "LU",
+  "LV",
+  "MT",
+  "NL",
+  "NO",
+  "PL",
+  "PT",
+  "RO",
+  "SE",
+  "SI",
+  "SK",
+  // Others
+  "AE",
+  // United Arab Emirates
+  "AU",
+  // Australia
+  "BR",
+  // Brazil (NEW)
+  "GI",
+  // Gibraltar (NEW)
+  "HK",
+  // Hong Kong
+  "IN",
+  // India (NEW)
+  "JP",
+  // Japan
+  "MY",
+  // Malaysia
+  "NZ",
+  // New Zealand
+  "SG",
+  // Singapore
+  "TH"
+  // Thailand
+]);
+var NAFixedRates = {
+  USD: { rate: 30, country: "United States" },
+  CAD: { rate: 20, country: "Canada" },
+  MXN: { rate: 300, country: "Mexico" }
+};
+var EUFixedRates = {
+  EUR: { rate: 30, country: "European Union" },
+  GBP: { rate: 20, country: "Great Britain" },
+  CHF: { rate: 30, country: "Switzerland" },
+  DKK: { rate: 180, country: "Denmark" },
+  NOK: { rate: 200, country: "Norway" },
+  SEK: { rate: 180, country: "Sweden" },
+  PLN: { rate: 100, country: "Poland" }
+};
+var OtherFixedRates = {
+  AUD: { rate: 30, country: "Australia" },
+  NZD: { rate: 30, country: "New Zealand" },
+  SGD: { rate: 50, country: "Singapore" },
+  MYR: { rate: 100, country: "Malaysia" },
+  JPY: { rate: 30, country: "Japan" }
+};
+var COUNTRY_CURRENCIES = {
+  US: "USD",
+  CA: "CAD",
+  MX: "MXN",
+  AT: "EUR",
+  BE: "EUR",
+  BG: "BGN",
+  CH: "CHF",
+  CY: "EUR",
+  CZ: "CZK",
+  DE: "EUR",
+  DK: "DKK",
+  EE: "EUR",
+  ES: "EUR",
+  FI: "EUR",
+  FR: "EUR",
+  GB: "GBP",
+  GI: "GIP",
+  GR: "EUR",
+  HR: "EUR",
+  HU: "HUF",
+  IE: "EUR",
+  IT: "EUR",
+  LI: "CHF",
+  LT: "EUR",
+  LU: "EUR",
+  LV: "EUR",
+  MT: "EUR",
+  NL: "EUR",
+  NO: "NOK",
+  PL: "PLN",
+  PT: "EUR",
+  RO: "RON",
+  SE: "SEK",
+  SI: "EUR",
+  SK: "EUR",
+  AE: "AED",
+  AU: "AUD",
+  BR: "BRL",
+  HK: "HKD",
+  IN: "INR",
+  JP: "JPY",
+  MY: "MYR",
+  NZ: "NZD",
+  SG: "SGD",
+  TH: "THB"
+};
+
+// utils/pricing.util.ts
+function getPricingRegionFromCountry(countryCode) {
+  const code = (countryCode || "").toUpperCase();
+  if (NORTH_AMERICA.has(code)) return "northAmerica" /* NORTH_AMERICA */;
+  if (EUROPE.has(code)) return "europe" /* EUROPE */;
+  return "others" /* OTHER */;
+}
+var NORTH_AMERICA = getCountriesByRegion("northAmerica" /* NORTH_AMERICA */);
+var EUROPE = getCountriesByRegion("europe" /* EUROPE */);
+function convertFixedFeeToLocalCurrency(currency, region) {
+  const currencyCode = currency.toUpperCase();
+  let fixedRate;
+  switch (region) {
+    case "northAmerica" /* NORTH_AMERICA */: {
+      fixedRate = NAFixedRates[currencyCode];
+      break;
+    }
+    case "europe" /* EUROPE */: {
+      fixedRate = EUFixedRates[currencyCode];
+      break;
+    }
+    case "others" /* OTHER */: {
+      fixedRate = OtherFixedRates[currencyCode];
+      break;
+    }
+  }
+  return fixedRate?.rate ?? null;
+}
+function getCountriesByRegion(region) {
+  const countries = /* @__PURE__ */ new Set();
+  for (const [country, mappedRegion] of Object.entries(REGION_MAPPING)) {
+    if (mappedRegion === region) {
+      countries.add(country);
+    }
+  }
+  return countries;
+}
+
+// utils/report-sign.util.ts
+var REPORT_NEGATE_PATHS = /* @__PURE__ */ new Set([
+  // Sales summary — reductions to revenue
+  "salesSummary.discounts.netDiscounts",
+  "salesSummary.refundsItems",
+  // Settlement — money going out of the merchant
+  "settlementBreakdown.cards.refunded",
+  "settlementBreakdown.cards.processingFees",
+  "settlementBreakdown.cash.refunded",
+  "settlementBreakdown.custom[].refunded",
+  "settlementBreakdown.custom[].processingFees",
+  // Tax breakdown — refunds sub-table renders signed-negative
+  "taxBreakdown.refunds.entries[].taxableSales",
+  "taxBreakdown.refunds.entries[].tax",
+  "taxBreakdown.refunds.total.taxableSales",
+  "taxBreakdown.refunds.total.tax",
+  // Refunds breakdown — reductions and naturally-signed entries
+  "refundsBreakdown.discountsReversed",
+  "refundsBreakdown.cashRoundingRefund",
+  // Fees breakdown — refunded magnitudes are money flowing back out
+  "feesBreakdown.productFee.refundedProductFees",
+  "feesBreakdown.cartFee.refundedCartFees",
+  // Discounts breakdown — refunded magnitudes reverse discount reductions
+  "discountsBreakdown.productDiscounts.refundedProductDiscounts",
+  "discountsBreakdown.cartDiscounts.refundedCartDiscounts",
+  // Staff sales — refunds are money flowing back out
+  "staffSales.staffSales[].refundSales",
+  "staffSales.refundTotal",
+  // Tips — refunds are money flowing back out
+  "tipsBreakdown.tips[].refundAmount"
+]);
+function signReportForDisplay(report) {
+  return negateAtPaths(report, "", REPORT_NEGATE_PATHS);
+}
+function negateAtPaths(value, path, paths) {
+  if (Array.isArray(value)) {
+    const next = `${path}[]`;
+    return value.map((item) => negateAtPaths(item, next, paths));
+  }
+  if (value !== null && typeof value === "object") {
+    const out = {};
+    for (const [key, child] of Object.entries(value)) {
+      const next = path ? `${path}.${key}` : key;
+      out[key] = negateAtPaths(child, next, paths);
+    }
+    return out;
+  }
+  if (typeof value === "number" && paths.has(path)) {
+    return value === 0 ? 0 : -value;
+  }
+  return value;
+}
+
+// utils/mongo.util.ts
+function padHex(value, length) {
+  return value.toString(16).padStart(length, "0");
+}
+var PROCESS_RANDOM = Array.from(
+  { length: 5 },
+  () => padHex(Math.floor(Math.random() * 256), 2)
+).join("");
+var objectIdCounter = Math.floor(Math.random() * 16777215);
+function generateMongoID() {
+  const timestamp = padHex(Math.floor(Date.now() / 1e3), 8);
+  objectIdCounter = (objectIdCounter + 1) % 16777216;
+  return timestamp + PROCESS_RANDOM + padHex(objectIdCounter, 6);
+}
+function getCurrentISODate() {
+  const now = new Date(Date.now());
+  return now.toISOString();
+}
+function normalizeMongoIdString(value) {
+  if (value == null || value === "") {
+    return null;
+  }
+  if (typeof value === "string") {
+    const t = value.trim();
+    return t.length > 0 ? t : null;
+  }
+  if (typeof value === "object" && value !== null && "$oid" in value) {
+    const oid = value.$oid;
+    return typeof oid === "string" && oid.length > 0 ? oid : null;
+  }
+  return null;
+}
+
+// order-state-machine/types.ts
+var PAYMENT_STATES = [
+  "unpaid",
+  "payment_pending",
+  "partially_paid",
+  "paid",
+  "partially_refunded",
+  "refunded",
+  "voided"
+];
+var FULFILLMENT_STATES = [
+  "draft",
+  "pending",
+  "on_hold",
+  "in_progress",
+  "fulfilled",
+  "partially_fulfilled",
+  "returned",
+  "partially_returned",
+  "cancelled"
+];
+function isPaymentState(value) {
+  return PAYMENT_STATES.includes(value);
+}
+function isFulfillmentState(value) {
+  return FULFILLMENT_STATES.includes(value);
+}
+var CONDITION_OPERATORS = [
+  "eq",
+  "neq",
+  "gt",
+  "gte",
+  "lt",
+  "lte",
+  "in",
+  "notIn",
+  "isEmpty",
+  "isNotEmpty"
+];
+function isConditionOperator(value) {
+  return CONDITION_OPERATORS.includes(value);
+}
+var PATH_MODES = [
+  "strict",
+  "permissive"
+];
+
+// order-state-machine/state-schema.ts
+var PAYMENT_DEFS = [
+  { id: "unpaid", label: "Unpaid", terminal: false },
+  { id: "payment_pending", label: "Payment Pending", terminal: false },
+  { id: "partially_paid", label: "Partially Paid", terminal: false },
+  { id: "paid", label: "Paid", terminal: false },
+  { id: "partially_refunded", label: "Partially Refunded", terminal: false },
+  { id: "refunded", label: "Refunded", terminal: true },
+  { id: "voided", label: "Voided", terminal: true }
+];
+var FULFILLMENT_DEFS = [
+  { id: "draft", label: "Draft", terminal: false },
+  { id: "pending", label: "Pending", terminal: false },
+  { id: "on_hold", label: "On Hold", terminal: false },
+  { id: "in_progress", label: "In Progress", terminal: false },
+  { id: "fulfilled", label: "Fulfilled", terminal: true },
+  { id: "partially_fulfilled", label: "Partially Fulfilled", terminal: false },
+  { id: "returned", label: "Returned", terminal: true },
+  { id: "partially_returned", label: "Partially Returned", terminal: false },
+  { id: "cancelled", label: "Cancelled", terminal: true }
+];
+function basePaymentDefinitions() {
+  return PAYMENT_DEFS.map((d) => ({
+    id: d.id,
+    label: d.label,
+    isBase: true,
+    isTerminal: d.terminal
+  }));
+}
+function baseFulfillmentDefinitions() {
+  return FULFILLMENT_DEFS.map((d) => ({
+    id: d.id,
+    label: d.label,
+    isBase: true,
+    isTerminal: d.terminal
+  }));
+}
+var STATE_SCHEMA = Object.freeze({
+  paymentStates: Object.freeze(basePaymentDefinitions()),
+  fulfillmentStates: Object.freeze(baseFulfillmentDefinitions())
+});
+
+// order-state-machine/financial-invariants.ts
+var REFUND_ALLOWED_FULFILLMENT = /* @__PURE__ */ new Set(["fulfilled", "returned", "partially_returned", "cancelled"]);
+var PAYMENT_COLLECTION_ORDER = ["unpaid", "partially_paid", "paid"];
+var FINANCIAL_INVARIANTS = [
+  {
+    id: "no-leave-refunded",
+    description: "Cannot change payment state after a full refund (no un-refund / reactivation of funds)",
+    check: (from, to) => from?.payment === "refunded" && to.payment !== "refunded"
+  },
+  {
+    id: "no-leave-voided",
+    description: "Cannot un-void payment (voided orders stay voided on the payment axis)",
+    check: (from, to) => from?.payment === "voided" && to.payment !== "voided"
+  },
+  {
+    id: "no-refund-without-fulfillment",
+    description: "Cannot mark payment as fully refunded unless fulfillment is delivered, returned, or cancelled",
+    check: (_from, to) => to.payment === "refunded" && !REFUND_ALLOWED_FULFILLMENT.has(to.fulfillment)
+  },
+  {
+    id: "no-partial-refund-in-draft",
+    description: "Cannot partially refund while order is still in draft fulfillment",
+    check: (_from, to) => to.payment === "partially_refunded" && to.fulfillment === "draft"
+  },
+  {
+    id: "no-payment-regression",
+    description: "Payment cannot regress to a lower collection state without a refund \u2014 collected funds must be returned through the refund flow, not by reverting payment state",
+    check: (from, to) => {
+      if (!from) return false;
+      const fromIdx = PAYMENT_COLLECTION_ORDER.indexOf(from.payment);
+      const toIdx = PAYMENT_COLLECTION_ORDER.indexOf(to.payment);
+      return fromIdx !== -1 && toIdx !== -1 && fromIdx > toIdx;
+    }
+  }
+];
+function getFinancialInvariantViolations(from, to) {
+  const ids = [];
+  for (const inv of FINANCIAL_INVARIANTS) {
+    if (inv.check(from, to)) {
+      ids.push(inv.id);
+    }
+  }
+  return ids;
+}
+function violatesFinancialInvariant(from, to) {
+  return getFinancialInvariantViolations(from, to).length > 0;
+}
+
+// order-state-machine/default-cross-axis-rules.ts
+var DEFAULT_CROSS_AXIS_RULES = [
+  {
+    id: "require-payment-before-prep",
+    label: "Require payment before prep",
+    description: "When moving fulfillment to in progress, payment must be paid or partially paid",
+    enabled: true,
+    trigger: { axis: "fulfillment", to: "in_progress" },
+    requires: { axis: "payment", states: ["paid", "partially_paid"] }
+  },
+  {
+    id: "require-fulfillment-or-return-before-full-refund",
+    label: "Require fulfillment or return before full refund",
+    description: "When moving payment to refunded, fulfillment must be fulfilled, returned, partially returned, or cancelled",
+    enabled: true,
+    trigger: { axis: "payment", to: "refunded" },
+    requires: {
+      axis: "fulfillment",
+      states: ["fulfilled", "returned", "partially_returned", "cancelled"]
+    }
+  },
+  {
+    id: "require-return-context-before-partial-refund",
+    label: "Require return path before partial refund",
+    description: "When moving payment to partially refunded, fulfillment must reflect a completed or return path",
+    enabled: true,
+    trigger: { axis: "payment", to: "partially_refunded" },
+    requires: {
+      axis: "fulfillment",
+      states: ["fulfilled", "partially_returned", "returned"]
+    }
+  },
+  {
+    id: "block-fulfillment-when-payment-voided",
+    label: "Block fulfillment completion when payment is voided",
+    description: "When moving fulfillment to fulfilled, payment must not be voided",
+    enabled: true,
+    trigger: { axis: "fulfillment", to: "fulfilled" },
+    requires: {
+      axis: "payment",
+      states: ["unpaid", "partially_paid", "paid", "partially_refunded", "refunded"]
+    }
+  },
+  {
+    id: "require-payment-before-fulfillment-complete",
+    label: "Require payment before fulfillment complete",
+    description: "When moving fulfillment to fulfilled, payment must be paid or partially paid",
+    enabled: true,
+    trigger: { axis: "fulfillment", to: "fulfilled" },
+    requires: { axis: "payment", states: ["paid", "partially_paid"] }
+  }
+];
+
+// order-state-machine/default-config.ts
+var DEFAULT_EPOCH = /* @__PURE__ */ new Date(0);
+var PAYMENT_LABELS = new Map(
+  basePaymentDefinitions().map((d) => [d.id, d.label])
+);
+var FULFILLMENT_LABELS = new Map(
+  baseFulfillmentDefinitions().map((d) => [d.id, d.label])
+);
+var TERMINAL_PAYMENT_STATES = new Set(
+  basePaymentDefinitions().filter((d) => d.isTerminal).map((d) => d.id)
+);
+var DISPLAY_LABEL_OVERRIDES = {
+  "unpaid|draft": "In Cart",
+  "unpaid|pending": "Pending Payment",
+  "unpaid|on_hold": "On Hold",
+  "unpaid|cancelled": "Cancelled",
+  "partially_paid|pending": "Deposit Received",
+  "partially_paid|on_hold": "On Hold - Deposit Received",
+  "paid|pending": "Paid - Awaiting Fulfillment",
+  "paid|on_hold": "Paid - On Hold",
+  "paid|fulfilled": "Completed",
+  "partially_refunded|fulfilled": "Partially Refunded",
+  "partially_refunded|partially_returned": "Partially Returned",
+  "refunded|fulfilled": "Refunded",
+  "refunded|returned": "Returned and Refunded",
+  "voided|cancelled": "Cancelled"
+};
+function buildDefaultDisplayStateMap() {
+  const rules = [];
+  for (const p of PAYMENT_STATES) {
+    for (const f of FULFILLMENT_STATES) {
+      const key = `${p}|${f}`;
+      const override = DISPLAY_LABEL_OVERRIDES[key];
+      if (TERMINAL_PAYMENT_STATES.has(p) && !override) continue;
+      const label = override ?? `${PAYMENT_LABELS.get(p)} / ${FULFILLMENT_LABELS.get(f)}`;
+      rules.push({ paymentState: p, fulfillmentState: f, label });
+    }
+  }
+  return rules;
+}
+var DEFAULT_DISPLAY_STATE_MAP = buildDefaultDisplayStateMap();
+var DEFAULT_CONFIG = {
+  _id: "default",
+  companyId: "system",
+  version: 1,
+  name: "Default",
+  isDefault: true,
+  paymentPaths: [],
+  fulfillmentPaths: [],
+  paymentPathMode: "permissive",
+  fulfillmentPathMode: "permissive",
+  crossAxisRules: [...DEFAULT_CROSS_AXIS_RULES],
+  transitionConditions: [],
+  validInitialStates: [{ payment: "unpaid", fulfillment: "draft" }],
+  displayStateMap: [...DEFAULT_DISPLAY_STATE_MAP],
+  createdAt: DEFAULT_EPOCH,
+  updatedAt: DEFAULT_EPOCH
+};
+function buildResolvedConfig(config) {
+  return {
+    ...config,
+    paymentStates: STATE_SCHEMA.paymentStates,
+    fulfillmentStates: STATE_SCHEMA.fulfillmentStates
+  };
+}
+var DEFAULT_RESOLVED_CONFIG = buildResolvedConfig(DEFAULT_CONFIG);
+
+// order-state-machine/pos-preset.ts
+var POS_CROSS_AXIS_RULES = [
+  {
+    id: "pos-pay-requires-open-fulfillment",
+    label: "Payments only on open fulfillment states",
+    description: "POS payments are only valid on orders whose fulfillment is open (draft / pending / on_hold) or auto-fulfilled in lock-step (fulfilled). Returned / cancelled / in-progress fulfillment must use refund flows instead.",
+    enabled: true,
+    trigger: { axis: "payment", to: ["payment_pending", "paid", "partially_paid"] },
+    requires: {
+      axis: "fulfillment",
+      states: ["draft", "pending", "on_hold", "fulfilled"]
+    }
+  }
+];
+var POS_VALID_INITIAL_STATES = [
+  { payment: "unpaid", fulfillment: "draft" },
+  { payment: "unpaid", fulfillment: "on_hold" },
+  { payment: "unpaid", fulfillment: "pending" },
+  { payment: "paid", fulfillment: "fulfilled" },
+  { payment: "partially_paid", fulfillment: "draft" },
+  { payment: "partially_paid", fulfillment: "pending" }
+];
+function buildPosPresetConfig(companyId) {
+  return {
+    ...DEFAULT_CONFIG,
+    _id: "pos-preset",
+    companyId: companyId ?? DEFAULT_CONFIG.companyId,
+    name: "POS Preset",
+    crossAxisRules: [...DEFAULT_CROSS_AXIS_RULES, ...POS_CROSS_AXIS_RULES],
+    validInitialStates: [...POS_VALID_INITIAL_STATES],
+    displayStateMap: [...DEFAULT_DISPLAY_STATE_MAP]
+  };
+}
+
+// order-state-machine/build-order-context.ts
+function sumNumbers(items) {
+  if (!items?.length) return 0;
+  let t = 0;
+  for (const x of items) {
+    const n = x.amount;
+    if (typeof n === "number" && Number.isFinite(n)) t += n;
+  }
+  return t;
+}
+function sumRefundQuantities(refunds) {
+  if (!refunds?.length) return 0;
+  let t = 0;
+  for (const r of refunds) {
+    const q = r.quantity;
+    if (typeof q === "number" && Number.isFinite(q) && q > 0) t += q;
+  }
+  return t;
+}
+function buildOrderContext(order, extras) {
+  const o = order ?? {};
+  const total = typeof o.total === "number" && Number.isFinite(o.total) ? o.total : 0;
+  const balance = typeof o.balance === "number" && Number.isFinite(o.balance) ? o.balance : 0;
+  const paymentMethods = o.paymentMethods ?? [];
+  const refunds = o.refunds ?? o.refund ?? [];
+  const lineItems = o.lineItems ?? [];
+  const totalPaid = sumNumbers(paymentMethods);
+  const totalRefunded = sumRefundQuantities(refunds);
+  const isFullyPaid = total > 0 ? balance <= 0 : totalPaid > 0 && balance <= 0;
+  const hasPartialPayments = totalPaid > 0 && balance > 0;
+  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);
+  }
+  const isFullyReturned = itemCount > 0 ? returnedItemCount >= itemCount : returnedItemCount > 0;
+  const hasPartialReturns = returnedItemCount > 0 && !isFullyReturned;
+  return {
+    order: {
+      total,
+      balance,
+      paymentMethods,
+      refunds,
+      lineItems
+    },
+    computed: {
+      balance,
+      isFullyPaid,
+      hasPartialPayments,
+      totalPaid,
+      totalRefunded,
+      itemCount,
+      fulfilledItemCount,
+      returnedItemCount,
+      isFullyReturned,
+      hasPartialReturns
+    },
+    splitPayment: extras?.splitPayment
+  };
+}
+
+// order-state-machine/display-state.ts
+function matchesOptional(actual, rule) {
+  if (rule === void 0) return true;
+  return Array.isArray(rule) ? rule.includes(actual) : rule === actual;
+}
+function deriveDisplayState(payment, fulfillment, config) {
+  for (const rule of config.displayStateMap) {
+    if (matchesOptional(payment, rule.paymentState) && matchesOptional(fulfillment, rule.fulfillmentState)) {
+      return { label: rule.label, color: rule.color, icon: rule.icon };
+    }
+  }
+  return { label: `${payment} / ${fulfillment}` };
+}
+function displayRuleMatchesPair(rule, payment, fulfillment) {
+  return matchesOptional(payment, rule.paymentState) && matchesOptional(fulfillment, rule.fulfillmentState);
+}
+
+// order-state-machine/condition-eval.ts
+function getByPath(root, path) {
+  const parts = path.split(".").filter(Boolean);
+  let cur = root;
+  for (const p of parts) {
+    if (cur === null || cur === void 0) return void 0;
+    if (typeof cur !== "object") return void 0;
+    cur = cur[p];
+  }
+  return cur;
+}
+function isEmptyValue(v) {
+  if (v === null || v === void 0) return true;
+  if (typeof v === "string") return v.length === 0;
+  if (Array.isArray(v)) return v.length === 0;
+  return false;
+}
+function evaluateCondition(condition, context) {
+  const left = getByPath(context, condition.field);
+  const op = condition.operator;
+  const right = condition.value;
+  let ok = false;
+  switch (op) {
+    case "eq":
+      ok = left === right;
+      break;
+    case "neq":
+      ok = left !== right;
+      break;
+    case "gt":
+      ok = typeof left === "number" && typeof right === "number" && left > right;
+      break;
+    case "gte":
+      ok = typeof left === "number" && typeof right === "number" && left >= right;
+      break;
+    case "lt":
+      ok = typeof left === "number" && typeof right === "number" && left < right;
+      break;
+    case "lte":
+      ok = typeof left === "number" && typeof right === "number" && left <= right;
+      break;
+    case "in":
+      ok = Array.isArray(right) && right.some((r) => r === left);
+      break;
+    case "notIn":
+      ok = Array.isArray(right) && !right.some((r) => r === left);
+      break;
+    case "isEmpty":
+      ok = isEmptyValue(left);
+      break;
+    case "isNotEmpty":
+      ok = !isEmptyValue(left);
+      break;
+    default: {
+      const _exhaustive = op;
+      return {
+        ok: false,
+        failed: {
+          field: condition.field,
+          operator: condition.operator,
+          value: condition.value,
+          reason: `Unknown operator: ${_exhaustive}`
+        }
+      };
+    }
+  }
+  if (!ok) {
+    return {
+      ok: false,
+      failed: {
+        field: condition.field,
+        operator: condition.operator,
+        value: condition.value
+      }
+    };
+  }
+  return { ok: true };
+}
+function groupPasses(group, context) {
+  const failed = [];
+  for (const c of group.conditions) {
+    const r = evaluateCondition(c, context);
+    if (!r.ok && r.failed) failed.push(r.failed);
+  }
+  return { ok: failed.length === 0, failed };
+}
+function evaluateConditionSet(set, context) {
+  if (!set || set.groups.length === 0) {
+    return { ok: true, failedConditions: [] };
+  }
+  const allFailed = [];
+  for (const g of set.groups) {
+    const { ok, failed } = groupPasses(g, context);
+    if (ok) return { ok: true, failedConditions: [] };
+    allFailed.push(...failed);
+  }
+  return { ok: false, failedConditions: allFailed };
+}
+function conditionSummary(c) {
+  return `${c.field} ${c.operator} ${JSON.stringify(c.value)}`;
+}
+
+// order-state-machine/engine.ts
+function pairInInitialList(to, config) {
+  return config.validInitialStates.some(
+    (p) => p.payment === to.payment && p.fulfillment === to.fulfillment
+  );
+}
+function triggerTargets(rule) {
+  const t = rule.trigger.to;
+  return Array.isArray(t) ? [...t] : [t];
+}
+function crossAxisRuleApplies(rule, from, to) {
+  if (!rule.enabled) return false;
+  const targets = triggerTargets(rule);
+  if (rule.trigger.axis === "fulfillment") {
+    if (!targets.includes(to.fulfillment)) return false;
+    if (from !== null && from.fulfillment === to.fulfillment) return false;
+    return true;
+  }
+  if (!targets.includes(to.payment)) return false;
+  if (from !== null && from.payment === to.payment) return false;
+  return true;
+}
+function crossAxisSatisfied(rule, to) {
+  const req = rule.requires;
+  if (req.axis === "payment") {
+    return req.states.includes(to.payment);
+  }
+  return req.states.includes(to.fulfillment);
+}
+function firstBlockingCrossAxisRule(from, to, config) {
+  for (const rule of config.crossAxisRules) {
+    if (!crossAxisRuleApplies(rule, from, to)) continue;
+    if (!crossAxisSatisfied(rule, to)) return rule;
+  }
+  return void 0;
+}
+function findConditionSet(config, id) {
+  if (!id) return void 0;
+  return config.transitionConditions.find((s) => s.id === id);
+}
+function pathExists(paths, fromId, toId) {
+  return paths.some((p) => p.from === fromId && p.to === toId);
+}
+function axisTransitionAllowed(mode, paths, fromId, toId) {
+  if (fromId === toId) return true;
+  if (mode === "permissive") return true;
+  return pathExists(paths, fromId, toId);
+}
+function collectPathConditionFailures(config, from, to, context) {
+  const failed = [];
+  if (from === null) return { failed };
+  if (from.payment !== to.payment) {
+    const p = config.paymentPaths.find(
+      (x) => x.from === from.payment && x.to === to.payment
+    );
+    const set = findConditionSet(config, p?.conditionSetId);
+    const ev = evaluateConditionSet(set, context);
+    if (!ev.ok) failed.push(...ev.failedConditions);
+  }
+  if (from.fulfillment !== to.fulfillment) {
+    const p = config.fulfillmentPaths.find(
+      (x) => x.from === from.fulfillment && x.to === to.fulfillment
+    );
+    const set = findConditionSet(config, p?.conditionSetId);
+    const ev = evaluateConditionSet(set, context);
+    if (!ev.ok) failed.push(...ev.failedConditions);
+  }
+  return { failed };
+}
+function pathBlocked(config, from, to) {
+  if (from === null) return false;
+  if (from.payment !== to.payment && !axisTransitionAllowed(
+    config.paymentPathMode,
+    config.paymentPaths,
+    from.payment,
+    to.payment
+  )) {
+    return true;
+  }
+  if (from.fulfillment !== to.fulfillment && !axisTransitionAllowed(
+    config.fulfillmentPathMode,
+    config.fulfillmentPaths,
+    from.fulfillment,
+    to.fulfillment
+  )) {
+    return true;
+  }
+  return false;
+}
+function canTransition(request) {
+  const { from, to, config, context } = request;
+  const fin = getFinancialInvariantViolations(from, to);
+  if (fin.length > 0) {
+    return {
+      allowed: false,
+      blockedBy: "financial_invariant",
+      guard: fin[0],
+      reason: `Blocked by financial invariant: ${fin[0]}`
+    };
+  }
+  const cross = firstBlockingCrossAxisRule(from, to, config);
+  if (cross) {
+    return {
+      allowed: false,
+      blockedBy: "cross_axis_rule",
+      guard: cross.id,
+      reason: `Blocked by cross-axis rule: ${cross.label}`
+    };
+  }
+  if (from === null) {
+    if (!pairInInitialList(to, config)) {
+      return {
+        allowed: false,
+        blockedBy: "path",
+        reason: "Target state is not a valid initial state for new orders"
+      };
+    }
+  } else if (pathBlocked(config, from, to)) {
+    return {
+      allowed: false,
+      blockedBy: "path",
+      reason: "Transition is not allowed by configured path rules"
+    };
+  }
+  if (!request.skipConditionEvaluation) {
+    const cond = collectPathConditionFailures(config, from, to, context);
+    if (cond.failed.length > 0) {
+      return {
+        allowed: false,
+        blockedBy: "condition",
+        reason: "Transition conditions not satisfied",
+        failedConditions: cond.failed
+      };
+    }
+  }
+  return { allowed: true };
+}
+function labelForPayment(id, config) {
+  return config.paymentStates.find((s) => s.id === id)?.label ?? id;
+}
+function labelForFulfillment(id, config) {
+  return config.fulfillmentStates.find((s) => s.id === id)?.label ?? id;
+}
+function transitionDisplayLabel(to, config) {
+  const pay = labelForPayment(to.payment, config);
+  const ful = labelForFulfillment(to.fulfillment, config);
+  const derived = deriveDisplayState(to.payment, to.fulfillment, config).label;
+  if (derived && derived !== `${to.payment} / ${to.fulfillment}`) {
+    return derived;
+  }
+  return `${pay} \xB7 ${ful}`;
+}
+function conditionMetLines(config, from, to, context) {
+  const lines = [];
+  const appendForPath = (p) => {
+    const set = findConditionSet(config, p?.conditionSetId);
+    if (!set) return;
+    for (const g of set.groups) {
+      for (const c of g.conditions) {
+        const r = evaluateCondition(c, context);
+        lines.push({
+          met: r.ok,
+          description: conditionSummary(c)
+        });
+      }
+    }
+  };
+  if (from.payment !== to.payment) {
+    const p = config.paymentPaths.find(
+      (x) => x.from === from.payment && x.to === to.payment
+    );
+    appendForPath(p);
+  }
+  if (from.fulfillment !== to.fulfillment) {
+    const p = config.fulfillmentPaths.find(
+      (x) => x.from === from.fulfillment && x.to === to.fulfillment
+    );
+    appendForPath(p);
+  }
+  return lines;
+}
+function getAvailableTransitions(current, config, context) {
+  const candidates = [];
+  for (const s of config.paymentStates) {
+    if (s.id === current.payment) continue;
+    candidates.push({ payment: s.id, fulfillment: current.fulfillment });
+  }
+  for (const s of config.fulfillmentStates) {
+    if (s.id === current.fulfillment) continue;
+    candidates.push({ payment: current.payment, fulfillment: s.id });
+  }
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const to of candidates) {
+    const key = `${to.payment}:${to.fulfillment}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    const result = canTransition({
+      from: current,
+      to,
+      config,
+      context
+    });
+    if (!result.allowed) continue;
+    out.push({
+      to,
+      displayLabel: transitionDisplayLabel(to, config),
+      conditions: conditionMetLines(config, current, to, context)
+    });
+  }
+  return out;
+}
+
+// order-state-machine/validate-config.ts
+function paymentStateIds(config) {
+  return new Set(config.paymentStates.map((s) => s.id));
+}
+function fulfillmentStateIds(config) {
+  return new Set(config.fulfillmentStates.map((s) => s.id));
+}
+var VALID_OPERATORS = new Set(CONDITION_OPERATORS);
+function validateConditionShape(c, path, errors) {
+  if (!VALID_OPERATORS.has(c.operator)) {
+    errors.push({
+      code: "invalid_condition_operator",
+      message: `Unknown operator "${c.operator}"`,
+      path
+    });
+    return;
+  }
+  const needsNumberCompare = ["gt", "gte", "lt", "lte"].includes(c.operator);
+  if (needsNumberCompare && typeof c.value !== "number") {
+    errors.push({
+      code: "invalid_condition_value_type",
+      message: `Operator "${c.operator}" requires a numeric value`,
+      path: `${path}.value`
+    });
+  }
+  if ((c.operator === "in" || c.operator === "notIn") && !Array.isArray(c.value)) {
+    errors.push({
+      code: "invalid_condition_value_type",
+      message: `Operator "${c.operator}" requires an array value`,
+      path: `${path}.value`
+    });
+  }
+}
+function validationContext() {
+  return buildOrderContext({
+    total: 100,
+    balance: 0,
+    paymentMethods: [{ amount: 100 }],
+    lineItems: [{ quantity: 1, fulfilledQuantity: 1, returnedQuantity: 0 }]
+  });
+}
+function pairKey(p) {
+  return `${p.payment}\0${p.fulfillment}`;
+}
+function validateConfig(config) {
+  const errors = [];
+  const warnings = [];
+  if (!Number.isFinite(config.version) || config.version < 1) {
+    errors.push({
+      code: "invalid_version",
+      message: "version must be a finite number >= 1",
+      path: "version"
+    });
+  }
+  if (!config.validInitialStates?.length) {
+    errors.push({
+      code: "missing_initial_states",
+      message: "validInitialStates must contain at least one pair",
+      path: "validInitialStates"
+    });
+  }
+  const payIds = paymentStateIds(config);
+  const fulIds = fulfillmentStateIds(config);
+  config.validInitialStates?.forEach((pair, i) => {
+    if (!payIds.has(pair.payment)) {
+      errors.push({
+        code: "initial_unknown_payment",
+        message: `validInitialStates[${i}].payment "${pair.payment}" is not defined`,
+        path: `validInitialStates[${i}].payment`
+      });
+    }
+    if (!fulIds.has(pair.fulfillment)) {
+      errors.push({
+        code: "initial_unknown_fulfillment",
+        message: `validInitialStates[${i}].fulfillment "${pair.fulfillment}" is not defined`,
+        path: `validInitialStates[${i}].fulfillment`
+      });
+    }
+  });
+  const conditionSetIds = new Set(config.transitionConditions.map((s) => s.id));
+  config.transitionConditions.forEach((set, si) => {
+    set.groups.forEach((g, gi) => {
+      g.conditions.forEach((c, ci) => {
+        validateConditionShape(
+          c,
+          `transitionConditions[${si}].groups[${gi}].conditions[${ci}]`,
+          errors
+        );
+      });
+    });
+  });
+  const pathConditionRef = (paths, axis) => {
+    paths.forEach((p, i) => {
+      if (p.conditionSetId && !conditionSetIds.has(p.conditionSetId)) {
+        errors.push({
+          code: "unknown_condition_set",
+          message: `${axis}Paths[${i}] references unknown conditionSetId "${p.conditionSetId}"`,
+          path: `${axis}Paths[${i}].conditionSetId`
+        });
+      }
+    });
+  };
+  pathConditionRef(config.paymentPaths, "payment");
+  pathConditionRef(config.fulfillmentPaths, "fulfillment");
+  config.paymentPaths.forEach((path, i) => {
+    if (!payIds.has(path.from) || !payIds.has(path.to)) {
+      errors.push({
+        code: "payment_path_unknown_state",
+        message: `paymentPaths[${i}] references unknown payment state`,
+        path: `paymentPaths[${i}]`
+      });
+      return;
+    }
+    for (const f of config.fulfillmentStates) {
+      const from = { payment: path.from, fulfillment: f.id };
+      const to = { payment: path.to, fulfillment: f.id };
+      if (getFinancialInvariantViolations(null, from).length > 0) continue;
+      const v = getFinancialInvariantViolations(from, to);
+      if (v.length > 0) {
+        errors.push({
+          code: "payment_path_violates_financial_invariant",
+          message: `paymentPaths[${i}] (${path.from}\u2192${path.to}) with fulfillment "${f.id}" violates invariant(s): ${v.join(", ")}`,
+          path: `paymentPaths[${i}]`
+        });
+      }
+    }
+  });
+  config.fulfillmentPaths.forEach((path, i) => {
+    if (!fulIds.has(path.from) || !fulIds.has(path.to)) {
+      errors.push({
+        code: "fulfillment_path_unknown_state",
+        message: `fulfillmentPaths[${i}] references unknown fulfillment state`,
+        path: `fulfillmentPaths[${i}]`
+      });
+      return;
+    }
+    for (const p of config.paymentStates) {
+      const from = { payment: p.id, fulfillment: path.from };
+      const to = { payment: p.id, fulfillment: path.to };
+      if (getFinancialInvariantViolations(null, from).length > 0) continue;
+      const v = getFinancialInvariantViolations(from, to);
+      if (v.length > 0) {
+        errors.push({
+          code: "fulfillment_path_violates_financial_invariant",
+          message: `fulfillmentPaths[${i}] (${path.from}\u2192${path.to}) with payment "${p.id}" violates invariant(s): ${v.join(", ")}`,
+          path: `fulfillmentPaths[${i}]`
+        });
+      }
+    }
+  });
+  config.crossAxisRules.forEach((rule, i) => {
+    const req = rule.requires;
+    if (req.axis === "payment") {
+      for (const id of req.states) {
+        if (!payIds.has(id)) {
+          errors.push({
+            code: "cross_axis_unknown_payment",
+            message: `crossAxisRules[${i}] requires unknown payment state "${id}"`,
+            path: `crossAxisRules[${i}].requires.states`
+          });
+        }
+      }
+    } else {
+      for (const id of req.states) {
+        if (!fulIds.has(id)) {
+          errors.push({
+            code: "cross_axis_unknown_fulfillment",
+            message: `crossAxisRules[${i}] requires unknown fulfillment state "${id}"`,
+            path: `crossAxisRules[${i}].requires.states`
+          });
+        }
+      }
+    }
+    const trig = rule.trigger;
+    const targets = Array.isArray(trig.to) ? trig.to : [trig.to];
+    if (trig.axis === "payment") {
+      for (const id of targets) {
+        if (!payIds.has(id)) {
+          errors.push({
+            code: "cross_axis_trigger_unknown_payment",
+            message: `crossAxisRules[${i}] triggers on unknown payment state "${id}"`,
+            path: `crossAxisRules[${i}].trigger.to`
+          });
+        }
+      }
+    } else {
+      for (const id of targets) {
+        if (!fulIds.has(id)) {
+          errors.push({
+            code: "cross_axis_trigger_unknown_fulfillment",
+            message: `crossAxisRules[${i}] triggers on unknown fulfillment state "${id}"`,
+            path: `crossAxisRules[${i}].trigger.to`
+          });
+        }
+      }
+    }
+  });
+  strictAxisReachability(config, "payment", payIds, warnings);
+  strictAxisReachability(config, "fulfillment", fulIds, warnings);
+  combinedReachability(config, warnings);
+  if (!config.displayStateMap.length) {
+    warnings.push({
+      code: "empty_display_map",
+      message: "displayStateMap is empty; UI will fall back to raw state pair labels",
+      path: "displayStateMap"
+    });
+  } else {
+    const missingDisplay = [];
+    for (const p of PAYMENT_STATES) {
+      for (const f of FULFILLMENT_STATES) {
+        if (!payIds.has(p) || !fulIds.has(f)) continue;
+        const matched = config.displayStateMap.some(
+          (rule) => displayRuleMatchesPair(rule, p, f)
+        );
+        if (!matched) missingDisplay.push(`${p}/${f}`);
+      }
+    }
+    if (missingDisplay.length > 0) {
+      const sample = missingDisplay.slice(0, 8).join(", ");
+      const more = missingDisplay.length > 8 ? ` (+${missingDisplay.length - 8} more)` : "";
+      warnings.push({
+        code: "display_map_missing_combos",
+        message: `No displayStateMap rule matches ${missingDisplay.length} base pair(s): ${sample}${more}`,
+        path: "displayStateMap"
+      });
+    }
+  }
+  refundReturnPathWarnings(config, payIds, fulIds, warnings);
+  if (config.paymentPathMode === "strict" && config.paymentPaths.length === 0) {
+    errors.push({
+      code: "strict_payment_paths_empty",
+      message: "paymentPathMode is strict but paymentPaths is empty",
+      path: "paymentPaths"
+    });
+  }
+  if (config.fulfillmentPathMode === "strict" && config.fulfillmentPaths.length === 0) {
+    errors.push({
+      code: "strict_fulfillment_paths_empty",
+      message: "fulfillmentPathMode is strict but fulfillmentPaths is empty",
+      path: "fulfillmentPaths"
+    });
+  }
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings
+  };
+}
+function strictAxisReachability(config, axis, ids, warnings) {
+  const mode = axis === "payment" ? config.paymentPathMode : config.fulfillmentPathMode;
+  const paths = axis === "payment" ? config.paymentPaths : config.fulfillmentPaths;
+  if (mode !== "strict" || paths.length === 0) return;
+  const reachable = /* @__PURE__ */ new Set();
+  const initials = new Set(
+    config.validInitialStates.map((p) => axis === "payment" ? p.payment : p.fulfillment)
+  );
+  for (const id of initials) {
+    if (ids.has(id)) bfsAxis(id, paths, reachable);
+  }
+  const stateRows = axis === "payment" ? config.paymentStates : config.fulfillmentStates;
+  for (const id of stateRows) {
+    if (!reachable.has(id.id)) {
+      warnings.push({
+        code: `${axis}_state_unreachable_strict`,
+        message: `State "${id.id}" may be unreachable from valid initial ${axis} states under strict paths`,
+        path: axis === "payment" ? "paymentPaths" : "fulfillmentPaths"
+      });
+    }
+    if (!id.isTerminal) {
+      const hasOut = paths.some((p) => p.from === id.id && p.to !== id.id);
+      if (!hasOut) {
+        warnings.push({
+          code: `${axis}_nonterminal_no_outbound`,
+          message: `Non-terminal ${axis} state "${id.id}" has no strict outbound path`,
+          path: axis === "payment" ? "paymentPaths" : "fulfillmentPaths"
+        });
+      }
+    }
+  }
+}
+function bfsAxis(start, paths, reachable) {
+  const q = [start];
+  reachable.add(start);
+  while (q.length) {
+    const cur = q.pop();
+    for (const p of paths) {
+      if (p.from !== cur) continue;
+      if (!reachable.has(p.to)) {
+        reachable.add(p.to);
+        q.push(p.to);
+      }
+    }
+  }
+}
+function combinedReachability(config, warnings) {
+  const ctx = validationContext();
+  const payIds = config.paymentStates.map((s) => s.id);
+  const fulIds = config.fulfillmentStates.map((s) => s.id);
+  const seen = /* @__PURE__ */ new Set();
+  const queue = [...config.validInitialStates];
+  for (const p of queue) {
+    seen.add(pairKey(p));
+  }
+  while (queue.length) {
+    const cur = queue.pop();
+    for (const np of payIds) {
+      if (np === cur.payment) continue;
+      const to = { payment: np, fulfillment: cur.fulfillment };
+      const r = canTransition({
+        from: cur,
+        to,
+        config,
+        context: ctx,
+        skipConditionEvaluation: true
+      });
+      const k = pairKey(to);
+      if (r.allowed && !seen.has(k)) {
+        seen.add(k);
+        queue.push(to);
+      }
+    }
+    for (const nf of fulIds) {
+      if (nf === cur.fulfillment) continue;
+      const to = { payment: cur.payment, fulfillment: nf };
+      const r = canTransition({
+        from: cur,
+        to,
+        config,
+        context: ctx,
+        skipConditionEvaluation: true
+      });
+      const k = pairKey(to);
+      if (r.allowed && !seen.has(k)) {
+        seen.add(k);
+        queue.push(to);
+      }
+    }
+  }
+  const total = payIds.length * fulIds.length;
+  if (seen.size < total && (config.paymentPathMode === "strict" || config.fulfillmentPathMode === "strict")) {
+    warnings.push({
+      code: "combined_pairs_not_all_reachable",
+      message: "Some payment\xD7fulfillment pairs appear unreachable under current paths, cross-axis rules, and financial invariants (structural check with generic context)",
+      path: "validInitialStates"
+    });
+  }
+}
+function refundReturnPathWarnings(config, payIds, fulIds, warnings) {
+  const hasReturned = config.fulfillmentPaths.some(
+    (p) => p.to === "returned" || p.from === "returned"
+  );
+  const hasRefunded = config.paymentPaths.some(
+    (p) => p.to === "refunded" || p.from === "refunded"
+  );
+  if (fulIds.has("returned") && hasReturned && payIds.has("refunded") && !hasRefunded && config.paymentPathMode === "strict") {
+    warnings.push({
+      code: "refund_path_missing_for_return",
+      message: 'Fulfillment paths mention "returned" but no strict payment path touches "refunded"; verify refund workflow',
+      path: "paymentPaths"
+    });
+  }
+}
+
+// order-state-machine/set-order-state.ts
+function mapToLegacyStatus(pair) {
+  const { payment, fulfillment } = pair;
+  if (payment === "voided") return "park-deleted";
+  if (payment === "refunded") return "refunded";
+  if (payment === "partially_refunded") return "partial-refund";
+  if (payment === "paid") return "completed";
+  if (fulfillment === "draft") return "in-cart";
+  if (fulfillment === "on_hold") return "parked";
+  if (fulfillment === "pending") return "parked";
+  if (fulfillment === "cancelled") return "park-deleted";
+  return "parked";
+}
+function setOrderState(order, paymentState, fulfillmentState, config, options) {
+  order.paymentState = paymentState;
+  order.fulfillmentState = fulfillmentState;
+  const display = deriveDisplayState(paymentState, fulfillmentState, config);
+  order.displayState = display.label;
+  if (options?.includeLegacyStatus !== false) {
+    order.status = mapToLegacyStatus({ payment: paymentState, fulfillment: fulfillmentState });
+  }
+}
+
+// order-state-machine/legacy-infer.ts
+function normalizeStatus(raw) {
+  return (raw ?? "").trim().toLowerCase();
+}
+function hasRefundActivity(order) {
+  const refunds = order.refunds ?? order.refund ?? [];
+  return refunds.some((r) => {
+    const q = r.quantity;
+    return typeof q === "number" && q > 0;
+  });
+}
+function inferStatesFromLegacyStatus(order) {
+  const status = normalizeStatus(order.status);
+  if (status === "completed") {
+    return { payment: "paid", fulfillment: "fulfilled" };
+  }
+  if (status === "in-cart") {
+    return { payment: "unpaid", fulfillment: "draft" };
+  }
+  if (status === "park-deleted") {
+    return { payment: "voided", fulfillment: "cancelled" };
+  }
+  if (status === "refunded") {
+    return { payment: "refunded", fulfillment: "returned" };
+  }
+  if (status === "partial-refund" || status === "partial_refund") {
+    return { payment: "partially_refunded", fulfillment: "partially_returned" };
+  }
+  if (status === "parked") {
+    const ctx = order.paymentMethods ?? [];
+    const paid = ctx.reduce((s, m) => {
+      const a = m.amount;
+      return s + (typeof a === "number" && Number.isFinite(a) ? a : 0);
+    }, 0);
+    const partial = paid > 0 || typeof order.balance === "number" && typeof order.total === "number" && order.total > 0 && order.balance > 0 && order.balance < order.total;
+    return {
+      payment: partial ? "partially_paid" : "unpaid",
+      fulfillment: "on_hold"
+    };
+  }
+  if (status === "" && hasRefundActivity(order)) {
+    return { payment: "partially_refunded", fulfillment: "partially_returned" };
+  }
+  return { payment: "unpaid", fulfillment: "pending" };
+}
+
+// order-state-machine/resolve-template.ts
+function resolveTemplate(templateJson, params, values = {}) {
+  const resolvedValues = {};
+  for (const param of params) {
+    const raw = values[param.key] ?? param.default;
+    if (raw === void 0 || raw === null) {
+      throw new Error(`Missing required parameter: "${param.key}" (${param.label})`);
+    }
+    validateParamValue(param, raw);
+    resolvedValues[param.key] = raw;
+  }
+  let resolved = templateJson;
+  for (const [key, value] of Object.entries(resolvedValues)) {
+    const placeholder = `{{${key}}}`;
+    const replacement = typeof value === "string" ? escapeJsonString(value) : String(value);
+    resolved = replaceAll(resolved, placeholder, replacement);
+  }
+  let fragment;
+  try {
+    fragment = JSON.parse(resolved);
+  } catch (err) {
+    throw new Error(
+      `Fragment template produced invalid JSON after substitution: ${err.message}`
+    );
+  }
+  return { fragment, resolvedValues };
+}
+function validateParamValue(param, value) {
+  const { key, label, type } = param;
+  if (type === "string" && typeof value !== "string") {
+    throw new Error(`Parameter "${key}" (${label}) must be a string, got ${typeof value}`);
+  }
+  if (type === "number") {
+    if (typeof value !== "number" || Number.isNaN(value)) {
+      throw new Error(`Parameter "${key}" (${label}) must be a number`);
+    }
+    if (param.min !== void 0 && value < param.min) {
+      throw new Error(`Parameter "${key}" (${label}) must be >= ${param.min}`);
+    }
+    if (param.max !== void 0 && value > param.max) {
+      throw new Error(`Parameter "${key}" (${label}) must be <= ${param.max}`);
+    }
+  }
+  if (type === "boolean" && typeof value !== "boolean") {
+    throw new Error(`Parameter "${key}" (${label}) must be a boolean`);
+  }
+  if (param.options && param.options.length > 0 && !param.options.includes(String(value))) {
+    throw new Error(
+      `Parameter "${key}" (${label}) must be one of: ${param.options.join(", ")}`
+    );
+  }
+}
+function escapeJsonString(value) {
+  return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t");
+}
+function replaceAll(str, search, replacement) {
+  let result = str;
+  let idx = result.indexOf(search);
+  while (idx !== -1) {
+    result = result.slice(0, idx) + replacement + result.slice(idx + search.length);
+    idx = result.indexOf(search, idx + replacement.length);
+  }
+  return result;
+}
+
+// order-state-machine/validate-fragment.ts
+function validateFragmentCompatibility(config, fragment) {
+  const errors = [];
+  validateStateReferences(fragment, errors);
+  validatePathUniqueness(config, fragment, errors);
+  validateConditionSetUniqueness(config, fragment, errors);
+  validateCrossAxisRuleUniqueness(config, fragment, errors);
+  return { valid: errors.length === 0, errors };
+}
+function validateStateReferences(fragment, errors) {
+  for (const path of fragment.paymentPaths ?? []) {
+    if (!isPaymentState(path.from)) {
+      errors.push({
+        code: "invalid_payment_state",
+        message: `Unknown payment state "${path.from}" in paymentPaths`,
+        path: `paymentPaths[from=${path.from}]`
+      });
+    }
+    if (!isPaymentState(path.to)) {
+      errors.push({
+        code: "invalid_payment_state",
+        message: `Unknown payment state "${path.to}" in paymentPaths`,
+        path: `paymentPaths[to=${path.to}]`
+      });
+    }
+  }
+  for (const path of fragment.fulfillmentPaths ?? []) {
+    if (!isFulfillmentState(path.from)) {
+      errors.push({
+        code: "invalid_fulfillment_state",
+        message: `Unknown fulfillment state "${path.from}" in fulfillmentPaths`,
+        path: `fulfillmentPaths[from=${path.from}]`
+      });
+    }
+    if (!isFulfillmentState(path.to)) {
+      errors.push({
+        code: "invalid_fulfillment_state",
+        message: `Unknown fulfillment state "${path.to}" in fulfillmentPaths`,
+        path: `fulfillmentPaths[to=${path.to}]`
+      });
+    }
+  }
+  for (const rule of fragment.crossAxisRules ?? []) {
+    const triggerStates = Array.isArray(rule.trigger.to) ? rule.trigger.to : [rule.trigger.to];
+    const check = rule.trigger.axis === "payment" ? isPaymentState : isFulfillmentState;
+    for (const s of triggerStates) {
+      if (!check(s)) {
+        errors.push({
+          code: `invalid_${rule.trigger.axis}_state`,
+          message: `Unknown ${rule.trigger.axis} state "${s}" in crossAxisRule "${rule.id}" trigger`,
+          path: `crossAxisRules[${rule.id}].trigger.to`
+        });
+      }
+    }
+    const reqCheck = rule.requires.axis === "payment" ? isPaymentState : isFulfillmentState;
+    for (const s of rule.requires.states) {
+      if (!reqCheck(s)) {
+        errors.push({
+          code: `invalid_${rule.requires.axis}_state`,
+          message: `Unknown ${rule.requires.axis} state "${s}" in crossAxisRule "${rule.id}" requires`,
+          path: `crossAxisRules[${rule.id}].requires.states`
+        });
+      }
+    }
+  }
+  for (const pair of fragment.validInitialStates ?? []) {
+    if (!isPaymentState(pair.payment)) {
+      errors.push({
+        code: "invalid_payment_state",
+        message: `Unknown payment state "${pair.payment}" in validInitialStates`,
+        path: "validInitialStates"
+      });
+    }
+    if (!isFulfillmentState(pair.fulfillment)) {
+      errors.push({
+        code: "invalid_fulfillment_state",
+        message: `Unknown fulfillment state "${pair.fulfillment}" in validInitialStates`,
+        path: "validInitialStates"
+      });
+    }
+  }
+  for (const rule of fragment.displayStateMap ?? []) {
+    const pStates = rule.paymentState ? Array.isArray(rule.paymentState) ? rule.paymentState : [rule.paymentState] : [];
+    for (const s of pStates) {
+      if (!isPaymentState(s)) {
+        errors.push({
+          code: "invalid_payment_state",
+          message: `Unknown payment state "${s}" in displayStateMap rule "${rule.label}"`,
+          path: "displayStateMap"
+        });
+      }
+    }
+    const fStates = rule.fulfillmentState ? Array.isArray(rule.fulfillmentState) ? rule.fulfillmentState : [rule.fulfillmentState] : [];
+    for (const s of fStates) {
+      if (!isFulfillmentState(s)) {
+        errors.push({
+          code: "invalid_fulfillment_state",
+          message: `Unknown fulfillment state "${s}" in displayStateMap rule "${rule.label}"`,
+          path: "displayStateMap"
+        });
+      }
+    }
+  }
+}
+function validatePathUniqueness(config, fragment, errors) {
+  const existingPaymentEdges = new Set(
+    config.paymentPaths.map((p) => `${p.from}->${p.to}`)
+  );
+  for (const path of fragment.paymentPaths ?? []) {
+    const edge = `${path.from}->${path.to}`;
+    if (existingPaymentEdges.has(edge)) {
+      errors.push({
+        code: "duplicate_payment_path",
+        message: `Payment path ${path.from} \u2192 ${path.to} already exists in the config`,
+        path: `paymentPaths[${edge}]`
+      });
+    }
+  }
+  const existingFulfillmentEdges = new Set(
+    config.fulfillmentPaths.map((p) => `${p.from}->${p.to}`)
+  );
+  for (const path of fragment.fulfillmentPaths ?? []) {
+    const edge = `${path.from}->${path.to}`;
+    if (existingFulfillmentEdges.has(edge)) {
+      errors.push({
+        code: "duplicate_fulfillment_path",
+        message: `Fulfillment path ${path.from} \u2192 ${path.to} already exists in the config`,
+        path: `fulfillmentPaths[${edge}]`
+      });
+    }
+  }
+}
+function validateConditionSetUniqueness(config, fragment, errors) {
+  const existingIds = new Set(config.transitionConditions.map((c) => c.id));
+  for (const cond of fragment.transitionConditions ?? []) {
+    if (existingIds.has(cond.id)) {
+      errors.push({
+        code: "duplicate_condition_set_id",
+        message: `Condition set ID "${cond.id}" already exists in the config`,
+        path: `transitionConditions[${cond.id}]`
+      });
+    }
+  }
+}
+function validateCrossAxisRuleUniqueness(config, fragment, errors) {
+  const existingIds = new Set(config.crossAxisRules.map((r) => r.id));
+  for (const rule of fragment.crossAxisRules ?? []) {
+    if (existingIds.has(rule.id)) {
+      errors.push({
+        code: "duplicate_cross_axis_rule_id",
+        message: `Cross-axis rule ID "${rule.id}" already exists in the config`,
+        path: `crossAxisRules[${rule.id}]`
+      });
+    }
+  }
+}
+
+// order-state-machine/merge-fragment.ts
+function displayRuleKey(rule) {
+  const p = rule.paymentState;
+  const f = rule.fulfillmentState;
+  const pKey = p === void 0 ? "*" : Array.isArray(p) ? p.slice().sort().join(",") : p;
+  const fKey = f === void 0 ? "*" : Array.isArray(f) ? f.slice().sort().join(",") : f;
+  return `${pKey}|${fKey}`;
+}
+function mergeFragment(config, fragment, extensionId) {
+  const merged = JSON.parse(JSON.stringify(config));
+  for (const path of fragment.paymentPaths ?? []) {
+    merged.paymentPaths.push({ ...path, _sourceExtensionId: extensionId });
+  }
+  for (const path of fragment.fulfillmentPaths ?? []) {
+    merged.fulfillmentPaths.push({ ...path, _sourceExtensionId: extensionId });
+  }
+  for (const rule of fragment.crossAxisRules ?? []) {
+    merged.crossAxisRules.push({ ...rule, _sourceExtensionId: extensionId });
+  }
+  for (const cond of fragment.transitionConditions ?? []) {
+    merged.transitionConditions.push({ ...cond, _sourceExtensionId: extensionId });
+  }
+  for (const pair of fragment.validInitialStates ?? []) {
+    merged.validInitialStates.push(pair);
+  }
+  for (const rule of fragment.displayStateMap ?? []) {
+    const tagged = { ...rule, _sourceExtensionId: extensionId };
+    const key = displayRuleKey(tagged);
+    const existingIdx = merged.displayStateMap.findIndex(
+      (r) => displayRuleKey(r) === key
+    );
+    if (existingIdx !== -1) {
+      merged.displayStateMap[existingIdx] = tagged;
+    } else {
+      merged.displayStateMap.push(tagged);
+    }
+  }
+  return merged;
+}
+
+// order-state-machine/remove-fragment.ts
+function removeFragment(config, extensionId) {
+  const cleaned = JSON.parse(JSON.stringify(config));
+  cleaned.paymentPaths = cleaned.paymentPaths.filter(
+    (p) => p._sourceExtensionId !== extensionId
+  );
+  cleaned.fulfillmentPaths = cleaned.fulfillmentPaths.filter(
+    (p) => p._sourceExtensionId !== extensionId
+  );
+  cleaned.crossAxisRules = cleaned.crossAxisRules.filter(
+    (r) => r._sourceExtensionId !== extensionId
+  );
+  cleaned.transitionConditions = cleaned.transitionConditions.filter(
+    (c) => c._sourceExtensionId !== extensionId
+  );
+  cleaned.displayStateMap = cleaned.displayStateMap.filter(
+    (d) => d._sourceExtensionId !== extensionId
+  );
+  return cleaned;
+}
+
+// order-state-machine/actions.ts
+var ORDER_STATE_ACTIONS = {
+  getOrderStateConfig: "getOrderStateConfig",
+  getAvailableTransitions: "getAvailableTransitions",
+  getOrderDisplayState: "getOrderDisplayState",
+  transitionOrderState: "transitionOrderState",
+  getStateConfigFragment: "getStateConfigFragment",
+  saveStateConfigFragment: "saveStateConfigFragment",
+  deleteStateConfigFragment: "deleteStateConfigFragment"
+};
+
+// order-state-machine/pubsub.ts
+var ORDER_STATE_TOPIC = "order-state";
+var ORDER_STATE_EVENTS = {
+  stateTransitionCompleted: "state-transition-completed",
+  stateTransitionBlocked: "state-transition-blocked",
+  configUpdated: "config-updated"
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AttributeType,
+  CONDITION_OPERATORS,
+  COUNTRY_CURRENCIES,
+  CURRENCY_CONFIG,
+  CompanyType,
+  CurrencyCode,
+  CustomTableAvailability,
+  CustomerPlatform,
+  DEFAULT_CONFIG,
+  DEFAULT_CROSS_AXIS_RULES,
+  DEFAULT_DISPLAY_STATE_MAP,
+  DEFAULT_RESOLVED_CONFIG,
+  EUFixedRates,
+  EUROPE,
+  ExtensionCategory,
+  FINANCIAL_INVARIANTS,
+  FULFILLMENT_STATES,
+  FeesCustomBillingStatus,
+  InventoryBaseActionEnum,
+  InventorySpecificActionType,
+  InvoiceStatus,
+  LibraryItemType,
+  MenuProject,
+  NAFixedRates,
+  NORTH_AMERICA,
+  NonRevenueItemType,
+  ORDER_STATE_ACTIONS,
+  ORDER_STATE_EVENTS,
+  ORDER_STATE_TOPIC,
+  OrderPlatform,
+  OtherFixedRates,
+  OwnerType,
+  PATH_MODES,
+  PAYMENT_STATES,
+  POS_CROSS_AXIS_RULES,
+  POS_VALID_INITIAL_STATES,
+  PaymentMethod,
+  Platform,
+  PreviewImageMode,
+  PricingLevel,
+  PricingPlanEnum,
+  PricingRegionEnum,
+  ProductStatus,
+  ProductType,
+  PublicationAvailability,
+  PublicationStatus,
+  REGION_MAPPING,
+  REPORT_NEGATE_PATHS,
+  ReceiptSendChannel,
+  ReceiptType,
+  ResidualPaymentMethod,
+  ResidualStatus,
+  STATE_SCHEMA,
+  STRIPE_SUPPORTED_COUNTRIES,
+  StationStatus,
+  StripeCurrencyCode,
+  StripeStatus,
+  TimePeriod,
+  TopMetericsSort,
+  UserTypes,
+  addAmounts,
+  amountToString,
+  baseFulfillmentDefinitions,
+  basePaymentDefinitions,
+  buildOrderContext,
+  buildPosPresetConfig,
+  buildResolvedConfig,
+  calculatePercentage,
+  canTransition,
+  conditionSummary,
+  convertFixedFeeToLocalCurrency,
+  createAmount,
+  crossAxisRuleApplies,
+  deriveDisplayState,
+  displayRuleMatchesPair,
+  divideAmount,
+  evaluateCondition,
+  evaluateConditionSet,
+  formatCurrency,
+  formatMinorUnitsToString,
+  fromMinorUnits,
+  generateMongoID,
+  getAvailableTransitions,
+  getCountriesByRegion,
+  getCurrencyConfig,
+  getCurrentISODate,
+  getFinancialInvariantViolations,
+  getMinorUnitMultiplier,
+  getMinorUnits,
+  getPricingRegionFromCountry,
+  inferStatesFromLegacyStatus,
+  isConditionOperator,
+  isFulfillmentState,
+  isPaymentState,
+  isSupportedCurrency,
+  mapToLegacyStatus,
+  mergeFragment,
+  multiplyAmount,
+  normalizeMongoIdString,
+  parseAmountToMinorUnits,
+  parseCurrencyCode,
+  parseStripeCurrencyCode,
+  removeFragment,
+  resolveTemplate,
+  setOrderState,
+  signReportForDisplay,
+  stringifyMinorUnits,
+  subtractAmounts,
+  toMinorUnits,
+  validateConfig,
+  validateFragmentCompatibility,
+  violatesFinancialInvariant
+});
+//# sourceMappingURL=index.js.map