@pisell/pisellos 2.1.119 → 2.1.120

package/lib/model/strategy/adapter/index.d.ts

@@ -0,0 +1,7 @@
+export * from './type';
+export { default as WalletPassAdapter } from './walletPass';
+export { WalletPassEvaluator } from './walletPass/evaluator';
+export { PromotionEvaluator } from './promotion/evaluator';
+export { PromotionAdapter } from './promotion/adapter';
+export { ItemRuleEvaluator } from './itemRule/evaluator';
+export { ItemRuleAdapter } from './itemRule/adapter';

package/lib/model/strategy/adapter/index.js

@@ -0,0 +1,57 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/model/strategy/adapter/index.ts
+var adapter_exports = {};
+__export(adapter_exports, {
+  ItemRuleAdapter: () => import_adapter2.ItemRuleAdapter,
+  ItemRuleEvaluator: () => import_evaluator3.ItemRuleEvaluator,
+  PromotionAdapter: () => import_adapter.PromotionAdapter,
+  PromotionEvaluator: () => import_evaluator2.PromotionEvaluator,
+  WalletPassAdapter: () => import_walletPass.default,
+  WalletPassEvaluator: () => import_evaluator.WalletPassEvaluator
+});
+module.exports = __toCommonJS(adapter_exports);
+__reExport(adapter_exports, require("./type"), module.exports);
+var import_walletPass = __toESM(require("./walletPass"));
+var import_evaluator = require("./walletPass/evaluator");
+var import_evaluator2 = require("./promotion/evaluator");
+var import_adapter = require("./promotion/adapter");
+var import_evaluator3 = require("./itemRule/evaluator");
+var import_adapter2 = require("./itemRule/adapter");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ItemRuleAdapter,
+  ItemRuleEvaluator,
+  PromotionAdapter,
+  PromotionEvaluator,
+  WalletPassAdapter,
+  WalletPassEvaluator,
+  ...require("./type")
+});

package/lib/model/strategy/adapter/itemRule/adapter.d.ts

@@ -0,0 +1,59 @@
+import type { EvaluationResult, RuntimeContext, ActionEffect } from '../../type';
+import type { BusinessAdapter } from '../type';
+import { type ItemRuleBusinessData, type QuantityCheckResult, type PrefillItemResult, type QuantityLimitResult } from './type';
+/**
+ * ItemRule 适配器
+ *
+ * 将堂食扫码点餐的商品规则业务数据转换为策略引擎格式，
+ * 并将引擎结果转换为数量校验和预填购物车的业务结果。
+ */
+export declare class ItemRuleAdapter implements BusinessAdapter {
+    name: string;
+    version: string;
+    prepareContext(businessData: ItemRuleBusinessData): RuntimeContext;
+    transformResult(result: EvaluationResult, businessData?: ItemRuleBusinessData): {
+        quantityChecks: QuantityCheckResult[];
+        prefillItems: PrefillItemResult[];
+    };
+    formatConfig(result: EvaluationResult, businessData?: ItemRuleBusinessData): {
+        result: EvaluationResult;
+        businessData?: ItemRuleBusinessData;
+    };
+    private processQuantityCheck;
+    /**
+     * 根据 scope 判断当前提交是否需要评估此规则
+     */
+    private shouldEvaluateForScope;
+    /**
+     * 计算目标商品在购物车中的实际数量
+     *
+     * cumulative scope 时还会加上历史订单数量。
+     */
+    private calculateActualQuantity;
+    /**
+     * 逐条评估数量规则
+     */
+    private evaluateQuantityRules;
+    /**
+     * 根据 source 解析出数量规则的实际数值
+     */
+    private resolveQuantityValue;
+    /**
+     * 格式化校验提示语，替换 {min} {max} 占位符
+     */
+    private formatValidationMessage;
+    /**
+     * 从单个 QUANTITY_CHECK action 中提取数量限制配置。
+     *
+     * 根据 scope + submissionIndex 判断是否适用，
+     * 解析动态数量来源（pax）后返回 min/max/exact/mustInclude。
+     * 不适用或无配置时返回 null。
+     */
+    extractQuantityLimits(action: ActionEffect, businessData: ItemRuleBusinessData): QuantityLimitResult | null;
+    private processPrefillCart;
+    /**
+     * 根据 quantityFrom 计算预填数量
+     */
+    private resolvePrefillQuantity;
+}
+export default ItemRuleAdapter;

package/lib/model/strategy/adapter/itemRule/adapter.js

@@ -0,0 +1,338 @@
+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);
+
+// src/model/strategy/adapter/itemRule/adapter.ts
+var adapter_exports = {};
+__export(adapter_exports, {
+  ItemRuleAdapter: () => ItemRuleAdapter,
+  default: () => adapter_default
+});
+module.exports = __toCommonJS(adapter_exports);
+var import_type = require("./type");
+var ItemRuleAdapter = class {
+  constructor() {
+    this.name = "ItemRuleAdapter";
+    this.version = "1.0.0";
+  }
+  prepareContext(businessData) {
+    const { pax, cartItems, serviceType, submissionIndex, custom } = businessData;
+    return {
+      entities: {
+        cartItems,
+        historicalItems: businessData.historicalItems || [],
+        pax
+      },
+      attributes: {
+        serviceType: serviceType || "",
+        totalPax: pax.total,
+        adultPax: pax.adult,
+        childPax: pax.child,
+        submissionIndex: submissionIndex ?? 0,
+        cartItemCount: cartItems.length,
+        cartTotalQuantity: cartItems.reduce((sum, item) => sum + item.quantity, 0),
+        ...custom
+      },
+      metadata: {
+        timestamp: Date.now()
+      }
+    };
+  }
+  transformResult(result, businessData) {
+    const quantityChecks = [];
+    const prefillItems = [];
+    if (!result.applicable || !businessData) {
+      return { quantityChecks, prefillItems };
+    }
+    for (const action of result.matchedActions) {
+      if (action.type === import_type.ITEM_RULE_ACTION_TYPES.QUANTITY_CHECK) {
+        const checkResult = this.processQuantityCheck(action, businessData);
+        if (checkResult) {
+          quantityChecks.push(checkResult);
+        }
+      } else if (action.type === import_type.ITEM_RULE_ACTION_TYPES.PREFILL_CART) {
+        const items = this.processPrefillCart(action, businessData);
+        prefillItems.push(...items);
+      }
+    }
+    return { quantityChecks, prefillItems };
+  }
+  formatConfig(result, businessData) {
+    return { result, businessData };
+  }
+  // ============================================
+  // Quantity Check 处理
+  // ============================================
+  processQuantityCheck(action, businessData) {
+    const config = action.config;
+    if (!config)
+      return null;
+    const { scope, quantityRules, targetType, targets, validationMessage } = config;
+    if (!this.shouldEvaluateForScope(scope, businessData.submissionIndex ?? 0)) {
+      return null;
+    }
+    const actualQuantity = this.calculateActualQuantity(
+      targets,
+      scope,
+      businessData
+    );
+    const { passed, failedRules, requiredMin, requiredMax, requiredExact, mustInclude } = this.evaluateQuantityRules(quantityRules, actualQuantity, businessData);
+    const message = this.formatValidationMessage(
+      validationMessage,
+      requiredMin,
+      requiredMax,
+      requiredExact
+    );
+    return {
+      ruleId: action.id,
+      passed,
+      targetType,
+      targets,
+      actualQuantity,
+      requiredMin,
+      requiredMax,
+      requiredExact,
+      mustInclude,
+      validationMessage: message,
+      scope,
+      failedRules: passed ? void 0 : failedRules
+    };
+  }
+  /**
+   * 根据 scope 判断当前提交是否需要评估此规则
+   */
+  shouldEvaluateForScope(scope, submissionIndex) {
+    switch (scope) {
+      case "each_submission":
+        return true;
+      case "first_submission_only":
+        return submissionIndex === 0;
+      case "subsequent_only":
+        return submissionIndex > 0;
+      case "cumulative":
+        return true;
+      default:
+        return true;
+    }
+  }
+  /**
+   * 计算目标商品在购物车中的实际数量
+   *
+   * cumulative scope 时还会加上历史订单数量。
+   */
+  calculateActualQuantity(targets, scope, businessData) {
+    const targetIds = new Set(targets.map((t) => t.product_id));
+    let quantity = 0;
+    const countFromItems = (items) => {
+      for (const item of items) {
+        if (targetIds.has(item.product_id)) {
+          quantity += item.quantity;
+        }
+      }
+    };
+    if (scope === "cumulative") {
+      if (businessData.historicalItems) {
+        countFromItems(businessData.historicalItems);
+      }
+      countFromItems(businessData.cartItems);
+    } else {
+      countFromItems(businessData.cartItems);
+    }
+    return quantity;
+  }
+  /**
+   * 逐条评估数量规则
+   */
+  evaluateQuantityRules(rules, actualQuantity, businessData) {
+    const failedRules = [];
+    let requiredMin;
+    let requiredMax;
+    let requiredExact;
+    let mustInclude;
+    for (const rule of rules) {
+      const resolvedValue = this.resolveQuantityValue(rule, businessData);
+      switch (rule.comparison) {
+        case "minimum": {
+          if (requiredMin === void 0 || resolvedValue > requiredMin) {
+            requiredMin = resolvedValue;
+          }
+          if (actualQuantity < resolvedValue) {
+            failedRules.push(rule);
+          }
+          break;
+        }
+        case "maximum": {
+          if (requiredMax === void 0 || resolvedValue < requiredMax) {
+            requiredMax = resolvedValue;
+          }
+          if (actualQuantity > resolvedValue) {
+            failedRules.push(rule);
+          }
+          break;
+        }
+        case "exact": {
+          requiredExact = resolvedValue;
+          if (actualQuantity !== resolvedValue) {
+            failedRules.push(rule);
+          }
+          break;
+        }
+        case "must_include": {
+          mustInclude = true;
+          if (actualQuantity < 1) {
+            failedRules.push(rule);
+          }
+          break;
+        }
+      }
+    }
+    return {
+      passed: failedRules.length === 0,
+      failedRules,
+      requiredMin,
+      requiredMax,
+      requiredExact,
+      mustInclude
+    };
+  }
+  /**
+   * 根据 source 解析出数量规则的实际数值
+   */
+  resolveQuantityValue(rule, businessData) {
+    switch (rule.source) {
+      case "total_pax":
+        return businessData.pax.total;
+      case "adult_pax":
+        return businessData.pax.adult;
+      case "fixed":
+        return rule.value ?? 0;
+      default:
+        return rule.value ?? 0;
+    }
+  }
+  /**
+   * 格式化校验提示语，替换 {min} {max} 占位符
+   */
+  formatValidationMessage(template, min, max, exact, locale) {
+    if (!template)
+      return void 0;
+    let text = typeof template === "string" ? template : template[locale || "en"] || Object.values(template)[0] || "";
+    text = text.replace(/\{min\}/g, String(min ?? ""));
+    text = text.replace(/\{max\}/g, String(max ?? ""));
+    text = text.replace(/\{exact\}/g, String(exact ?? ""));
+    return text;
+  }
+  // ============================================
+  // Quantity Limit 提取（仅读取配置，不做校验）
+  // ============================================
+  /**
+   * 从单个 QUANTITY_CHECK action 中提取数量限制配置。
+   *
+   * 根据 scope + submissionIndex 判断是否适用，
+   * 解析动态数量来源（pax）后返回 min/max/exact/mustInclude。
+   * 不适用或无配置时返回 null。
+   */
+  extractQuantityLimits(action, businessData) {
+    const config = action.config;
+    if (!config)
+      return null;
+    const { scope, quantityRules, targetType, targets } = config;
+    if (!this.shouldEvaluateForScope(scope, businessData.submissionIndex ?? 0)) {
+      return null;
+    }
+    let requiredMin;
+    let requiredMax;
+    let requiredExact;
+    let mustInclude;
+    for (const rule of quantityRules) {
+      const resolvedValue = this.resolveQuantityValue(rule, businessData);
+      switch (rule.comparison) {
+        case "minimum": {
+          if (requiredMin === void 0 || resolvedValue > requiredMin) {
+            requiredMin = resolvedValue;
+          }
+          break;
+        }
+        case "maximum": {
+          if (requiredMax === void 0 || resolvedValue < requiredMax) {
+            requiredMax = resolvedValue;
+          }
+          break;
+        }
+        case "exact": {
+          requiredExact = resolvedValue;
+          break;
+        }
+        case "must_include": {
+          mustInclude = true;
+          break;
+        }
+      }
+    }
+    return {
+      ruleId: action.id,
+      targetType,
+      targets,
+      requiredMin,
+      requiredMax,
+      requiredExact,
+      mustInclude,
+      scope
+    };
+  }
+  // ============================================
+  // Prefill Cart 处理
+  // ============================================
+  processPrefillCart(action, businessData) {
+    const config = action.config;
+    if (!(config == null ? void 0 : config.products))
+      return [];
+    const results = [];
+    for (const prefillProduct of config.products) {
+      const quantity = this.resolvePrefillQuantity(prefillProduct.quantityFrom, prefillProduct.quantity, businessData);
+      if (quantity <= 0)
+        continue;
+      results.push({
+        ruleId: action.id,
+        product_id: prefillProduct.product_id,
+        product_variant_id: prefillProduct.product_variant_id,
+        quantity
+      });
+    }
+    return results;
+  }
+  /**
+   * 根据 quantityFrom 计算预填数量
+   */
+  resolvePrefillQuantity(quantityFrom, fixedValue, businessData) {
+    switch (quantityFrom) {
+      case "total_pax":
+        return businessData.pax.total;
+      case "adult_pax":
+        return businessData.pax.adult;
+      case "fixed":
+        return fixedValue ?? 0;
+      default:
+        return fixedValue ?? 0;
+    }
+  }
+};
+var adapter_default = ItemRuleAdapter;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ItemRuleAdapter
+});

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

@@ -0,0 +1,43 @@
+import type { StrategyConfig } from '../../type';
+import { type ItemRuleBusinessData, type ItemRuleEvaluationResult, type QuantityCheckResult, type QuantityLimitResult, type PrefillItemResult } from './type';
+/**
+ * ItemRule 评估器
+ *
+ * 组合 StrategyEngine + ItemRuleAdapter，提供面向业务的高层 API。
+ * 支持批量评估多条 item_rule 策略配置，聚合数量校验和预填购物车结果。
+ */
+export declare class ItemRuleEvaluator {
+    private engine;
+    private adapter;
+    private strategyConfigs;
+    constructor();
+    /**
+     * 设置策略配置列表
+     * 自动过滤 metadata.type === 'item_rule' 的配置
+     */
+    setStrategyConfigs(configs: StrategyConfig[]): void;
+    getStrategyConfigs(): StrategyConfig[];
+    /**
+     * 完整评估：数量校验 + 预填购物车
+     */
+    evaluate(businessData: ItemRuleBusinessData): ItemRuleEvaluationResult;
+    /**
+     * 获取当前配置中各商品的数量限制
+     *
+     * 不做购物车校验，仅从策略配置中提取 QUANTITY_CHECK 规则的
+     * min / max / exact / mustInclude 限制值。
+     * 会评估条件是否满足、根据 scope + submissionIndex 过滤。
+     */
+    getQuantityLimits(businessData: ItemRuleBusinessData): QuantityLimitResult[];
+    /**
+     * 便捷方法：仅做数量校验，返回是否全部通过及失败详情
+     */
+    validateCart(businessData: ItemRuleBusinessData): {
+        passed: boolean;
+        failures: QuantityCheckResult[];
+    };
+    /**
+     * 便捷方法：仅获取需要预填到购物车的商品
+     */
+    getPrefillItems(businessData: ItemRuleBusinessData): PrefillItemResult[];
+}

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

@@ -0,0 +1,124 @@
+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);
+
+// src/model/strategy/adapter/itemRule/evaluator.ts
+var evaluator_exports = {};
+__export(evaluator_exports, {
+  ItemRuleEvaluator: () => ItemRuleEvaluator
+});
+module.exports = __toCommonJS(evaluator_exports);
+var import_engine = require("../../engine");
+var import_adapter = require("./adapter");
+var import_type = require("./type");
+var ItemRuleEvaluator = class {
+  constructor() {
+    this.strategyConfigs = [];
+    this.engine = new import_engine.StrategyEngine({
+      debug: false,
+      enableTrace: false
+    });
+    this.adapter = new import_adapter.ItemRuleAdapter();
+  }
+  /**
+   * 设置策略配置列表
+   * 自动过滤 metadata.type === 'item_rule' 的配置
+   */
+  setStrategyConfigs(configs) {
+    this.strategyConfigs = configs.filter(
+      (c) => c.metadata.type === "item_rule"
+    );
+  }
+  getStrategyConfigs() {
+    return this.strategyConfigs;
+  }
+  /**
+   * 完整评估：数量校验 + 预填购物车
+   */
+  evaluate(businessData) {
+    const configs = businessData.strategyConfigs ? businessData.strategyConfigs.filter((c) => c.metadata.type === "item_rule") : this.strategyConfigs;
+    const allQuantityChecks = [];
+    const allPrefillItems = [];
+    const rawResults = [];
+    const context = this.adapter.prepareContext(businessData);
+    for (const config of configs) {
+      const evalResult = this.engine.evaluate(config, context);
+      rawResults.push(evalResult);
+      const { quantityChecks, prefillItems } = this.adapter.transformResult(
+        evalResult,
+        businessData
+      );
+      allQuantityChecks.push(...quantityChecks);
+      allPrefillItems.push(...prefillItems);
+    }
+    const failedChecks = allQuantityChecks.filter((c) => !c.passed);
+    return {
+      quantityChecks: allQuantityChecks,
+      prefillItems: allPrefillItems,
+      allPassed: failedChecks.length === 0,
+      failedChecks,
+      rawResults
+    };
+  }
+  /**
+   * 获取当前配置中各商品的数量限制
+   *
+   * 不做购物车校验，仅从策略配置中提取 QUANTITY_CHECK 规则的
+   * min / max / exact / mustInclude 限制值。
+   * 会评估条件是否满足、根据 scope + submissionIndex 过滤。
+   */
+  getQuantityLimits(businessData) {
+    const configs = businessData.strategyConfigs ? businessData.strategyConfigs.filter((c) => c.metadata.type === "item_rule") : this.strategyConfigs;
+    const results = [];
+    const context = this.adapter.prepareContext(businessData);
+    for (const config of configs) {
+      const evalResult = this.engine.evaluate(config, context);
+      if (!evalResult.applicable)
+        continue;
+      for (const action of evalResult.matchedActions) {
+        if (action.type !== import_type.ITEM_RULE_ACTION_TYPES.QUANTITY_CHECK)
+          continue;
+        const limit = this.adapter.extractQuantityLimits(action, businessData);
+        if (limit) {
+          results.push(limit);
+        }
+      }
+    }
+    return results;
+  }
+  /**
+   * 便捷方法：仅做数量校验，返回是否全部通过及失败详情
+   */
+  validateCart(businessData) {
+    const result = this.evaluate(businessData);
+    return {
+      passed: result.allPassed,
+      failures: result.failedChecks
+    };
+  }
+  /**
+   * 便捷方法：仅获取需要预填到购物车的商品
+   */
+  getPrefillItems(businessData) {
+    const result = this.evaluate(businessData);
+    return result.prefillItems;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ItemRuleEvaluator
+});

package/lib/model/strategy/adapter/itemRule/examples.d.ts

@@ -0,0 +1,64 @@
+import type { StrategyConfig } from '../../type';
+/**
+ * 场景：火锅店扫码点餐，要求小料数量 >= 成人人数，自动添加到购物车
+ *
+ * WHEN: Always active
+ * THEN:
+ *   - Quantity Check: 小料最少数量 = Adult Pax
+ *   - Prefill Cart: 自动添加小料 x Adult Pax
+ */
+export declare const MIN_CONDIMENT_PER_PERSON_STRATEGY: StrategyConfig;
+/**
+ * 场景：包子限量供应，每桌最多3份（含加单累计），肉包和菜包合计
+ *
+ * WHEN: Always active
+ * THEN:
+ *   - Quantity Check: 肉包 + 菜包 合计 <= 3，scope=cumulative
+ */
+export declare const MAX_BUNS_PER_TABLE_STRATEGY: StrategyConfig;
+/**
+ * 场景：堂食必须选择一个锅底（按商品匹配），自动预填默认锅底
+ *
+ * WHEN: Service Type = Dine-in
+ * THEN:
+ *   - Quantity Check: 指定锅底商品精确1份
+ *   - Prefill Cart: 自动添加默认锅底 x 1
+ */
+export declare const HOTPOT_BASE_REQUIRED_STRATEGY: StrategyConfig;
+/**
+ * ItemRuleEvaluator 简洁调用示例
+ *
+ * 覆盖方法：
+ * - setStrategyConfigs
+ * - getStrategyConfigs
+ * - evaluate
+ * - getQuantityLimits
+ * - validateCart
+ * - getPrefillItems
+ */
+export declare function quickUseItemRuleEvaluator(): {
+    configCount: number;
+    evaluation: import("./type").ItemRuleEvaluationResult;
+    quantityLimits: import("./type").QuantityLimitResult[];
+    validation: {
+        passed: boolean;
+        failures: import("./type").QuantityCheckResult[];
+    };
+    prefillItems: import("./type").PrefillItemResult[];
+};
+/**
+ * ItemRuleEvaluator 完整可运行 Demo
+ *
+ * 说明：
+ * 1) 首次提交：触发 first_submission_only + cumulative + 条件规则
+ * 2) 追加提交：演示 first_submission_only 不再触发
+ * 3) 覆盖 strategyConfigs 临时传入：演示按需仅评估部分规则
+ */
+export declare function runItemRuleEvaluatorDemo(): {
+    firstEvaluation: import("./type").ItemRuleEvaluationResult;
+    validateResult: {
+        passed: boolean;
+        failures: import("./type").QuantityCheckResult[];
+    };
+    prefillItems: import("./type").PrefillItemResult[];
+};