@pisell/pisellos 2.1.150 → 2.1.151

package/lib/model/strategy/adapter/walletPass/evaluator.d.ts

@@ -8,10 +8,12 @@ export declare class WalletPassEvaluator {
     private engine;
     private strategyConfigs;
     private locale;
+    private otherParams;
     constructor();
     setStrategyConfigs(strategyConfigs: StrategyConfig[]): void;
     getStrategyConfigs(): StrategyConfig[];
     setLocale(locale: string): void;
+    setOtherParams(otherParams: any): void;
     getText(key: string): string;
     /**
      * 搜索券的格式

package/lib/model/strategy/adapter/walletPass/evaluator.js

@@ -45,10 +45,27 @@ var defaultStrategyMetadataCustom = {
   maxPassesPerItem: 0,
   deductOptionPrice: false
 };
+var FIELD_REASON_CODE_MAP = {
+  orderTotalAmount: "order_total_amount_not_enough",
+  applicableProductTotalAmount: "applicable_product_total_amount_not_enough",
+  applicableProductCount: "applicable_product_count_not_enough"
+};
+var AMOUNT_FIELDS = /* @__PURE__ */ new Set([
+  "orderTotalAmount",
+  "applicableProductTotalAmount"
+]);
+function formatReason(template, value, currency = "") {
+  if (!template)
+    return template;
+  const v = value === void 0 || value === null ? "" : String(value);
+  const c = currency === void 0 || currency === null ? "" : String(currency);
+  return template.replace(/\$\{value\}/g, () => v).replace(/\{value\}/g, () => v).replace(/\{currency\}/g, () => c);
+}
 var WalletPassEvaluator = class {
   constructor() {
     this.strategyConfigs = [];
     this.locale = "en";
+    this.otherParams = {};
     this.engine = new import__.StrategyEngine({
       debug: false,
       enableTrace: false
@@ -64,6 +81,9 @@ var WalletPassEvaluator = class {
   setLocale(locale) {
     this.locale = locale;
   }
+  setOtherParams(otherParams) {
+    this.otherParams = otherParams;
+  }
   getText(key) {
     var _a, _b;
     return (_b = (_a = import_locales.locales) == null ? void 0 : _a[this.locale]) == null ? void 0 : _b[key];
@@ -101,7 +121,7 @@ var WalletPassEvaluator = class {
    * 评估可用的 vouchers
    */
   evaluate(input) {
-    var _a, _b;
+    var _a, _b, _c, _d, _e, _f, _g;
     const { orderTotalAmount, products, vouchers, strategyConfigs } = input;
     const productIds = products.map((p) => p.product_id);
     const results = [];
@@ -176,7 +196,13 @@ var WalletPassEvaluator = class {
         });
       } else {
         let reasonCode = "not_meet_the_required_conditions";
-        if (evaluationResult.code) {
+        let thresholdValue = void 0;
+        const failedField = (_c = evaluationResult.matched) == null ? void 0 : _c.failedField;
+        const failedRule = (_e = (_d = evaluationResult.matched) == null ? void 0 : _d.failedRules) == null ? void 0 : _e[0];
+        if (failedField && FIELD_REASON_CODE_MAP[failedField]) {
+          reasonCode = FIELD_REASON_CODE_MAP[failedField];
+          thresholdValue = failedRule == null ? void 0 : failedRule.value;
+        } else if (evaluationResult.code) {
           const codeMapping = {
             INSUFFICIENT_AMOUNT: "not_meet_the_required_conditions",
             USAGE_LIMIT_EXCEEDED: "usage_limit_reached",
@@ -186,6 +212,10 @@ var WalletPassEvaluator = class {
           };
           reasonCode = codeMapping[evaluationResult.code] || "not_meet_the_required_conditions";
         }
+        const rawText = this.getText(reasonCode);
+        const currency = failedField && AMOUNT_FIELDS.has(failedField) ? ((_g = (_f = this.otherParams) == null ? void 0 : _f.getData) == null ? void 0 : _g.call(_f, "shop_symbol")) || "" : "";
+        console.log(currency, "currency12345");
+        const reason = thresholdValue !== void 0 ? formatReason(rawText, thresholdValue, currency) : rawText;
         results.push({
           voucher,
           isApplicable: false,
@@ -193,7 +223,7 @@ var WalletPassEvaluator = class {
           maxDeduction: 0,
           deductTaxAndFee: false,
           applicableProductIds: [],
-          reason: this.getText(reasonCode),
+          reason,
           reasonCode,
           strategyResult: evaluationResult
         });
@@ -386,6 +416,7 @@ var WalletPassEvaluator = class {
    * 计算适用商品的总金额和数量
    */
   calculateApplicableProducts(products, applicableProductIds, deductTaxAndFee) {
+    console.log(products, "products1234");
     let total = 0;
     let count = 0;
     if (applicableProductIds !== null && applicableProductIds.length === 0) {

package/lib/model/strategy/adapter/walletPass/locales.js

@@ -29,7 +29,10 @@ var locales = {
     "usage_limit_reached": "已达到使用次数上限",
     "max_passes_per_item_reached": "该商品已达到卡券使用上限",
     "not_available_for_this_channel": "当前渠道不可使用",
-    "not_valid_for_this_order_type": "当前订单类型不适用"
+    "not_valid_for_this_order_type": "当前订单类型不适用",
+    "order_total_amount_not_enough": "满 {currency}{value} 可用",
+    "applicable_product_total_amount_not_enough": "满 {currency}{value} 可用",
+    "applicable_product_count_not_enough": "至少 {value} 件"
   },
   "en": {
     "not_meet_the_required_conditions": "Not meet the required conditions.",
@@ -37,7 +40,10 @@ var locales = {
     "usage_limit_reached": "Usage limit reached.",
     "max_passes_per_item_reached": "Max passes per item reached.",
     "not_available_for_this_channel": "Not available for this channel.",
-    "not_valid_for_this_order_type": "Not valid for this order type."
+    "not_valid_for_this_order_type": "Not valid for this order type.",
+    "order_total_amount_not_enough": "Spend {currency}{value} to use",
+    "applicable_product_total_amount_not_enough": "Spend {currency}{value} to use",
+    "applicable_product_count_not_enough": "Min. Qty {value}"
   },
   "zh-HK": {
     "not_meet_the_required_conditions": "未達使用條件",
@@ -45,7 +51,10 @@ var locales = {
     "usage_limit_reached": "已達使用次數上限",
     "max_passes_per_item_reached": "該商品已達卡券使用上限",
     "not_available_for_this_channel": "當前渠道不可使用",
-    "not_valid_for_this_order_type": "當前訂單類型不適用"
+    "not_valid_for_this_order_type": "當前訂單類型不適用",
+    "order_total_amount_not_enough": "滿 {currency}{value} 可用",
+    "applicable_product_total_amount_not_enough": "滿 {currency}{value} 可用",
+    "applicable_product_count_not_enough": "至少 {value} 件"
   }
 };
 // Annotate the CommonJS export names for ESM import in node:

package/lib/model/strategy/engine.d.ts

@@ -27,17 +27,30 @@ export declare class StrategyEngine {
      *
      * @param group 条件组
      * @param context 运行时上下文
-     * @returns 评估结果对象，包含条件是否满足和收集到的 actionIds
+     * @returns 评估结果对象，包含条件是否满足、收集到的 actionIds、以及失败的原子规则信息
      */
     private evaluateConditionGroup;
     /**
-     * 评估条件组的逻辑运算
+     * 评估条件组的逻辑运算（带失败规则收集）
+     *
+     * 失败规则收集策略：
+     * - `and`：返回第一个失败的原子规则（嵌套 group 递归取其首个失败原子规则）
+     * - `or`：所有分支失败时，聚合每个分支的失败规则
+     * - `not`：被取反规则实际通过时，记录该规则
+     */
+    private evaluateGroupLogicDetailed;
+    /**
+     * 评估单个规则（带失败规则收集）
+     */
+    private evaluateRuleDetailed;
+    /**
+     * 评估原子规则（不收集失败信息，仅返回布尔结果）
      */
-    private evaluateGroupLogic;
+    private evaluateAtomicRule;
     /**
-     * 评估单个规则
+     * 构建失败规则信息
      */
-    private evaluateRule;
+    private buildFailedRuleInfo;
     /**
      * 评估代码模式条件
      */

package/lib/model/strategy/engine.js

@@ -42,7 +42,7 @@ var StrategyEngine = class {
    * 评估策略
    */
   evaluate(config, context) {
-    var _a;
+    var _a, _b;
     const startTime = Date.now();
     const trace = {
       steps: [],
@@ -105,7 +105,11 @@ var StrategyEngine = class {
         matched: {
           conditions: applicable,
           actionIds: evaluationResult.actionIds,
-          details: {}
+          details: {},
+          ...applicable ? {} : {
+            failedField: (_a = evaluationResult.failedRules[0]) == null ? void 0 : _a.field,
+            failedRules: evaluationResult.failedRules
+          }
         },
         matchedActions: sortedActions,
         outputs: {},
@@ -119,7 +123,7 @@ var StrategyEngine = class {
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : "Unknown error";
       if (this.options.enableTrace) {
-        (_a = trace.errors) == null ? void 0 : _a.push({
+        (_b = trace.errors) == null ? void 0 : _b.push({
           step: "evaluation",
           error: errorMessage,
           timestamp: Date.now()
@@ -149,12 +153,15 @@ var StrategyEngine = class {
    *
    * @param group 条件组
    * @param context 运行时上下文
-   * @returns 评估结果对象，包含条件是否满足和收集到的 actionIds
+   * @returns 评估结果对象，包含条件是否满足、收集到的 actionIds、以及失败的原子规则信息
    */
   evaluateConditionGroup(group, context) {
     const collectedActionIds = [];
-    const isCurrentLayerSatisfied = this.evaluateGroupLogic(group, context);
-    if (isCurrentLayerSatisfied) {
+    const { satisfied, failedRules } = this.evaluateGroupLogicDetailed(
+      group,
+      context
+    );
+    if (satisfied) {
       collectedActionIds.push(...group.actionIds);
       for (const rule of group.rules) {
         if (this.isConditionGroup(rule)) {
@@ -164,41 +171,98 @@ var StrategyEngine = class {
       }
     }
     return {
-      satisfied: isCurrentLayerSatisfied,
-      actionIds: collectedActionIds
+      satisfied,
+      actionIds: collectedActionIds,
+      failedRules
     };
   }
   /**
-   * 评估条件组的逻辑运算
+   * 评估条件组的逻辑运算（带失败规则收集）
+   *
+   * 失败规则收集策略：
+   * - `and`：返回第一个失败的原子规则（嵌套 group 递归取其首个失败原子规则）
+   * - `or`：所有分支失败时，聚合每个分支的失败规则
+   * - `not`：被取反规则实际通过时，记录该规则
    */
-  evaluateGroupLogic(group, context) {
+  evaluateGroupLogicDetailed(group, context) {
     const { operator, rules } = group;
     switch (operator) {
-      case "and":
-        return rules.every((rule) => this.evaluateRule(rule, context));
-      case "or":
-        return rules.some((rule) => this.evaluateRule(rule, context));
-      case "not":
-        if (rules.length === 0)
-          return false;
-        return !this.evaluateRule(rules[0], context);
+      case "and": {
+        for (const rule of rules) {
+          const ruleResult = this.evaluateRuleDetailed(rule, context);
+          if (!ruleResult.satisfied) {
+            return {
+              satisfied: false,
+              failedRules: ruleResult.failedRules
+            };
+          }
+        }
+        return { satisfied: true, failedRules: [] };
+      }
+      case "or": {
+        const aggregated = [];
+        for (const rule of rules) {
+          const ruleResult = this.evaluateRuleDetailed(rule, context);
+          if (ruleResult.satisfied) {
+            return { satisfied: true, failedRules: [] };
+          }
+          aggregated.push(...ruleResult.failedRules);
+        }
+        return { satisfied: false, failedRules: aggregated };
+      }
+      case "not": {
+        if (rules.length === 0) {
+          return { satisfied: false, failedRules: [] };
+        }
+        const ruleResult = this.evaluateRuleDetailed(rules[0], context);
+        if (ruleResult.satisfied) {
+          const 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: ${operator}`);
     }
   }
   /**
-   * 评估单个规则
+   * 评估单个规则（带失败规则收集）
    */
-  evaluateRule(rule, context) {
+  evaluateRuleDetailed(rule, context) {
     if (this.isConditionGroup(rule)) {
-      return this.evaluateGroupLogic(rule, context);
+      return this.evaluateGroupLogicDetailed(rule, context);
     }
     const conditionRule = rule;
+    const satisfied = this.evaluateAtomicRule(conditionRule, context);
+    if (satisfied) {
+      return { satisfied: true, failedRules: [] };
+    }
+    return {
+      satisfied: false,
+      failedRules: [this.buildFailedRuleInfo(conditionRule, context)]
+    };
+  }
+  /**
+   * 评估原子规则（不收集失败信息，仅返回布尔结果）
+   */
+  evaluateAtomicRule(conditionRule, context) {
     if (conditionRule.type === "code" && conditionRule.code) {
       return this.evaluateCodeCondition(conditionRule.code, context);
     }
     return this.evaluateOperatorCondition(conditionRule, context);
   }
+  /**
+   * 构建失败规则信息
+   */
+  buildFailedRuleInfo(conditionRule, context) {
+    const actualValue = conditionRule.field ? this.getFieldValue(conditionRule.field, context) : void 0;
+    return {
+      field: conditionRule.field,
+      operator: conditionRule.operator,
+      value: conditionRule.value,
+      actualValue
+    };
+  }
   /**
    * 评估代码模式条件
    */

package/lib/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/lib/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/lib/modules/Cart/utils/cartProduct.js

@@ -46,6 +46,18 @@ var import_decimal = __toESM(require("decimal.js"));
 var import_utils = require("../../Product/utils");
 var import_utils2 = require("../../../solution/ShopDiscount/utils");
 var import_utils3 = require("../../Summary/utils");
+var toDiscountPayload = (discountItem) => {
+  var _a, _b;
+  return {
+    amount: discountItem.amount,
+    tag: discountItem.type,
+    par_value: (_a = discountItem.discount) == null ? void 0 : _a.percent,
+    config: discountItem.config,
+    metadata: {
+      discount_card_type: (_b = discountItem == null ? void 0 : discountItem.discount) == null ? void 0 : _b.discount_card_type
+    }
+  };
+};
 var handleVariantProduct = (product) => {
   var _a;
   if (product == null ? void 0 : product.product_variant_id) {
@@ -90,6 +102,14 @@ var formatProductToCartItem = (params) => {
       num,
       discounts
     });
+    const origin_total = getProductTotalPrice({
+      product: cartItem._productInit || cartItem._productOrigin,
+      bundle,
+      options,
+      num,
+      discounts: []
+    });
+    cartItem.summaryOriginTotal = (origin_total || 0) * (num || 1);
     cartItem.image = product == null ? void 0 : product.cover;
     cartItem.like_status = "common";
     cartItem.duration = product == null ? void 0 : product.duration;
@@ -184,17 +204,24 @@ var formatProductToCartItemOrigin = (params) => {
 var getProductTotalPrice = (params) => {
   const { product, bundle, options, discounts } = params;
   let price = Number(product.price);
+  const optionRows = (options == null ? void 0 : options.map((currentValue) => ({
+    unit: Number(currentValue.price ?? currentValue.add_price ?? 0),
+    num: Number(currentValue.num ?? currentValue.quantity ?? 1)
+  }))) ?? [];
   if (discounts == null ? void 0 : discounts.length) {
     discounts.forEach((currentValue) => {
       var _a;
-      price = (0, import_utils2.getDiscountAmount)({
-        amount: currentValue.amount,
-        tag: currentValue.type,
-        par_value: currentValue.discount.percent,
-        metadata: {
-          discount_card_type: (_a = currentValue == null ? void 0 : currentValue.discount) == null ? void 0 : _a.discount_card_type
+      const payload = toDiscountPayload(currentValue);
+      price = (0, import_utils2.getDiscountAmount)(payload, price, price);
+      if (((_a = currentValue == null ? void 0 : currentValue.config) == null ? void 0 : _a.deductOptionPrice) && optionRows.length) {
+        for (let i = 0; i < optionRows.length; i++) {
+          const row = optionRows[i];
+          optionRows[i] = {
+            ...row,
+            unit: (0, import_utils2.getDiscountAmount)(payload, row.unit, row.unit)
+          };
         }
-      }, price, price);
+      }
     });
   }
   if (bundle == null ? void 0 : bundle.length) {
@@ -202,10 +229,11 @@ var getProductTotalPrice = (params) => {
       return accumulator + Number(currentValue.price) * Number(currentValue.num);
     }, price);
   }
-  if (options == null ? void 0 : options.length) {
-    price = options.reduce((accumulator, currentValue) => {
-      return accumulator + Number(currentValue.price) * Number(currentValue.num);
-    }, price);
+  if (optionRows.length) {
+    price = optionRows.reduce(
+      (accumulator, row) => accumulator + row.unit * row.num,
+      price
+    );
   }
   return Math.max(0, price);
 };
@@ -313,7 +341,6 @@ var formatBundleToOrigin = (bundle) => {
       option: formatOptionsToOrigin(getBundleValueByKey("option")),
       discount_list: d.discount_list,
       "bundle_selling_price": d == null ? void 0 : d.price,
-      // "custom_price": d?.price,
       metadata: {
         custom_product_bundle_map_id: d._id,
         product_discount_difference

package/lib/modules/Discount/index.d.ts

@@ -17,18 +17,14 @@ export declare class DiscountModule extends BaseModule implements Module, Discou
     setOriginalDiscountList(originalDiscountList: Discount[]): Promise<void>;
     getOriginalDiscountList(): Discount[];
     loadPrepareConfig(params: {
-        action?: 'create' | 'edit';
+        action?: 'create';
         with_good_pass: 0 | 1;
         with_discount_card: 0 | 1;
         customer_id: number;
         with_wallet_pass_holder: 0 | 1;
         request_timezone: string;
-        order_id?: number;
-    }): Promise<Discount[]>;
-    batchSearch(code: string, options?: {
-        customerId?: number;
-        orderId?: number;
     }): Promise<Discount[]>;
+    batchSearch(code: string, customerId?: number): Promise<Discount[]>;
     batchSearchByProductIds(productIds: number[]): Promise<any>;
     filterEnabledDiscountList(discountList: Discount[]): Discount[];
     private checkUsageCreditsLimit;

package/lib/modules/Discount/index.js

@@ -102,8 +102,7 @@ var DiscountModule = class extends import_BaseModule.BaseModule {
     ) || [];
     return goodPassList;
   }
-  async batchSearch(code, options) {
-    const { customerId, orderId } = options || {};
+  async batchSearch(code, customerId) {
     const result = await this.request.get(`/machinecode/batch-search`, {
       code,
       translate_flag: 1,
@@ -113,7 +112,6 @@ var DiscountModule = class extends import_BaseModule.BaseModule {
       with: ["extensionData", "customScheduleSnapshot", "holder.detail"],
       order_behavior_count: 1,
       order_behavior_count_customer_id: customerId || 1,
-      ...orderId ? { order_behavior_count_order_id: orderId } : {},
       request_timezone: Intl.DateTimeFormat().resolvedOptions().timeZone
     });
     const resultDiscountList = this.filterEnabledDiscountList((result == null ? void 0 : result.data) || []) || [];

package/lib/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/lib/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';