@pisell/pisellos 3.0.76 → 3.0.77

package/lib/modules/Discount/index.js

@@ -185,7 +185,7 @@ var DiscountModule = class extends import_BaseModule.BaseModule {
   async destroy() {
     this.store.discountList = [];
     this.core.effects.offByModuleDestroy(this.name);
-    await this.core.effects.emit(`${this.name}:onDestroy`, {});
+    await this.core.effects.emit(import_types.DiscountHooks.OnDestroy, {});
     console.log("[Discount] 已销毁");
   }
   async clear() {

package/lib/modules/Guests/index.js

@@ -41,8 +41,8 @@ var GuestListModule = class extends import_BaseModule.BaseModule {
   }
   async addGuest(guest) {
     this.state.list.push(guest);
-    await this.core.effects.emit(`${this.name}:onGuestAdd`, guest);
-    await this.core.effects.emit(`${this.name}:onGuestChange`, this.state.list);
+    await this.core.effects.emit(import_types.GuestHooks.OnGuestAdd, guest);
+    await this.core.effects.emit(import_types.GuestHooks.OnGuestChange, this.state.list);
   }
   async updateGuest(id, updates) {
     const index = this.state.list.findIndex((g) => g.id === id);
@@ -56,15 +56,15 @@ var GuestListModule = class extends import_BaseModule.BaseModule {
       import_types.GuestHooks.OnGuestUpdate,
       this.state.list[index]
     );
-    await this.core.effects.emit(`${this.name}:onGuestChange`, this.state.list);
+    await this.core.effects.emit(import_types.GuestHooks.OnGuestChange, this.state.list);
   }
   async removeGuest(id) {
     const index = this.state.list.findIndex((g) => g.id === id);
     if (index === -1)
       return;
     const [removed] = this.state.list.splice(index, 1);
-    await this.core.effects.emit(`${this.name}:onGuestRemove`, removed);
-    await this.core.effects.emit(`${this.name}:onGuestChange`, this.state.list);
+    await this.core.effects.emit(import_types.GuestHooks.OnGuestRemove, removed);
+    await this.core.effects.emit(import_types.GuestHooks.OnGuestChange, this.state.list);
   }
   async getGuests() {
     return this.state.list;
@@ -77,8 +77,8 @@ var GuestListModule = class extends import_BaseModule.BaseModule {
     if (!guest)
       return;
     guest.items.push(item);
-    await this.core.effects.emit(`${this.name}:onGuestUpdate`, guest);
-    await this.core.effects.emit(`${this.name}:onGuestChange`, this.state.list);
+    await this.core.effects.emit(import_types.GuestHooks.OnGuestUpdate, guest);
+    await this.core.effects.emit(import_types.GuestHooks.OnGuestChange, this.state.list);
   }
   async removeItemFromGuest(guestId, itemId) {
     const guest = this.state.list.find((g) => g.id === guestId);
@@ -88,8 +88,8 @@ var GuestListModule = class extends import_BaseModule.BaseModule {
     if (index === -1)
       return;
     guest.items.splice(index, 1);
-    await this.core.effects.emit(`${this.name}:onGuestUpdate`, guest);
-    await this.core.effects.emit(`${this.name}:onGuestChange`, this.state.list);
+    await this.core.effects.emit(import_types.GuestHooks.OnGuestUpdate, guest);
+    await this.core.effects.emit(import_types.GuestHooks.OnGuestChange, this.state.list);
   }
 };
 // Annotate the CommonJS export names for ESM import in node:

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

@@ -1,27 +1,14 @@
 import { Module, PisellCore, ModuleOptions } from '../../types';
 import { BaseModule } from '../BaseModule';
-import { OrderModuleAPI, CommitOrderParams, CheckoutOrderParams } from './types';
+import { OrderModuleAPI, CommitOrderParams } from './types';
 import { CartItem } from '../Cart/types';
 export declare class OrderModule extends BaseModule implements Module, OrderModuleAPI {
     protected defaultName: string;
     protected defaultVersion: string;
     private store;
     private request;
-    private logger;
     constructor(name?: string, version?: string);
     initialize(core: PisellCore, options: ModuleOptions): Promise<void>;
-    /**
-     * 记录信息日志
-     */
-    private logInfo;
-    /**
-     * 记录警告日志
-     */
-    private logWarning;
-    /**
-     * 记录错误日志
-     */
-    private logError;
     createOrder(params: CommitOrderParams['query']): {
         type: "virtual" | "appointment_booking";
         platform: string;
@@ -39,15 +26,4 @@ export declare class OrderModule extends BaseModule implements Module, OrderModu
         type: 'holder' | 'account';
     }): boolean;
     submitOrder(order: CommitOrderParams): Promise<void>;
-    /**
-     * Checkout 专用：创建订单到后端
-     *
-     * 专门为 Checkout 模块设计的订单创建方法，
-     * 直接调用 /order/checkout 接口创建订单
-     * 接收已经处理好的订单数据，无需再处理购物车
-     *
-     * @param params Checkout 订单参数（已处理的订单数据）
-     * @returns 后端返回的订单数据（包含订单ID等）
-     */
-    createOrderByCheckout(params: CheckoutOrderParams): Promise<any>;
 }

package/lib/modules/Order/index.js

@@ -1,8 +1,6 @@
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -16,14 +14,6 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/modules/Order/index.ts
@@ -35,11 +25,9 @@ module.exports = __toCommonJS(Order_exports);
 var import_BaseModule = require("../BaseModule");
 var import_utils = require("./utils");
 var import_utils2 = require("../Product/utils");
-var import_dayjs = __toESM(require("dayjs"));
 var OrderModule = class extends import_BaseModule.BaseModule {
-  // LoggerManager 实例
   constructor(name, version) {
-    super(name || "order", version);
+    super(name, version);
     this.defaultName = "order";
     this.defaultVersion = "1.0.0";
   }
@@ -47,49 +35,6 @@ var OrderModule = class extends import_BaseModule.BaseModule {
     this.core = core;
     this.store = options.store;
     this.request = this.core.getPlugin("request");
-    const appPlugin = this.core.getPlugin("app");
-    if (!appPlugin) {
-      throw new Error("Order 模块需要 app 插件支持");
-    }
-    const app = appPlugin.getApp();
-    this.logger = app.logger;
-    this.logInfo("OrderModule initialized successfully");
-  }
-  /**
-   * 记录信息日志
-   */
-  logInfo(title, metadata) {
-    if (this.logger) {
-      this.logger.addLog({
-        type: "info",
-        title: `[OrderModule] ${title}`,
-        metadata: metadata || {}
-      });
-    }
-  }
-  /**
-   * 记录警告日志
-   */
-  logWarning(title, metadata) {
-    if (this.logger) {
-      this.logger.addLog({
-        type: "warning",
-        title: `[OrderModule] ${title}`,
-        metadata: metadata || {}
-      });
-    }
-  }
-  /**
-   * 记录错误日志
-   */
-  logError(title, metadata) {
-    if (this.logger) {
-      this.logger.addLog({
-        type: "error",
-        title: `[OrderModule] ${title}`,
-        metadata: metadata || {}
-      });
-    }
   }
   createOrder(params) {
     var _a;
@@ -146,11 +91,6 @@ var OrderModule = class extends import_BaseModule.BaseModule {
     return order;
   }
   checkBeforeSubmitOrder(params) {
-    var _a;
-    this.logInfo("checkBeforeSubmitOrder called", {
-      cartItemsCount: ((_a = params.cartItems) == null ? void 0 : _a.length) || 0,
-      type: params.type
-    });
     const { cartItems, type } = params;
     if (type === "holder") {
       const hasNoHolderId = cartItems.some((item) => !item.holder_id);
@@ -161,136 +101,11 @@ var OrderModule = class extends import_BaseModule.BaseModule {
     return true;
   }
   async submitOrder(order) {
-    var _a, _b, _c;
-    this.logInfo("submitOrder called", {
-      url: order.url,
-      orderType: order.query.type,
-      platform: order.query.platform,
-      cartItemsCount: ((_a = order.query.cartItems) == null ? void 0 : _a.length) || 0
-    });
     const { url, query } = order;
     const fetchUrl = url || "/order/appointment";
     const params = this.createOrder(query);
-    this.logInfo("Calling backend order API", {
-      url: fetchUrl,
-      orderType: params.type,
-      platform: params.platform,
-      isDeposit: params.is_deposit,
-      bookingsCount: ((_b = params.bookings) == null ? void 0 : _b.length) || 0,
-      relationProductsCount: ((_c = params.relation_products) == null ? void 0 : _c.length) || 0,
-      scheduleDate: params.schedule_date
-    });
     return this.request.post(fetchUrl, params);
   }
-  /**
-   * Checkout 专用：创建订单到后端
-   * 
-   * 专门为 Checkout 模块设计的订单创建方法，
-   * 直接调用 /order/checkout 接口创建订单
-   * 接收已经处理好的订单数据，无需再处理购物车
-   * 
-   * @param params Checkout 订单参数（已处理的订单数据）
-   * @returns 后端返回的订单数据（包含订单ID等）
-   */
-  async createOrderByCheckout(params) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q;
-    this.logInfo("createOrderByCheckout called", {
-      type: params.type,
-      platform: params.platform,
-      is_deposit: params.is_deposit,
-      customer_id: params.customer_id,
-      bookingsCount: ((_a = params.bookings) == null ? void 0 : _a.length) || 0,
-      relationProductsCount: ((_b = params.relation_products) == null ? void 0 : _b.length) || 0,
-      paymentsCount: ((_c = params.payments) == null ? void 0 : _c.length) || 0,
-      depositAmount: params.deposit_amount,
-      productTaxFee: params.product_tax_fee,
-      note: params.note,
-      scheduleDate: params.schedule_date,
-      hasOrderId: !!params.order_id,
-      orderIdIncluded: params.order_id,
-      paymentMethods: ((_d = params.payments) == null ? void 0 : _d.map((p) => p.code)) || []
-    });
-    console.log("[Order] createOrderByCheckout 开始创建订单:", {
-      type: params.type,
-      platform: params.platform,
-      is_deposit: params.is_deposit,
-      customer_id: params.customer_id,
-      bookingsCount: ((_e = params.bookings) == null ? void 0 : _e.length) || 0,
-      relationProductsCount: ((_f = params.relation_products) == null ? void 0 : _f.length) || 0,
-      paymentsCount: ((_g = params.payments) == null ? void 0 : _g.length) || 0
-    });
-    try {
-      const orderData = {
-        sales_channel: "my_pisel",
-        order_sales_channel: "online_store",
-        shop_note: "",
-        schedule_date: "",
-        is_deposit: 0,
-        bookings: [],
-        relation_products: [],
-        relation_forms: [],
-        payments: [],
-        is_full_overwrite_flag: 1,
-        ...params
-        // 使用传入的参数覆盖默认值
-      };
-      if ((_h = orderData.payments) == null ? void 0 : _h.length) {
-        orderData.small_ticket_data_flag = 1;
-      }
-      if (!params.order_id && !orderData.schedule_date) {
-        orderData.schedule_date = (0, import_dayjs.default)().format("YYYY-MM-DD HH:mm:ss");
-      }
-      console.log("[Order] 调用后端接口创建订单:", {
-        url: "/order/checkout",
-        orderType: orderData.type,
-        platform: orderData.platform,
-        isDeposit: orderData.is_deposit,
-        customerId: orderData.customer_id,
-        bookingsCount: ((_i = orderData.bookings) == null ? void 0 : _i.length) || 0,
-        relationProductsCount: ((_j = orderData.relation_products) == null ? void 0 : _j.length) || 0,
-        paymentsCount: ((_k = orderData.payments) == null ? void 0 : _k.length) || 0,
-        paymentsMethods: ((_l = orderData.payments) == null ? void 0 : _l.map((p) => p.code)) || []
-      });
-      this.logInfo("Calling backend checkout API", {
-        url: "/order/checkout",
-        orderType: orderData.type,
-        platform: orderData.platform,
-        isDeposit: orderData.is_deposit,
-        customerId: orderData.customer_id,
-        depositAmount: orderData.deposit_amount,
-        bookingsCount: ((_m = orderData.bookings) == null ? void 0 : _m.length) || 0,
-        relationProductsCount: ((_n = orderData.relation_products) == null ? void 0 : _n.length) || 0,
-        paymentsCount: ((_o = orderData.payments) == null ? void 0 : _o.length) || 0,
-        paymentMethods: ((_p = orderData.payments) == null ? void 0 : _p.map((p) => ({
-          code: p.code,
-          amount: p.amount,
-          type: p.type,
-          hasVoucherId: !!p.voucher_id,
-          orderPaymentType: p.order_payment_type
-        }))) || [],
-        productTaxFee: orderData.product_tax_fee,
-        note: orderData.note,
-        scheduleDate: orderData.schedule_date,
-        hasOrderId: !!orderData.order_id,
-        smallTicketDataFlag: orderData.small_ticket_data_flag
-      });
-      const response = await this.request.post("/order/checkout", orderData);
-      this.logInfo("Order API called successfully", {
-        response
-      });
-      console.log("[Order] 订单创建成功，后端响应:", {
-        success: !!response,
-        hasOrderId: !!(((_q = response == null ? void 0 : response.data) == null ? void 0 : _q.order_id) || (response == null ? void 0 : response.order_id))
-      });
-      return response;
-    } catch (error) {
-      console.error("[Order] createOrderByCheckout 创建订单失败:", error);
-      this.logInfo("Order API called failed", {
-        error: error instanceof Error ? error.message : String(error)
-      });
-      throw error;
-    }
-  }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

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

@@ -19,45 +19,6 @@ export interface CommitOrderParams {
         extraData?: Record<string, any>;
     };
 }
-/**
- * 支付项数据
- */
-export interface PaymentItemData {
-    /** 当前支付项的唯一 ID */
-    uuid: string;
-    /** 当前支付方式付出去多少钱 */
-    amount: string;
-    /** 支付类型代码 */
-    code: string;
-    /** 支付类型id */
-    id: number;
-    /** 支付类型名称 */
-    name: string;
-    /** 支付类型 */
-    type: string;
-    /** 是否已同步到后端 */
-    isSynced?: boolean;
-}
-/**
- * Checkout 专用订单创建参数
- */
-export interface CheckoutOrderParams {
-    type: 'virtual' | 'appointment_booking';
-    platform: 'PC' | 'H5';
-    sales_channel?: string;
-    order_sales_channel?: string;
-    bookings?: any[];
-    shop_note?: string;
-    schedule_date?: string;
-    is_deposit?: number;
-    relation_products?: any[];
-    relation_forms?: any[];
-    payments?: PaymentItemData[];
-    customer_id?: string;
-    /** 小票数据标记，当有支付项时设置为1 */
-    small_ticket_data_flag?: number;
-    [key: string]: any;
-}
 /**
  * 订单模块 API
  */
@@ -80,10 +41,4 @@ export interface OrderModuleAPI {
      * @param params 订单信息
      */
     submitOrder: (params: CommitOrderParams) => Promise<void>;
-    /**
-     * Checkout 专用：创建订单到后端
-     * @param params 订单参数
-     * @returns 后端返回的订单数据
-     */
-    createOrderByCheckout: (params: CheckoutOrderParams) => Promise<any>;
 }

package/lib/modules/Order/utils.js

@@ -60,7 +60,7 @@ var getAllDiscountList = (cartItem) => {
   var _a, _b, _c, _d;
   let discountList = ((_b = (_a = cartItem == null ? void 0 : cartItem._origin) == null ? void 0 : _a.product) == null ? void 0 : _b.discount_list) || [];
   (((_d = (_c = cartItem == null ? void 0 : cartItem._origin) == null ? void 0 : _c.product) == null ? void 0 : _d.product_bundle) || []).forEach((item) => {
-    discountList = [...discountList, ...(item == null ? void 0 : item.discount_list) || []];
+    discountList = [...discountList, ...item.discount_list || []];
     item.discount_list = void 0;
   });
   return discountList;

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

@@ -1,191 +1,16 @@
 import { Module, PisellCore, ModuleOptions } from '../../types';
-import { RequestPlugin } from '../../plugins';
 import { BaseModule } from '../BaseModule';
-import { PaymentModuleAPI, PaymentMethod, PaymentOrder, PaymentItem, PaymentItemInput, PaymentUpdateFields, PushOrderParams, CashPayment, EftposPayment, WalletPassPayment, RoundingRule, RoundingInterval, RoundingResult } from './types';
-export * from './types';
-export { generateRequestUniqueId };
-/**
- * 生成请求唯一ID
- * 格式: 年月日时分秒毫秒+4位随机数
- * 示例: 20241201143025123456
- */
-declare function generateRequestUniqueId(): string;
-/**
- * 支付模块实现
- *
- * 负责处理支付相关的数据管理和本地存储
- */
+import { Payment, PaymentModuleAPI, PaymentMethod, PaymentStatus } from './types';
 export declare class PaymentModule extends BaseModule implements Module, PaymentModuleAPI {
     protected defaultName: string;
     protected defaultVersion: string;
-    request: RequestPlugin;
-    private app;
-    private store;
-    private dbManager;
-    private logger;
-    protected otherParams: any;
-    cash: CashPayment;
-    eftpos: EftposPayment;
-    wallet: WalletPassPayment;
+    private state;
     constructor(name?: string, version?: string);
-    initialize(core: PisellCore, options: ModuleOptions): Promise<void>;
-    /**
-     * 记录信息日志
-     */
-    logInfo(title: string, metadata?: any): void;
-    /**
-     * 记录警告日志
-     */
-    logWarning(title: string, metadata?: any): void;
-    /**
-     * 记录错误日志
-     */
-    logError(title: string, error?: any, metadata?: any): void;
-    /**
-     * 记录调试日志
-     */
-    logDebug(title: string, metadata?: any): void;
-    /**
-     * 网络恢复以后，尝试执行队列
-     *
-     */
-    private registerNetworkHandlers;
-    /**
-     * 获取支付方式列表
-     */
-    getPayMethodListAsync(): Promise<PaymentMethod[]>;
-    /**
-     * 后台刷新支付方式列表
-     */
-    private refreshPaymentMethodsInBackground;
-    /**
-     * 检查支付方式列表是否有变化
-     */
-    private hasPaymentMethodsChanged;
-    /**
-     * 获取订单列表
-     */
-    getOrderListAsync(): Promise<PaymentOrder[]>;
-    /**
-     * 根据订单UUID获取支付订单（新方法）
-     */
-    getPaymentOrderByUuidAsync(orderUuid: string): Promise<PaymentOrder | null>;
-    /**
-     * 创建支付订单（新方法，专注支付数据）
-     */
-    createPaymentOrderAsync(params: PushOrderParams): Promise<PaymentOrder>;
-    /**
-     * 删除支付订单（新方法）
-     */
-    deletePaymentOrderAsync(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>;
-    /**
-     * 获取支付项（新方法）
-     *
-     * @param orderUuid 订单UUID
-     * @param includeVoided 是否包含已撤销的支付项，默认为false
-     * @returns 支付项数组
-     */
-    getPaymentItemsAsync(orderUuid: string, includeVoided?: boolean): Promise<PaymentItem[]>;
-    /**
-     * 获取所有支付项（包括已撤销的）
-     *
-     * @param orderUuid 订单UUID
-     * @returns 所有支付项数组（包括撤销的）
-     */
-    getAllPaymentItemsAsync(orderUuid: string): Promise<PaymentItem[]>;
-    /**
-     * 为某个订单添加支付项（新方法）
-     */
-    addPaymentItemAsync(orderUuid: string, paymentItem: PaymentItemInput): Promise<void>;
-    /**
-     * 删除一个支付项 - 标记删除而非物理删除
-     */
-    deletePaymentAsync(orderUuid: string, paymentUuid: string): Promise<void>;
-    /**
-     * 批量更新代金券类支付项（覆盖更新）
-     *
-     * 删除所有现有的带 voucher_id 的支付项，然后添加新的代金券支付项
-     * 这是一个覆盖式更新，确保代金券支付项的一致性
-     */
-    updateVoucherPaymentItemsAsync(orderUuid: string, voucherPaymentItems: PaymentItemInput[]): Promise<void>;
-    /**
-     * 更新一个支付项
-     */
-    updatePaymentAsync(orderUuid: string, paymentUuid: string, params: PaymentUpdateFields): Promise<void>;
-    /**
-     * 提交支付
-     */
-    submitPayAsync(orderUuid?: string): Promise<{
-        status: 'success' | 'failed';
-    }>;
-    /**
-     * 提交单个订单的支付（推送到任务队列）
-     */
-    private submitSingleOrderPayment;
-    /**
-     * 获取订单剩余待付金额
-     */
-    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 ensurePaymentTables;
-    /**
-     * 获取部分支付的订单
-     */
-    getPartiallyPaidOrdersAsync(): Promise<PaymentOrder[]>;
-    /**
-     * 智能金额舍入
-     *
-     * 根据指定的舍入间隔和规则对金额进行舍入处理
-     *
-     * @param originalAmount 原始金额
-     * @param interval 舍入间隔 (0.05, 0.1, 0.5, 1)
-     * @param rule 舍入规则 (standard, standard_down, always_up, always_down)
-     * @returns 舍入结果详情（包含原始金额、舍入后金额和舍入差额）
-     */
-    roundAmountAsync(originalAmount: number | string, interval: RoundingInterval | number, rule: RoundingRule | string): Promise<RoundingResult>;
-    /**
-     * 标准舍入处理（处理中点情况）
-     *
-     * @param value 要舍入的值
-     * @param midpointUp 中点是否向上舍入
-     * @returns 舍入后的值
-     */
-    private standardRound;
+    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>;
 }