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 SimpleAccount extends ContractBase {
    address: TEth.Address;
    client: Web3Client;
    explorer: IBlockchainExplorer;
    constructor(address?: TEth.Address, client?: Web3Client, explorer?: IBlockchainExplorer);
    Types: TSimpleAccountTypes;
    $meta: {
        source: string;
        class: string;
    };
    validateUserOp(sender: TSender, userOp: {
        sender: TAddress;
        nonce: bigint;
        initCode: TEth.Hex;
        callData: TEth.Hex;
        callGasLimit: bigint;
        verificationGasLimit: bigint;
        preVerificationGas: bigint;
        maxFeePerGas: bigint;
        maxPriorityFeePerGas: bigint;
        paymasterAndData: TEth.Hex;
        signature: TEth.Hex;
    }, userOpHash: TEth.Hex, missingAccountFunds: bigint): Promise<TxWriter>;
    validateUserOp(sender: TSender, userOp: {
        sender: TAddress;
        nonce: bigint;
        initCode: TEth.Hex;
        callData: TEth.Hex;
        callGasLimit: bigint;
        verificationGasLimit: bigint;
        preVerificationGas: bigint;
        maxFeePerGas: bigint;
        maxPriorityFeePerGas: bigint;
        paymasterAndData: TEth.Hex;
        signature: TEth.Hex;
    }, userOpHash: TEth.Hex, missingAccountFunds: bigint): Promise<TxWriter>;
    getNonce(): Promise<bigint>;
    entryPoint(): Promise<TAddress>;
    entryPoint(): Promise<TAddress>;
    tokensReceived(sender: TSender, operator: TAddress, from: TAddress, to: TAddress, amount: bigint, userData: TEth.Hex, operatorData: TEth.Hex): Promise<TxWriter>;
    tokensReceived(sender: TSender, input0: TAddress, input1: TAddress, input2: TAddress, input3: bigint, input4: TEth.Hex, input5: TEth.Hex): Promise<TxWriter>;
    onERC721Received(sender: TSender, operator: TAddress, from: TAddress, tokenId: bigint, data: TEth.Hex): Promise<TxWriter>;
    onERC721Received(sender: TSender, input0: TAddress, input1: TAddress, input2: bigint, input3: TEth.Hex): Promise<TxWriter>;
    supportsInterface(interfaceId: TEth.Hex): Promise<boolean>;
    supportsInterface(interfaceId: TEth.Hex): Promise<boolean>;
    onERC1155Received(sender: TSender, operator: TAddress, from: TAddress, id: bigint, value: bigint, data: TEth.Hex): Promise<TxWriter>;
    onERC1155Received(sender: TSender, input0: TAddress, input1: TAddress, input2: bigint, input3: bigint, input4: TEth.Hex): Promise<TxWriter>;
    onERC1155BatchReceived(sender: TSender, operator: TAddress, from: TAddress, ids: bigint[], values: bigint[], data: TEth.Hex): Promise<TxWriter>;
    onERC1155BatchReceived(sender: TSender, input0: TAddress, input1: TAddress, input2: bigint[], input3: bigint[], input4: TEth.Hex): Promise<TxWriter>;
    proxiableUUID(): Promise<TEth.Hex>;
    proxiableUUID(): Promise<TEth.Hex>;
    upgradeTo(sender: TSender, newImplementation: TAddress): Promise<TxWriter>;
    upgradeToAndCall(sender: TSender, newImplementation: TAddress, data: TEth.Hex): Promise<TxWriter>;
    execute(sender: TSender, dest: TAddress, value: bigint, func: TEth.Hex): Promise<TxWriter>;
    executeBatch(sender: TSender, dest: TAddress[], func: TEth.Hex[]): Promise<TxWriter>;
    initialize(sender: TSender, anOwner: TAddress): Promise<TxWriter>;
    getDeposit(): Promise<bigint>;
    addDeposit(sender: TSender): Promise<TxWriter>;
    withdrawDepositTo(sender: TSender, withdrawAddress: TAddress, amount: bigint): Promise<TxWriter>;
    owner(): Promise<TAddress>;
    $call(): ISimpleAccountTxCaller;
    $signed(): TOverrideReturns<ISimpleAccountTxCaller, Promise<{
        signed: TEth.Hex;
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
    }>>;
    $data(): ISimpleAccountTxData;
    $gas(): TOverrideReturns<ISimpleAccountTxCaller, Promise<{
        gas?: bigint;
        price?: bigint;
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
    }>>;
    onTransaction<TMethod extends keyof TSimpleAccountTypes['Methods']>(method: TMethod, options: Parameters<ContractBase['$onTransaction']>[0]): SubjectStream<{
        tx: TEth.Tx;
        block: TEth.Block<TEth.Hex>;
        calldata: {
            method: TMethod;
            arguments: TSimpleAccountTypes['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>[]>;
    onUpgraded(fn?: (event: TClientEventsStreamData<TEventArguments<'Upgraded'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'Upgraded'>>>;
    onAdminChanged(fn?: (event: TClientEventsStreamData<TEventArguments<'AdminChanged'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'AdminChanged'>>>;
    onBeaconUpgraded(fn?: (event: TClientEventsStreamData<TEventArguments<'BeaconUpgraded'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'BeaconUpgraded'>>>;
    onInitialized(fn?: (event: TClientEventsStreamData<TEventArguments<'Initialized'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'Initialized'>>>;
    onSimpleAccountInitialized(fn?: (event: TClientEventsStreamData<TEventArguments<'SimpleAccountInitialized'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'SimpleAccountInitialized'>>>;
    extractLogsUpgraded(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'Upgraded'>>[];
    extractLogsAdminChanged(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'AdminChanged'>>[];
    extractLogsBeaconUpgraded(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'BeaconUpgraded'>>[];
    extractLogsInitialized(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'Initialized'>>[];
    extractLogsSimpleAccountInitialized(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'SimpleAccountInitialized'>>[];
    getPastLogsUpgraded(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            implementation?: TAddress;
        };
    }): Promise<ITxLogItem<TEventParams<'Upgraded'>>[]>;
    getPastLogsAdminChanged(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {};
    }): Promise<ITxLogItem<TEventParams<'AdminChanged'>>[]>;
    getPastLogsBeaconUpgraded(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            beacon?: TAddress;
        };
    }): Promise<ITxLogItem<TEventParams<'BeaconUpgraded'>>[]>;
    getPastLogsInitialized(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {};
    }): Promise<ITxLogItem<TEventParams<'Initialized'>>[]>;
    getPastLogsSimpleAccountInitialized(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            entryPoint?: TAddress;
            owner?: TAddress;
        };
    }): Promise<ITxLogItem<TEventParams<'SimpleAccountInitialized'>>[]>;
    abi: TAbiItem[];
    storage: SimpleAccountStorageReader;
}
type TSender = TAccount & {
    value?: string | number | bigint;
};
type TEventLogOptions<TParams> = {
    fromBlock?: number | Date;
    toBlock?: number | Date;
    params?: TParams;
};
export type TSimpleAccountTypes = {
    Events: {
        Upgraded: {
            outputParams: {
                implementation: TAddress;
            };
            outputArgs: [implementation: TAddress];
        };
        AdminChanged: {
            outputParams: {
                previousAdmin: TAddress;
                newAdmin: TAddress;
            };
            outputArgs: [previousAdmin: TAddress, newAdmin: TAddress];
        };
        BeaconUpgraded: {
            outputParams: {
                beacon: TAddress;
            };
            outputArgs: [beacon: TAddress];
        };
        Initialized: {
            outputParams: {
                version: number;
            };
            outputArgs: [version: number];
        };
        SimpleAccountInitialized: {
            outputParams: {
                entryPoint: TAddress;
                owner: TAddress;
            };
            outputArgs: [entryPoint: TAddress, owner: TAddress];
        };
    };
    Methods: {
        validateUserOp: {
            method: "validateUserOp";
            arguments: [userOp: {
                sender: TAddress;
                nonce: bigint;
                initCode: TEth.Hex;
                callData: TEth.Hex;
                callGasLimit: bigint;
                verificationGasLimit: bigint;
                preVerificationGas: bigint;
                maxFeePerGas: bigint;
                maxPriorityFeePerGas: bigint;
                paymasterAndData: TEth.Hex;
                signature: TEth.Hex;
            }, userOpHash: TEth.Hex, missingAccountFunds: bigint] | [userOp: {
                sender: TAddress;
                nonce: bigint;
                initCode: TEth.Hex;
                callData: TEth.Hex;
                callGasLimit: bigint;
                verificationGasLimit: bigint;
                preVerificationGas: bigint;
                maxFeePerGas: bigint;
                maxPriorityFeePerGas: bigint;
                paymasterAndData: TEth.Hex;
                signature: TEth.Hex;
            }, userOpHash: TEth.Hex, missingAccountFunds: bigint];
        };
        getNonce: {
            method: "getNonce";
            arguments: [];
        };
        entryPoint: {
            method: "entryPoint";
            arguments: [] | [];
        };
        tokensReceived: {
            method: "tokensReceived";
            arguments: [operator: TAddress, from: TAddress, to: TAddress, amount: bigint, userData: TEth.Hex, operatorData: TEth.Hex] | [input0: TAddress, input1: TAddress, input2: TAddress, input3: bigint, input4: TEth.Hex, input5: TEth.Hex];
        };
        onERC721Received: {
            method: "onERC721Received";
            arguments: [operator: TAddress, from: TAddress, tokenId: bigint, data: TEth.Hex] | [input0: TAddress, input1: TAddress, input2: bigint, input3: TEth.Hex];
        };
        supportsInterface: {
            method: "supportsInterface";
            arguments: [interfaceId: TEth.Hex] | [interfaceId: TEth.Hex];
        };
        onERC1155Received: {
            method: "onERC1155Received";
            arguments: [operator: TAddress, from: TAddress, id: bigint, value: bigint, data: TEth.Hex] | [input0: TAddress, input1: TAddress, input2: bigint, input3: bigint, input4: TEth.Hex];
        };
        onERC1155BatchReceived: {
            method: "onERC1155BatchReceived";
            arguments: [operator: TAddress, from: TAddress, ids: bigint[], values: bigint[], data: TEth.Hex] | [input0: TAddress, input1: TAddress, input2: bigint[], input3: bigint[], input4: TEth.Hex];
        };
        proxiableUUID: {
            method: "proxiableUUID";
            arguments: [] | [];
        };
        upgradeTo: {
            method: "upgradeTo";
            arguments: [newImplementation: TAddress];
        };
        upgradeToAndCall: {
            method: "upgradeToAndCall";
            arguments: [newImplementation: TAddress, data: TEth.Hex];
        };
        execute: {
            method: "execute";
            arguments: [dest: TAddress, value: bigint, func: TEth.Hex];
        };
        executeBatch: {
            method: "executeBatch";
            arguments: [dest: TAddress[], func: TEth.Hex[]];
        };
        initialize: {
            method: "initialize";
            arguments: [anOwner: TAddress];
        };
        getDeposit: {
            method: "getDeposit";
            arguments: [];
        };
        addDeposit: {
            method: "addDeposit";
            arguments: [];
        };
        withdrawDepositTo: {
            method: "withdrawDepositTo";
            arguments: [withdrawAddress: TAddress, amount: bigint];
        };
        owner: {
            method: "owner";
            arguments: [];
        };
    };
};
declare class SimpleAccountStorageReader extends ContractStorageReaderBase {
    address: TAddress;
    client: Web3Client;
    explorer: IBlockchainExplorer;
    constructor(address: TAddress, client: Web3Client, explorer: IBlockchainExplorer);
    _initialized(): Promise<number>;
    _initializing(): Promise<boolean>;
    owner(): Promise<TAddress>;
    $slots: {
        slot: number;
        position: number;
        name: string;
        size: number;
        type: string;
    }[];
}
interface ISimpleAccountTxCaller {
    validateUserOp(sender: TSender, userOp: {
        sender: TAddress;
        nonce: bigint;
        initCode: TEth.Hex;
        callData: TEth.Hex;
        callGasLimit: bigint;
        verificationGasLimit: bigint;
        preVerificationGas: bigint;
        maxFeePerGas: bigint;
        maxPriorityFeePerGas: bigint;
        paymasterAndData: TEth.Hex;
        signature: TEth.Hex;
    }, userOpHash: TEth.Hex, missingAccountFunds: bigint): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    validateUserOp(sender: TSender, userOp: {
        sender: TAddress;
        nonce: bigint;
        initCode: TEth.Hex;
        callData: TEth.Hex;
        callGasLimit: bigint;
        verificationGasLimit: bigint;
        preVerificationGas: bigint;
        maxFeePerGas: bigint;
        maxPriorityFeePerGas: bigint;
        paymasterAndData: TEth.Hex;
        signature: TEth.Hex;
    }, userOpHash: TEth.Hex, missingAccountFunds: bigint): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    tokensReceived(sender: TSender, operator: TAddress, from: TAddress, to: TAddress, amount: bigint, userData: TEth.Hex, operatorData: TEth.Hex): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    onERC721Received(sender: TSender, operator: TAddress, from: TAddress, tokenId: bigint, data: TEth.Hex): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    onERC1155Received(sender: TSender, operator: TAddress, from: TAddress, id: bigint, value: bigint, data: TEth.Hex): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    onERC1155BatchReceived(sender: TSender, operator: TAddress, from: TAddress, ids: bigint[], values: bigint[], data: TEth.Hex): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    upgradeTo(sender: TSender, newImplementation: TAddress): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    upgradeToAndCall(sender: TSender, newImplementation: TAddress, data: TEth.Hex): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    execute(sender: TSender, dest: TAddress, value: bigint, func: TEth.Hex): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    executeBatch(sender: TSender, dest: TAddress[], func: TEth.Hex[]): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    initialize(sender: TSender, anOwner: TAddress): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    addDeposit(sender: TSender): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    withdrawDepositTo(sender: TSender, withdrawAddress: TAddress, amount: bigint): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
}
interface ISimpleAccountTxData {
    validateUserOp(sender: TSender, userOp: {
        sender: TAddress;
        nonce: bigint;
        initCode: TEth.Hex;
        callData: TEth.Hex;
        callGasLimit: bigint;
        verificationGasLimit: bigint;
        preVerificationGas: bigint;
        maxFeePerGas: bigint;
        maxPriorityFeePerGas: bigint;
        paymasterAndData: TEth.Hex;
        signature: TEth.Hex;
    }, userOpHash: TEth.Hex, missingAccountFunds: bigint): Promise<TEth.TxLike>;
    validateUserOp(sender: TSender, userOp: {
        sender: TAddress;
        nonce: bigint;
        initCode: TEth.Hex;
        callData: TEth.Hex;
        callGasLimit: bigint;
        verificationGasLimit: bigint;
        preVerificationGas: bigint;
        maxFeePerGas: bigint;
        maxPriorityFeePerGas: bigint;
        paymasterAndData: TEth.Hex;
        signature: TEth.Hex;
    }, userOpHash: TEth.Hex, missingAccountFunds: bigint): Promise<TEth.TxLike>;
    tokensReceived(sender: TSender, operator: TAddress, from: TAddress, to: TAddress, amount: bigint, userData: TEth.Hex, operatorData: TEth.Hex): Promise<TEth.TxLike>;
    onERC721Received(sender: TSender, operator: TAddress, from: TAddress, tokenId: bigint, data: TEth.Hex): Promise<TEth.TxLike>;
    onERC1155Received(sender: TSender, operator: TAddress, from: TAddress, id: bigint, value: bigint, data: TEth.Hex): Promise<TEth.TxLike>;
    onERC1155BatchReceived(sender: TSender, operator: TAddress, from: TAddress, ids: bigint[], values: bigint[], data: TEth.Hex): Promise<TEth.TxLike>;
    upgradeTo(sender: TSender, newImplementation: TAddress): Promise<TEth.TxLike>;
    upgradeToAndCall(sender: TSender, newImplementation: TAddress, data: TEth.Hex): Promise<TEth.TxLike>;
    execute(sender: TSender, dest: TAddress, value: bigint, func: TEth.Hex): Promise<TEth.TxLike>;
    executeBatch(sender: TSender, dest: TAddress[], func: TEth.Hex[]): Promise<TEth.TxLike>;
    initialize(sender: TSender, anOwner: TAddress): Promise<TEth.TxLike>;
    addDeposit(sender: TSender): Promise<TEth.TxLike>;
    withdrawDepositTo(sender: TSender, withdrawAddress: TAddress, amount: bigint): Promise<TEth.TxLike>;
}
type TEvents = TSimpleAccountTypes['Events'];
type TEventParams<TEventName extends keyof TEvents> = Partial<TEvents[TEventName]['outputParams']>;
type TEventArguments<TEventName extends keyof TEvents> = Partial<TEvents[TEventName]['outputArgs']>;
export {};