@pisell/pisellos 2.3.150 → 2.3.152

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

@@ -1,6 +1,6 @@
 import type { EvaluationResult, RuntimeContext, ActionEffect } from '../../type';
 import type { BusinessAdapter } from '../type';
-import { type ItemRuleBusinessData, type QuantityCheckResult, type PrefillItemResult, type QuantityLimitResult, type AllergyRequirement } from './type';
+import { type ItemRuleBusinessData, type ItemRuleCartAction, type QuantityCheckResult, type PrefillItemResult, type QuantityLimitResult, type AllergyRequirement } from './type';
 /**
  * ItemRule 适配器
  *
@@ -14,6 +14,7 @@ export declare class ItemRuleAdapter implements BusinessAdapter {
     transformResult(result: EvaluationResult, businessData?: ItemRuleBusinessData): {
         quantityChecks: QuantityCheckResult[];
         prefillItems: PrefillItemResult[];
+        cartActions: ItemRuleCartAction[];
         allergyRequirements: AllergyRequirement[];
     };
     private processAllergyCheck;
@@ -66,5 +67,6 @@ export declare class ItemRuleAdapter implements BusinessAdapter {
      * 根据 quantityFrom 计算预填数量
      */
     private resolvePrefillQuantity;
+    private processDeleteProduct;
 }
 export default ItemRuleAdapter;

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

@@ -50,11 +50,13 @@ class ItemRuleAdapter {
   transformResult(result, businessData) {
     const quantityChecks = [];
     const prefillItems = [];
+    const cartActions = [];
     const allergyRequirements = [];
     if (!result.applicable || !businessData) {
       return {
         quantityChecks,
         prefillItems,
+        cartActions,
         allergyRequirements
       };
     }
@@ -66,7 +68,27 @@ class ItemRuleAdapter {
         }
       } else if (action.type === _type.ITEM_RULE_ACTION_TYPES.PREFILL_CART) {
         const items = this.processPrefillCart(action, businessData);
-        prefillItems.push(...items);
+        prefillItems.push(...items.filter(item => item.quantity > 0));
+        if (items.length) {
+          cartActions.push({
+            type: _type.ITEM_RULE_ACTION_TYPES.PREFILL_CART,
+            strategyId: result.config.metadata.id,
+            ruleId: action.id,
+            priority: action.priority ?? 0,
+            products: items
+          });
+        }
+      } else if (action.type === _type.ITEM_RULE_ACTION_TYPES.DELETE_PRODUCT) {
+        const products = this.processDeleteProduct(action, businessData);
+        if (products.length) {
+          cartActions.push({
+            type: _type.ITEM_RULE_ACTION_TYPES.DELETE_PRODUCT,
+            strategyId: result.config.metadata.id,
+            ruleId: action.id,
+            priority: action.priority ?? 0,
+            products
+          });
+        }
       } else if (action.type === _type.ITEM_RULE_ACTION_TYPES.ALLERGY_CHECK) {
         const requirement = this.processAllergyCheck(action, result, businessData);
         if (requirement) allergyRequirements.push(requirement);
@@ -75,6 +97,7 @@ class ItemRuleAdapter {
     return {
       quantityChecks,
       prefillItems,
+      cartActions,
       allergyRequirements
     };
   }
@@ -423,16 +446,24 @@ class ItemRuleAdapter {
 
   processPrefillCart(action, businessData) {
     const config = action.config;
-    if (!config?.products) return [];
+    if (!Array.isArray(config?.products)) return [];
+    if (config.scope !== businessData.executionScope) return [];
+    if (config.scope === 'set_handover' && action.target !== 'cart') return [];
     const results = [];
     for (const prefillProduct of config.products) {
       const quantity = this.resolvePrefillQuantity(prefillProduct.quantityFrom, prefillProduct.quantity, businessData);
-      if (quantity <= 0) continue;
+      const shouldSyncZero = config.scope === 'set_handover' && prefillProduct.repeat_skip === true;
+      if (!Number.isFinite(quantity) || quantity < 0 || quantity === 0 && !shouldSyncZero) {
+        continue;
+      }
       results.push({
         ruleId: action.id,
         product_id: prefillProduct.product_id,
         product_variant_id: prefillProduct.product_variant_id,
-        quantity
+        quantity,
+        ...(prefillProduct.repeat_skip !== undefined ? {
+          repeat_skip: prefillProduct.repeat_skip === true
+        } : {})
       });
     }
     return results;
@@ -449,10 +480,29 @@ class ItemRuleAdapter {
         return businessData.pax.adult;
       case 'fixed':
         return fixedValue ?? 0;
+      case 'main_product_number':
+        {
+          const mainProductNumber = businessData.mainProductNumber ?? 0;
+          return Number.isFinite(mainProductNumber) ? Math.max(0, mainProductNumber) : 0;
+        }
       default:
         return fixedValue ?? 0;
     }
   }
+  processDeleteProduct(action, businessData) {
+    const config = action.config;
+    if (action.target !== 'cart' || config?.scope !== 'set_handover' || config.scope !== businessData.executionScope || !Array.isArray(config.products)) {
+      return [];
+    }
+    const productIds = new Set();
+    for (const product of config.products) {
+      const productId = Number(product?.product_id);
+      if (Number.isInteger(productId) && productId > 0) productIds.add(productId);
+    }
+    return Array.from(productIds, product_id => ({
+      product_id
+    }));
+  }
 }
 exports.ItemRuleAdapter = ItemRuleAdapter;
 var _default = exports.default = ItemRuleAdapter;

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

@@ -1,5 +1,5 @@
 import type { StrategyConfig } from '../../type';
-import { type ItemRuleBusinessData, type ItemRuleEvaluationResult, type QuantityCheckResult, type QuantityLimitResult, type PrefillItemResult, type AllergyRequirement } from './type';
+import { type ItemRuleBusinessData, type ItemRuleEvaluationResult, type QuantityCheckResult, type QuantityLimitResult, type PrefillItemResult, type ItemRuleCartAction, type AllergyRequirement } from './type';
 /**
  * ItemRule 评估器
  *
@@ -47,4 +47,6 @@ export declare class ItemRuleEvaluator {
      * 便捷方法：仅获取需要预填到购物车的商品
      */
     getPrefillItems(businessData: ItemRuleBusinessData): PrefillItemResult[];
+    /** 获取按优先级排序的购物车动作，交由销售业务层执行。 */
+    getCartActions(businessData: ItemRuleBusinessData): ItemRuleCartAction[];
 }

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

@@ -43,6 +43,7 @@ class ItemRuleEvaluator {
     const configs = businessData.strategyConfigs ? businessData.strategyConfigs.filter(c => c.metadata.type === 'item_rule') : this.strategyConfigs;
     const allQuantityChecks = [];
     const allPrefillItems = [];
+    const allCartActions = [];
     const allAllergyRequirements = [];
     const rawResults = [];
     const context = this.adapter.prepareContext(businessData);
@@ -52,16 +53,19 @@ class ItemRuleEvaluator {
       const {
         quantityChecks,
         prefillItems,
+        cartActions,
         allergyRequirements
       } = this.adapter.transformResult(evalResult, businessData);
       allQuantityChecks.push(...quantityChecks);
       allPrefillItems.push(...prefillItems);
+      allCartActions.push(...cartActions);
       allAllergyRequirements.push(...allergyRequirements);
     }
     const failedChecks = allQuantityChecks.filter(c => !c.passed);
     return {
       quantityChecks: allQuantityChecks,
       prefillItems: allPrefillItems,
+      cartActions: allCartActions.sort((left, right) => right.priority - left.priority),
       allergyRequirements: allAllergyRequirements,
       allPassed: failedChecks.length === 0,
       failedChecks,
@@ -130,5 +134,10 @@ class ItemRuleEvaluator {
     const result = this.evaluate(businessData);
     return result.prefillItems;
   }
+
+  /** 获取按优先级排序的购物车动作，交由销售业务层执行。 */
+  getCartActions(businessData) {
+    return this.evaluate(businessData).cartActions;
+  }
 }
 exports.ItemRuleEvaluator = ItemRuleEvaluator;

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

@@ -4,6 +4,8 @@ export declare const ITEM_RULE_ACTION_TYPES: {
     readonly QUANTITY_CHECK: "QUANTITY_CHECK";
     /** 预填购物车 */
     readonly PREFILL_CART: "PREFILL_CART";
+    /** 按商品 ID 删除购物车商品 */
+    readonly DELETE_PRODUCT: "DELETE_PRODUCT";
     /** 加购前过敏信息确认 */
     readonly ALLERGY_CHECK: "ALLERGY_CHECK";
 };
@@ -101,6 +103,10 @@ export interface AllergyRequirement {
     promptScope: AllergyPromptScope;
     allowNote: boolean;
 }
+/** 购物车动作触发时机，与数量校验的提交范围相互独立。 */
+export type ItemRuleExecutionScope = 'set_handover';
+/** 预填数量来源；主商品数量不扩展到 QUANTITY_CHECK。 */
+export type PrefillQuantitySource = QuantitySource | 'main_product_number';
 /**
  * 预填商品项
  */
@@ -110,9 +116,11 @@ export interface PrefillProduct {
     /** 变体 ID（可选，0 或不填表示无变体/默认） */
     product_variant_id?: number;
     /** 数量来源 */
-    quantityFrom: QuantitySource;
+    quantityFrom: PrefillQuantitySource;
     /** 固定数量（当 quantityFrom 为 'fixed' 时使用） */
     quantity?: number;
+    /** 设置取餐方式时同步自动附加行的数量，重复执行不累加。 */
+    repeat_skip?: boolean;
 }
 /**
  * Prefill Cart Action 的详细配置
@@ -120,9 +128,18 @@ export interface PrefillProduct {
  * 存储在 ActionEffect.config 中
  */
 export interface PrefillCartConfig {
+    /** 不填时保持原有预填时机；set_handover 仅在设置取餐方式时执行。 */
+    scope?: ItemRuleExecutionScope;
     /** 要预填的商品列表 */
     products: PrefillProduct[];
 }
+/** 删除指定商品的全部购物车行，不区分变体或是否为自动添加。 */
+export interface DeleteProductConfig {
+    scope: ItemRuleExecutionScope;
+    products: Array<{
+        product_id: number;
+    }>;
+}
 /**
  * 购物车商品摘要
  */
@@ -157,6 +174,10 @@ export interface ItemRuleBusinessData {
     historicalItems?: CartItemSummary[];
     /** 服务类型（如 'dine-in', 'takeaway'） */
     serviceType?: string;
+    /** 当前购物车动作触发时机；未填时不评估 set_handover 动作。 */
+    executionScope?: ItemRuleExecutionScope;
+    /** 由销售业务层提供的主商品总数量，不包含附加费用商品。 */
+    mainProductNumber?: number;
     /** 当前业务渠道（如 'kiosk', 'pos', 'online_store'） */
     channel?: string;
     /** 当前正在加入购物车的商品；ALLERGY_CHECK 只读取该商品的 Target。 */
@@ -209,7 +230,23 @@ export interface PrefillItemResult {
     product_variant_id?: number;
     /** 应添加的数量 */
     quantity: number;
+    /** true 时执行器同步自动附加行数量；quantity=0 表示移除该自动行。 */
+    repeat_skip?: boolean;
 }
+/** 保留不同购物车动作之间的优先级与执行顺序。 */
+export type ItemRuleCartAction = {
+    strategyId: string;
+    ruleId: string;
+    priority: number;
+} & ({
+    type: 'PREFILL_CART';
+    products: PrefillItemResult[];
+} | {
+    type: 'DELETE_PRODUCT';
+    products: Array<{
+        product_id: number;
+    }>;
+});
 /**
  * 单条规则的数量限制（不含校验结果，仅描述配置中的约束）
  */
@@ -258,6 +295,8 @@ export interface ItemRuleEvaluationResult {
     quantityChecks: QuantityCheckResult[];
     /** 需要预填的商品列表 */
     prefillItems: PrefillItemResult[];
+    /** 按 priority 降序排列的购物车动作；同优先级保持策略与动作顺序。 */
+    cartActions: ItemRuleCartAction[];
     /** 当前商品命中的过敏门禁要求；不同 Action/商品不会合并。 */
     allergyRequirements: AllergyRequirement[];
     /** 所有校验是否全部通过 */

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

@@ -13,6 +13,8 @@ const ITEM_RULE_ACTION_TYPES = exports.ITEM_RULE_ACTION_TYPES = {
   QUANTITY_CHECK: 'QUANTITY_CHECK',
   /** 预填购物车 */
   PREFILL_CART: 'PREFILL_CART',
+  /** 按商品 ID 删除购物车商品 */
+  DELETE_PRODUCT: 'DELETE_PRODUCT',
   /** 加购前过敏信息确认 */
   ALLERGY_CHECK: 'ALLERGY_CHECK'
 };
@@ -78,6 +80,10 @@ const ITEM_RULE_TEMPLATES = exports.ITEM_RULE_TEMPLATES = {
 // Prefill Cart 相关类型
 // ============================================
 
+/** 购物车动作触发时机，与数量校验的提交范围相互独立。 */
+
+/** 预填数量来源；主商品数量不扩展到 QUANTITY_CHECK。 */
+
 /**
  * 预填商品项
  */
@@ -88,6 +94,8 @@ const ITEM_RULE_TEMPLATES = exports.ITEM_RULE_TEMPLATES = {
  * 存储在 ActionEffect.config 中
  */
 
+/** 删除指定商品的全部购物车行，不区分变体或是否为自动添加。 */
+
 // ============================================
 // 业务数据类型（Evaluator 输入）
 // ============================================
@@ -116,6 +124,8 @@ const ITEM_RULE_TEMPLATES = exports.ITEM_RULE_TEMPLATES = {
  * 单个 Prefill Cart 的预填结果
  */
 
+/** 保留不同购物车动作之间的优先级与执行顺序。 */
+
 /**
  * 单条规则的数量限制（不含校验结果，仅描述配置中的约束）
  */

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

@@ -1 +1,46 @@
-"use strict";
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "BUY_X_GET_Y_FREE_STRATEGY", {
+  enumerable: true,
+  get: function () {
+    return _examples.BUY_X_GET_Y_FREE_STRATEGY;
+  }
+});
+Object.defineProperty(exports, "ITEM_REWARD_STRATEGY", {
+  enumerable: true,
+  get: function () {
+    return _examples.ITEM_REWARD_STRATEGY;
+  }
+});
+Object.defineProperty(exports, "PromotionAdapter", {
+  enumerable: true,
+  get: function () {
+    return _adapter.PromotionAdapter;
+  }
+});
+Object.defineProperty(exports, "PromotionEvaluator", {
+  enumerable: true,
+  get: function () {
+    return _evaluator.PromotionEvaluator;
+  }
+});
+Object.defineProperty(exports, "X_ITEMS_FOR_Y_PRICE_STRATEGY", {
+  enumerable: true,
+  get: function () {
+    return _examples.X_ITEMS_FOR_Y_PRICE_STRATEGY;
+  }
+});
+Object.defineProperty(exports, "default", {
+  enumerable: true,
+  get: function () {
+    return _adapter.default;
+  }
+});
+var _evaluator = require("./evaluator");
+var _adapter = _interopRequireWildcard(require("./adapter"));
+var _examples = require("./examples");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }

package/lib/modules/OpenData/types.d.ts

@@ -82,6 +82,8 @@ export interface OpenDataConfig {
     'sale.enabled_item_rules'?: number[];
     'fulfillment.enable_pickup'?: boolean;
     'fulfillment.handover_mode'?: string[];
+    'fulfillment.takeaway_fees_rules'?: number[];
+    'fulfillment.dine_in_fees_rules'?: number[];
     'fulfillment.pickup.timing_mode'?: 'asap_only' | 'scheduled_only' | 'asap_and_scheduled';
     'fulfillment.pickup.schedule'?: number[];
     'fulfillment.pickup.advance_days'?: number;

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

@@ -509,7 +509,9 @@ export declare class OrderModule extends BaseModule implements Module, OrderModu
     private applyOrderProductUpdateToTempOrder;
     updateOrderProduct(params: UpdateOrderProductParams): Promise<OrderProduct[]>;
     updateOrderProducts(paramsList: UpdateOrderProductParams[]): Promise<OrderProduct[]>;
-    updateOrderProductQuantity(params: UpdateOrderProductQuantityParams): Promise<OrderProduct[]>;
+    updateOrderProductQuantity(params: UpdateOrderProductQuantityParams, options?: {
+        isCurrentOrder?: () => boolean;
+    }): Promise<OrderProduct[]>;
     updateOrderBooking(params: UpdateOrderBookingParams): any[];
     /**
      * 商品行写路径收尾：促销 → 折扣 → 清洗 → summary → 持久化。

package/lib/modules/Order/index.js

@@ -3792,7 +3792,7 @@ class OrderModule extends _BaseModule.BaseModule {
       const uid = line.metadata?.unique_identification_number || line.unique_identification_number;
       return uid !== undefined && uid !== null && String(uid) === String(insertAfterProductUid);
     }) : -1;
-    let insertAtIndex = anchorIndex >= 0 ? anchorIndex + 1 : undefined;
+    let insertAtIndex = options?.insertAtStart ? 0 : anchorIndex >= 0 ? anchorIndex + 1 : undefined;
     try {
       if (booking) {
         const productRecord = product;
@@ -4320,7 +4320,9 @@ class OrderModule extends _BaseModule.BaseModule {
     });
     return tempOrder.products;
   }
-  async updateOrderProductQuantity(params) {
+  async updateOrderProductQuantity(params, options) {
+    const isCurrentOrder = options?.isCurrentOrder;
+    if (isCurrentOrder && !isCurrentOrder()) return this.store.tempOrder?.products || [];
     const {
       product_id,
       product_variant_id,
@@ -4389,19 +4391,27 @@ class OrderModule extends _BaseModule.BaseModule {
     if (normalizedProduct.num > targetProduct.num) {
       this.createCartIntentCommitGuard('increase_quantity', tempOrder)();
     }
+    if (isCurrentOrder && !isCurrentOrder()) return tempOrder.products;
     tempOrder.products[productIndex] = normalizedProduct;
-    this.prepareVirtualSettlementTempOrder(tempOrder);
-    const isVirtualSettlement = this.isActiveVirtualSettlementOrder(tempOrder);
-    const promotionPayload = !isVirtualSettlement ? await this.evaluatePromotion() : null;
-    if (!isVirtualSettlement) {
-      this.applyDiscount();
+    if (isCurrentOrder) {
+      await this.finalizeProductOrderMutation(tempOrder, {
+        skipEditDiscountConfigRefresh: true,
+        isCurrentOrder
+      });
+    } else {
+      this.prepareVirtualSettlementTempOrder(tempOrder);
+      const isVirtualSettlement = this.isActiveVirtualSettlementOrder(tempOrder);
+      const promotionPayload = !isVirtualSettlement ? await this.evaluatePromotion() : null;
+      if (!isVirtualSettlement) {
+        this.applyDiscount();
+      }
+      this.sanitizeTempOrderProducts(tempOrder);
+      await this.recalculateSummary({
+        createIfMissing: true
+      });
+      this.persistTempOrder();
+      this.emitPromotionApplied(promotionPayload);
     }
-    this.sanitizeTempOrderProducts(tempOrder);
-    await this.recalculateSummary({
-      createIfMissing: true
-    });
-    this.persistTempOrder();
-    this.emitPromotionApplied(promotionPayload);
     this.logInfo('updateOrderProductQuantity success', {
       params
     });
@@ -4466,6 +4476,8 @@ class OrderModule extends _BaseModule.BaseModule {
    * await order.removeProductsFromOrder([identityA, identityB]);
    */
   async removeProductsFromOrder(identities, options) {
+    const isCurrentOrder = options?.isCurrentOrder;
+    if (isCurrentOrder && !isCurrentOrder()) return this.store.tempOrder?.products || [];
     const tempOrder = this.ensureTempOrder();
     if (!identities.length) {
       return tempOrder.products;
@@ -4533,7 +4545,14 @@ class OrderModule extends _BaseModule.BaseModule {
       }
     }
     this.removeSalesNotesForMissingProductLines(tempOrder);
-    await this.finalizeAfterProductsMutation(tempOrder);
+    if (isCurrentOrder) {
+      await this.finalizeProductOrderMutation(tempOrder, {
+        skipEditDiscountConfigRefresh: true,
+        isCurrentOrder
+      });
+    } else {
+      await this.finalizeAfterProductsMutation(tempOrder);
+    }
     this.logInfo('removeProductsFromOrder success', {
       identities
     });

package/lib/modules/Order/types.d.ts

@@ -441,6 +441,8 @@ export type AddProductBookingInput = Record<string, any>;
  */
 export interface AddProductToOrderOptions {
     insertAfterProductUid?: string;
+    /** 新增商品行插入 products 首位，优先于 insertAfterProductUid。 */
+    insertAtStart?: boolean;
     /** 跳过同商品/规格匹配，始终新增购物车行。 */
     disableMerge?: boolean;
     /** 商品行 UID 落定后，由 OrderModule 原子绑定到该行的 Sales Notes 草稿。 */
@@ -460,6 +462,8 @@ export interface AddProductToOrderOptions {
  * 预约合并行减量时仍删除最新真实行，再把剩余代表行移动到被删除代表行原位置。
  */
 export interface RemoveProductsFromOrderOptions {
+    /** 自动购物车写入的订单归属检查；失效时不再变更或发布异步收尾结果。 */
+    isCurrentOrder?: () => boolean;
     preserveDisplayPosition?: {
         remainingProductUid: string;
         anchorProductUid: string;
@@ -897,7 +901,9 @@ export interface OrderModuleAPI {
     updateOrderProduct: (params: UpdateOrderProductParams) => Promise<OrderProduct[]>;
     /** 批量更新购物车行，末尾仅触发一次促销重算与 summary 刷新 */
     updateOrderProducts: (paramsList: UpdateOrderProductParams[]) => Promise<OrderProduct[]>;
-    updateOrderProductQuantity: (params: UpdateOrderProductQuantityParams) => Promise<OrderProduct[]>;
+    updateOrderProductQuantity: (params: UpdateOrderProductQuantityParams, options?: {
+        isCurrentOrder?: () => boolean;
+    }) => Promise<OrderProduct[]>;
     updateOrderBooking: (params: UpdateOrderBookingParams) => any[];
     removeProductFromOrder: (identity: OrderProductIdentity, options?: RemoveProductsFromOrderOptions) => Promise<OrderProduct[]>;
     /** 批量删除购物车行，末尾仅触发一次促销重算与 summary 刷新 */

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

@@ -49,5 +49,5 @@ export declare class Product extends BaseModule implements Module {
     getCategories(): ProductCategory[];
     setOtherParams(key: string, value: any): void;
     getOtherParams(): any;
-    getProductType(): "duration" | "normal" | "session";
+    getProductType(): "normal" | "duration" | "session";
 }

package/lib/solution/BaseSales/fulfillmentItemRules.d.ts

@@ -0,0 +1,27 @@
+import type { OrderModule } from '../../modules/Order';
+import type { ShopServiceType } from '../../modules/Order/types';
+import type { ProductList } from '../../modules/ProductList';
+import type { OpenDataConfig } from '../../modules/OpenData/types';
+interface FulfillmentItemRulesHost {
+    getOrder: () => OrderModule;
+    getProducts: () => ProductList | undefined;
+    loadOpenData: () => Promise<OpenDataConfig | null>;
+    getScope: () => string;
+    getOtherParams: () => Record<string, any>;
+    fetchStrategyModels: (ids: number[]) => Promise<any>;
+    reportError: (error: unknown) => void;
+}
+/** Executes item rules at the sales boundary, independent of the calling template. */
+export declare class FulfillmentItemRulesController {
+    private readonly host;
+    private sequence;
+    private pending;
+    private evaluator;
+    constructor(host: FulfillmentItemRulesHost);
+    invalidate(): void;
+    apply(serviceType: ShopServiceType): Promise<void>;
+    private loadProducts;
+    private getMainProductNumber;
+    private loadPrefillSources;
+}
+export {};