@pisell/pisellos 0.0.230 → 0.0.232

package/lib/modules/Payment/cashRecommendationAlgorithm.js

@@ -0,0 +1,342 @@
+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/modules/Payment/cashRecommendationAlgorithm.ts
+var cashRecommendationAlgorithm_exports = {};
+__export(cashRecommendationAlgorithm_exports, {
+  CURRENCY_DENOMINATIONS: () => CURRENCY_DENOMINATIONS,
+  recommendOptimalPayments: () => recommendOptimalPayments
+});
+module.exports = __toCommonJS(cashRecommendationAlgorithm_exports);
+var CURRENCY_DENOMINATIONS = {
+  // 美元
+  "USD": [100, 50, 20, 10, 5, 2, 1, 0.5, 0.25, 0.1, 0.05, 0.01],
+  // 人民币
+  "CNY": [100, 50, 20, 10, 5, 1, 0.5, 0.1, 0.05, 0.01],
+  "RMB": [100, 50, 20, 10, 5, 1, 0.5, 0.1, 0.05, 0.01],
+  // 欧元
+  "EUR": [500, 200, 100, 50, 20, 10, 5, 2, 1, 0.5, 0.2, 0.1, 0.05, 0.02, 0.01],
+  // 日元
+  "JPY": [1e4, 5e3, 2e3, 1e3, 500, 100, 50, 10, 5, 1],
+  // 英镑
+  "GBP": [50, 20, 10, 5, 2, 1, 0.5, 0.2, 0.1, 0.05, 0.02, 0.01],
+  // 澳元
+  "AUD": [100, 50, 20, 10, 5, 2, 1, 0.5, 0.2, 0.1],
+  // 加元
+  "CAD": [100, 50, 20, 10, 5, 2, 1, 0.25, 0.1, 0.05],
+  // 港元
+  "HKD": [1e3, 500, 100, 50, 20, 10, 5, 2, 1, 0.5, 0.2, 0.1],
+  // 新台币
+  "TWD": [2e3, 1e3, 500, 200, 100, 50, 10, 5, 1],
+  // 韩元
+  "KRW": [5e4, 1e4, 5e3, 1e3, 500, 100, 50, 10, 5, 1],
+  // 新加坡元
+  "SGD": [1e4, 1e3, 100, 50, 10, 5, 2, 1, 0.5, 0.2, 0.1, 0.05, 0.01],
+  // 瑞士法郎
+  "CHF": [1e3, 200, 100, 50, 20, 10, 5, 2, 1, 0.5, 0.2, 0.1, 0.05],
+  // 默认通用面额（如果币种不在列表中）
+  "DEFAULT": [100, 50, 20, 10, 5, 1, 0.5, 0.25, 0.1, 0.05, 0.01]
+};
+function recommendOptimalPayments(targetAmount, denominations) {
+  if (targetAmount <= 0 || !isFinite(targetAmount) || isNaN(targetAmount)) {
+    return [];
+  }
+  if (!denominations || !Array.isArray(denominations) || denominations.length === 0) {
+    return [Math.ceil(targetAmount)];
+  }
+  const maxReasonableDenom = targetAmount * 5;
+  const validDenoms = denominations.filter((denom) => denom > 0 && isFinite(denom) && !isNaN(denom) && denom <= maxReasonableDenom).slice(0, 8);
+  if (validDenoms.length === 0) {
+    return [Math.ceil(targetAmount)];
+  }
+  try {
+    const precision = 100;
+    const target = Math.round(targetAmount * precision);
+    const denoms = validDenoms.map((d) => Math.round(d * precision)).sort((a, b) => b - a);
+    const paymentOptions = [];
+    const exactCombination = findExactCombination(target, denoms, precision);
+    if (exactCombination) {
+      paymentOptions.push(exactCombination);
+    }
+    for (let i = 0; i < Math.min(denoms.length, 6); i++) {
+      const denom = denoms[i];
+      const count = Math.ceil(target / denom);
+      const sum = count * denom;
+      if (sum >= target && count <= 12) {
+        paymentOptions.push({
+          combination: Array(count).fill(denom / precision),
+          sum: sum / precision,
+          coinCount: count,
+          denomTypes: 1
+        });
+      }
+    }
+    for (let i = 0; i < Math.min(denoms.length - 1, 5); i++) {
+      for (let j = i + 1; j < Math.min(denoms.length, 6); j++) {
+        const denom1 = denoms[i];
+        const denom2 = denoms[j];
+        const maxCount1 = Math.min(Math.ceil(target / denom1) + 1, 8);
+        const maxCount2 = Math.min(Math.ceil(target / denom2) + 1, 10);
+        for (let count1 = 1; count1 <= maxCount1; count1++) {
+          for (let count2 = 1; count2 <= maxCount2; count2++) {
+            const sum = count1 * denom1 + count2 * denom2;
+            if (sum >= target) {
+              const combination = [
+                ...Array(count1).fill(denom1 / precision),
+                ...Array(count2).fill(denom2 / precision)
+              ];
+              paymentOptions.push({
+                combination,
+                sum: sum / precision,
+                coinCount: count1 + count2,
+                denomTypes: 2
+              });
+            }
+          }
+        }
+      }
+    }
+    for (let i = 0; i < Math.min(denoms.length - 2, 3); i++) {
+      for (let j = i + 1; j < Math.min(denoms.length - 1, 4); j++) {
+        for (let k = j + 1; k < Math.min(denoms.length, 5); k++) {
+          const denom1 = denoms[i];
+          const denom2 = denoms[j];
+          const denom3 = denoms[k];
+          const maxCount1 = Math.min(Math.ceil(target / denom1) + 1, 5);
+          const maxCount2 = Math.min(Math.ceil(target / denom2) + 1, 6);
+          const maxCount3 = Math.min(Math.ceil(target / denom3) + 1, 8);
+          for (let count1 = 1; count1 <= maxCount1; count1++) {
+            for (let count2 = 1; count2 <= maxCount2; count2++) {
+              for (let count3 = 1; count3 <= maxCount3; count3++) {
+                const sum = count1 * denom1 + count2 * denom2 + count3 * denom3;
+                if (sum >= target) {
+                  const combination = [
+                    ...Array(count1).fill(denom1 / precision),
+                    ...Array(count2).fill(denom2 / precision),
+                    ...Array(count3).fill(denom3 / precision)
+                  ];
+                  paymentOptions.push({
+                    combination,
+                    sum: sum / precision,
+                    coinCount: count1 + count2 + count3,
+                    denomTypes: 3
+                  });
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+    for (let i = 0; i < Math.min(denoms.length - 3, 2); i++) {
+      for (let j = i + 1; j < Math.min(denoms.length - 2, 3); j++) {
+        for (let k = j + 1; k < Math.min(denoms.length - 1, 4); k++) {
+          for (let l = k + 1; l < Math.min(denoms.length, 5); l++) {
+            const denom1 = denoms[i];
+            const denom2 = denoms[j];
+            const denom3 = denoms[k];
+            const denom4 = denoms[l];
+            const maxCount1 = Math.min(Math.ceil(target / denom1) + 1, 3);
+            const maxCount2 = Math.min(Math.ceil(target / denom2) + 1, 4);
+            const maxCount3 = Math.min(Math.ceil(target / denom3) + 1, 5);
+            const maxCount4 = Math.min(Math.ceil(target / denom4) + 1, 6);
+            for (let count1 = 1; count1 <= maxCount1; count1++) {
+              for (let count2 = 1; count2 <= maxCount2; count2++) {
+                for (let count3 = 1; count3 <= maxCount3; count3++) {
+                  for (let count4 = 1; count4 <= maxCount4; count4++) {
+                    const sum = count1 * denom1 + count2 * denom2 + count3 * denom3 + count4 * denom4;
+                    if (sum >= target) {
+                      const combination = [
+                        ...Array(count1).fill(denom1 / precision),
+                        ...Array(count2).fill(denom2 / precision),
+                        ...Array(count3).fill(denom3 / precision),
+                        ...Array(count4).fill(denom4 / precision)
+                      ];
+                      paymentOptions.push({
+                        combination,
+                        sum: sum / precision,
+                        coinCount: count1 + count2 + count3 + count4,
+                        denomTypes: 4
+                      });
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+    if (paymentOptions.length === 0) {
+      const minValidDenom = validDenoms.find((denom) => denom >= targetAmount);
+      if (minValidDenom) {
+        return [minValidDenom];
+      } else {
+        const maxDenom = Math.max(...validDenoms);
+        const count = Math.ceil(targetAmount / maxDenom);
+        return [count * maxDenom];
+      }
+    }
+    const uniqueCombinations = removeDuplicateAndExtendedCombinations(paymentOptions, targetAmount);
+    uniqueCombinations.sort((a, b) => {
+      if (a.denomTypes !== b.denomTypes) {
+        return a.denomTypes - b.denomTypes;
+      }
+      if (a.coinCount !== b.coinCount) {
+        return a.coinCount - b.coinCount;
+      }
+      return a.sum - b.sum;
+    });
+    const uniqueAmounts = /* @__PURE__ */ new Set();
+    const finalResults = [];
+    for (const item of uniqueCombinations) {
+      const roundedAmount = Math.round(item.sum * 100) / 100;
+      if (!uniqueAmounts.has(roundedAmount) && finalResults.length < 10) {
+        uniqueAmounts.add(roundedAmount);
+        finalResults.push(roundedAmount);
+      }
+    }
+    return finalResults.sort((a, b) => a - b);
+  } catch (error) {
+    console.warn("推荐支付金额计算出错:", error);
+    const safeAmount = Math.ceil(targetAmount);
+    return [targetAmount, safeAmount];
+  }
+}
+function findExactCombination(target, denoms, precision) {
+  function dfs(remaining, denomIndex, currentCombination) {
+    if (remaining === 0) {
+      return currentCombination;
+    }
+    if (remaining < 0 || denomIndex >= denoms.length || currentCombination.length > 10) {
+      return null;
+    }
+    const denom = denoms[denomIndex];
+    const maxCount = Math.min(Math.floor(remaining / denom), 8);
+    for (let count = maxCount; count >= 0; count--) {
+      const newCombination = [...currentCombination, ...Array(count).fill(denom)];
+      const result = dfs(remaining - count * denom, denomIndex + 1, newCombination);
+      if (result) {
+        return result;
+      }
+    }
+    return null;
+  }
+  const exactMatch = dfs(target, 0, []);
+  if (exactMatch && exactMatch.length > 0) {
+    const denomTypes = new Set(exactMatch).size;
+    return {
+      combination: exactMatch.map((d) => d / precision),
+      sum: target / precision,
+      coinCount: exactMatch.length,
+      denomTypes
+    };
+  }
+  return null;
+}
+function removeDuplicateAndExtendedCombinations(combinations, targetAmount) {
+  const result = [];
+  combinations.sort((a, b) => {
+    if (a.denomTypes !== b.denomTypes) {
+      return a.denomTypes - b.denomTypes;
+    }
+    if (a.coinCount !== b.coinCount) {
+      return a.coinCount - b.coinCount;
+    }
+    return a.sum - b.sum;
+  });
+  for (let i = 0; i < combinations.length; i++) {
+    const current = combinations[i];
+    let shouldSkip = false;
+    for (let j = 0; j < result.length; j++) {
+      const existing = result[j];
+      if (isSameCombination(current.combination, existing.combination)) {
+        shouldSkip = true;
+        break;
+      }
+      if (isExtensionOf(current.combination, existing.combination)) {
+        shouldSkip = true;
+        break;
+      }
+    }
+    if (!shouldSkip) {
+      for (let j = result.length - 1; j >= 0; j--) {
+        if (isExtensionOf(result[j].combination, current.combination)) {
+          result.splice(j, 1);
+        }
+      }
+      result.push(current);
+    }
+  }
+  return result;
+}
+function isExtensionOf(combinationA, combinationB) {
+  if (combinationA.length <= combinationB.length) {
+    return false;
+  }
+  const countA = {};
+  const countB = {};
+  combinationA.forEach((coin) => {
+    countA[coin] = (countA[coin] || 0) + 1;
+  });
+  combinationB.forEach((coin) => {
+    countB[coin] = (countB[coin] || 0) + 1;
+  });
+  for (const coin in countB) {
+    if (!countA[coin] || countA[coin] < countB[coin]) {
+      return false;
+    }
+  }
+  let hasExtra = false;
+  for (const coin in countA) {
+    if (countA[coin] > (countB[coin] || 0)) {
+      hasExtra = true;
+      break;
+    }
+  }
+  return hasExtra;
+}
+function isSameCombination(combinationA, combinationB) {
+  if (combinationA.length !== combinationB.length) {
+    return false;
+  }
+  const countA = {};
+  const countB = {};
+  combinationA.forEach((coin) => {
+    countA[coin] = (countA[coin] || 0) + 1;
+  });
+  combinationB.forEach((coin) => {
+    countB[coin] = (countB[coin] || 0) + 1;
+  });
+  for (const coin in countA) {
+    if (countA[coin] !== (countB[coin] || 0)) {
+      return false;
+    }
+  }
+  for (const coin in countB) {
+    if (countB[coin] !== (countA[coin] || 0)) {
+      return false;
+    }
+  }
+  return true;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CURRENCY_DENOMINATIONS,
+  recommendOptimalPayments
+});

package/lib/modules/Payment/eftpos.js

@@ -39,7 +39,7 @@ var EftposPaymentImpl = class {
       type: eftposMethod.type,
       voucher_id: ""
     };
-    await this.paymentModule.pushPaymentAsync(orderUuid, paymentItem);
+    await this.paymentModule.addPaymentItemAsync(orderUuid, paymentItem);
   }
   async checkDeviceStatus() {
     return true;

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

@@ -1,6 +1,7 @@
 import { Module, PisellCore, ModuleOptions } from '../../types';
+import { RequestPlugin } from '../../plugins';
 import { BaseModule } from '../BaseModule';
-import { PaymentModuleAPI, PaymentMethod, PaymentOrder, PaymentItem, PaymentItemInput, PaymentUpdateFields, PushOrderParams, CashPayment, EftposPayment, WalletPayment } from './types';
+import { PaymentModuleAPI, PaymentMethod, PaymentOrder, PaymentItem, PaymentItemInput, PaymentUpdateFields, PushOrderParams, CashPayment, EftposPayment, WalletPassPayment, RoundingRule, RoundingInterval } from './types';
 export * from './types';
 export { generateRequestUniqueId };
 /**
@@ -12,40 +13,19 @@ declare function generateRequestUniqueId(): string;
 /**
  * 支付模块实现
  *
- * 支付流程说明：
- * 1. 用户操作 → 调用支付API (pushPaymentAsync, submitPayAsync等)
- * 2. 数据处理 → 更新本地IndexDB中的订单和支付项数据
- * 3. 立即完成 → 本地订单状态立即更新为PaymentStatus.Finished（isSynced保持false）
- * 4. 后台同步 → 网络请求推送到TasksManager异步同步到服务器
- * 5. 同步成功 → 网络请求成功后，isSynced设为true
- * 6. 自动重试 → TasksManager自动重试失败的网络请求，直到isSynced为true
- *
- * 数据状态说明：
- * - PaymentStatus.Processing: 订单正在进行支付操作
- * - PaymentStatus.PartiallyPaid + isSynced=false: 部分支付完成，等待服务器同步
- * - PaymentStatus.PartiallyPaid + isSynced=true: 部分支付且已同步到服务器
- * - PaymentStatus.Finished + isSynced=false: 本地支付完成，等待服务器同步
- * - PaymentStatus.Finished + isSynced=true: 支付完成且已同步到服务器
- *
- * 这种设计的优势：
- * - 即时反馈：支付操作后立即显示完成状态，用户体验更佳
- * - 离线支持：即使网络断开也能正常操作，数据保存在本地
- * - 同步追踪：通过isSynced清楚知道哪些数据还未同步到服务器
- * - 自动重试：TasksManager会自动重试失败的网络请求
- * - 异步处理：不阻塞用户界面，网络同步在后台进行
- * - 数据一致性：通过事件系统确保数据状态同步
+ * 负责处理支付相关的数据管理和本地存储
  */
 export declare class PaymentModule extends BaseModule implements Module, PaymentModuleAPI {
     protected defaultName: string;
     protected defaultVersion: string;
-    private request;
+    request: RequestPlugin;
     private app;
     private store;
     private dbManager;
     private logger;
     cash: CashPayment;
     eftpos: EftposPayment;
-    wallet: WalletPayment;
+    wallet: WalletPassPayment;
     constructor(name?: string, version?: string);
     initialize(core: PisellCore, options: ModuleOptions): Promise<void>;
     /**
@@ -93,20 +73,10 @@ export declare class PaymentModule extends BaseModule implements Module, Payment
      * 创建支付订单（新方法，专注支付数据）
      */
     createPaymentOrderAsync(params: PushOrderParams): Promise<PaymentOrder>;
-    /**
-     * 往交易组中添加订单（兼容性方法）
-     * @deprecated 使用 createPaymentOrderAsync 替代
-     */
-    pushOrderAsync(params: PushOrderParams): Promise<PaymentOrder>;
     /**
      * 删除支付订单（新方法）
      */
     deletePaymentOrderAsync(orderUuid: string): Promise<void>;
-    /**
-     * 删除订单（兼容性方法）
-     * @deprecated 使用 deletePaymentOrderAsync 替代
-     */
-    deleteOrderAsync(orderUuid: string): Promise<void>;
     /**
      * 更新订单
      */
@@ -124,26 +94,34 @@ export declare class PaymentModule extends BaseModule implements Module, Payment
     replaceOrderIdByUuidAsync(orderUuid: string, newOrderId: string): Promise<PaymentOrder | null>;
     /**
      * 获取支付项（新方法）
+     *
+     * @param orderUuid 订单UUID
+     * @param includeVoided 是否包含已撤销的支付项，默认为false
+     * @returns 支付项数组
      */
-    getPaymentItemsAsync(orderUuid: string): Promise<PaymentItem[]>;
+    getPaymentItemsAsync(orderUuid: string, includeVoided?: boolean): Promise<PaymentItem[]>;
     /**
-     * 获取支付项（兼容性方法）
-     * @deprecated 使用 getPaymentItemsAsync 替代
+     * 获取所有支付项（包括已撤销的）
+     *
+     * @param orderUuid 订单UUID
+     * @returns 所有支付项数组（包括撤销的）
      */
-    getPaymentAsync(orderUuid: string): Promise<PaymentItem[]>;
+    getAllPaymentItemsAsync(orderUuid: string): Promise<PaymentItem[]>;
     /**
      * 为某个订单添加支付项（新方法）
      */
     addPaymentItemAsync(orderUuid: string, paymentItem: PaymentItemInput): Promise<void>;
     /**
-     * 为某个订单设置一个支付项（兼容性方法）
-     * @deprecated 使用 addPaymentItemAsync 替代
+     * 删除一个支付项 - 标记删除而非物理删除
      */
-    pushPaymentAsync(orderUuid: string, paymentItem: PaymentItemInput): Promise<void>;
+    deletePaymentAsync(orderUuid: string, paymentUuid: string): Promise<void>;
     /**
-     * 删除一个支付项
+     * 批量更新代金券类支付项（覆盖更新）
+     *
+     * 删除所有现有的带 voucher_id 的支付项，然后添加新的代金券支付项
+     * 这是一个覆盖式更新，确保代金券支付项的一致性
      */
-    deletePaymentAsync(orderUuid: string, paymentUuid: string): Promise<void>;
+    updateVoucherPaymentItemsAsync(orderUuid: string, voucherPaymentItems: PaymentItemInput[]): Promise<void>;
     /**
      * 更新一个支付项
      */
@@ -158,10 +136,6 @@ export declare class PaymentModule extends BaseModule implements Module, Payment
      * 提交单个订单的支付（推送到任务队列）
      */
     private submitSingleOrderPayment;
-    /**
-     * 添加到同步任务队列
-     */
-    private addToSyncQueue;
     /**
      * 获取订单剩余待付金额
      */
@@ -186,15 +160,6 @@ export declare class PaymentModule extends BaseModule implements Module, Payment
      * 获取钱包支付方式
      */
     getWalletPaymentMethod(): Promise<PaymentMethod | null>;
-    /**
-     * 注册任务处理函数
-     */
-    private registerTaskHandlers;
-    /**
-     * 静态方法：处理支付同步任务（后台网络同步）
-     * 这个方法里不允许用 this，因为需要作为静态方法注入到任务队列里
-     */
-    static syncPaymentTask(payload: any): Promise<any>;
     /**
      * 确保支付模块所需的数据库表已创建
      */
@@ -204,77 +169,22 @@ export declare class PaymentModule extends BaseModule implements Module, Payment
      */
     getPartiallyPaidOrdersAsync(): Promise<PaymentOrder[]>;
     /**
-     * 获取未同步到服务器的订单
-     */
-    getUnsyncedOrdersAsync(): Promise<PaymentOrder[]>;
-    /**
-     * 清理已完成且已同步的订单
-     * 注意：只清理完全支付的订单，部分支付的订单保留以便继续支付
-     */
-    cleanupFinishedOrders(): Promise<void>;
-    /**
-     * 检测未同步的订单并重新加入任务队列
-     *
-     * 此方法专门用于处理因网络问题导致任务队列执行失败但队列被清空的情况。
-     * 它会检查本地 IndexDB 中所有未同步的订单（isSynced: false），
-     * 并将这些订单重新添加到任务队列中。
-     *
-     * 使用场景：
-     * - 网络恢复后重新检查未同步的订单
-     * - 应用启动时检查并重新排队未完成的支付
-     * - 用户手动重试前的预检查
-     *
-     * @returns Promise<number> 返回重新加入队列的订单数量
-     */
-    recheckAndRequeueUnsyncedOrders(): Promise<number>;
-    /**
-     * 手动执行支付同步队列
-     * 外部可以调用此方法来触发支付同步任务的执行
-     *
-     * 注意：此方法只执行现有队列中的任务，不会检查未同步的订单。
-     * 如果需要检查未同步订单，请先调用 recheckAndRequeueUnsyncedOrders()
+     * 智能金额舍入
      *
-     * 使用示例：
-     * ```typescript
-     * // 1. 先检查并重新排队未同步订单，然后执行队列
-     * const requeuedCount = await paymentModule.recheckAndRequeueUnsyncedOrders();
-     * if (requeuedCount > 0) {
-     *   await paymentModule.runPaymentSyncQueue();
-     * }
+     * 根据指定的舍入间隔和规则对金额进行舍入处理
      *
-     * // 2. 或者直接执行现有队列（不检查未同步订单）
-     * await paymentModule.runPaymentSyncQueue();
-     * ```
+     * @param originalAmount 原始金额
+     * @param interval 舍入间隔 (0.05, 0.1, 0.5, 1)
+     * @param rule 舍入规则 (standard, standard_down, always_up, always_down)
+     * @returns 舍入后的金额（保留两位小数的字符串）
      */
-    runPaymentSyncQueue(): Promise<void>;
+    roundAmountAsync(originalAmount: number | string, interval: RoundingInterval | number, rule: RoundingRule | string): Promise<string>;
     /**
-     * 重新将订单添加到同步队列
-     * 用于处理因网络问题导致任务队列清空但订单未同步的情况
+     * 标准舍入处理（处理中点情况）
      *
-     * @param order 要重新添加的订单
-     * @returns Promise<boolean> 是否成功添加到队列
+     * @param value 要舍入的值
+     * @param midpointUp 中点是否向上舍入
+     * @returns 舍入后的值
      */
-    private reAddOrderToSyncQueue;
-    /**
-     * 删除支付项（新方法）
-     */
-    deletePaymentItemAsync(orderUuid: string, paymentUuid: string): Promise<void>;
-    /**
-     * 更新支付项（新方法）
-     */
-    updatePaymentItemAsync(orderUuid: string, paymentUuid: string, params: PaymentUpdateFields): Promise<void>;
-    /**
-     * 获取订单剩余待付金额（新方法）
-     */
-    getRemainingAmountAsync(orderUuid: string): Promise<number>;
-    /**
-     * 获取订单剩余待付金额（基于用户输入的金额）（新方法）
-     */
-    getRemainingAmountWithInputAsync(inputAmount: string | number, orderUuid: string): Promise<number>;
-    /**
-     * 提交支付（新方法）
-     */
-    submitPaymentAsync(orderUuid: string): Promise<{
-        status: 'success' | 'failed';
-    }>;
+    private standardRound;
 }