@pisell/pisellos 2.2.291 → 2.2.293

package/lib/modules/Order/salesNotes.js

@@ -0,0 +1,382 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.buildSalesNoteText = buildSalesNoteText;
+exports.decodeSalesNotes = decodeSalesNotes;
+exports.decodeSalesNotesSnapshot = decodeSalesNotesSnapshot;
+exports.encodeSalesNotes = encodeSalesNotes;
+exports.finalizeSalesNotesForCheckout = finalizeSalesNotesForCheckout;
+exports.getSalesNotePolicy = getSalesNotePolicy;
+const MAX_UUID_LENGTH = 255;
+const LOCALIZED_NOTE_LOCALES = ['en', 'zh-CN', 'zh-HK', 'ja', 'pt'];
+const UUID_V4_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+/**
+ * 备注业务规则统一注册在 OS；调用方只传 note_type、目标行和原始文本。
+ * 后续新增备注类型时在这里增加 policy，不把 importance / Relation 规则下放给 UI。
+ */
+const SALES_NOTE_POLICIES = {
+  allergy: {
+    note_type: 'allergy',
+    importance: 'high',
+    uniquePerPrimaryTarget: true,
+    primary_relation_type: 'about',
+    secondary_order_relation_type: 'related_to'
+  }
+};
+function getSalesNotePolicy(note_type) {
+  return SALES_NOTE_POLICIES[note_type] || null;
+}
+function normalizeUuid(value, field, options) {
+  const uuid = String(value ?? '').trim();
+  if (!uuid && !options?.allowEmpty) {
+    throw new Error(`[Order Notes] ${field} 不能为空`);
+  }
+  if (uuid.length > MAX_UUID_LENGTH) {
+    throw new Error(`[Order Notes] ${field} 不能超过 ${MAX_UUID_LENGTH} 个字符`);
+  }
+  return uuid;
+}
+function normalizeEntityUuid(value, field) {
+  const uuid = normalizeUuid(value, field);
+  if (!UUID_V4_PATTERN.test(uuid)) {
+    throw new Error(`[Order Notes] ${field} 必须为 UUID v4`);
+  }
+  return uuid;
+}
+function normalizeTextRecord(value) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return {};
+  return Object.entries(value).reduce((result, [locale, text]) => {
+    if (typeof text === 'string') result[locale] = text;
+    return result;
+  }, {});
+}
+function normalizeLocalizedLabel(label) {
+  if (typeof label === 'string') {
+    const text = label.trim();
+    return text ? {
+      default: text
+    } : {};
+  }
+  return Object.entries(label || {}).reduce((result, [locale, value]) => {
+    const text = String(value ?? '').trim();
+    if (text) result[locale] = text;
+    return result;
+  }, {});
+}
+function getLocaleCandidates(locale) {
+  const raw = String(locale || '').trim();
+  const normalized = raw.replace(/_/g, '-');
+  const base = normalized.split('-')[0];
+  return Array.from(new Set([raw, normalized, base].filter(Boolean)));
+}
+function normalizeLocaleLookupKey(locale) {
+  return String(locale || '').trim().replace(/_/g, '-').toLowerCase();
+}
+function resolveLocalizedLabel(label, locale) {
+  if (typeof label === 'string') return label.trim();
+  const normalized = normalizeLocalizedLabel(label);
+  const entries = Object.entries(normalized);
+  const lowerCaseLookup = new Map(entries.map(([key, value]) => [normalizeLocaleLookupKey(key), value]));
+  for (const candidate of getLocaleCandidates(locale)) {
+    const matched = lowerCaseLookup.get(normalizeLocaleLookupKey(candidate));
+    if (matched) return matched;
+  }
+  const localeBase = normalizeLocaleLookupKey(locale).split('-')[0];
+  const sameLanguage = entries.find(([key]) => normalizeLocaleLookupKey(key).split('-')[0] === localeBase)?.[1];
+  return sameLanguage || lowerCaseLookup.get('en') || lowerCaseLookup.get('zh-cn') || lowerCaseLookup.get('default') || entries[0]?.[1] || '';
+}
+function joinNoteParts(parts) {
+  return parts.map(part => String(part ?? '')).filter(part => part.trim().length > 0).join(',');
+}
+function buildSalesNoteText(input) {
+  if (input.kind === 'plain') {
+    const text = String(input.input ?? '');
+    if (!text.trim()) throw new Error('[Order Notes] 备注输入不能为空');
+    return {
+      'zh-CN': '',
+      original: text
+    };
+  }
+  if (input.kind === 'resolved') {
+    const text = normalizeTextRecord(input.text);
+    if (!Object.values(text).some(value => value.trim())) {
+      throw new Error('[Order Notes] 备注文本不能为空');
+    }
+    return text;
+  }
+  const inputText = String(input.input ?? '');
+  const seenIds = new Set();
+  const selections = (input.selections || []).filter(selection => {
+    const id = String(selection?.id ?? '').trim();
+    if (!id || seenIds.has(id)) return false;
+    seenIds.add(id);
+    return true;
+  });
+  if (!selections.length && !inputText.trim()) {
+    throw new Error('[Order Notes] 过敏选项和补充说明不能同时为空');
+  }
+  const result = {};
+  for (const locale of LOCALIZED_NOTE_LOCALES) {
+    result[locale] = joinNoteParts([...selections.map(selection => resolveLocalizedLabel(selection.label, locale)), inputText]);
+  }
+  result.original = joinNoteParts([...selections.map(selection => resolveLocalizedLabel(selection.label, input.locale)), inputText]);
+  return result;
+}
+function validateSalesNote(note, options = {}) {
+  normalizeEntityUuid(note.uuid, 'Note uuid');
+  const note_type = String(note.note_type || '').trim();
+  const policy = getSalesNotePolicy(note_type);
+  if (!policy) {
+    throw new Error(`[Order Notes] 当前未注册备注类型: ${note_type || '(empty)'}`);
+  }
+  if (note.importance !== policy.importance) {
+    throw new Error(`[Order Notes] ${note_type} importance 必须为 ${policy.importance}`);
+  }
+  const text = note.content?.text;
+  if (!text || typeof text !== 'object' || Array.isArray(text) || Object.values(text).some(value => typeof value !== 'string') || !Object.values(text).some(value => value.trim())) {
+    throw new Error('[Order Notes] content.text 不能为空');
+  }
+  if (!Array.isArray(note.note_relations) || note.note_relations.length === 0) {
+    throw new Error('[Order Notes] note_relations 不能为空');
+  }
+  const relationUuids = new Set();
+  let primaryCount = 0;
+  let orderRelationCount = 0;
+  for (const relation of note.note_relations) {
+    const relationUuid = normalizeEntityUuid(relation.uuid, 'Relation uuid');
+    if (relationUuids.has(relationUuid)) {
+      throw new Error('[Order Notes] 同一 Note 内 Relation uuid 不能重复');
+    }
+    relationUuids.add(relationUuid);
+    if (relation.is_primary !== 0 && relation.is_primary !== 1) {
+      throw new Error('[Order Notes] is_primary 只允许整数 0 或 1');
+    }
+    if (relation.relation_type !== 'about' && relation.relation_type !== 'related_to') {
+      throw new Error('[Order Notes] relation_type 不合法');
+    }
+    if (relation.target_type !== 'order' && relation.target_type !== 'order_detail') {
+      throw new Error('[Order Notes] target_type 不合法');
+    }
+    if (relation.is_primary === 1) {
+      primaryCount += 1;
+      if (relation.relation_type !== policy.primary_relation_type || relation.target_type !== 'order_detail') {
+        throw new Error('[Order Notes] 主关系必须使用 about + order_detail');
+      }
+      const targetUuid = normalizeUuid(relation.target_uuid, 'Relation target_uuid');
+      if (options.productTargetUuids && !options.productTargetUuids.has(targetUuid)) {
+        throw new Error('[Order Notes] 商品 Relation target_uuid 不属于当前订单');
+      }
+      continue;
+    }
+    if (relation.target_type === 'order' && relation.relation_type === policy.secondary_order_relation_type) {
+      orderRelationCount += 1;
+      const targetUuid = normalizeUuid(relation.target_uuid, 'Relation target_uuid', {
+        allowEmpty: options.allowUnresolvedOrderTarget === true
+      });
+      if (options.expectedOrderTargetUuid !== undefined && targetUuid !== options.expectedOrderTargetUuid) {
+        throw new Error('[Order Notes] 订单 Relation target_uuid 与 shop_order_number 不一致');
+      }
+      continue;
+    }
+    throw new Error('[Order Notes] 非主体关系必须使用 related_to + order');
+  }
+  if (primaryCount !== 1) {
+    throw new Error('[Order Notes] 每条 Note 必须且只能有一个主关系');
+  }
+  if (orderRelationCount !== 1) {
+    throw new Error('[Order Notes] 每条商品 Note 必须且只能有一个订单冗余关系');
+  }
+}
+function encodeSalesNotes(notes, options = {}) {
+  const entityUuids = new Set();
+  const uniquePolicyTargets = new Set();
+  return (notes || []).map(note => {
+    validateSalesNote(note, options);
+    const noteUuid = normalizeEntityUuid(note.uuid, 'Note uuid');
+    if (entityUuids.has(noteUuid)) {
+      throw new Error('[Order Notes] Note/Relation uuid 不能重复');
+    }
+    entityUuids.add(noteUuid);
+    const note_type = String(note.note_type).trim();
+    const noteRelations = note.note_relations.map(relation => {
+      const relationUuid = normalizeEntityUuid(relation.uuid, 'Relation uuid');
+      if (entityUuids.has(relationUuid)) {
+        throw new Error('[Order Notes] Note/Relation uuid 不能重复');
+      }
+      entityUuids.add(relationUuid);
+      const allowEmptyTarget = options.allowUnresolvedOrderTarget === true && relation.is_primary === 0 && relation.relation_type === 'related_to' && relation.target_type === 'order';
+      return {
+        uuid: relationUuid,
+        relation_type: relation.relation_type,
+        target_type: relation.target_type,
+        target_uuid: normalizeUuid(relation.target_uuid, 'Relation target_uuid', {
+          allowEmpty: allowEmptyTarget
+        }),
+        is_primary: relation.is_primary
+      };
+    });
+    const primaryRelation = noteRelations.find(relation => relation.is_primary === 1);
+    const policy = getSalesNotePolicy(note_type);
+    if (policy.uniquePerPrimaryTarget) {
+      const policyTargetKey = [note_type, primaryRelation.target_type, primaryRelation.target_uuid].join(':');
+      if (uniquePolicyTargets.has(policyTargetKey)) {
+        throw new Error('[Order Notes] 同一商品行不能重复提交同类型 Note');
+      }
+      uniquePolicyTargets.add(policyTargetKey);
+    }
+    return {
+      uuid: noteUuid,
+      note_type,
+      content: {
+        text: {
+          ...(note.content?.text || {})
+        }
+      },
+      importance: note.importance,
+      note_relations: noteRelations
+    };
+  });
+}
+function decodeRelation(value) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return null;
+  const raw = value;
+  const uuid = String(raw.uuid ?? '').trim();
+  const target_uuid = String(raw.target_uuid ?? '').trim();
+  const relation_type = raw.relation_type;
+  const target_type = raw.target_type;
+  const is_primary = raw.is_primary;
+  if (!uuid || relation_type !== 'about' && relation_type !== 'related_to' || target_type !== 'order' && target_type !== 'order_detail' || is_primary !== 0 && is_primary !== 1) {
+    return null;
+  }
+  return {
+    uuid,
+    relation_type,
+    target_type,
+    target_uuid,
+    is_primary
+  };
+}
+function decodeSalesNotesSnapshot(value, options = {}) {
+  if (!Array.isArray(value)) return {
+    notes: [],
+    complete: false
+  };
+  const notes = [];
+  const entityUuids = new Set();
+  const uniquePolicyTargets = new Set();
+  let complete = true;
+  for (const item of value) {
+    if (!item || typeof item !== 'object' || Array.isArray(item)) {
+      complete = false;
+      continue;
+    }
+    const raw = item;
+    const uuid = String(raw.uuid ?? '').trim();
+    const note_type = String(raw.note_type ?? '').trim();
+    const importance = String(raw.importance ?? '').trim();
+    const rawText = raw.content?.text;
+    const text = normalizeTextRecord(rawText);
+    if (!rawText || typeof rawText !== 'object' || Array.isArray(rawText) || Object.keys(text).length !== Object.keys(rawText).length) {
+      complete = false;
+      continue;
+    }
+    const rawNoteRelations = Array.isArray(raw.note_relations) ? raw.note_relations : null;
+    const noteRelations = rawNoteRelations ? rawNoteRelations.map(relation => decodeRelation(relation)).filter(relation => relation !== null) : [];
+    if (!rawNoteRelations || noteRelations.length !== rawNoteRelations.length) {
+      complete = false;
+      continue;
+    }
+    const note = {
+      uuid,
+      note_type,
+      content: {
+        text
+      },
+      importance,
+      note_relations: noteRelations
+    };
+    try {
+      validateSalesNote(note, {
+        allowUnresolvedOrderTarget: options.allowUnresolvedOrderTarget
+      });
+      if (entityUuids.has(note.uuid)) {
+        complete = false;
+        continue;
+      }
+      entityUuids.add(note.uuid);
+      let hasDuplicateRelationUuid = false;
+      for (const relation of note.note_relations) {
+        if (entityUuids.has(relation.uuid)) {
+          hasDuplicateRelationUuid = true;
+          break;
+        }
+      }
+      if (hasDuplicateRelationUuid) {
+        complete = false;
+        continue;
+      }
+      note.note_relations.forEach(relation => entityUuids.add(relation.uuid));
+      const policy = getSalesNotePolicy(note.note_type);
+      const primaryRelation = note.note_relations.find(relation => relation.is_primary === 1);
+      if (policy?.uniquePerPrimaryTarget && primaryRelation) {
+        const policyTargetKey = [note.note_type, primaryRelation.target_type, primaryRelation.target_uuid].join(':');
+        if (uniquePolicyTargets.has(policyTargetKey)) {
+          complete = false;
+          continue;
+        }
+        uniquePolicyTargets.add(policyTargetKey);
+      }
+      notes.push(note);
+    } catch {
+      complete = false;
+    }
+  }
+  return {
+    notes,
+    complete
+  };
+}
+function decodeSalesNotes(value, options = {}) {
+  return decodeSalesNotesSnapshot(value, options).notes;
+}
+function finalizeSalesNotesForCheckout(params) {
+  if (!Array.isArray(params.notes)) {
+    throw new Error('[Order Notes] checkout notes 必须为数组');
+  }
+  if (params.notes.length === 0) return [];
+  const shopOrderNumber = normalizeUuid(params.shopOrderNumber, 'shop_order_number');
+  const productTargetUuids = new Set();
+  for (const rawTargetUuid of params.productTargetUuids || []) {
+    const targetUuid = normalizeUuid(rawTargetUuid, '商品 target_uuid');
+    if (productTargetUuids.has(targetUuid)) {
+      throw new Error('[Order Notes] 商品行业务标识不能重复');
+    }
+    productTargetUuids.add(targetUuid);
+  }
+  const decoded = decodeSalesNotesSnapshot(params.notes, {
+    allowUnresolvedOrderTarget: true
+  });
+  if (!decoded.complete || decoded.notes.length !== params.notes.length) {
+    throw new Error('[Order Notes] checkout Notes 快照不完整');
+  }
+  const finalizedNotes = decoded.notes.map(note => ({
+    ...note,
+    content: {
+      text: {
+        ...note.content.text
+      }
+    },
+    note_relations: note.note_relations.map(relation => ({
+      ...relation,
+      ...(relation.is_primary === 0 && relation.relation_type === 'related_to' && relation.target_type === 'order' ? {
+        target_uuid: shopOrderNumber
+      } : {})
+    }))
+  }));
+  return encodeSalesNotes(finalizedNotes, {
+    expectedOrderTargetUuid: shopOrderNumber,
+    productTargetUuids
+  });
+}

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

@@ -8,6 +8,13 @@ import type { PaymentItem } from '../Payment/types';
 import type { ICustomer } from '../AccountList/types';
 import type { OrderProductDiscountItem } from '../../server/modules/order/types';
 export type { OrderProductDiscountItem } from '../../server/modules/order/types';
+export type PickupReferenceMode = 'counter_pickup' | 'table_service';
+export type ShopServiceType = 'dine_in' | 'takeaway';
+export interface ShopServiceData {
+    pickup_reference_mode?: PickupReferenceMode;
+    service_type?: ShopServiceType | '';
+    [key: string]: any;
+}
 export declare enum OrderHooks {
     OnOrderCreate = "order:onOrderCreate",
     OnOrderUpdate = "order:onOrderUpdate",
@@ -191,6 +198,8 @@ export interface OrderLocalizedText {
 export interface OrderProduct extends OrderProductIdentity {
     order_detail_id: number | null;
     num: number;
+    /** Product 或当前 Variant 的生产编码 */
+    production_code?: string;
     bundle_edit?: number;
     product_sku: OrderProductSku;
     gift_card?: number;
@@ -236,6 +245,72 @@ export interface OrderSummary {
     tax_title?: string;
     tax_rate?: number;
 }
+export type SalesNoteRelationType = 'about' | 'related_to';
+export type SalesNoteTargetType = 'order' | 'order_detail';
+export type SalesNoteLocalizedText = string | Record<string, string>;
+export interface SalesNoteLocalizedSelection {
+    id: string;
+    label: SalesNoteLocalizedText;
+}
+export type SalesNoteTextInput = {
+    kind: 'localizedSelections';
+    selections: SalesNoteLocalizedSelection[];
+    locale: string;
+    input?: string;
+} | {
+    kind: 'plain';
+    input: string;
+} | {
+    kind: 'resolved';
+    text: Record<string, string>;
+};
+export interface SalesNoteRelation {
+    uuid: string;
+    relation_type: SalesNoteRelationType;
+    target_type: SalesNoteTargetType;
+    target_uuid: string;
+    is_primary: 0 | 1;
+}
+export interface SalesNote {
+    uuid: string;
+    note_type: string;
+    content: {
+        text: Record<string, string>;
+    };
+    importance: string;
+    note_relations: SalesNoteRelation[];
+}
+export interface SalesNoteTarget {
+    target_type: 'order_detail';
+    target_uuid: string;
+}
+export interface SetSalesNoteInput {
+    note_type: string;
+    target: SalesNoteTarget;
+    text: SalesNoteTextInput;
+}
+export interface SalesNoteDraftInput {
+    note_type: string;
+    text: SalesNoteTextInput;
+}
+export interface SalesNotesRuntimeState {
+    loaded: boolean;
+    dirty: boolean;
+}
+/**
+ * Sales Notes 乐观写入前的可恢复快照。
+ * 该对象应视为 opaque token，只用于原样传回 restoreSalesNotesMutationSnapshot。
+ */
+export interface SalesNotesMutationSnapshot {
+    orderIdentity: {
+        orderId: number | string | null;
+        externalSaleNumber: string;
+    };
+    notes: SalesNote[];
+    state: SalesNotesRuntimeState;
+}
+export type SalesNoteProtocolRelation = SalesNoteRelation;
+export type SalesNoteProtocol = SalesNote;
 export interface OrderTempOrder {
     order_id: number | null;
     external_sale_number: string;
@@ -275,6 +350,7 @@ export interface OrderTempOrder {
     created_at: string | undefined;
     request_unique_idempotency_token?: string;
     products: OrderProduct[];
+    notes: SalesNote[];
     bookings: any[];
     payments: any[];
     surcharges: any[];
@@ -287,6 +363,7 @@ export interface OrderTempOrder {
     summary?: OrderSummary;
     _extend?: {
         productsByUid?: Record<string, Record<string, any>>;
+        salesNotesState?: SalesNotesRuntimeState;
         [key: string]: any;
     };
 }
@@ -295,7 +372,7 @@ export interface OrderSubmitProduct extends Omit<OrderProduct, 'unique_identific
     payment_price: string;
     product_sku: OrderProductSku;
 }
-export interface OrderSubmitPayload extends Omit<OrderTempOrder, 'platform' | 'products' | '_extend' | 'customer' | 'discount_list' | 'created_at'> {
+export interface OrderSubmitPayload extends Omit<OrderTempOrder, 'platform' | 'products' | 'notes' | '_extend' | 'customer' | 'discount_list' | 'created_at'> {
     platform: string;
     created_at?: string | undefined;
     request_unique_idempotency_token?: string;
@@ -304,6 +381,7 @@ export interface OrderSubmitPayload extends Omit<OrderTempOrder, 'platform' | 'p
         form_record_id: number | string;
     }>;
     products: OrderSubmitProduct[];
+    notes?: SalesNoteProtocol[];
     summary?: OrderSummary;
     small_ticket_data_flag?: number;
 }
@@ -332,6 +410,8 @@ export interface AddProductToOrderOptions {
     insertAfterProductUid?: string;
     /** 跳过同商品/规格匹配，始终新增购物车行。 */
     disableMerge?: boolean;
+    /** 商品行 UID 落定后，由 OrderModule 原子绑定到该行的 Sales Notes 草稿。 */
+    salesNotes?: SalesNoteDraftInput[];
 }
 /**
  * 删除商品后的可选位置保持策略。
@@ -747,9 +827,17 @@ export interface OrderModuleAPI {
     updateTempOrderShopDiscount: (amount: string | number) => string;
     updateTempOrderDepositAmount: (amount: string | number) => OrderSummary;
     updateTempOrderCustomer: (customer: UpdateTempOrderCustomerInput) => OrderSnapshot['customer'];
+    updateTempOrderPickupReferenceMode: (mode: PickupReferenceMode) => ShopServiceData;
+    updateTempOrderServiceType: (serviceType: ShopServiceType) => ShopServiceData;
     updateTempOrderBuzzer: (buzzer: string) => string;
     updateTempOrderContactsInfo: (contactsInfo: Record<string, any> | null) => Record<string, any> | null;
     addProductToOrder: (product: Partial<OrderProduct> & OrderProductIdentity, booking?: AddProductBookingInput, options?: AddProductToOrderOptions) => Promise<OrderProduct[]>;
+    getSalesNotes: () => SalesNote[];
+    createSalesNotesMutationSnapshot: () => SalesNotesMutationSnapshot;
+    restoreSalesNotesMutationSnapshot: (snapshot: SalesNotesMutationSnapshot) => void;
+    setSalesNote: (input: SetSalesNoteInput) => Promise<SalesNote>;
+    removeSalesNote: (uuid: string) => Promise<void>;
+    clearSalesNotes: () => Promise<void>;
     updateOrderProduct: (params: UpdateOrderProductParams) => Promise<OrderProduct[]>;
     /** 批量更新购物车行，末尾仅触发一次促销重算与 summary 刷新 */
     updateOrderProducts: (paramsList: UpdateOrderProductParams[]) => Promise<OrderProduct[]>;
@@ -897,10 +985,10 @@ export interface OrderModuleAPI {
     /** 读取上次 applyPromotion 产出的赠品操作 diff（toAdd / toReduce / toRemove） */
     getLastGiftActions: () => OrderLastGiftActions | null;
     /**
-   * 取消订单
-   * @param params 取消订单参数
-   * @returns 后端返回结果
-   */
+     * 取消订单
+     * @param params 取消订单参数
+     * @returns 后端返回结果
+     */
     cancelOrder: (params: CancelOrderParams) => Promise<any>;
     /**
      * 变更预约状态

package/lib/modules/Order/types.js

@@ -59,6 +59,10 @@ let OrderHooks = exports.OrderHooks = /*#__PURE__*/function (OrderHooks) {
  * - `source`：缺省表示真实业务变更；`detailHydrate` 仅表示打开详情时快照已就绪
  * 清空时整个 payload 为 null。
  */
+/**
+ * Sales Notes 乐观写入前的可恢复快照。
+ * 该对象应视为 opaque token，只用于原样传回 restoreSalesNotesMutationSnapshot。
+ */
 /**
  * 添加商品行时的顺序控制。
  * 默认追加到 products 尾部；预约数量同步可插入到既有预约组的最新行之后，

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

@@ -210,6 +210,18 @@ export interface SubmitPayloadEnhancerContext {
     now: Date;
 }
 export type SubmitPayloadEnhancer = (payload: OrderSubmitPayload, ctx: SubmitPayloadEnhancerContext) => OrderSubmitPayload;
+/**
+ * 解析 checkout 的订单类型。
+ * dine_in 普通落库单在新增桌台资源后，即使原类型仍是 virtual，也必须按 table-order 提交。
+ */
+export declare function resolveSubmitOrderType(params: {
+    requestedType?: string;
+    tempOrderType?: string;
+    orderId?: unknown;
+    businessCode?: string;
+    tempOrderBusinessCode?: string;
+    bookings?: unknown;
+}): string;
 export declare function buildSubmitPayload(params: {
     tempOrder: OrderTempOrder;
     cacheId?: string;