import { TAddress } from '../../../models/TAddress';
import { TAccount } from '../../../models/TAccount';
import { ClientEventsStream, TClientEventsStreamData } from '../../../clients/ClientEventsStream';
import { ContractBase } from '../../../contracts/ContractBase';
import { ContractStorageReaderBase } from '../../../contracts/ContractStorageReaderBase';
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 WETH extends ContractBase {
    address: TEth.Address;
    client: Web3Client;
    explorer: IBlockchainExplorer;
    constructor(address?: TEth.Address, client?: Web3Client, explorer?: IBlockchainExplorer);
    Types: TWETHTypes;
    $meta: {
        class: string;
    };
    name(): Promise<string>;
    approve(sender: TSender, guy: TAddress, wad: bigint): Promise<TxWriter>;
    totalSupply(): Promise<bigint>;
    transferFrom(sender: TSender, src: TAddress, dst: TAddress, wad: bigint): Promise<TxWriter>;
    withdraw(sender: TSender, wad: bigint): Promise<TxWriter>;
    decimals(): Promise<number>;
    balanceOf(input0: TAddress): Promise<bigint>;
    symbol(): Promise<string>;
    transfer(sender: TSender, dst: TAddress, wad: bigint): Promise<TxWriter>;
    deposit(sender: TSender): Promise<TxWriter>;
    allowance(input0: TAddress, input1: TAddress): Promise<bigint>;
    $call(): IWETHTxCaller;
    $signed(): TOverrideReturns<IWETHTxCaller, Promise<{
        signed: TEth.Hex;
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
    }>>;
    $data(): IWETHTxData;
    $gas(): TOverrideReturns<IWETHTxCaller, Promise<{
        gas?: bigint;
        price?: bigint;
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
    }>>;
    onTransaction<TMethod extends keyof TWETHTypes['Methods']>(method: TMethod, options: Parameters<ContractBase['$onTransaction']>[0]): SubjectStream<{
        tx: TEth.Tx;
        block: TEth.Block<TEth.Hex>;
        calldata: {
            method: TMethod;
            arguments: TWETHTypes['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>[]>;
    onApproval(fn?: (event: TClientEventsStreamData<TEventArguments<'Approval'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'Approval'>>>;
    onTransfer(fn?: (event: TClientEventsStreamData<TEventArguments<'Transfer'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'Transfer'>>>;
    onDeposit(fn?: (event: TClientEventsStreamData<TEventArguments<'Deposit'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'Deposit'>>>;
    onWithdrawal(fn?: (event: TClientEventsStreamData<TEventArguments<'Withdrawal'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'Withdrawal'>>>;
    extractLogsApproval(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'Approval'>>[];
    extractLogsTransfer(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'Transfer'>>[];
    extractLogsDeposit(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'Deposit'>>[];
    extractLogsWithdrawal(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'Withdrawal'>>[];
    getPastLogsApproval(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            src?: TAddress;
            guy?: TAddress;
        };
    }): Promise<ITxLogItem<TEventParams<'Approval'>>[]>;
    getPastLogsTransfer(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            src?: TAddress;
            dst?: TAddress;
        };
    }): Promise<ITxLogItem<TEventParams<'Transfer'>>[]>;
    getPastLogsDeposit(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            dst?: TAddress;
        };
    }): Promise<ITxLogItem<TEventParams<'Deposit'>>[]>;
    getPastLogsWithdrawal(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            src?: TAddress;
        };
    }): Promise<ITxLogItem<TEventParams<'Withdrawal'>>[]>;
    abi: TAbiItem[];
    storage: WETHStorageReader;
}
type TSender = TAccount & {
    value?: string | number | bigint;
};
type TEventLogOptions<TParams> = {
    fromBlock?: number | Date;
    toBlock?: number | Date;
    params?: TParams;
};
export type TWETHTypes = {
    Events: {
        Approval: {
            outputParams: {
                src: TAddress;
                guy: TAddress;
                wad: bigint;
            };
            outputArgs: [src: TAddress, guy: TAddress, wad: bigint];
        };
        Transfer: {
            outputParams: {
                src: TAddress;
                dst: TAddress;
                wad: bigint;
            };
            outputArgs: [src: TAddress, dst: TAddress, wad: bigint];
        };
        Deposit: {
            outputParams: {
                dst: TAddress;
                wad: bigint;
            };
            outputArgs: [dst: TAddress, wad: bigint];
        };
        Withdrawal: {
            outputParams: {
                src: TAddress;
                wad: bigint;
            };
            outputArgs: [src: TAddress, wad: bigint];
        };
    };
    Methods: {
        name: {
            method: "name";
            arguments: [];
        };
        approve: {
            method: "approve";
            arguments: [guy: TAddress, wad: bigint];
        };
        totalSupply: {
            method: "totalSupply";
            arguments: [];
        };
        transferFrom: {
            method: "transferFrom";
            arguments: [src: TAddress, dst: TAddress, wad: bigint];
        };
        withdraw: {
            method: "withdraw";
            arguments: [wad: bigint];
        };
        decimals: {
            method: "decimals";
            arguments: [];
        };
        balanceOf: {
            method: "balanceOf";
            arguments: [input0: TAddress];
        };
        symbol: {
            method: "symbol";
            arguments: [];
        };
        transfer: {
            method: "transfer";
            arguments: [dst: TAddress, wad: bigint];
        };
        deposit: {
            method: "deposit";
            arguments: [];
        };
        allowance: {
            method: "allowance";
            arguments: [input0: TAddress, input1: TAddress];
        };
    };
};
declare class WETHStorageReader extends ContractStorageReaderBase {
    address: TAddress;
    client: Web3Client;
    explorer: IBlockchainExplorer;
    constructor(address: TAddress, client: Web3Client, explorer: IBlockchainExplorer);
    name(): Promise<string>;
    symbol(): Promise<string>;
    decimals(): Promise<number>;
    balanceOf(key: TAddress): Promise<number>;
    allowance(key: TAddress): Promise<Record<string | number, number>>;
    $slots: {
        slot: number;
        position: number;
        name: string;
        size: number;
        type: string;
    }[];
}
interface IWETHTxCaller {
    approve(sender: TSender, guy: TAddress, wad: bigint): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    transferFrom(sender: TSender, src: TAddress, dst: TAddress, wad: bigint): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    withdraw(sender: TSender, wad: bigint): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    transfer(sender: TSender, dst: TAddress, wad: bigint): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    deposit(sender: TSender): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
}
interface IWETHTxData {
    approve(sender: TSender, guy: TAddress, wad: bigint): Promise<TEth.TxLike>;
    transferFrom(sender: TSender, src: TAddress, dst: TAddress, wad: bigint): Promise<TEth.TxLike>;
    withdraw(sender: TSender, wad: bigint): Promise<TEth.TxLike>;
    transfer(sender: TSender, dst: TAddress, wad: bigint): Promise<TEth.TxLike>;
    deposit(sender: TSender): Promise<TEth.TxLike>;
}
type TEvents = TWETHTypes['Events'];
type TEventParams<TEventName extends keyof TEvents> = Partial<TEvents[TEventName]['outputParams']>;
type TEventArguments<TEventName extends keyof TEvents> = Partial<TEvents[TEventName]['outputArgs']>;
export {};