@pisell/pisellos 3.0.57 → 3.0.58

package/dist/modules/Rules/index.js

@@ -28,7 +28,6 @@ import { RulesHooks } from "./types";
 import { uniqueById } from "../../solution/ShopDiscount/utils";
 import { getProductOriginTotalPrice, getProductTotalPrice } from "../Cart/utils";
 import Decimal from 'decimal.js';
-import { isBoolean } from 'lodash-es';
 export var RulesModule = /*#__PURE__*/function (_BaseModule) {
   _inherits(RulesModule, _BaseModule);
   var _super = _createSuper(RulesModule);
@@ -297,25 +296,19 @@ export var RulesModule = /*#__PURE__*/function (_BaseModule) {
 
             // 记录可抵扣的商品详情
             var applicableProducts = discountApplicableProducts.get(discount.id) || [];
-            var discountType = discount.tag || discount.type;
-            var productData = {
+            applicableProducts.push({
               amount: product.price,
-              type: discountType,
-              tag: discountType,
+              type: discount.tag || discount.type,
+              tag: discount.tag || discount.type,
               discount: {
                 resource_id: discount.id,
                 title: discount.format_title,
                 original_amount: product.origin_total,
                 pre_value: discount.par_value,
                 product_id: originProduct.id
-              }
-            };
-
-            // 如果 discount.tag 或者 discount.type 是 good_pass，则不需要添加 num 属性
-            if (discountType !== 'good_pass') {
-              productData.num = product.num || 1;
-            }
-            applicableProducts.push(productData);
+              },
+              num: product.num || 1
+            });
             discountApplicableProducts.set(discount.id, applicableProducts);
           }
         });
@@ -337,10 +330,10 @@ export var RulesModule = /*#__PURE__*/function (_BaseModule) {
         var applicableDiscounts = sortedDiscountList.filter(function (discount) {
           var _product$discount_lis6;
           // 如果商品价格为 0，其实不需要使用任何优惠券，直接 return true
-          // 商品券时主商品价格小于等于0不可用
-          if ((Number(product.price) <= 0 || !product.price) && (discount.tag || discount.type) === 'good_pass') return false;
-          // 折扣卡时总价小于等于0时不可用
-          if ((Number(product.total) <= 0 || !product.total) && !((_product$discount_lis6 = product.discount_list) !== null && _product$discount_lis6 !== void 0 && _product$discount_lis6.find(function (n) {
+          // 商品券时主商品价格为0不可用
+          if ((Number(product.price) === 0 || !product.price) && (discount.tag || discount.type) === 'good_pass') return false;
+          // 折扣卡时总价为0时不可用
+          if ((Number(product.total) === 0 || !product.total) && !((_product$discount_lis6 = product.discount_list) !== null && _product$discount_lis6 !== void 0 && _product$discount_lis6.find(function (n) {
             var _n$discount;
             return ((_n$discount = n.discount) === null || _n$discount === void 0 ? void 0 : _n$discount.resource_id) === discount.id;
           })) && (discount.tag || discount.type) !== 'good_pass') return false;
@@ -380,8 +373,7 @@ export var RulesModule = /*#__PURE__*/function (_BaseModule) {
         }
 
         // 如果没有适用的优惠券，或者手动折扣，则不适用优惠券
-        // 自定义商品：如果未开启适用折扣卡（product.vouchersApplicable），则不适用优惠券
-        if (applicableDiscounts.length === 0 || isManualDiscount || isBoolean(product.vouchersApplicable) && !product.vouchersApplicable) {
+        if (applicableDiscounts.length === 0 || isManualDiscount) {
           if (product.isClient) {
             processedProductsMap.set(product._id, [_this3.hooks.setProduct(originProduct, _objectSpread(_objectSpread({}, isManualDiscount ? {} : {
               origin_total: getProductOriginTotalPrice({
@@ -457,23 +449,18 @@ export var RulesModule = /*#__PURE__*/function (_BaseModule) {
 
           // 计算使用折扣卡/商品券以后，单个商品的总 total
           var targetProductTotal = _selectedDiscount.tag === 'good_pass' ? new Decimal(productOriginTotal).minus(new Decimal(product.price || 0)).toNumber() : new Decimal(100).minus(_selectedDiscount.par_value || 0).div(100).mul(new Decimal(productOriginTotal)).toNumber();
-          var discountType = _selectedDiscount.tag === 'product_discount_card' ? 'discount_card' : _selectedDiscount.tag;
           var discountDetail = {
             amount: new Decimal(productOriginTotal).minus(new Decimal(targetProductTotal)).toNumber(),
-            type: discountType,
+            type: _selectedDiscount.tag === 'product_discount_card' ? 'discount_card' : _selectedDiscount.tag,
             discount: {
               resource_id: _selectedDiscount.id,
               title: _selectedDiscount.format_title,
               original_amount: productOriginTotal,
               product_id: originProduct.id,
               percent: _selectedDiscount.par_value
-            }
+            },
+            num: product.num || 1
           };
-
-          // 如果 discount.tag 或者 discount.type 是 good_pass，则不需要添加 num 属性
-          if ((_selectedDiscount.tag || _selectedDiscount.type) !== 'good_pass') {
-            discountDetail.num = product.num || 1;
-          }
           appliedProducts.push(discountDetail);
           appliedDiscountProducts.set(_selectedDiscount.id, appliedProducts);
 

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

@@ -39,7 +39,6 @@ type ProductDetail = {
     original_price?: number | string;
     num?: number;
     quantity: number;
-    vouchersApplicable?: boolean;
 };
 export interface RulesParamsHooks {
     getProduct: (product: Record<string, any>) => ProductDetail;

package/dist/modules/index.d.ts

@@ -3,7 +3,6 @@ export * from './ProductList';
 export * from './Cart';
 export * from './Account';
 export * from './AccountList';
-export * from './Customer';
 export * from './Date';
 export * from './Guests';
 export * from './Order';

package/dist/modules/index.js

@@ -3,7 +3,6 @@ export * from "./ProductList";
 export * from "./Cart";
 export * from "./Account";
 export * from "./AccountList";
-export * from "./Customer";
 export * from "./Date";
 export * from "./Guests";
 export * from "./Order";

package/dist/plugins/window.d.ts

@@ -13,7 +13,6 @@ export interface WindowPlugin extends Plugin {
     navigator: Partial<Navigator>;
     document: Partial<Document>;
     history: History;
-    interaction?: any;
 }
 /**
  * 简单的 Storage 接口实现

package/dist/solution/BookingByStep/index.js

@@ -112,7 +112,7 @@ export var BookingByStepImpl = /*#__PURE__*/function (_BaseModule) {
                   this.otherData = ((_data$this$otherParam = data[this.otherParams.cacheId]) === null || _data$this$otherParam === void 0 || (_data$this$otherParam = _data$this$otherParam[this.name]) === null || _data$this$otherParam === void 0 ? void 0 : _data$this$otherParam['otherData']) || {};
                 }
               }
-              moduleArr = ['accountList', 'cart', 'schedule', 'summary', 'step', 'products', 'date', 'order'];
+              moduleArr = ['accountList', 'cart', 'schedule', 'summary', 'step', 'products', 'date', 'order', 'payment'];
               moduleArr.forEach(function (step) {
                 var targetModule = createModule(step, _this2.name);
                 if (targetModule) {
@@ -1213,14 +1213,6 @@ export var BookingByStepImpl = /*#__PURE__*/function (_BaseModule) {
             _this6.store.cart.removeItem(n._id);
           });
         }
-        // // 如果 date.startTime 和 dateRange 里的 startTime 不一样，需要修正 dateRange
-        // const dateRange = this.store.date.getDateRange()
-        // if (dateRange?.[0] && !dayjs(dateRange[0].date).isSame(dayjs(date.startTime), 'day')) {
-        //   this.setDateRange([
-        //     { date: dayjs(date.startTime).format('YYYY-MM-DD'), status: 'available', week: '', weekNum: 0 },
-        //     { date: dayjs(date.endTime).format('YYYY-MM-DD'), status: 'available', week: '', weekNum: 0 },
-        //   ]);
-        // }
       }
     }
   }, {

package/dist/solution/ShopDiscount/index.js

@@ -29,7 +29,6 @@ import { ShopDiscountHooks } from "./types";
 import { DiscountModule } from "../../modules/Discount";
 import { RulesModule } from "../../modules/Rules";
 import Decimal from 'decimal.js';
-import { isBoolean } from 'lodash-es';
 export var ShopDiscountImpl = /*#__PURE__*/function (_BaseModule) {
   _inherits(ShopDiscountImpl, _BaseModule);
   var _super = _createSuper(ShopDiscountImpl);
@@ -496,9 +495,8 @@ export var ShopDiscountImpl = /*#__PURE__*/function (_BaseModule) {
           return n.id === id;
         });
         var product = (_this3$hooks2 = _this3.hooks) === null || _this3$hooks2 === void 0 ? void 0 : _this3$hooks2.getProduct(targetProduct);
-        // 如果 product.total 是小于等于0有可能是她已经用过商品券或者折扣卡导致的，或者本身就是负数价格，所以此时还需要判断 origin_total 是否小于等于0
-        // 如果 product.vouchersApplicable是布尔值，并且是 false，也当做免费商品处理，此商品不可用优惠券或折扣卡
-        return Number(product === null || product === void 0 ? void 0 : product.total) <= 0 && (Number(product === null || product === void 0 ? void 0 : product.origin_total) <= 0 || !(product !== null && product !== void 0 && product.origin_total)) || isBoolean(product === null || product === void 0 ? void 0 : product.vouchersApplicable) && !(product !== null && product !== void 0 && product.vouchersApplicable);
+        // 如果 product.total 是 0有可能是她已经用过商品券或者折扣卡导致的 0，所以此时还需要判断 origin_total 是否为 0
+        return Number(product === null || product === void 0 ? void 0 : product.total) === 0 && (Number(product === null || product === void 0 ? void 0 : product.origin_total) === 0 || !(product !== null && product !== void 0 && product.origin_total));
       };
       var allUsedProductIds = newDiscountList.map(function (n) {
         var _n$appliedProductDeta;

package/dist/solution/index.d.ts

@@ -1,5 +1,3 @@
 export * from './BuyTickets';
 export * from './BookingByStep';
-export * from './BookingTicket';
 export * from './ShopDiscount';
-export * from './Checkout';

package/dist/solution/index.js

@@ -1,5 +1,3 @@
 export * from "./BuyTickets";
 export * from "./BookingByStep";
-export * from "./BookingTicket";
-export * from "./ShopDiscount";
-export * from "./Checkout";
+export * from "./ShopDiscount";

package/dist/types/index.d.ts

@@ -38,9 +38,7 @@ export interface PisellCore {
     getModuleExports: <T = any>(name: string) => T | null;
     hasModule: (name: string) => boolean;
     effects: {
-        on: (event: string, callback: (payload: any) => void) => () => void;
-        once: (event: string, callback: (payload: any) => void) => () => void;
-        off: (event: string, callback: (payload: any) => void) => void;
+        on: (event: string, callback: (payload: any) => void) => void;
         emit: (event: string, payload: any, value?: any) => Promise<{
             status: boolean;
             data: any;

package/lib/core/index.js

@@ -61,7 +61,7 @@ var PisellOSCore = class {
         console.log(`${prefix} ${message}`);
         break;
       case "warn":
-        console.log(`%c${prefix}%c ${message}`, "color: #f59e0b; font-weight: bold;", "color: #f59e0b;");
+        console.warn(`${prefix} ${message}`);
         break;
       case "error":
         console.error(`${prefix} ${message}`);

package/lib/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/lib/effects/index.js

@@ -31,9 +31,6 @@ var EffectsManager = class {
     if (!this.listeners.has(event))
       this.listeners.set(event, /* @__PURE__ */ new Set());
     (_a = this.listeners.get(event)) == null ? void 0 : _a.add(callback);
-    return () => {
-      this.off(event, callback);
-    };
   }
   off(event, callback) {
     var _a;
@@ -52,7 +49,7 @@ var EffectsManager = class {
       await callback(payload);
       this.off(event, wrapper);
     };
-    return this.on(event, wrapper);
+    this.on(event, wrapper);
   }
   async emit(event, payload) {
     const callbacks = this.listeners.get(event);

package/lib/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/lib/modules/AccountList/index.js

@@ -288,33 +288,6 @@ var AccountListModule = class extends import_BaseModule.BaseModule {
     );
     return accountModules;
   }
-  /**
-   * 获取客户列表
-   * @param params 查询参数
-   * @returns 客户列表
-   */
-  async getCustomerList(params = {}) {
-    const url = "/customer/es/data";
-    const { page = 1, pageSize = 20, keyword, ...otherParams } = params;
-    try {
-      this.store.isLoading = true;
-      this.store.error = null;
-      const queryParams = {
-        page,
-        pageSize,
-        ...keyword && { keyword },
-        ...otherParams
-      };
-      const res = await this.request.get(url, queryParams);
-      return (res == null ? void 0 : res.data) || [];
-    } catch (error) {
-      console.error("Failed to fetch customer list:", error);
-      this.store.error = error instanceof Error ? error.message : "Failed to fetch customer list";
-      throw error;
-    } finally {
-      this.store.isLoading = false;
-    }
-  }
   /**
    * 获取holder类型账户列表
    * @param params

package/lib/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/lib/modules/Cart/index.js

@@ -31,7 +31,7 @@ var import_utils2 = require("../Product/utils");
 __reExport(Cart_exports, require("./types"), module.exports);
 var CartModule = class extends import_BaseModule.BaseModule {
   constructor(name, version) {
-    super(name || "cart", version || "1.0.0");
+    super(name, version);
     // 提供给 baseModule 用的默认名称 和 默认版本
     this.defaultName = "cart";
     this.defaultVersion = "1.0.0";

package/lib/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>;
 }