import { TAddress } from '../../models/TAddress';
import { TAccount } from '../../models/TAccount';
import { ClientEventsStream, TClientEventsStreamData } from '../../clients/ClientEventsStream';
import { ContractBase } from '../../contracts/ContractBase';
import { TxWriter } from '../../txs/TxWriter';
import { ITxLogItem } from '../../txs/receipt/ITxLogItem';
import { Web3Client } from '../../clients/Web3Client';
import { IBlockchainExplorer } from '../../explorer/IBlockchainExplorer';
import { SubjectStream } from '../../class/SubjectStream';
import type { TAbiItem } from '../../types/TAbi';
import type { TEth } from '../../models/TEth';
import type { TOverrideReturns } from '../../utils/types';
export declare class RefundEscrow extends ContractBase {
    address: TEth.Address;
    client: Web3Client;
    explorer: IBlockchainExplorer;
    constructor(address?: TEth.Address, client?: Web3Client, explorer?: IBlockchainExplorer);
    Types: TRefundEscrowTypes;
    $meta: {
        class: string;
    };
    $constructor(deployer: TSender, beneficiary_: TAddress): Promise<TxWriter>;
    beneficiary(): Promise<TAddress>;
    beneficiaryWithdraw(sender: TSender): Promise<TxWriter>;
    close(sender: TSender): Promise<TxWriter>;
    deposit(sender: TSender, refundee: TAddress): Promise<TxWriter>;
    depositsOf(payee: TAddress): Promise<bigint>;
    enableRefunds(sender: TSender): Promise<TxWriter>;
    owner(): Promise<TAddress>;
    renounceOwnership(sender: TSender): Promise<TxWriter>;
    state(): Promise<number>;
    transferOwnership(sender: TSender, newOwner: TAddress): Promise<TxWriter>;
    withdraw(sender: TSender, payee: TAddress): Promise<TxWriter>;
    withdrawalAllowed(input0: TAddress): Promise<boolean>;
    $call(): IRefundEscrowTxCaller;
    $signed(): TOverrideReturns<IRefundEscrowTxCaller, Promise<{
        signed: TEth.Hex;
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
    }>>;
    $data(): IRefundEscrowTxData;
    $gas(): TOverrideReturns<IRefundEscrowTxCaller, Promise<{
        gas?: bigint;
        price?: bigint;
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
    }>>;
    onTransaction<TMethod extends keyof TRefundEscrowTypes['Methods']>(method: TMethod, options: Parameters<ContractBase['$onTransaction']>[0]): SubjectStream<{
        tx: TEth.Tx;
        block: TEth.Block<TEth.Hex>;
        calldata: {
            method: TMethod;
            arguments: TRefundEscrowTypes['Methods'][TMethod]['arguments'];
        };
    }>;
    onLog(event: keyof TEvents, cb?: (event: TClientEventsStreamData) => void): ClientEventsStream<TClientEventsStreamData>;
    getPastLogs<TEventName extends keyof TEvents>(events: TEventName[], options?: TEventLogOptions<TEventParams<TEventName>>): Promise<ITxLogItem<TEventParams<TEventName>, TEventName>[]>;
    getPastLogs<TEventName extends keyof TEvents>(event: TEventName, options?: TEventLogOptions<TEventParams<TEventName>>): Promise<ITxLogItem<TEventParams<TEventName>, TEventName>[]>;
    onDeposited(fn?: (event: TClientEventsStreamData<TEventArguments<'Deposited'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'Deposited'>>>;
    onOwnershipTransferred(fn?: (event: TClientEventsStreamData<TEventArguments<'OwnershipTransferred'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'OwnershipTransferred'>>>;
    onRefundsClosed(fn?: (event: TClientEventsStreamData<TEventArguments<'RefundsClosed'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'RefundsClosed'>>>;
    onRefundsEnabled(fn?: (event: TClientEventsStreamData<TEventArguments<'RefundsEnabled'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'RefundsEnabled'>>>;
    onWithdrawn(fn?: (event: TClientEventsStreamData<TEventArguments<'Withdrawn'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'Withdrawn'>>>;
    extractLogsDeposited(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'Deposited'>>[];
    extractLogsOwnershipTransferred(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'OwnershipTransferred'>>[];
    extractLogsRefundsClosed(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'RefundsClosed'>>[];
    extractLogsRefundsEnabled(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'RefundsEnabled'>>[];
    extractLogsWithdrawn(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'Withdrawn'>>[];
    getPastLogsDeposited(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            payee?: TAddress;
        };
    }): Promise<ITxLogItem<TEventParams<'Deposited'>>[]>;
    getPastLogsOwnershipTransferred(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            previousOwner?: TAddress;
            newOwner?: TAddress;
        };
    }): Promise<ITxLogItem<TEventParams<'OwnershipTransferred'>>[]>;
    getPastLogsRefundsClosed(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {};
    }): Promise<ITxLogItem<TEventParams<'RefundsClosed'>>[]>;
    getPastLogsRefundsEnabled(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {};
    }): Promise<ITxLogItem<TEventParams<'RefundsEnabled'>>[]>;
    getPastLogsWithdrawn(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            payee?: TAddress;
        };
    }): Promise<ITxLogItem<TEventParams<'Withdrawn'>>[]>;
    abi: TAbiItem[];
}
type TSender = TAccount & {
    value?: string | number | bigint;
};
type TEventLogOptions<TParams> = {
    fromBlock?: number | Date;
    toBlock?: number | Date;
    params?: TParams;
};
export type TRefundEscrowTypes = {
    Events: {
        Deposited: {
            outputParams: {
                payee: TAddress;
                weiAmount: bigint;
            };
            outputArgs: [payee: TAddress, weiAmount: bigint];
        };
        OwnershipTransferred: {
            outputParams: {
                previousOwner: TAddress;
                newOwner: TAddress;
            };
            outputArgs: [previousOwner: TAddress, newOwner: TAddress];
        };
        RefundsClosed: {
            outputParams: {};
            outputArgs: [];
        };
        RefundsEnabled: {
            outputParams: {};
            outputArgs: [];
        };
        Withdrawn: {
            outputParams: {
                payee: TAddress;
                weiAmount: bigint;
            };
            outputArgs: [payee: TAddress, weiAmount: bigint];
        };
    };
    Methods: {
        beneficiary: {
            method: "beneficiary";
            arguments: [];
        };
        beneficiaryWithdraw: {
            method: "beneficiaryWithdraw";
            arguments: [];
        };
        close: {
            method: "close";
            arguments: [];
        };
        deposit: {
            method: "deposit";
            arguments: [refundee: TAddress];
        };
        depositsOf: {
            method: "depositsOf";
            arguments: [payee: TAddress];
        };
        enableRefunds: {
            method: "enableRefunds";
            arguments: [];
        };
        owner: {
            method: "owner";
            arguments: [];
        };
        renounceOwnership: {
            method: "renounceOwnership";
            arguments: [];
        };
        state: {
            method: "state";
            arguments: [];
        };
        transferOwnership: {
            method: "transferOwnership";
            arguments: [newOwner: TAddress];
        };
        withdraw: {
            method: "withdraw";
            arguments: [payee: TAddress];
        };
        withdrawalAllowed: {
            method: "withdrawalAllowed";
            arguments: [input0: TAddress];
        };
    };
};
interface IRefundEscrowTxCaller {
    beneficiaryWithdraw(sender: TSender): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    close(sender: TSender): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    deposit(sender: TSender, refundee: TAddress): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    enableRefunds(sender: TSender): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    renounceOwnership(sender: TSender): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    transferOwnership(sender: TSender, newOwner: TAddress): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    withdraw(sender: TSender, payee: TAddress): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
}
interface IRefundEscrowTxData {
    beneficiaryWithdraw(sender: TSender): Promise<TEth.TxLike>;
    close(sender: TSender): Promise<TEth.TxLike>;
    deposit(sender: TSender, refundee: TAddress): Promise<TEth.TxLike>;
    enableRefunds(sender: TSender): Promise<TEth.TxLike>;
    renounceOwnership(sender: TSender): Promise<TEth.TxLike>;
    transferOwnership(sender: TSender, newOwner: TAddress): Promise<TEth.TxLike>;
    withdraw(sender: TSender, payee: TAddress): Promise<TEth.TxLike>;
}
type TEvents = TRefundEscrowTypes['Events'];
type TEventParams<TEventName extends keyof TEvents> = Partial<TEvents[TEventName]['outputParams']>;
type TEventArguments<TEventName extends keyof TEvents> = Partial<TEvents[TEventName]['outputArgs']>;
export {};