@pisell/pisellos 2.2.313 → 2.2.315

package/lib/shared/receipt/templateVisibility.d.ts

@@ -0,0 +1,23 @@
+/** Template children are direct module members; legacy missing values stay visible. */
+export interface InvoiceDataVisibility {
+    handover: {
+        show: boolean;
+        method: boolean;
+        fulfillmentTime: boolean;
+    };
+    customer: {
+        show: boolean;
+        name: boolean;
+        email: boolean;
+        phone: boolean;
+    };
+    card: {
+        show: boolean;
+        passTypes: ReadonlySet<string> | null;
+    };
+}
+export declare function invoiceSettingIsVisible(value: unknown): boolean;
+export declare function getInvoiceTemplateModules(settings: unknown): Record<string, any>[];
+export declare function resolveInvoiceDataVisibility(settings: unknown): InvoiceDataVisibility;
+/** Whether an old unfiltered snapshot is unsafe for this template. */
+export declare function requiresInvoiceDataFiltering(settings: unknown): boolean;

package/lib/shared/receipt/templateVisibility.js

@@ -0,0 +1,63 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getInvoiceTemplateModules = getInvoiceTemplateModules;
+exports.invoiceSettingIsVisible = invoiceSettingIsVisible;
+exports.requiresInvoiceDataFiltering = requiresInvoiceDataFiltering;
+exports.resolveInvoiceDataVisibility = resolveInvoiceDataVisibility;
+/** Template children are direct module members; legacy missing values stay visible. */
+
+function invoiceSettingIsVisible(value) {
+  return value !== 0 && value !== false;
+}
+function getInvoiceTemplateModules(settings) {
+  if (Array.isArray(settings)) return settings.filter(isRecord);
+  if (!isRecord(settings)) return [];
+  if (isRecord(settings.template_settings)) {
+    return getInvoiceTemplateModules(settings.template_settings);
+  }
+  const modules = settings.modules ?? settings.module;
+  return Array.isArray(modules) ? modules.filter(isRecord) : [];
+}
+function isRecord(value) {
+  return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+function resolveInvoiceDataVisibility(settings) {
+  const modules = getInvoiceTemplateModules(settings);
+  // Native templates use the first occurrence of each module.
+  const module = key => modules.find(item => item.key === key);
+  const handover = module('handover');
+  const customer = module('customer');
+  const card = module('card');
+  const field = (config, key) => invoiceSettingIsVisible(config?.[key]?.is_show);
+  const passTypes = Array.isArray(card?.pass_type) && card.pass_type.length > 0 ? new Set(card.pass_type.filter(tag => typeof tag === 'string' && tag.length > 0)) : null;
+  return {
+    handover: {
+      show: invoiceSettingIsVisible(handover?.is_show),
+      method: field(handover, 'method'),
+      fulfillmentTime: field(handover, 'fulfillment_time')
+    },
+    customer: {
+      show: invoiceSettingIsVisible(customer?.is_show),
+      name: field(customer, 'name'),
+      email: field(customer, 'email'),
+      phone: field(customer, 'phone')
+    },
+    card: {
+      show: invoiceSettingIsVisible(card?.is_show),
+      passTypes
+    }
+  };
+}
+
+/** Whether an old unfiltered snapshot is unsafe for this template. */
+function requiresInvoiceDataFiltering(settings) {
+  const {
+    handover,
+    customer,
+    card
+  } = resolveInvoiceDataVisibility(settings);
+  return !handover.show || !handover.method || !handover.fulfillmentTime || !customer.show || !customer.name || !customer.email || !customer.phone || !card.show || card.passTypes !== null;
+}

package/lib/shared/sales/loadSalesOrderSnapshot.d.ts

@@ -0,0 +1,9 @@
+import type { RequestPlugin } from '../../plugins/request';
+export declare const SALES_ORDER_RELATIONS: string[];
+/** Shared transport contract; remote callers use their host's /h5 prefix. */
+export declare function loadSalesOrderSnapshot(request: RequestPlugin, params: {
+    lookup: string | number;
+    transport: 'remote' | 'os-server';
+    forceRemote?: boolean;
+    with?: string[];
+}): Promise<any>;

package/lib/shared/sales/loadSalesOrderSnapshot.js

@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SALES_ORDER_RELATIONS = void 0;
+exports.loadSalesOrderSnapshot = loadSalesOrderSnapshot;
+const SALES_ORDER_RELATIONS = exports.SALES_ORDER_RELATIONS = ['products', 'bookings', 'payments', 'customer', 'summary', 'contacts_info', 'order_meta_list', 'refunds', 'notes'];
+
+/** Shared transport contract; remote callers use their host's /h5 prefix. */
+function loadSalesOrderSnapshot(request, params) {
+  const lookup = String(params.lookup ?? '').trim();
+  if (!lookup) throw new Error('加载销售详情需要 lookup');
+  return request.get(`/order/sales/${encodeURIComponent(lookup)}`, {
+    with: params.with ?? SALES_ORDER_RELATIONS,
+    ...(params.forceRemote && !lookup.startsWith('LOCAL_') ? {
+      forceRemote: true
+    } : {})
+  }, params.transport === 'os-server' ? {
+    osServer: true
+  } : undefined);
+}

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 {};

package/lib/solution/BaseSales/fulfillmentItemRules.js

@@ -0,0 +1,259 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FulfillmentItemRulesController = void 0;
+var _dayjs = _interopRequireDefault(require("dayjs"));
+var _itemRule = require("../../model/strategy/adapter/itemRule");
+var _transformBaseProductToOrderProduct = require("./utils/transformBaseProductToOrderProduct");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const ownershipField = 'fulfillment_item_rule';
+function positiveIds(value) {
+  if (!Array.isArray(value)) return [];
+  return [...new Set(value.map(Number).filter(id => Number.isInteger(id) && id > 0))];
+}
+function lineIdentity(line) {
+  return {
+    product_id: line.product_id,
+    product_variant_id: line.product_variant_id,
+    unique_identification_number: line.metadata?.unique_identification_number || line.unique_identification_number,
+    product_sku: line.product_sku,
+    product_bundle: line.product_bundle
+  };
+}
+function cartFingerprint(lines) {
+  return JSON.stringify(lines.map(line => [lineIdentity(line), line.num, line.metadata?.[ownershipField]]));
+}
+function selectionFingerprint(lines, excludedIds) {
+  const quantities = new Map();
+  for (const line of lines) {
+    if (excludedIds.has(Number(line.product_id)) || line.metadata?._giftInfo) continue;
+    const key = JSON.stringify([Number(line.product_id), Number(line.product_variant_id) || 0]);
+    quantities.set(key, (quantities.get(key) || 0) + Number(line.num || 0));
+  }
+  return JSON.stringify([...quantities].sort(([left], [right]) => left.localeCompare(right)));
+}
+function ownerKey(action, product) {
+  return JSON.stringify([action.strategyId, action.ruleId, product.product_id, product.product_variant_id ?? 0]);
+}
+function ownedLines(lines, key) {
+  return lines.filter(line => line.metadata?.[ownershipField] === key);
+}
+
+/** Executes item rules at the sales boundary, independent of the calling template. */
+class FulfillmentItemRulesController {
+  sequence = 0;
+  pending = Promise.resolve();
+  evaluator = new _itemRule.ItemRuleEvaluator();
+  constructor(host) {
+    this.host = host;
+  }
+  invalidate() {
+    this.sequence += 1;
+  }
+  apply(serviceType) {
+    const sequence = ++this.sequence;
+    // Even an unsupported mode supersedes any pending takeaway operation.
+    if (serviceType !== 'takeaway' && serviceType !== 'dine_in') return Promise.resolve();
+    const order = this.host.getOrder();
+    const tempOrder = order.getTempOrder?.();
+    const scope = this.host.getScope();
+    const identity = JSON.stringify([tempOrder?.order_id, tempOrder?.external_sale_number, tempOrder?.customer_id]);
+    const initialProducts = tempOrder?.products;
+    const initialFingerprint = cartFingerprint(initialProducts || []);
+    const isCurrent = () => sequence === this.sequence && scope === this.host.getScope() && this.host.getOrder() === order && order.getTempOrder?.() === tempOrder && identity === JSON.stringify([tempOrder?.order_id, tempOrder?.external_sale_number, tempOrder?.customer_id]) && tempOrder?.metadata?.shop_service_data?.service_type === serviceType;
+    const run = async () => {
+      const openData = await this.host.loadOpenData();
+      const ids = positiveIds(openData?.[`fulfillment.${serviceType}_fees_rules`]);
+      if (!ids.length || !isCurrent()) return;
+      if (!tempOrder) return;
+      const assertSnapshot = () => {
+        if (!isCurrent() || tempOrder.products !== initialProducts || cartFingerprint(tempOrder.products) !== initialFingerprint) {
+          throw new Error('The order changed while preparing fulfillment item rules');
+        }
+      };
+      assertSnapshot();
+      const response = await this.host.fetchStrategyModels(ids);
+      assertSnapshot();
+      if (response?.code !== 200 || !Array.isArray(response?.data?.list)) {
+        throw new Error('Unable to load fulfillment item rules');
+      }
+      // Response order need not match the configured order (the latter breaks priority ties).
+      const configs = ids.map(id => {
+        const config = response.data.list.find(item => Number(item?.id) === id)?.metadata;
+        if (config?.metadata?.type !== 'item_rule' || !Array.isArray(config.actions) || !config.conditions) {
+          throw new Error(`Invalid or missing fulfillment item rule ${id}`);
+        }
+        return config;
+      });
+      const runtime = this.host.getOtherParams();
+      const pax = runtime.itemRule?.pax || {};
+      const businessData = {
+        executionScope: 'set_handover',
+        serviceType,
+        channel: String(runtime.channel ?? runtime.platform ?? ''),
+        pax: {
+          total: Number(pax.total) || 0,
+          adult: Number(pax.adult) || 0,
+          child: Number(pax.child) || 0
+        },
+        cartItems: tempOrder.products.map(line => ({
+          product_id: Number(line.product_id),
+          product_variant_id: Number(line.product_variant_id) || 0,
+          quantity: Number(line.num) || 0
+        })),
+        strategyConfigs: configs,
+        custom: runtime.itemRule?.custom
+      };
+      const initialEvaluation = this.evaluator.evaluate(businessData);
+      const requiresMainQuantity = initialEvaluation.rawResults.some(result => result.applicable && result.matchedActions.some(action => action.type === 'PREFILL_CART' && action.target === 'cart' && action.config?.scope === 'set_handover' && action.config.products?.some(product => product.quantityFrom === 'main_product_number')));
+      const actions = requiresMainQuantity ? this.evaluator.evaluate({
+        ...businessData,
+        mainProductNumber: await this.getMainProductNumber(tempOrder.products, configs)
+      }).cartActions : initialEvaluation.cartActions;
+      assertSnapshot();
+      // Prepare every addition before changing the cart; missing products must not leave a half-loaded batch.
+      const sources = await this.loadPrefillSources(actions, tempOrder.products);
+      assertSnapshot();
+      const targetIds = new Set(actions.flatMap(action => action.products.map(product => Number(product.product_id))));
+      const originalSelection = selectionFingerprint(tempOrder.products, targetIds);
+      // Promotion may add gifts or split/merge rows. Only a change to the purchased
+      // quantities invalidates this selection, not promotion's own line reshaping.
+      const targetIsCurrent = () => isCurrent() && selectionFingerprint(tempOrder.products, targetIds) === originalSelection;
+      for (const action of actions) {
+        if (!targetIsCurrent()) return;
+        if (action.type === 'DELETE_PRODUCT') {
+          const deletedIds = new Set(action.products.map(product => Number(product.product_id)));
+          const lines = tempOrder.products.filter(line => deletedIds.has(Number(line.product_id)));
+          if (lines.length) {
+            await order.removeProductsFromOrder(lines.map(lineIdentity), {
+              isCurrentOrder: targetIsCurrent
+            });
+          }
+          continue;
+        }
+        for (const product of action.products) {
+          if (!targetIsCurrent()) return;
+          const key = ownerKey(action, product);
+          const existing = ownedLines(tempOrder.products, key);
+          const quantity = Math.max(0, Math.floor(Number(product.quantity) || 0));
+          if (product.repeat_skip && existing.length) {
+            if (quantity === 0) {
+              await order.removeProductsFromOrder(existing.map(lineIdentity), {
+                isCurrentOrder: targetIsCurrent
+              });
+              continue;
+            }
+            // Keep one owned row and its pricing; never absorb independently added products.
+            if (existing.length > 1) {
+              await order.removeProductsFromOrder(existing.slice(1).map(lineIdentity), {
+                isCurrentOrder: targetIsCurrent
+              });
+            }
+            if (!targetIsCurrent()) return;
+            if (Number(existing[0].num) !== quantity) {
+              await order.updateOrderProductQuantity({
+                ...lineIdentity(existing[0]),
+                num: quantity
+              }, {
+                isCurrentOrder: targetIsCurrent
+              });
+            }
+            continue;
+          }
+          if (quantity === 0) continue;
+          const source = sources.get(Number(product.product_id));
+          const line = (0, _transformBaseProductToOrderProduct.transformBaseProductToOrderProduct)({
+            sourceProduct: source,
+            payload: {
+              product_id: product.product_id,
+              product_variant_id: product.product_variant_id ?? 0,
+              quantity
+            }
+          });
+          if (!line) throw new Error(`Unable to prepare fulfillment product ${product.product_id}`);
+          line.metadata = {
+            ...line.metadata,
+            [ownershipField]: key
+          };
+          const beforeProducts = tempOrder.products;
+          const beforeFingerprint = cartFingerprint(beforeProducts);
+          await order.addProductToOrder(line, undefined, {
+            insertAtStart: true,
+            disableMerge: true,
+            availabilityCommitGuard: () => {
+              if (!targetIsCurrent() || tempOrder.products !== beforeProducts || cartFingerprint(tempOrder.products) !== beforeFingerprint) {
+                throw new Error('The order changed while adding a fulfillment product');
+              }
+            },
+            availabilityCommitTargetGuard: () => targetIsCurrent() && ownedLines(tempOrder.products, key).length > 0
+          });
+        }
+      }
+    };
+    // Serialize writes; a newer choice invalidates the old request before its next mutation.
+    const task = this.pending.then(run).catch(error => {
+      if (sequence === this.sequence) this.host.reportError(error);
+      // Fees are best effort by product decision: Next must remain usable on failure.
+    });
+    this.pending = task;
+    return task;
+  }
+  async loadProducts(ids) {
+    if (!ids.length) return [];
+    const products = this.host.getProducts();
+    if (!products) throw new Error('products module is unavailable for fulfillment item rules');
+    const runtime = this.host.getOtherParams();
+    const now = (0, _dayjs.default)();
+    return products.loadProducts({
+      product_ids: ids,
+      cacheId: runtime.cacheId,
+      customer_id: this.host.getOrder().getTempOrder()?.customer_id ?? undefined,
+      schedule_date: now.format('YYYY-MM-DD'),
+      schedule_datetime: now.format('YYYY-MM-DD HH:mm:ss')
+    });
+  }
+  async getMainProductNumber(lines, configs) {
+    const feeIds = new Set(configs.flatMap(config => config.actions.flatMap(action => action.config?.scope === 'set_handover' && ['PREFILL_CART', 'DELETE_PRODUCT'].includes(action.type) ? (action.config.products || []).map(product => Number(product.product_id)) : [])));
+    const candidates = lines.filter(line => !line.metadata?.[ownershipField] && !feeIds.has(Number(line.product_id)));
+    if (!candidates.length) return 0;
+    const ids = positiveIds(candidates.map(line => line.product_id));
+    const cached = (await this.host.getProducts()?.queryProducts({
+      includeIds: ids
+    })) || [];
+    const sources = new Map();
+    for (const line of candidates) {
+      const cachedSource = cached.find(product => Number(product.id) === Number(line.product_id));
+      const source = Array.isArray(cachedSource?.data_variants) ? cachedSource : line._origin;
+      if (Array.isArray(source?.data_variants)) sources.set(Number(line.product_id), source);
+    }
+    const missing = ids.filter(id => !sources.has(id));
+    for (const source of await this.loadProducts(missing)) sources.set(Number(source.id ?? source.product_id), source);
+    if (ids.some(id => !sources.has(id))) throw new Error('Unable to identify fulfillment main products');
+    return candidates.reduce((sum, line) => {
+      const source = sources.get(Number(line.product_id));
+      const isMain = source?.data_variants?.some(variant => variant?.data?.client_meta?.is_main_product === 1);
+      return sum + (isMain ? Math.max(0, Math.floor(Number(line.num) || 0)) : 0);
+    }, 0);
+  }
+  async loadPrefillSources(actions, lines) {
+    const ids = positiveIds(actions.flatMap(action => action.type === 'PREFILL_CART' ? action.products.filter(product => product.quantity > 0).map(product => product.product_id) : []));
+    const cached = ids.length ? (await this.host.getProducts()?.queryProducts({
+      includeIds: ids
+    })) || [] : [];
+    const sources = new Map(cached.map(product => [Number(product.id), product]));
+    // Existing owned rows can supply their original product if the catalog no longer contains it.
+    for (const line of lines) {
+      if (line.metadata?.[ownershipField] && line._origin && !sources.has(Number(line.product_id))) {
+        sources.set(Number(line.product_id), line._origin);
+      }
+    }
+    for (const source of await this.loadProducts(ids.filter(id => !sources.has(id)))) {
+      sources.set(Number(source.id ?? source.product_id), source);
+    }
+    if (ids.some(id => !sources.has(id))) throw new Error('Unable to load fulfillment fee products');
+    return sources;
+  }
+}
+exports.FulfillmentItemRulesController = FulfillmentItemRulesController;

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

@@ -1,7 +1,10 @@
 import { Module, ModuleOptions, PisellCore } from '../../types';
 import { BaseModule } from '../../modules/BaseModule';
-import { BaseSalesOrderProduct, BaseSalesOrderProductIdentity, BaseSalesPaymentStatus, BaseSalesUpdateOrderProductQuantityParams, BaseSalesCalculateProductBookingPriceParams, BaseSalesPriceRecalculationContextChange, BaseSalesProductBookingPriceResult, BaseSalesQuotationCustomerScopeInfo, BaseSalesScanCodeResult, BaseSalesCashPaymentOptions, BaseSalesCashPaymentConfig, BaseSalesPayCashParams, BaseSalesPayCashResult, BaseSalesCommitPaymentMethodParams, BaseSalesCommitPaymentMethodResult, BaseSalesConfirmWalletPaymentResult } from './types';
+import { type LocalEftposFinalization } from '../../modules/Order/localEftposState';
+import { BaseSalesOrderProduct, BaseSalesOrderProductIdentity, BaseSalesPaymentStatus, BaseSalesSubmitSalesOrderParams, BaseSalesUpdateOrderProductQuantityParams, BaseSalesCalculateProductBookingPriceParams, BaseSalesPriceRecalculationContextChange, BaseSalesProductBookingPriceResult, BaseSalesQuotationCustomerScopeInfo, BaseSalesScanCodeResult, BaseSalesCashPaymentOptions, BaseSalesCashPaymentConfig, BaseSalesPayCashParams, BaseSalesPayCashResult, BaseSalesCommitPaymentMethodParams, BaseSalesCommitPaymentMethodResult, BaseSalesConfirmWalletPaymentResult } from './types';
 import { OrderModule } from '../../modules/Order';
+import { type PickupTimingBookingInput } from '../../modules/Order/pickupTiming';
+import type { PickupTimingAvailability, PickupTimingSelection, PickupTimingValidationResult } from '../../modules/FulfillmentTiming';
 import type { AddProductBookingInput, AddProductToOrderOptions, LoadSalesDetailParams, OrderPaymentData, OrderPaymentUpdateOptions, OrderPaymentUpdateResult, OrderPaymentSource, SendCustomerPayLinkParams, SyncPaymentsToOrderParams, SyncPaymentsToOrderResult, UpdateTempOrderCustomerInput, UpdateOrderBookingParams, UpdateOrderProductParams, OrderTempOrder, OrderSummary, OrderPromotionEvaluator, OrderGiftSelectResolver, OrderUnfulfilledPromotion, OrderLastGiftActions, RemoveProductsFromOrderOptions, ReplaceTempOrderOptions, SalesNote, SalesNotesMutationSnapshot, SetSalesNoteInput, PickupReferenceMode, ShopServiceData, ShopServiceType } from '../../modules/Order/types';
 import type { SubmitPayloadEnhancer } from '../../modules/Order/utils';
 import type { Discount, VirtualCurrencyAsset } from '../../modules/Discount/types';
@@ -16,6 +19,7 @@ import { QuotationModule } from '../../modules/Quotation';
 import type { ISalesDetail, ISalesDetailHeader, ISalesBooking, ISalesPayment, ISalesSurcharge } from './utils/parseSalesResponse';
 import { AppPlugin } from '../../plugins/app';
 import { type TransformBaseProductToOrderProductParams } from './utils/transformBaseProductToOrderProduct';
+import type { OpenDataConfig } from '../../modules/OpenData/types';
 export interface BaseSalesState {
     order?: OrderModule;
     products?: ProductList;
@@ -76,6 +80,9 @@ export declare class BaseSalesImpl extends BaseModule implements Module {
     private serverOrderChangeHydrateInFlight;
     private queuedServerOrderChanges;
     private serverOrderChangeSyncEnabled;
+    protected pickupTimingEnabled: boolean;
+    private pickupTimingController?;
+    private fulfillmentItemRulesController?;
     constructor(name?: string, version?: string);
     /**
      * 子类可覆盖此方法以追加/收敛要注册的子模块。
@@ -99,6 +106,7 @@ export declare class BaseSalesImpl extends BaseModule implements Module {
     private isCurrentSalesOrderRecord;
     setServerOrderChangeSyncEnabled(enabled: boolean): void;
     private queueLatestServerOrderChange;
+    private shouldSyncServerOrderChanges;
     private drainQueuedServerOrderChanges;
     private syncCurrentSalesDetailFromServerOrderChange;
     private registerServerOrderChangeSync;
@@ -153,6 +161,25 @@ export declare class BaseSalesImpl extends BaseModule implements Module {
     private getAuthoritativeBundleUnitPrice;
     private mergeProductForPriceQuery;
     protected getSubmitOrderSalesChannel(): string | undefined;
+    /** Only solutions opting into Pickup Timing supply effective OpenData. */
+    protected loadPickupTimingOpenData(_force: boolean): Promise<Record<string, unknown>>;
+    protected loadFulfillmentItemRuleOpenData(): Promise<OpenDataConfig | null>;
+    private getFulfillmentItemRulesController;
+    protected isPickupTimingEnabled(): boolean;
+    protected getPickupTimingContextData(key: string): unknown;
+    protected getPickupTimingScope(): string;
+    protected resetPickupTimingCache(): void;
+    private getPickupTimingController;
+    getPickupTimingAvailability(params?: {
+        date?: string;
+        force?: boolean;
+    }): Promise<PickupTimingAvailability>;
+    getPickupTimingSelection(): PickupTimingSelection;
+    setPickupTimingSelection(selection: PickupTimingSelection): Promise<PickupTimingSelection>;
+    validatePickupTimingSelection(selection: PickupTimingSelection): Promise<PickupTimingValidationResult>;
+    preparePickupTimingForCheckout(options?: {
+        freeze?: boolean;
+    }): Promise<PickupTimingSelection>;
     /** Subclasses with target-scoped OpenData override this guard before reusing the cache. */
     protected isInvoiceOpenDataCacheCurrent(): boolean;
     private getFulfillmentRefModeConfigs;
@@ -249,7 +276,10 @@ export declare class BaseSalesImpl extends BaseModule implements Module {
     updateTempOrderShopDiscount(amount: string | number): string;
     updateTempOrderDepositAmount(amount: string | number): OrderSummary;
     setPickupReferenceMode(mode: PickupReferenceMode): ShopServiceData;
-    setServiceType(serviceType: ShopServiceType): ShopServiceData;
+    setServiceType(serviceType: ShopServiceType): Promise<ShopServiceData>;
+    getPickupTimingBooking(): import("../../modules/Order").PickupTimingBooking | null;
+    setPickupTimingBooking(input: PickupTimingBookingInput): import("../../modules/Order").PickupTimingBooking;
+    clearPickupTimingBooking(): void;
     updateTempOrderContactsInfo(contactsInfo: Record<string, any> | null): Record<string, any> | null;
     /** @deprecated OrderModule 不再负责 tempOrder localStorage 持久化。 */
     setEnableTempOrderPersist(enabled: boolean): void;
@@ -315,13 +345,8 @@ export declare class BaseSalesImpl extends BaseModule implements Module {
         productList?: Record<string, any>[];
         discountList?: Discount[];
     }): Promise<void>;
-    submitScanOrder<T = any>(params?: {
-        payments?: OrderPaymentSource[];
-        paymentStatus?: BaseSalesPaymentStatus;
-        smallTicketDataFlag?: number;
-        confirmPendingVoucherPayments?: boolean;
-        enhancePayload?: SubmitPayloadEnhancer;
-    }): Promise<T>;
+    submitScanOrder<T = any>(params?: BaseSalesSubmitSalesOrderParams): Promise<T>;
+    private buildVirtualSettlementOrderData;
     private buildVirtualSettlementSubmitData;
     /**
      * 提交当前 Sales 订单。
@@ -329,13 +354,11 @@ export declare class BaseSalesImpl extends BaseModule implements Module {
      * PaymentModal 场景通过 smallTicketDataFlag=1 请求 B 端小票数据；
      * payments 会交给 OrderModule 统一映射为 Sales 协议支付项。
      */
-    submitSalesOrder<T = any>(params?: {
-        payments?: OrderPaymentSource[];
-        paymentStatus?: BaseSalesPaymentStatus;
-        smallTicketDataFlag?: number;
-        confirmPendingVoucherPayments?: boolean;
-        enhancePayload?: SubmitPayloadEnhancer;
-    }): Promise<T>;
+    submitSalesOrder<T = any>(params?: BaseSalesSubmitSalesOrderParams): Promise<T>;
+    private pendingLocalEftposFinalizations;
+    finalizeLocalEftposPayment(params: LocalEftposFinalization): Promise<any>;
+    /** Entry gate also reads SQLite state, so stale sessions/restarts cannot bypass it. */
+    ensureSalesOrderReadyForPayment(): Promise<void>;
     saveSalesOrderDraft<T = any>(params?: {
         platform?: string;
         businessCode?: string;