@pisell/pisellos 2.1.151 → 2.1.152

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

@@ -8,12 +8,10 @@ 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,27 +45,10 @@ 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
@@ -81,9 +64,6 @@ 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];
@@ -121,7 +101,7 @@ var WalletPassEvaluator = class {
    * 评估可用的 vouchers
    */
   evaluate(input) {
-    var _a, _b, _c, _d, _e, _f, _g;
+    var _a, _b;
     const { orderTotalAmount, products, vouchers, strategyConfigs } = input;
     const productIds = products.map((p) => p.product_id);
     const results = [];
@@ -196,13 +176,7 @@ var WalletPassEvaluator = class {
         });
       } else {
         let reasonCode = "not_meet_the_required_conditions";
-        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) {
+        if (evaluationResult.code) {
           const codeMapping = {
             INSUFFICIENT_AMOUNT: "not_meet_the_required_conditions",
             USAGE_LIMIT_EXCEEDED: "usage_limit_reached",
@@ -212,10 +186,6 @@ 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,
@@ -223,7 +193,7 @@ var WalletPassEvaluator = class {
           maxDeduction: 0,
           deductTaxAndFee: false,
           applicableProductIds: [],
-          reason,
+          reason: this.getText(reasonCode),
           reasonCode,
           strategyResult: evaluationResult
         });
@@ -416,7 +386,6 @@ 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,10 +29,7 @@ var locales = {
     "usage_limit_reached": "已达到使用次数上限",
     "max_passes_per_item_reached": "该商品已达到卡券使用上限",
     "not_available_for_this_channel": "当前渠道不可使用",
-    "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} 件"
+    "not_valid_for_this_order_type": "当前订单类型不适用"
   },
   "en": {
     "not_meet_the_required_conditions": "Not meet the required conditions.",
@@ -40,10 +37,7 @@ 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.",
-    "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}"
+    "not_valid_for_this_order_type": "Not valid for this order type."
   },
   "zh-HK": {
     "not_meet_the_required_conditions": "未達使用條件",
@@ -51,10 +45,7 @@ var locales = {
     "usage_limit_reached": "已達使用次數上限",
     "max_passes_per_item_reached": "該商品已達卡券使用上限",
     "not_available_for_this_channel": "當前渠道不可使用",
-    "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} 件"
+    "not_valid_for_this_order_type": "當前訂單類型不適用"
   }
 };
 // Annotate the CommonJS export names for ESM import in node:

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

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

package/lib/model/strategy/engine.js

@@ -42,7 +42,7 @@ var StrategyEngine = class {
    * 评估策略
    */
   evaluate(config, context) {
-    var _a, _b;
+    var _a;
     const startTime = Date.now();
     const trace = {
       steps: [],
@@ -105,11 +105,7 @@ var StrategyEngine = class {
         matched: {
           conditions: applicable,
           actionIds: evaluationResult.actionIds,
-          details: {},
-          ...applicable ? {} : {
-            failedField: (_a = evaluationResult.failedRules[0]) == null ? void 0 : _a.field,
-            failedRules: evaluationResult.failedRules
-          }
+          details: {}
         },
         matchedActions: sortedActions,
         outputs: {},
@@ -123,7 +119,7 @@ var StrategyEngine = class {
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : "Unknown error";
       if (this.options.enableTrace) {
-        (_b = trace.errors) == null ? void 0 : _b.push({
+        (_a = trace.errors) == null ? void 0 : _a.push({
           step: "evaluation",
           error: errorMessage,
           timestamp: Date.now()
@@ -153,15 +149,12 @@ var StrategyEngine = class {
    *
    * @param group 条件组
    * @param context 运行时上下文
-   * @returns 评估结果对象，包含条件是否满足、收集到的 actionIds、以及失败的原子规则信息
+   * @returns 评估结果对象，包含条件是否满足和收集到的 actionIds
    */
   evaluateConditionGroup(group, context) {
     const collectedActionIds = [];
-    const { satisfied, failedRules } = this.evaluateGroupLogicDetailed(
-      group,
-      context
-    );
-    if (satisfied) {
+    const isCurrentLayerSatisfied = this.evaluateGroupLogic(group, context);
+    if (isCurrentLayerSatisfied) {
       collectedActionIds.push(...group.actionIds);
       for (const rule of group.rules) {
         if (this.isConditionGroup(rule)) {
@@ -171,98 +164,41 @@ var StrategyEngine = class {
       }
     }
     return {
-      satisfied,
-      actionIds: collectedActionIds,
-      failedRules
+      satisfied: isCurrentLayerSatisfied,
+      actionIds: collectedActionIds
     };
   }
   /**
-   * 评估条件组的逻辑运算（带失败规则收集）
-   *
-   * 失败规则收集策略：
-   * - `and`：返回第一个失败的原子规则（嵌套 group 递归取其首个失败原子规则）
-   * - `or`：所有分支失败时，聚合每个分支的失败规则
-   * - `not`：被取反规则实际通过时，记录该规则
+   * 评估条件组的逻辑运算
    */
-  evaluateGroupLogicDetailed(group, context) {
+  evaluateGroupLogic(group, context) {
     const { operator, rules } = group;
     switch (operator) {
-      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: [] };
-      }
+      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);
       default:
         throw new Error(`Unknown operator: ${operator}`);
     }
   }
   /**
-   * 评估单个规则（带失败规则收集）
+   * 评估单个规则
    */
-  evaluateRuleDetailed(rule, context) {
+  evaluateRule(rule, context) {
     if (this.isConditionGroup(rule)) {
-      return this.evaluateGroupLogicDetailed(rule, context);
+      return this.evaluateGroupLogic(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,23 +165,6 @@ 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,8 +75,6 @@ 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,18 +46,6 @@ 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) {
@@ -102,14 +90,6 @@ 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;
@@ -204,24 +184,17 @@ 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;
-      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 = (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
         }
-      }
+      }, price, price);
     });
   }
   if (bundle == null ? void 0 : bundle.length) {
@@ -229,11 +202,10 @@ var getProductTotalPrice = (params) => {
       return accumulator + Number(currentValue.price) * Number(currentValue.num);
     }, price);
   }
-  if (optionRows.length) {
-    price = optionRows.reduce(
-      (accumulator, row) => accumulator + row.unit * row.num,
-      price
-    );
+  if (options == null ? void 0 : options.length) {
+    price = options.reduce((accumulator, currentValue) => {
+      return accumulator + Number(currentValue.price) * Number(currentValue.num);
+    }, price);
   }
   return Math.max(0, price);
 };
@@ -341,6 +313,7 @@ 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

@@ -1,6 +1,6 @@
 import { Module, PisellCore, ModuleOptions } from '../../types';
 import { BaseModule } from '../BaseModule';
-import { Discount, DiscountModuleAPI } from './types';
+import { Discount, DiscountModuleAPI, DiscountWithReason } from './types';
 export declare class DiscountModule extends BaseModule implements Module, DiscountModuleAPI {
     protected defaultName: string;
     protected defaultVersion: string;
@@ -17,17 +17,23 @@ export declare class DiscountModule extends BaseModule implements Module, Discou
     setOriginalDiscountList(originalDiscountList: Discount[]): Promise<void>;
     getOriginalDiscountList(): Discount[];
     loadPrepareConfig(params: {
-        action?: 'create';
+        action?: 'create' | 'edit';
         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, customerId?: number): Promise<Discount[]>;
+    batchSearch(code: string, options?: {
+        customerId?: number;
+        orderId?: number;
+    }): Promise<DiscountWithReason>;
     batchSearchByProductIds(productIds: number[]): Promise<any>;
     filterEnabledDiscountList(discountList: Discount[]): Discount[];
     private checkUsageCreditsLimit;
+    filterEnabledDiscountListWithReason(discountList: Discount[]): DiscountWithReason;
+    private checkUsageCreditsLimitWithFailKey;
     uniqueByProductId(discountList: Discount[]): Discount[];
     filterDiscountListByProductIds(discountList: Discount[], productIds: number[]): Discount[];
     calcDiscountApplicableProductTotalPrice(discount: Discount): number | undefined;

package/lib/modules/Discount/index.js

@@ -102,20 +102,23 @@ var DiscountModule = class extends import_BaseModule.BaseModule {
     ) || [];
     return goodPassList;
   }
-  async batchSearch(code, customerId) {
+  async batchSearch(code, options) {
+    const { customerId, orderId } = options || {};
     const result = await this.request.get(`/machinecode/batch-search`, {
       code,
       translate_flag: 1,
       tags: ["good_pass", "product_discount_card"],
-      available: 1,
+      // available: 1,
       relation_product: 1,
       with: ["extensionData", "customScheduleSnapshot", "holder.detail"],
       order_behavior_count: 1,
       order_behavior_count_customer_id: customerId || 1,
+      ...orderId ? { order_behavior_count_order_id: orderId } : {},
+      unified_status_info_flag: 1,
       request_timezone: Intl.DateTimeFormat().resolvedOptions().timeZone
     });
-    const resultDiscountList = this.filterEnabledDiscountList((result == null ? void 0 : result.data) || []) || [];
-    return resultDiscountList;
+    const resultDiscountWithReason = this.filterEnabledDiscountListWithReason((result == null ? void 0 : result.data) || []) || [];
+    return resultDiscountWithReason;
   }
   async batchSearchByProductIds(productIds) {
     const result = await this.request.get(`/machinecode/batch-search`, {
@@ -170,6 +173,64 @@ var DiscountModule = class extends import_BaseModule.BaseModule {
     }
     return true;
   }
+  // 过滤启用且可用的优惠券，并返回校验失败原因
+  filterEnabledDiscountListWithReason(discountList) {
+    let lists = discountList.filter((discount) => discount.limit_status === "enable").filter((discount) => {
+      const remaining = new import_decimal.default((discount == null ? void 0 : discount.par_value) || 0).minus(new import_decimal.default((discount == null ? void 0 : discount.used_par_value) || 0)).greaterThan(0);
+      return remaining;
+    }).map((discount) => {
+      const limitFailKey = this.checkUsageCreditsLimitWithFailKey(discount);
+      return {
+        ...discount,
+        usageLimitFailKey: limitFailKey
+      };
+    });
+    const availableLists = lists.filter((item) => !item.usageLimitFailKey && item.unified_available_status !== 0);
+    const currentFailDiscount = lists.find((item) => item.usageLimitFailKey);
+    return {
+      discountList: availableLists,
+      unavailableReasonKey: currentFailDiscount == null ? void 0 : currentFailDiscount.usageLimitFailKey
+    };
+  }
+  // 检查使用次数限制，并返回校验失败原因
+  checkUsageCreditsLimitWithFailKey(discount) {
+    if (!discount.extension_data || discount.extension_data.length === 0) {
+      return null;
+    }
+    const usageCreditsData = discount.extension_data.find(
+      (data) => data.field_key === "usage_credits"
+    );
+    if (!usageCreditsData) {
+      return null;
+    }
+    const value = usageCreditsData.value;
+    if (value.total_credits && value.total_credits > 0) {
+      if ((discount.total_order_behavior_count || 0) >= value.total_credits) {
+        return "total_credits";
+      }
+    }
+    if (value.per_user_limit && value.per_user_limit > 0) {
+      if ((discount.customer_order_behavior_count || 0) >= value.per_user_limit) {
+        return "per_user_limit";
+      }
+    }
+    if (value.max_per_day && value.max_per_day > 0) {
+      if ((discount.today_order_behavior_count || 0) >= value.max_per_day) {
+        return "max_per_day";
+      }
+    }
+    if (value.max_per_week && value.max_per_week > 0) {
+      if ((discount.week_order_behavior_count || 0) >= value.max_per_week) {
+        return "max_per_week";
+      }
+    }
+    if (value.max_per_month && value.max_per_month > 0) {
+      if ((discount.month_order_behavior_count || 0) >= value.max_per_month) {
+        return "max_per_month";
+      }
+    }
+    return null;
+  }
   // 根据productIds去重
   uniqueByProductId(discountList) {
     return (0, import_utils.uniqueById)(discountList, "product_id");

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';
+        type: 'all_packages' | 'specific_packages' | 'product_all' | 'products';
         exclude_bundle_product_ids: number[];
         include_bundle_product_ids: number[];
         filter: 0 | 1;
@@ -33,8 +33,6 @@ 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;
@@ -63,6 +61,11 @@ interface UsageCreditsValue {
     max_per_week: number;
     max_per_month: number;
 }
+export type DiscountFilterRejectKey = 'total_credits' | 'per_user_limit' | 'max_per_day' | 'max_per_week' | 'max_per_month';
+export interface DiscountWithReason {
+    discountList: Discount[];
+    unavailableReasonKey: DiscountFilterRejectKey | null;
+}
 interface ExtensionData {
     id: number;
     shop_id: number;
@@ -91,7 +94,6 @@ 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";
@@ -116,21 +118,6 @@ 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[];
@@ -149,6 +136,8 @@ export interface Discount {
     start_date?: string;
     start_time?: string;
     discount_rule_uncheck_flag?: boolean;
+    usageLimitFailKey?: string | null;
+    unified_available_status?: number | undefined | null;
 }
 export interface DiscountState {
     discountList: Discount[];