@pisell/pisellos 3.0.57 → 3.0.59

package/dist/core/index.js

@@ -67,8 +67,7 @@ var PisellOSCore = /*#__PURE__*/function () {
           console.log("".concat(prefix, " ").concat(message));
           break;
         case 'warn':
-          // 使用 console.log 避免显示堆栈跟踪，提升性能
-          console.log("%c".concat(prefix, "%c ").concat(message), 'color: #f59e0b; font-weight: bold;', 'color: #f59e0b;');
+          console.warn("".concat(prefix, " ").concat(message));
           break;
         case 'error':
           console.error("".concat(prefix, " ").concat(message));

package/dist/effects/index.d.ts

@@ -2,17 +2,16 @@ type EffectCallback = (payload: any) => void | Promise<void | {
     status: boolean;
     message?: string;
 }>;
-type UnsubscribeFunction = () => void;
 declare class EffectsManager {
     private listeners;
-    on(event: string, callback: EffectCallback): UnsubscribeFunction;
+    on(event: string, callback: EffectCallback): void;
     off(event: string, callback: EffectCallback): void;
     offByModuleDestroy(module: string): void;
-    once(event: string, callback: EffectCallback): UnsubscribeFunction;
+    once(event: string, callback: EffectCallback): void;
     emit(event: string, payload: any): Promise<{
         status: boolean;
         data: any;
     }>;
     clear(): void;
 }
-export { EffectsManager, UnsubscribeFunction };
+export { EffectsManager };

package/dist/effects/index.js

@@ -11,7 +11,6 @@ function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _d
 function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
 function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
-// 取消监听函数类型
 var EffectsManager = /*#__PURE__*/function () {
   function EffectsManager() {
     _classCallCheck(this, EffectsManager);
@@ -20,15 +19,9 @@ var EffectsManager = /*#__PURE__*/function () {
   _createClass(EffectsManager, [{
     key: "on",
     value: function on(event, callback) {
-      var _this$listeners$get,
-        _this = this;
+      var _this$listeners$get;
       if (!this.listeners.has(event)) this.listeners.set(event, new Set());
       (_this$listeners$get = this.listeners.get(event)) === null || _this$listeners$get === void 0 || _this$listeners$get.add(callback);
-
-      // 返回取消函数
-      return function () {
-        _this.off(event, callback);
-      };
     }
   }, {
     key: "off",
@@ -41,17 +34,17 @@ var EffectsManager = /*#__PURE__*/function () {
   }, {
     key: "offByModuleDestroy",
     value: function offByModuleDestroy(module) {
-      var _this2 = this;
+      var _this = this;
       Array.from(this.listeners.keys()).forEach(function (item) {
         if (item.startsWith(module)) {
-          _this2.listeners.delete(item);
+          _this.listeners.delete(item);
         }
       });
     }
   }, {
     key: "once",
     value: function once(event, callback) {
-      var _this3 = this;
+      var _this2 = this;
       var wrapper = /*#__PURE__*/function () {
         var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(payload) {
           return _regeneratorRuntime().wrap(function _callee$(_context) {
@@ -60,7 +53,7 @@ var EffectsManager = /*#__PURE__*/function () {
                 _context.next = 2;
                 return callback(payload);
               case 2:
-                _this3.off(event, wrapper);
+                _this2.off(event, wrapper);
               case 3:
               case "end":
                 return _context.stop();
@@ -71,9 +64,7 @@ var EffectsManager = /*#__PURE__*/function () {
           return _ref.apply(this, arguments);
         };
       }();
-
-      // 调用修改后的on方法，它会返回取消函数
-      return this.on(event, wrapper);
+      this.on(event, wrapper);
     }
   }, {
     key: "emit",

package/dist/modules/AccountList/index.d.ts

@@ -1,7 +1,7 @@
 import { Module, PisellCore, ModuleOptions } from '../../types';
 import { AccountModule, Account } from '../Account';
 import { BaseModule } from '../BaseModule';
-import { IFetchHolderAccountsParams, IHolder, IGetCustomerListParams } from './types';
+import { IFetchHolderAccountsParams, IHolder } from './types';
 export declare class AccountListModule extends BaseModule implements Module {
     protected defaultName: string;
     protected defaultVersion: string;
@@ -37,12 +37,6 @@ export declare class AccountListModule extends BaseModule implements Module {
         customerId: number;
         type?: 'unshift' | 'push';
     }): Promise<AccountModule[]>;
-    /**
-     * 获取客户列表
-     * @param params 查询参数
-     * @returns 客户列表
-     */
-    getCustomerList(params?: IGetCustomerListParams): Promise<any>;
     /**
      * 获取holder类型账户列表
      * @param params

package/dist/modules/AccountList/index.js

@@ -1,9 +1,4 @@
-var _excluded = ["page", "pageSize", "keyword"];
 function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
-function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
-function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
-function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
-function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
 function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
 function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
 function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
@@ -509,68 +504,6 @@ export var AccountListModule = /*#__PURE__*/function (_BaseModule) {
       }
       return addHolderAccounts;
     }()
-    /**
-     * 获取客户列表
-     * @param params 查询参数
-     * @returns 客户列表
-     */
-    )
-  }, {
-    key: "getCustomerList",
-    value: (function () {
-      var _getCustomerList = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee9() {
-        var params,
-          url,
-          _params$page,
-          page,
-          _params$pageSize,
-          pageSize,
-          keyword,
-          otherParams,
-          queryParams,
-          res,
-          _args9 = arguments;
-        return _regeneratorRuntime().wrap(function _callee9$(_context9) {
-          while (1) switch (_context9.prev = _context9.next) {
-            case 0:
-              params = _args9.length > 0 && _args9[0] !== undefined ? _args9[0] : {};
-              url = '/customer/es/data';
-              _params$page = params.page, page = _params$page === void 0 ? 1 : _params$page, _params$pageSize = params.pageSize, pageSize = _params$pageSize === void 0 ? 20 : _params$pageSize, keyword = params.keyword, otherParams = _objectWithoutProperties(params, _excluded);
-              _context9.prev = 3;
-              this.store.isLoading = true;
-              this.store.error = null;
-              queryParams = _objectSpread(_objectSpread({
-                page: page,
-                pageSize: pageSize
-              }, keyword && {
-                keyword: keyword
-              }), otherParams);
-              _context9.next = 9;
-              return this.request.get(url, queryParams);
-            case 9:
-              res = _context9.sent;
-              return _context9.abrupt("return", (res === null || res === void 0 ? void 0 : res.data) || []);
-            case 13:
-              _context9.prev = 13;
-              _context9.t0 = _context9["catch"](3);
-              console.error('Failed to fetch customer list:', _context9.t0);
-              this.store.error = _context9.t0 instanceof Error ? _context9.t0.message : 'Failed to fetch customer list';
-              throw _context9.t0;
-            case 18:
-              _context9.prev = 18;
-              this.store.isLoading = false;
-              return _context9.finish(18);
-            case 21:
-            case "end":
-              return _context9.stop();
-          }
-        }, _callee9, this, [[3, 13, 18, 21]]);
-      }));
-      function getCustomerList() {
-        return _getCustomerList.apply(this, arguments);
-      }
-      return getCustomerList;
-    }()
     /**
      * 获取holder类型账户列表
      * @param params
@@ -579,15 +512,15 @@ export var AccountListModule = /*#__PURE__*/function (_BaseModule) {
   }, {
     key: "fetchHolderAccounts",
     value: (function () {
-      var _fetchHolderAccounts = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee10(params) {
+      var _fetchHolderAccounts = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee9(params) {
         var url, _ref, form_id, shop_id, num, skip, customer_id, _res$data, res;
-        return _regeneratorRuntime().wrap(function _callee10$(_context10) {
-          while (1) switch (_context10.prev = _context10.next) {
+        return _regeneratorRuntime().wrap(function _callee9$(_context9) {
+          while (1) switch (_context9.prev = _context9.next) {
             case 0:
               url = params.url || '/account/holder';
               _ref = (params === null || params === void 0 ? void 0 : params.query) || {}, form_id = _ref.form_id, shop_id = _ref.shop_id, num = _ref.num, skip = _ref.skip, customer_id = _ref.customer_id;
-              _context10.prev = 2;
-              _context10.next = 5;
+              _context9.prev = 2;
+              _context9.next = 5;
               return this.request.get(url, {
                 customer_id: customer_id,
                 form_id: form_id,
@@ -596,30 +529,30 @@ export var AccountListModule = /*#__PURE__*/function (_BaseModule) {
                 skip: skip || 1
               });
             case 5:
-              res = _context10.sent;
+              res = _context9.sent;
               this.store.accountList = [];
               this.store.accounts = [];
               if (!(res !== null && res !== void 0 && (_res$data = res.data) !== null && _res$data !== void 0 && (_res$data = _res$data.list) !== null && _res$data !== void 0 && _res$data.length)) {
-                _context10.next = 11;
+                _context9.next = 11;
                 break;
               }
-              _context10.next = 11;
+              _context9.next = 11;
               return this.addHolderAccounts({
                 holders: res.data.list,
                 customerId: customer_id
               });
             case 11:
-              _context10.next = 16;
+              _context9.next = 16;
               break;
             case 13:
-              _context10.prev = 13;
-              _context10.t0 = _context10["catch"](2);
-              console.error(_context10.t0);
+              _context9.prev = 13;
+              _context9.t0 = _context9["catch"](2);
+              console.error(_context9.t0);
             case 16:
             case "end":
-              return _context10.stop();
+              return _context9.stop();
           }
-        }, _callee10, this, [[2, 13]]);
+        }, _callee9, this, [[2, 13]]);
       }));
       function fetchHolderAccounts(_x11) {
         return _fetchHolderAccounts.apply(this, arguments);

package/dist/modules/AccountList/types.d.ts

@@ -67,31 +67,3 @@ export interface IHolder {
     main_field: string;
     customer_cover?: string;
 }
-/**
- * 获取客户列表参数
- */
-export interface IGetCustomerListParams {
-    /** 页码 */
-    page?: number;
-    /** 每页数量 */
-    pageSize?: number;
-    /** 搜索关键词 */
-    keyword?: string;
-    /** 其他筛选参数 */
-    [key: string]: any;
-}
-/**
- * 客户数据
- */
-export interface ICustomer {
-    /** 客户ID */
-    id: string | number;
-    /** 客户姓名 */
-    name: string;
-    /** 客户电话 */
-    phone?: string;
-    /** 客户邮箱 */
-    email?: string;
-    /** 其他客户信息 */
-    [key: string]: any;
-}

package/dist/modules/AccountList/types.js

@@ -22,12 +22,4 @@ export var AccountListHooks = /*#__PURE__*/function (AccountListHooks) {
 
 /**
  * holder类型数据
- */
-
-/**
- * 获取客户列表参数
- */
-
-/**
- * 客户数据
  */

package/dist/modules/Cart/index.js

@@ -39,7 +39,7 @@ export var CartModule = /*#__PURE__*/function (_BaseModule) {
   function CartModule(name, version) {
     var _this;
     _classCallCheck(this, CartModule);
-    _this = _super.call(this, name || 'cart', version || '1.0.0');
+    _this = _super.call(this, name, version);
     // 提供给 baseModule 用的默认名称 和 默认版本
     _defineProperty(_assertThisInitialized(_this), "defaultName", 'cart');
     _defineProperty(_assertThisInitialized(_this), "defaultVersion", '1.0.0');

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

@@ -1,280 +1,16 @@
 import { Module, PisellCore, ModuleOptions } from '../../types';
 import { BaseModule } from '../BaseModule';
-import { PaymentModuleAPI, PaymentMethod, PaymentOrder, PaymentItem, PaymentItemInput, PaymentUpdateFields, PushOrderParams, CashPayment, EftposPayment, WalletPayment } from './types';
-export * from './types';
-export { generateRequestUniqueId };
-/**
- * 生成请求唯一ID
- * 格式: 年月日时分秒毫秒+4位随机数
- * 示例: 20241201143025123456
- */
-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会自动重试失败的网络请求
- * - 异步处理：不阻塞用户界面，网络同步在后台进行
- * - 数据一致性：通过事件系统确保数据状态同步
- */
+import { Payment, PaymentModuleAPI, PaymentMethod, PaymentStatus } from './types';
 export declare class PaymentModule extends BaseModule implements Module, PaymentModuleAPI {
     protected defaultName: string;
     protected defaultVersion: string;
-    private request;
-    private app;
-    private store;
-    private dbManager;
-    private logger;
-    cash: CashPayment;
-    eftpos: EftposPayment;
-    wallet: WalletPayment;
+    private state;
     constructor(name?: string, version?: string);
-    initialize(core: PisellCore, options: ModuleOptions): Promise<void>;
-    /**
-     * 记录信息日志
-     */
-    private logInfo;
-    /**
-     * 记录警告日志
-     */
-    private logWarning;
-    /**
-     * 记录错误日志
-     */
-    private logError;
-    /**
-     * 记录调试日志
-     */
-    private logDebug;
-    /**
-     * 网络恢复以后，尝试执行队列
-     *
-     */
-    private registerNetworkHandlers;
-    /**
-     * 获取支付方式列表
-     */
-    getPayMethodListAsync(): Promise<PaymentMethod[]>;
-    /**
-     * 后台刷新支付方式列表
-     */
-    private refreshPaymentMethodsInBackground;
-    /**
-     * 检查支付方式列表是否有变化
-     */
-    private hasPaymentMethodsChanged;
-    /**
-     * 获取订单列表
-     */
-    getOrderListAsync(): Promise<PaymentOrder[]>;
-    /**
-     * 根据订单UUID获取支付订单（新方法）
-     */
-    getPaymentOrderByUuidAsync(orderUuid: string): Promise<PaymentOrder | null>;
-    /**
-     * 创建支付订单（新方法，专注支付数据）
-     */
-    createPaymentOrderAsync(params: PushOrderParams): Promise<PaymentOrder>;
-    /**
-     * 往交易组中添加订单（兼容性方法）
-     * @deprecated 使用 createPaymentOrderAsync 替代
-     */
-    pushOrderAsync(params: PushOrderParams): Promise<PaymentOrder>;
-    /**
-     * 删除支付订单（新方法）
-     */
-    deletePaymentOrderAsync(orderUuid: string): Promise<void>;
-    /**
-     * 删除订单（兼容性方法）
-     * @deprecated 使用 deletePaymentOrderAsync 替代
-     */
-    deleteOrderAsync(orderUuid: string): Promise<void>;
-    /**
-     * 更新订单
-     */
-    updateOrderAsync(orderUuid: string, params: Partial<PaymentOrder>): Promise<void>;
-    /**
-     * 基于UUID替换订单ID
-     *
-     * 此方法用于将本地虚拟订单ID替换为真实的订单ID。
-     * 当前端模拟下单流程完成后，后端返回真实订单ID时调用此方法。
-     *
-     * @param orderUuid 订单的UUID
-     * @param newOrderId 新的订单ID (来自后端)
-     * @returns 更新后的订单对象，如果订单不存在则返回null
-     */
-    replaceOrderIdByUuidAsync(orderUuid: string, newOrderId: string): Promise<PaymentOrder | null>;
-    /**
-     * 获取支付项（新方法）
-     */
-    getPaymentItemsAsync(orderUuid: string): Promise<PaymentItem[]>;
-    /**
-     * 获取支付项（兼容性方法）
-     * @deprecated 使用 getPaymentItemsAsync 替代
-     */
-    getPaymentAsync(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>;
-    /**
-     * 更新一个支付项
-     */
-    updatePaymentAsync(orderUuid: string, paymentUuid: string, params: PaymentUpdateFields): Promise<void>;
-    /**
-     * 提交支付
-     */
-    submitPayAsync(orderUuid?: string): Promise<{
-        status: 'success' | 'failed';
-    }>;
-    /**
-     * 提交单个订单的支付（推送到任务队列）
-     */
-    private submitSingleOrderPayment;
-    /**
-     * 添加到同步任务队列
-     */
-    private addToSyncQueue;
-    /**
-     * 获取订单剩余待付金额
-     */
-    getRemainingOrderAmountAsync(orderUuid: string): Promise<number>;
-    /**
-     * 在比如现金支付界面的地方，用户输入了一个金额，在下方显示剩余多少金额，通过此方法获取
-     */
-    getRemainingOrderAmountWithInputAsync(inputAmount: string | number, orderUuid: string): Promise<number>;
-    /**
-     * 重新计算订单金额
-     */
-    private recalculateOrderAmount;
-    /**
-     * 获取现金支付方式
-     */
-    getCashPaymentMethod(): Promise<PaymentMethod | null>;
-    /**
-     * 获取Eftpos支付方式
-     */
-    getEftposPaymentMethod(): Promise<PaymentMethod | null>;
-    /**
-     * 获取钱包支付方式
-     */
-    getWalletPaymentMethod(): Promise<PaymentMethod | null>;
-    /**
-     * 注册任务处理函数
-     */
-    private registerTaskHandlers;
-    /**
-     * 静态方法：处理支付同步任务（后台网络同步）
-     * 这个方法里不允许用 this，因为需要作为静态方法注入到任务队列里
-     */
-    static syncPaymentTask(payload: any): Promise<any>;
-    /**
-     * 确保支付模块所需的数据库表已创建
-     */
-    private ensurePaymentTables;
-    /**
-     * 获取部分支付的订单
-     */
-    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();
-     * ```
-     */
-    runPaymentSyncQueue(): Promise<void>;
-    /**
-     * 重新将订单添加到同步队列
-     * 用于处理因网络问题导致任务队列清空但订单未同步的情况
-     *
-     * @param order 要重新添加的订单
-     * @returns Promise<boolean> 是否成功添加到队列
-     */
-    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';
-    }>;
+    initialize(core: PisellCore, options?: ModuleOptions): Promise<void>;
+    processPayment(paymentId: string): Promise<void>;
+    getPayment(paymentId: string): Promise<Payment>;
+    getPaymentHistory(): Promise<Payment[]>;
+    refund(paymentId: string): Promise<void>;
+    getAvailablePaymentMethods(): PaymentMethod[];
+    checkPaymentStatus(paymentId: string): Promise<PaymentStatus>;
 }