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 PaymentSplitter extends ContractBase {
    address: TEth.Address;
    client: Web3Client;
    explorer: IBlockchainExplorer;
    constructor(address?: TEth.Address, client?: Web3Client, explorer?: IBlockchainExplorer);
    Types: TPaymentSplitterTypes;
    $meta: {
        class: string;
    };
    $constructor(deployer: TSender, payees: TAddress[], shares_: bigint[]): Promise<TxWriter>;
    payee(index: bigint): Promise<TAddress>;
    releasable(account: TAddress): Promise<bigint>;
    releasable(token: TAddress, account: TAddress): Promise<bigint>;
    release(sender: TSender, account: TAddress): Promise<TxWriter>;
    release(sender: TSender, token: TAddress, account: TAddress): Promise<TxWriter>;
    released(token: TAddress, account: TAddress): Promise<bigint>;
    released(account: TAddress): Promise<bigint>;
    shares(account: TAddress): Promise<bigint>;
    totalReleased(token: TAddress): Promise<bigint>;
    totalReleased(): Promise<bigint>;
    totalShares(): Promise<bigint>;
    $call(): IPaymentSplitterTxCaller;
    $signed(): TOverrideReturns<IPaymentSplitterTxCaller, Promise<{
        signed: TEth.Hex;
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
    }>>;
    $data(): IPaymentSplitterTxData;
    $gas(): TOverrideReturns<IPaymentSplitterTxCaller, Promise<{
        gas?: bigint;
        price?: bigint;
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
    }>>;
    onTransaction<TMethod extends keyof TPaymentSplitterTypes['Methods']>(method: TMethod, options: Parameters<ContractBase['$onTransaction']>[0]): SubjectStream<{
        tx: TEth.Tx;
        block: TEth.Block<TEth.Hex>;
        calldata: {
            method: TMethod;
            arguments: TPaymentSplitterTypes['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>[]>;
    onERC20PaymentReleased(fn?: (event: TClientEventsStreamData<TEventArguments<'ERC20PaymentReleased'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'ERC20PaymentReleased'>>>;
    onPayeeAdded(fn?: (event: TClientEventsStreamData<TEventArguments<'PayeeAdded'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'PayeeAdded'>>>;
    onPaymentReceived(fn?: (event: TClientEventsStreamData<TEventArguments<'PaymentReceived'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'PaymentReceived'>>>;
    onPaymentReleased(fn?: (event: TClientEventsStreamData<TEventArguments<'PaymentReleased'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'PaymentReleased'>>>;
    extractLogsERC20PaymentReleased(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'ERC20PaymentReleased'>>[];
    extractLogsPayeeAdded(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'PayeeAdded'>>[];
    extractLogsPaymentReceived(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'PaymentReceived'>>[];
    extractLogsPaymentReleased(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'PaymentReleased'>>[];
    getPastLogsERC20PaymentReleased(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            token?: TAddress;
        };
    }): Promise<ITxLogItem<TEventParams<'ERC20PaymentReleased'>>[]>;
    getPastLogsPayeeAdded(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {};
    }): Promise<ITxLogItem<TEventParams<'PayeeAdded'>>[]>;
    getPastLogsPaymentReceived(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {};
    }): Promise<ITxLogItem<TEventParams<'PaymentReceived'>>[]>;
    getPastLogsPaymentReleased(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {};
    }): Promise<ITxLogItem<TEventParams<'PaymentReleased'>>[]>;
    abi: TAbiItem[];
}
type TSender = TAccount & {
    value?: string | number | bigint;
};
type TEventLogOptions<TParams> = {
    fromBlock?: number | Date;
    toBlock?: number | Date;
    params?: TParams;
};
export type TPaymentSplitterTypes = {
    Events: {
        ERC20PaymentReleased: {
            outputParams: {
                token: TAddress;
                to: TAddress;
                amount: bigint;
            };
            outputArgs: [token: TAddress, to: TAddress, amount: bigint];
        };
        PayeeAdded: {
            outputParams: {
                account: TAddress;
                shares: bigint;
            };
            outputArgs: [account: TAddress, shares: bigint];
        };
        PaymentReceived: {
            outputParams: {
                from: TAddress;
                amount: bigint;
            };
            outputArgs: [from: TAddress, amount: bigint];
        };
        PaymentReleased: {
            outputParams: {
                to: TAddress;
                amount: bigint;
            };
            outputArgs: [to: TAddress, amount: bigint];
        };
    };
    Methods: {
        payee: {
            method: "payee";
            arguments: [index: bigint];
        };
        releasable: {
            method: "releasable";
            arguments: [account: TAddress] | [token: TAddress, account: TAddress];
        };
        release: {
            method: "release";
            arguments: [account: TAddress] | [token: TAddress, account: TAddress];
        };
        released: {
            method: "released";
            arguments: [token: TAddress, account: TAddress] | [account: TAddress];
        };
        shares: {
            method: "shares";
            arguments: [account: TAddress];
        };
        totalReleased: {
            method: "totalReleased";
            arguments: [token: TAddress] | [];
        };
        totalShares: {
            method: "totalShares";
            arguments: [];
        };
    };
};
interface IPaymentSplitterTxCaller {
    release(sender: TSender, account: TAddress): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    release(sender: TSender, token: TAddress, account: TAddress): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
}
interface IPaymentSplitterTxData {
    release(sender: TSender, account: TAddress): Promise<TEth.TxLike>;
    release(sender: TSender, token: TAddress, account: TAddress): Promise<TEth.TxLike>;
}
type TEvents = TPaymentSplitterTypes['Events'];
type TEventParams<TEventName extends keyof TEvents> = Partial<TEvents[TEventName]['outputParams']>;
type TEventArguments<TEventName extends keyof TEvents> = Partial<TEvents[TEventName]['outputArgs']>;
export {};