import { Token, TokenAmount } from "../Tokens";
import { SerializedTokenAmount } from "../Tokens/TokenAmount";
import { ChainId } from "../constants";
import { Wallet } from "../wallet";
export interface PaymentRequestData {
    id: number;
    payer: string;
    payee: string;
    amount: TokenAmount;
    totalAmount: TokenAmount;
}
export interface PaymentRequestPayload {
    rid: number;
    payer: string;
    payee: string;
    token: string;
    total: string;
    amount: string;
    deadline?: string;
    metadata?: Record<string, any>;
    requested_on: string;
    chain: ChainId;
}
export interface PaymentRequestDto {
    payee: string;
    payer: string;
    token: string;
    total: string;
    deadline?: number;
    metadata?: Record<string, any>;
}
export interface SerializedPaymentRequest {
    _type: "PaymentRequest";
    rid: number;
    payer: string;
    payee: string;
    amount: SerializedTokenAmount;
    totalAmount: SerializedTokenAmount;
    metadata: Record<string, any>;
    requestedOn: string;
    fulfilledOn: string;
    deadline: string;
}
/**
 * Class representation of a Payment request.  Facilitates queries and fulfillment
 */
export declare class PaymentRequest<MetaDataShape extends Record<string, any> = Record<string, any>> {
    private id;
    private payer;
    private payee;
    private amount;
    private totalAmount;
    private _metadata?;
    private _requestedOn?;
    private _fulfilledOn?;
    private _deadline?;
    private onFulfill?;
    constructor(id: number, payer: string, payee: string, amount: TokenAmount, totalAmount: TokenAmount, _metadata?: MetaDataShape | undefined, _requestedOn?: Date | undefined, _fulfilledOn?: Date | undefined, _deadline?: Date | undefined);
    /**
     * Basic info on the given payment request
     */
    get info(): PaymentRequestData;
    /**
     * Custom metadata as defined in the request origination.  Shape influences Payment request.
     */
    get metadata(): MetaDataShape | undefined;
    get deadline(): Date | undefined;
    get requestedOn(): Date | undefined;
    get fulfilledOn(): Date | undefined;
    /**
     *
     * @param field Field to access
     * @returns corresponding value in the metadata
     */
    get(field: keyof MetaDataShape): MetaDataShape[keyof MetaDataShape] | undefined;
    setOnFulfillCallback(f: (req?: PaymentRequest) => unknown): void;
    /**
     *
     * @param transactionHash Hash where payment was sen
     * @returns Receipt of payment being counted in the wallet service
     */
    fulfill(transactionHash: string): Promise<{
        request: PaymentRequest<MetaDataShape>;
        receipt: {
            amountCredited: TokenAmount;
            isFullyRepaid: boolean;
            hash: string;
            rid: number;
            time: number;
        };
    }>;
    static isSerializedPaymentRequest: (obj?: any) => obj is SerializedPaymentRequest;
    static parseJson: ({ rid, payer, payee, amount, totalAmount, deadline, metadata, fulfilledOn, requestedOn, }: SerializedPaymentRequest) => PaymentRequest<Record<string, any>>;
    toJSON: () => {
        _type: string;
        rid: number;
        payer: string;
        payee: string;
        amount: string;
        totalAmount: string;
        metadata: string;
        requestedOn: string;
        fulfilledOn: string;
        deadline: string;
    };
    /**
     *
     * @param json JSON-representation to serialize
     * @param getToken method to fetch a token given a token address
     * @returns PaymenRequest object populated with fields from json
     */
    static deserialize<MetaDataShape extends Record<string, any> = Record<string, any>>(json: PaymentRequestPayload, getToken: (address: string) => Token): PaymentRequest<MetaDataShape>;
    /**
     *
     * @param id ID of payment request to fetch
     * @param getToken Helper method to fetch a token given its address
     * @param apiKey Optional api key
     * @returns PaymentRequest object of corresponding ID
     */
    static fetch<MetaDataShape extends Record<string, any> = Record<string, any>>(id: number, getToken: (adress: string) => Token, apiKey?: string): Promise<PaymentRequest<MetaDataShape>>;
    /**
     *
     * @param payee Address of wallet where payments should be sent
     * @param payer Address of wallet where payments should originate
     * @param amount Token and amount to be request
     * @param signer Wallet object to authorize the request
     * @param opts optionally declare a deadline for the request, or set metadata for the request
     * @param apiKey Optional api key for Node Finance
     * @returns PaymentRequest object of newly-created request
     */
    static create<MetaDataShape extends Record<string, any> = Record<string, any>>(payee: string, payer: string, amount: TokenAmount, signer: Wallet, opts?: {
        deadline?: Date | number;
        metadata?: MetaDataShape;
    }, apiKey?: string): Promise<PaymentRequest<MetaDataShape>>;
}