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";
import { PaymentProviderDataInput } from "../types/payment-collection";
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 | typeof BasePaymentService;
};
/**
 * Helps retrieve payment providers
 */
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 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<PaymentSession>;
    createSessionNew(sessionInput: PaymentProviderDataInput): Promise<PaymentSession>;
    /**
     * Refreshes a payment session with the given provider.
     * This means, that we delete the current one and create a new.
     * @param paymentSession - the payment session object to
     *    update
     * @param cart - a cart object used to calculate the amount, etc. from
     * @return the payment session
     */
    refreshSession(paymentSession: PaymentSession, cart: Cart): Promise<PaymentSession>;
    refreshSessionNew(paymentSession: PaymentSession, sessionInput: PaymentProviderDataInput): Promise<PaymentSession>;
    /**
     * Updates an existing payment session.
     * @param paymentSession - the payment session object to
     *    update
     * @param cart - the cart object to update for
     * @return the updated payment session
     */
    updateSession(paymentSession: PaymentSession, cart: Cart): Promise<PaymentSession>;
    updateSessionNew(paymentSession: PaymentSession, sessionInput: PaymentProviderDataInput): 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<TProvider extends AbstractPaymentService | typeof BasePaymentService>(providerId: string): TProvider extends AbstractPaymentService ? AbstractPaymentService : typeof BasePaymentService;
    createPayment(cart: Cart & {
        payment_session: PaymentSession;
    }): Promise<Payment>;
    createPaymentNew(paymentInput: Omit<PaymentProviderDataInput, "customer">): 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>;
    refundFromPayment(payment: Payment, amount: number, reason: string, note?: string): Promise<Refund>;
    retrieveRefund(id: string, config?: FindConfig<Refund>): Promise<Refund | never>;
}
export {};