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 IERC1820Registry extends ContractBase {
    address: TEth.Address;
    client: Web3Client;
    explorer: IBlockchainExplorer;
    constructor(address?: TEth.Address, client?: Web3Client, explorer?: IBlockchainExplorer);
    Types: TIERC1820RegistryTypes;
    $meta: {
        class: string;
    };
    getInterfaceImplementer(account: TAddress, _interfaceHash: TEth.Hex): Promise<TAddress>;
    getManager(account: TAddress): Promise<TAddress>;
    implementsERC165Interface(account: TAddress, interfaceId: TEth.Hex): Promise<boolean>;
    implementsERC165InterfaceNoCache(account: TAddress, interfaceId: TEth.Hex): Promise<boolean>;
    interfaceHash(interfaceName: string): Promise<TEth.Hex>;
    setInterfaceImplementer(sender: TSender, account: TAddress, _interfaceHash: TEth.Hex, implementer: TAddress): Promise<TxWriter>;
    setManager(sender: TSender, account: TAddress, newManager: TAddress): Promise<TxWriter>;
    updateERC165Cache(sender: TSender, account: TAddress, interfaceId: TEth.Hex): Promise<TxWriter>;
    $call(): IIERC1820RegistryTxCaller;
    $signed(): TOverrideReturns<IIERC1820RegistryTxCaller, Promise<{
        signed: TEth.Hex;
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
    }>>;
    $data(): IIERC1820RegistryTxData;
    $gas(): TOverrideReturns<IIERC1820RegistryTxCaller, Promise<{
        gas?: bigint;
        price?: bigint;
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
    }>>;
    onTransaction<TMethod extends keyof TIERC1820RegistryTypes['Methods']>(method: TMethod, options: Parameters<ContractBase['$onTransaction']>[0]): SubjectStream<{
        tx: TEth.Tx;
        block: TEth.Block<TEth.Hex>;
        calldata: {
            method: TMethod;
            arguments: TIERC1820RegistryTypes['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>[]>;
    onInterfaceImplementerSet(fn?: (event: TClientEventsStreamData<TEventArguments<'InterfaceImplementerSet'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'InterfaceImplementerSet'>>>;
    onManagerChanged(fn?: (event: TClientEventsStreamData<TEventArguments<'ManagerChanged'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'ManagerChanged'>>>;
    extractLogsInterfaceImplementerSet(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'InterfaceImplementerSet'>>[];
    extractLogsManagerChanged(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'ManagerChanged'>>[];
    getPastLogsInterfaceImplementerSet(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            account?: TAddress;
            interfaceHash?: TEth.Hex;
            implementer?: TAddress;
        };
    }): Promise<ITxLogItem<TEventParams<'InterfaceImplementerSet'>>[]>;
    getPastLogsManagerChanged(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            account?: TAddress;
            newManager?: TAddress;
        };
    }): Promise<ITxLogItem<TEventParams<'ManagerChanged'>>[]>;
    abi: TAbiItem[];
}
type TSender = TAccount & {
    value?: string | number | bigint;
};
type TEventLogOptions<TParams> = {
    fromBlock?: number | Date;
    toBlock?: number | Date;
    params?: TParams;
};
export type TIERC1820RegistryTypes = {
    Events: {
        InterfaceImplementerSet: {
            outputParams: {
                account: TAddress;
                interfaceHash: TEth.Hex;
                implementer: TAddress;
            };
            outputArgs: [account: TAddress, interfaceHash: TEth.Hex, implementer: TAddress];
        };
        ManagerChanged: {
            outputParams: {
                account: TAddress;
                newManager: TAddress;
            };
            outputArgs: [account: TAddress, newManager: TAddress];
        };
    };
    Methods: {
        getInterfaceImplementer: {
            method: "getInterfaceImplementer";
            arguments: [account: TAddress, _interfaceHash: TEth.Hex];
        };
        getManager: {
            method: "getManager";
            arguments: [account: TAddress];
        };
        implementsERC165Interface: {
            method: "implementsERC165Interface";
            arguments: [account: TAddress, interfaceId: TEth.Hex];
        };
        implementsERC165InterfaceNoCache: {
            method: "implementsERC165InterfaceNoCache";
            arguments: [account: TAddress, interfaceId: TEth.Hex];
        };
        interfaceHash: {
            method: "interfaceHash";
            arguments: [interfaceName: string];
        };
        setInterfaceImplementer: {
            method: "setInterfaceImplementer";
            arguments: [account: TAddress, _interfaceHash: TEth.Hex, implementer: TAddress];
        };
        setManager: {
            method: "setManager";
            arguments: [account: TAddress, newManager: TAddress];
        };
        updateERC165Cache: {
            method: "updateERC165Cache";
            arguments: [account: TAddress, interfaceId: TEth.Hex];
        };
    };
};
interface IIERC1820RegistryTxCaller {
    setInterfaceImplementer(sender: TSender, account: TAddress, _interfaceHash: TEth.Hex, implementer: TAddress): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    setManager(sender: TSender, account: TAddress, newManager: TAddress): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    updateERC165Cache(sender: TSender, account: TAddress, interfaceId: TEth.Hex): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
}
interface IIERC1820RegistryTxData {
    setInterfaceImplementer(sender: TSender, account: TAddress, _interfaceHash: TEth.Hex, implementer: TAddress): Promise<TEth.TxLike>;
    setManager(sender: TSender, account: TAddress, newManager: TAddress): Promise<TEth.TxLike>;
    updateERC165Cache(sender: TSender, account: TAddress, interfaceId: TEth.Hex): Promise<TEth.TxLike>;
}
type TEvents = TIERC1820RegistryTypes['Events'];
type TEventParams<TEventName extends keyof TEvents> = Partial<TEvents[TEventName]['outputParams']>;
type TEventArguments<TEventName extends keyof TEvents> = Partial<TEvents[TEventName]['outputArgs']>;
export {};