@medusajs/medusa 1.3.5 → 1.3.6-next.0

package/dist/services/payment-provider.d.ts

@@ -1,67 +1,87 @@
-export default PaymentProviderService;
-declare const PaymentProviderService_base: any;
+import { BasePaymentService } from "medusa-interfaces";
+import { AbstractPaymentService, TransactionBaseService } from "../interfaces";
+import { EntityManager } from "typeorm";
+import { PaymentSessionRepository } from "../repositories/payment-session";
+import { PaymentRepository } from "../repositories/payment";
+import { RefundRepository } from "../repositories/refund";
+import { PaymentProviderRepository } from "../repositories/payment-provider";
+import { FindConfig, Selector } from "../types/common";
+import { Cart, Payment, PaymentProvider, PaymentSession, PaymentSessionStatus, Refund } from "../models";
+declare type PaymentProviderKey = `pp_${string}` | "systemPaymentProviderService";
+declare type InjectedDependencies = {
+    manager: EntityManager;
+    paymentSessionRepository: typeof PaymentSessionRepository;
+    paymentProviderRepository: typeof PaymentProviderRepository;
+    paymentRepository: typeof PaymentRepository;
+    refundRepository: typeof RefundRepository;
+} & {
+    [key in `${PaymentProviderKey}`]: AbstractPaymentService<never> | typeof BasePaymentService;
+};
 /**
- * Helps retrive payment providers
+ * Helps retrieve payment providers
  */
-declare class PaymentProviderService extends PaymentProviderService_base {
-    [x: string]: any;
-    constructor(container: any);
-    /** @private {logger} */
-    private container_;
-    manager_: any;
-    paymentSessionRepository_: any;
-    paymentRepository_: any;
-    refundRepository_: any;
-    withTransaction(manager: any): PaymentProviderService;
-    registerInstalledProviders(providers: any): Promise<void>;
-    list(): Promise<any>;
-    retrievePayment(id: any, relations?: any[]): Promise<any>;
-    listPayments(selector: any, config?: {
-        skip: number;
-        take: number;
-        order: {
-            created_at: string;
-        };
-    }): any;
-    retrieveSession(id: any, relations?: any[]): Promise<any>;
+export default class PaymentProviderService extends TransactionBaseService {
+    protected manager_: EntityManager;
+    protected transactionManager_: EntityManager | undefined;
+    protected readonly container_: InjectedDependencies;
+    protected readonly paymentSessionRepository_: typeof PaymentSessionRepository;
+    protected readonly paymentProviderRepository_: typeof PaymentProviderRepository;
+    protected readonly paymentRepository_: typeof PaymentRepository;
+    protected readonly refundRepository_: typeof RefundRepository;
+    constructor(container: InjectedDependencies);
+    registerInstalledProviders(providerIds: string[]): Promise<void>;
+    list(): Promise<PaymentProvider[]>;
+    retrievePayment(id: string, relations?: string[]): Promise<Payment | never>;
+    listPayments(selector: Selector<Payment>, config?: FindConfig<Payment>): Promise<Payment[]>;
+    retrieveSession(id: string, relations?: string[]): Promise<PaymentSession | never>;
     /**
      * Creates a payment session with the given provider.
-     * @param {string} providerId - the id of the provider to create payment with
-     * @param {Cart} cart - a cart object used to calculate the amount, etc. from
-     * @return {Promise} the payment session
+     * @param providerId - the id of the provider to create payment with
+     * @param cart - a cart object used to calculate the amount, etc. from
+     * @return the payment session
      */
-    createSession(providerId: string, cart: Cart): Promise<any>;
+    createSession(providerId: string, cart: Cart): Promise<PaymentSession>;
     /**
      * Refreshes a payment session with the given provider.
      * This means, that we delete the current one and create a new.
-     * @param {PaymentSession} paymentSession - the payment session object to
+     * @param paymentSession - the payment session object to
      *    update
-     * @param {Cart} cart - a cart object used to calculate the amount, etc. from
-     * @return {Promise} the payment session
+     * @param cart - a cart object used to calculate the amount, etc. from
+     * @return the payment session
      */
-    refreshSession(paymentSession: PaymentSession, cart: Cart): Promise<any>;
+    refreshSession(paymentSession: PaymentSession, cart: Cart): Promise<PaymentSession>;
     /**
      * Updates an existing payment session.
-     * @param {PaymentSession} paymentSession - the payment session object to
+     * @param paymentSession - the payment session object to
      *    update
-     * @param {Cart} cart - the cart object to update for
-     * @return {Promise} the updated payment session
+     * @param cart - the cart object to update for
+     * @return the updated payment session
      */
-    updateSession(paymentSession: PaymentSession, cart: Cart): Promise<any>;
-    deleteSession(paymentSession: any): any;
+    updateSession(paymentSession: PaymentSession, cart: Cart): Promise<PaymentSession>;
+    deleteSession(paymentSession: PaymentSession): Promise<PaymentSession | undefined>;
     /**
      * Finds a provider given an id
      * @param {string} providerId - the id of the provider to get
      * @return {PaymentService} the payment provider
      */
-    retrieveProvider(providerId: string): PaymentService;
-    createPayment(cart: any): Promise<any>;
-    updatePayment(paymentId: any, update: any): Promise<any>;
-    authorizePayment(paymentSession: any, context: any): Promise<any>;
-    updateSessionData(paySession: any, update: any): Promise<any>;
-    cancelPayment(paymentObj: any): Promise<any>;
-    getStatus(payment: any): Promise<any>;
-    capturePayment(paymentObj: any): Promise<any>;
-    refundPayment(payObjs: any, amount: any, reason: any, note: any): Promise<any>;
-    retrieveRefund(id: any, config?: {}): Promise<any>;
+    retrieveProvider<TProvider extends AbstractPaymentService<never> | typeof BasePaymentService>(providerId: string): TProvider extends AbstractPaymentService<never> ? AbstractPaymentService<never> : typeof BasePaymentService;
+    createPayment(cart: Cart & {
+        payment_session: PaymentSession;
+    }): Promise<Payment>;
+    updatePayment(paymentId: string, data: {
+        order_id?: string;
+        swap_id?: string;
+    }): Promise<Payment>;
+    authorizePayment(paymentSession: PaymentSession, context: Record<string, unknown>): Promise<PaymentSession | undefined>;
+    updateSessionData(paymentSession: PaymentSession, data: Record<string, unknown>): Promise<PaymentSession>;
+    cancelPayment(paymentObj: Partial<Payment> & {
+        id: string;
+    }): Promise<Payment>;
+    getStatus(payment: Payment): Promise<PaymentSessionStatus>;
+    capturePayment(paymentObj: Partial<Payment> & {
+        id: string;
+    }): Promise<Payment>;
+    refundPayment(payObjs: Payment[], amount: number, reason: string, note?: string): Promise<Refund>;
+    retrieveRefund(id: string, config?: FindConfig<Refund>): Promise<Refund | never>;
 }
+export {};