@pisell/pisellos 2.1.149 → 2.1.151

package/dist/model/strategy/engine.js

@@ -6,6 +6,8 @@ function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o =
 function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
 function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
 function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
 function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
@@ -68,6 +70,7 @@ export var StrategyEngine = /*#__PURE__*/function () {
         errors: []
       };
       try {
+        var _evaluationResult$fai;
         // 验证配置
         this.validateConfig(config);
         if (this.options.enableTrace) {
@@ -125,11 +128,14 @@ export var StrategyEngine = /*#__PURE__*/function () {
           applicable: applicable,
           code: applicable ? SUCCESS_CODES.SUCCESS : NOT_APPLICABLE_CODES.CONDITION_NOT_MET,
           message: applicable ? 'Strategy is applicable' : 'Conditions not met',
-          matched: {
+          matched: _objectSpread({
             conditions: applicable,
             actionIds: evaluationResult.actionIds,
             details: {}
-          },
+          }, applicable ? {} : {
+            failedField: (_evaluationResult$fai = evaluationResult.failedRules[0]) === null || _evaluationResult$fai === void 0 ? void 0 : _evaluationResult$fai.field,
+            failedRules: evaluationResult.failedRules
+          }),
           matchedActions: sortedActions,
           outputs: {},
           config: config
@@ -174,19 +180,18 @@ export var StrategyEngine = /*#__PURE__*/function () {
      *
      * @param group 条件组
      * @param context 运行时上下文
-     * @returns 评估结果对象，包含条件是否满足和收集到的 actionIds
+     * @returns 评估结果对象，包含条件是否满足、收集到的 actionIds、以及失败的原子规则信息
      */
   }, {
     key: "evaluateConditionGroup",
     value: function evaluateConditionGroup(group, context) {
       var collectedActionIds = [];
 
-      // 评估当前层的 operator 和 rules
-      var isCurrentLayerSatisfied = this.evaluateGroupLogic(group, context);
-
-      // 如果当前层条件满足
-      if (isCurrentLayerSatisfied) {
-        // 收集当前层的 actionIds
+      // 评估当前层的 operator 和 rules（同时收集失败信息）
+      var _this$evaluateGroupLo = this.evaluateGroupLogicDetailed(group, context),
+        satisfied = _this$evaluateGroupLo.satisfied,
+        failedRules = _this$evaluateGroupLo.failedRules;
+      if (satisfied) {
         collectedActionIds.push.apply(collectedActionIds, _toConsumableArray(group.actionIds));
 
         // 递归评估嵌套的 ConditionGroup，收集嵌套层的 actionIds
@@ -207,54 +212,134 @@ export var StrategyEngine = /*#__PURE__*/function () {
         }
       }
       return {
-        satisfied: isCurrentLayerSatisfied,
-        actionIds: collectedActionIds
+        satisfied: satisfied,
+        actionIds: collectedActionIds,
+        failedRules: failedRules
       };
     }
 
     /**
-     * 评估条件组的逻辑运算
+     * 评估条件组的逻辑运算（带失败规则收集）
+     *
+     * 失败规则收集策略：
+     * - `and`：返回第一个失败的原子规则（嵌套 group 递归取其首个失败原子规则）
+     * - `or`：所有分支失败时，聚合每个分支的失败规则
+     * - `not`：被取反规则实际通过时，记录该规则
      */
   }, {
-    key: "evaluateGroupLogic",
-    value: function evaluateGroupLogic(group, context) {
-      var _this = this;
+    key: "evaluateGroupLogicDetailed",
+    value: function evaluateGroupLogicDetailed(group, context) {
       var operator = group.operator,
         rules = group.rules;
       switch (operator) {
         case 'and':
-          // 所有规则都必须满足
-          return rules.every(function (rule) {
-            return _this.evaluateRule(rule, context);
-          });
+          {
+            var _iterator2 = _createForOfIteratorHelper(rules),
+              _step2;
+            try {
+              for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+                var rule = _step2.value;
+                var ruleResult = this.evaluateRuleDetailed(rule, context);
+                if (!ruleResult.satisfied) {
+                  return {
+                    satisfied: false,
+                    failedRules: ruleResult.failedRules
+                  };
+                }
+              }
+            } catch (err) {
+              _iterator2.e(err);
+            } finally {
+              _iterator2.f();
+            }
+            return {
+              satisfied: true,
+              failedRules: []
+            };
+          }
         case 'or':
-          // 任一规则满足即可
-          return rules.some(function (rule) {
-            return _this.evaluateRule(rule, context);
-          });
+          {
+            var aggregated = [];
+            var _iterator3 = _createForOfIteratorHelper(rules),
+              _step3;
+            try {
+              for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+                var _rule = _step3.value;
+                var _ruleResult = this.evaluateRuleDetailed(_rule, context);
+                if (_ruleResult.satisfied) {
+                  return {
+                    satisfied: true,
+                    failedRules: []
+                  };
+                }
+                aggregated.push.apply(aggregated, _toConsumableArray(_ruleResult.failedRules));
+              }
+            } catch (err) {
+              _iterator3.e(err);
+            } finally {
+              _iterator3.f();
+            }
+            return {
+              satisfied: false,
+              failedRules: aggregated
+            };
+          }
         case 'not':
-          // 对第一个规则取反
-          if (rules.length === 0) return false;
-          return !this.evaluateRule(rules[0], context);
+          {
+            if (rules.length === 0) {
+              return {
+                satisfied: false,
+                failedRules: []
+              };
+            }
+            var _ruleResult2 = this.evaluateRuleDetailed(rules[0], context);
+            if (_ruleResult2.satisfied) {
+              // 被取反规则实际通过，导致 not 失败
+              var failed = this.isConditionGroup(rules[0]) ? [] : [this.buildFailedRuleInfo(rules[0], context)];
+              return {
+                satisfied: false,
+                failedRules: failed
+              };
+            }
+            return {
+              satisfied: true,
+              failedRules: []
+            };
+          }
         default:
           throw new Error("Unknown operator: ".concat(operator));
       }
     }
 
     /**
-     * 评估单个规则
+     * 评估单个规则（带失败规则收集）
      */
   }, {
-    key: "evaluateRule",
-    value: function evaluateRule(rule, context) {
-      // 如果是嵌套的条件组，递归评估
+    key: "evaluateRuleDetailed",
+    value: function evaluateRuleDetailed(rule, context) {
       if (this.isConditionGroup(rule)) {
-        return this.evaluateGroupLogic(rule, context);
+        return this.evaluateGroupLogicDetailed(rule, context);
       }
-
-      // 原子条件规则
       var conditionRule = rule;
+      var satisfied = this.evaluateAtomicRule(conditionRule, context);
+      if (satisfied) {
+        return {
+          satisfied: true,
+          failedRules: []
+        };
+      }
+      return {
+        satisfied: false,
+        failedRules: [this.buildFailedRuleInfo(conditionRule, context)]
+      };
+    }
 
+    /**
+     * 评估原子规则（不收集失败信息，仅返回布尔结果）
+     */
+  }, {
+    key: "evaluateAtomicRule",
+    value: function evaluateAtomicRule(conditionRule, context) {
       // Code 模式：使用 eval 执行
       if (conditionRule.type === 'code' && conditionRule.code) {
         return this.evaluateCodeCondition(conditionRule.code, context);
@@ -264,6 +349,21 @@ export var StrategyEngine = /*#__PURE__*/function () {
       return this.evaluateOperatorCondition(conditionRule, context);
     }
 
+    /**
+     * 构建失败规则信息
+     */
+  }, {
+    key: "buildFailedRuleInfo",
+    value: function buildFailedRuleInfo(conditionRule, context) {
+      var actualValue = conditionRule.field ? this.getFieldValue(conditionRule.field, context) : undefined;
+      return {
+        field: conditionRule.field,
+        operator: conditionRule.operator,
+        value: conditionRule.value,
+        actualValue: actualValue
+      };
+    }
+
     /**
      * 评估代码模式条件
      */
@@ -323,11 +423,11 @@ export var StrategyEngine = /*#__PURE__*/function () {
       // 支持点号路径，如 "order.total"
       var path = field.split('.');
       var value = context.attributes;
-      var _iterator2 = _createForOfIteratorHelper(path),
-        _step2;
+      var _iterator4 = _createForOfIteratorHelper(path),
+        _step4;
       try {
-        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-          var key = _step2.value;
+        for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+          var key = _step4.value;
           if (value && _typeof(value) === 'object' && key in value) {
             value = value[key];
           } else {
@@ -335,9 +435,9 @@ export var StrategyEngine = /*#__PURE__*/function () {
           }
         }
       } catch (err) {
-        _iterator2.e(err);
+        _iterator4.e(err);
       } finally {
-        _iterator2.f();
+        _iterator4.f();
       }
       return value;
     }
@@ -437,11 +537,11 @@ export var StrategyEngine = /*#__PURE__*/function () {
       var actionMap = new Map(actions.map(function (action) {
         return [action.id, action];
       }));
-      var _iterator3 = _createForOfIteratorHelper(actionIds),
-        _step3;
+      var _iterator5 = _createForOfIteratorHelper(actionIds),
+        _step5;
       try {
-        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
-          var id = _step3.value;
+        for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+          var id = _step5.value;
           var action = actionMap.get(id);
           if (action) {
             matchedActions.push(action);
@@ -453,9 +553,9 @@ export var StrategyEngine = /*#__PURE__*/function () {
           }
         }
       } catch (err) {
-        _iterator3.e(err);
+        _iterator5.e(err);
       } finally {
-        _iterator3.f();
+        _iterator5.f();
       }
       return matchedActions;
     }

package/dist/model/strategy/type.d.ts

@@ -165,6 +165,23 @@ export interface MatchedInfo {
     actionIds: string[];
     /** 详细匹配信息 */
     details: Record<string, any>;
+    /** 顶层第一个失败的 field（仅在 conditions=false 时存在，便于直接消费） */
+    failedField?: string;
+    /** 失败的原子规则列表（仅在 conditions=false 时存在；or 全失败时可能有多条） */
+    failedRules?: FailedRuleInfo[];
+}
+/**
+ * 失败规则信息
+ */
+export interface FailedRuleInfo {
+    /** 字段名 */
+    field?: string;
+    /** 运算符 */
+    operator?: string;
+    /** 配置的比较值（阈值） */
+    value?: any;
+    /** 实际取到的字段值 */
+    actualValue?: any;
 }
 /**
  * 执行轨迹

package/dist/model/strategy/type.js

@@ -51,6 +51,10 @@
  * 匹配信息
  */
 
+/**
+ * 失败规则信息
+ */
+
 /**
  * 执行轨迹
  */

package/dist/modules/Cart/types.d.ts

@@ -75,6 +75,8 @@ export interface CartItem {
     summaryTotal?: number | string;
     /** 商品原价总价，排除原始价格为0的场景 */
     origin_total?: number | string;
+    /** 基于 origin_total 乘以 商品数量的价格 */
+    summaryOriginTotal?: number | string;
     /** 商品数量 */
     num?: number;
     /** 商品图片 */

package/dist/modules/Cart/utils/cartProduct.js

@@ -15,6 +15,20 @@ import { isNormalProduct } from "../../Product/utils";
 import { getDiscountAmount } from "../../../solution/ShopDiscount/utils";
 import { calcDiscountListDifference } from "../../Summary/utils";
 
+/** 与 Rules / ShopDiscount 一致的折扣入参，用于主价与 option 单价 */
+var toDiscountPayload = function toDiscountPayload(discountItem) {
+  var _discountItem$discoun, _discountItem$discoun2;
+  return {
+    amount: discountItem.amount,
+    tag: discountItem.type,
+    par_value: (_discountItem$discoun = discountItem.discount) === null || _discountItem$discoun === void 0 ? void 0 : _discountItem$discoun.percent,
+    config: discountItem.config,
+    metadata: {
+      discount_card_type: discountItem === null || discountItem === void 0 || (_discountItem$discoun2 = discountItem.discount) === null || _discountItem$discoun2 === void 0 ? void 0 : _discountItem$discoun2.discount_card_type
+    }
+  };
+};
+
 /**
  * @title 处理组合商品
  * @description 组合商品需要直接修改 product 里的价格和 is_charge_tax
@@ -58,6 +72,7 @@ export var formatProductToCartItem = function formatProductToCartItem(params) {
     quantity = _params$quantity === void 0 ? 1 : _params$quantity,
     discounts = params.discounts;
   var num = quantity; // 当前按照单个商品加入购物车
+
   if (product) {
     cartItem.id = product === null || product === void 0 ? void 0 : product.id;
     cartItem.name = product === null || product === void 0 ? void 0 : product.title;
@@ -83,6 +98,15 @@ export var formatProductToCartItem = function formatProductToCartItem(params) {
       num: num,
       discounts: discounts
     });
+    // 不包含折扣卡商品券的总价
+    var origin_total = getProductTotalPrice({
+      product: cartItem._productInit || cartItem._productOrigin,
+      bundle: bundle,
+      options: options,
+      num: num,
+      discounts: []
+    });
+    cartItem.summaryOriginTotal = (origin_total || 0) * (num || 1);
     cartItem.image = product === null || product === void 0 ? void 0 : product.cover;
     cartItem.like_status = 'common';
     cartItem.duration = product === null || product === void 0 ? void 0 : product.duration;
@@ -185,6 +209,7 @@ export var formatProductToCartItemOrigin = function formatProductToCartItemOrigi
  * @returns 商品总价
  */
 export var getProductTotalPrice = function getProductTotalPrice(params) {
+  var _options$map;
   var product = params.product,
     bundle = params.bundle,
     options = params.options,
@@ -192,22 +217,29 @@ export var getProductTotalPrice = function getProductTotalPrice(params) {
   // const num = params.num || 1;
   var price = Number(product.price);
 
+  // option 行：unit 折后价在循环中与主商品使用同一套 getDiscountAmount（含 deductOptionPrice）
+  var optionRows = (_options$map = options === null || options === void 0 ? void 0 : options.map(function (currentValue) {
+    var _ref, _currentValue$price, _ref2, _currentValue$num;
+    return {
+      unit: Number((_ref = (_currentValue$price = currentValue.price) !== null && _currentValue$price !== void 0 ? _currentValue$price : currentValue.add_price) !== null && _ref !== void 0 ? _ref : 0),
+      num: Number((_ref2 = (_currentValue$num = currentValue.num) !== null && _currentValue$num !== void 0 ? _currentValue$num : currentValue.quantity) !== null && _ref2 !== void 0 ? _ref2 : 1)
+    };
+  })) !== null && _options$map !== void 0 ? _options$map : [];
+
   // 如果商品有折扣，则计算折扣
   if (discounts !== null && discounts !== void 0 && discounts.length) {
     discounts.forEach(function (currentValue) {
-      var _currentValue$discoun;
-      // 不是商品券则代表折扣卡，计算打折后的价格
-      // 一个商品折扣卡只能存在于一张
-      // if (currentValue.type !== 'good_pass') {
-      price = getDiscountAmount({
-        amount: currentValue.amount,
-        tag: currentValue.type,
-        par_value: currentValue.discount.percent,
-        metadata: {
-          discount_card_type: currentValue === null || currentValue === void 0 || (_currentValue$discoun = currentValue.discount) === null || _currentValue$discoun === void 0 ? void 0 : _currentValue$discoun.discount_card_type
+      var _currentValue$config;
+      var payload = toDiscountPayload(currentValue);
+      price = getDiscountAmount(payload, price, price);
+      if (currentValue !== null && currentValue !== void 0 && (_currentValue$config = currentValue.config) !== null && _currentValue$config !== void 0 && _currentValue$config.deductOptionPrice && optionRows.length) {
+        for (var i = 0; i < optionRows.length; i++) {
+          var row = optionRows[i];
+          optionRows[i] = _objectSpread(_objectSpread({}, row), {}, {
+            unit: getDiscountAmount(payload, row.unit, row.unit)
+          });
         }
-      }, price, price);
-      // }
+      }
     });
   }
   if (bundle !== null && bundle !== void 0 && bundle.length) {
@@ -216,10 +248,10 @@ export var getProductTotalPrice = function getProductTotalPrice(params) {
     }, price);
   }
 
-  // 单规格
-  if (options !== null && options !== void 0 && options.length) {
-    price = options.reduce(function (accumulator, currentValue) {
-      return accumulator + Number(currentValue.price) * Number(currentValue.num);
+  // 单规格 / 加购 option
+  if (optionRows.length) {
+    price = optionRows.reduce(function (accumulator, row) {
+      return accumulator + row.unit * row.num;
     }, price);
   }
   return Math.max(0, price);
@@ -350,7 +382,6 @@ export var formatBundleToOrigin = function formatBundleToOrigin(bundle) {
       option: formatOptionsToOrigin(getBundleValueByKey('option')),
       discount_list: d.discount_list,
       "bundle_selling_price": d === null || d === void 0 ? void 0 : d.price,
-      // "custom_price": d?.price,
       metadata: {
         custom_product_bundle_map_id: d._id,
         product_discount_difference: product_discount_difference
@@ -379,11 +410,11 @@ export var getProductDeposit = function getProductDeposit(params) {
   // 判定商品是否有定金规则
   if ((product === null || product === void 0 || (_product$custom_depos2 = product.custom_deposit_data) === null || _product$custom_depos2 === void 0 ? void 0 : _product$custom_depos2.has_deposit) == 1) {
     var total = new Decimal(0);
-    var _ref = (product === null || product === void 0 ? void 0 : product.custom_deposit_data) || {},
-      deposit_fixed = _ref.deposit_fixed,
-      deposit_percentage = _ref.deposit_percentage,
-      deposit_policy_data = _ref.deposit_policy_data,
-      self_deposit_policy_ids = _ref.self_deposit_policy_ids;
+    var _ref3 = (product === null || product === void 0 ? void 0 : product.custom_deposit_data) || {},
+      deposit_fixed = _ref3.deposit_fixed,
+      deposit_percentage = _ref3.deposit_percentage,
+      deposit_policy_data = _ref3.deposit_policy_data,
+      self_deposit_policy_ids = _ref3.self_deposit_policy_ids;
     // 所有协议数据
     var allProtocols = deposit_policy_data || [];
     // 是否存在定金，主商品has_deposit为1，但是自身没有定金设置，需要判定子商品是否存在定金，如果不存在最终判定也是不存在定金
@@ -477,9 +508,9 @@ export var handleProductDeposit = function handleProductDeposit(params) {
       depositTotal: new Decimal(0)
     };
   }
-  var _ref2 = depositData || {},
-    deposit_fixed = _ref2.deposit_fixed,
-    deposit_percentage = _ref2.deposit_percentage;
+  var _ref4 = depositData || {},
+    deposit_fixed = _ref4.deposit_fixed,
+    deposit_percentage = _ref4.deposit_percentage;
   if (typeof deposit_fixed === 'string' && typeof deposit_percentage === 'string') {
     var depositFixed = Decimal(deposit_fixed || 0);
     var depositPercent = Decimal(deposit_percentage || 0);

package/dist/modules/Discount/types.d.ts

@@ -19,7 +19,7 @@ interface PackageSubItemUsageRules {
     type: 'universal_discount' | 'package_exclusive' | 'single_item_promo' | 'custom_usage_rules';
     rules: ("original_price" | "markup_price")[];
     package_scope?: {
-        type: 'all_packages' | 'specific_packages' | 'product_all' | 'products';
+        type: 'all_packages' | 'specific_packages';
         exclude_bundle_product_ids: number[];
         include_bundle_product_ids: number[];
         filter: 0 | 1;
@@ -33,6 +33,8 @@ interface Limitedrelationproductdata {
     product_ids: number[];
     product_collection_id: number[];
     package_sub_item_usage_rules?: PackageSubItemUsageRules;
+    filter: 0 | 1;
+    exclude_product_ids: number[];
 }
 interface ApplicableProductDetails {
     amount: string;
@@ -89,6 +91,7 @@ export interface Discount {
     balance: string;
     format_title: Formattitle;
     metadata?: {
+        num?: number;
         discount_card_type?: 'fixed_amount' | 'percent';
         custom_product_bundle_map_id?: string;
         validity_type?: "custom_schedule_validity" | "fixed_validity";
@@ -113,6 +116,21 @@ export interface Discount {
     isSelected?: boolean;
     isAvailable?: boolean;
     isUsed?: boolean;
+    config?: {
+        isAvailable?: boolean;
+        /** 最大抵扣金额 */
+        maxDeductionAmount?: number;
+        /** 每单最多使用张数 */
+        maxUsagePerOrder?: number;
+        /** 是否抵扣税费与附加费 */
+        deductTaxAndFee?: boolean;
+        /** 适用粒度（多商品共用） */
+        allowCrossProduct?: boolean;
+        /** 可用商品数量上限 */
+        applicableProductLimit?: number;
+        /** 是否抵扣单规格价格 (Option Price) */
+        deductOptionPrice?: boolean;
+    };
     applicableProductIds?: number[];
     applicableProductDetails: ApplicableProductDetails[];
     appliedProductDetails: ApplicableProductDetails[];

package/dist/modules/Order/index.d.ts

@@ -1,26 +1,13 @@
 import { Module, PisellCore, ModuleOptions } from '../../types';
 import { BaseModule } from '../BaseModule';
-import { OrderModuleAPI, CommitOrderParams, SubmitScanOrderParams, ScanOrderMoreParams, CheckoutOrderParams, UpdateProductInOrderParams } from './types';
+import { OrderModuleAPI, CommitOrderParams, CheckoutOrderParams } from './types';
 import { CartItem } from '../Cart/types';
-import { type SubmitPayloadEnhancer } from './utils';
-import type { ScanOrderOrderProduct, ScanOrderOrderProductIdentity, ScanOrderSummary, ScanOrderTempOrder } from '../../solution/ScanOrder/types';
-import type { Discount } from '../Discount/types';
-import { UnavailableReason } from '../Rules/types';
 export declare class OrderModule extends BaseModule implements Module, OrderModuleAPI {
     protected defaultName: string;
     protected defaultVersion: string;
     private store;
     private request;
     private logger;
-    private window;
-    private cacheId;
-    private salesSummaryModuleName;
-    private rulesHooksOverride?;
-    /**
-     * Populate `savedAmount` on each discount based on product-level discount details.
-     * Only selected discounts get a non-zero value.
-     */
-    static populateSavedAmounts(productList: Array<Record<string, any>>, discountList: Array<Record<string, any>>): void;
     constructor(name?: string, version?: string);
     initialize(core: PisellCore, options: ModuleOptions): Promise<void>;
     /**
@@ -35,52 +22,6 @@ export declare class OrderModule extends BaseModule implements Module, OrderModu
      * 记录错误日志
      */
     private logError;
-    private registerDiscountModules;
-    private createDefaultRulesHooks;
-    loadDiscountConfig(params: {
-        customerId: number;
-        action?: 'create';
-    }): Promise<void>;
-    getDiscountList(): Discount[];
-    scanCode(code: string, customerId?: number): Promise<{
-        isAvailable: boolean;
-        discountList: Discount[];
-        type: 'server' | 'clientCalc';
-        unavailableReason?: UnavailableReason;
-    }>;
-    applyDiscount(): void;
-    initTempOrder(params: {
-        cacheId?: string;
-        salesSummaryModuleName?: string;
-    }): void;
-    private getTempOrderStorageKey;
-    private restoreTempOrderFromStorage;
-    persistTempOrder(): void;
-    private createDefaultTempOrderInstance;
-    ensureTempOrder(): ScanOrderTempOrder;
-    restoreOrder(): ScanOrderTempOrder;
-    getTempOrder(): ScanOrderTempOrder | null;
-    addNewOrder(): Promise<ScanOrderTempOrder>;
-    getOrderProducts(): ScanOrderOrderProduct[];
-    private getSalesSummary;
-    recalculateSummary(options?: {
-        createIfMissing?: boolean;
-    }): Promise<ScanOrderSummary | null>;
-    getScanOrderSummary(): Promise<ScanOrderSummary>;
-    updateTempOrderNote(note: string): string;
-    updateTempOrderBuzzer(buzzer: string): string;
-    updateTempOrderContactsInfo(contactsInfo: any[]): any[];
-    addProductToOrder(product: Partial<ScanOrderOrderProduct> & ScanOrderOrderProductIdentity): Promise<ScanOrderOrderProduct[]>;
-    updateProductInOrder(params: UpdateProductInOrderParams): Promise<ScanOrderOrderProduct[]>;
-    removeProductFromOrder(identity: ScanOrderOrderProductIdentity): Promise<ScanOrderOrderProduct[]>;
-    submitTempOrder<T = any>(params?: {
-        cacheId?: string;
-        platform?: string;
-        businessCode?: string;
-        channel?: string;
-        type?: string;
-        enhancePayload?: SubmitPayloadEnhancer;
-    }): Promise<T>;
     createOrder(params: CommitOrderParams['query']): {
         type: "virtual" | "appointment_booking";
         platform: string;
@@ -110,9 +51,4 @@ export declare class OrderModule extends BaseModule implements Module, OrderModu
      * @returns 后端返回的订单数据（包含订单ID等）
      */
     createOrderByCheckout(params: CheckoutOrderParams): Promise<any>;
-    submitScanOrder<T = any>(params: SubmitScanOrderParams): Promise<T>;
-    scanOrderMore<T = any>(params: ScanOrderMoreParams): Promise<T>;
-    getOrderInfoByRemote(order_id: number): Promise<any>;
-    getLastOrderInfo(): Record<string, any> | undefined;
 }
-export type { UpdateProductInOrderParams } from './types';