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 EnsRegistry extends ContractBase {
    address: TEth.Address;
    client: Web3Client;
    explorer: IBlockchainExplorer;
    constructor(address?: TEth.Address, client?: Web3Client, explorer?: IBlockchainExplorer);
    Types: TEnsRegistryTypes;
    $meta: {
        class: string;
    };
    $constructor(deployer: TSender, _old: TAddress): Promise<TxWriter>;
    isApprovedForAll(owner: TAddress, operator: TAddress): Promise<boolean>;
    old(): Promise<TAddress>;
    owner(node: TEth.Hex): Promise<TAddress>;
    recordExists(node: TEth.Hex): Promise<boolean>;
    resolver(node: TEth.Hex): Promise<TAddress>;
    setApprovalForAll(sender: TSender, operator: TAddress, approved: boolean): Promise<TxWriter>;
    setOwner(sender: TSender, node: TEth.Hex, owner: TAddress): Promise<TxWriter>;
    setRecord(sender: TSender, node: TEth.Hex, owner: TAddress, resolver: TAddress, ttl: number): Promise<TxWriter>;
    setResolver(sender: TSender, node: TEth.Hex, resolver: TAddress): Promise<TxWriter>;
    setSubnodeOwner(sender: TSender, node: TEth.Hex, label: TEth.Hex, owner: TAddress): Promise<TxWriter>;
    setSubnodeRecord(sender: TSender, node: TEth.Hex, label: TEth.Hex, owner: TAddress, resolver: TAddress, ttl: number): Promise<TxWriter>;
    setTTL(sender: TSender, node: TEth.Hex, ttl: number): Promise<TxWriter>;
    ttl(node: TEth.Hex): Promise<number>;
    $call(): IEnsRegistryTxCaller;
    $signed(): TOverrideReturns<IEnsRegistryTxCaller, Promise<{
        signed: TEth.Hex;
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
    }>>;
    $data(): IEnsRegistryTxData;
    $gas(): TOverrideReturns<IEnsRegistryTxCaller, Promise<{
        gas?: bigint;
        price?: bigint;
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
    }>>;
    onTransaction<TMethod extends keyof TEnsRegistryTypes['Methods']>(method: TMethod, options: Parameters<ContractBase['$onTransaction']>[0]): SubjectStream<{
        tx: TEth.Tx;
        block: TEth.Block<TEth.Hex>;
        calldata: {
            method: TMethod;
            arguments: TEnsRegistryTypes['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>[]>;
    onApprovalForAll(fn?: (event: TClientEventsStreamData<TEventArguments<'ApprovalForAll'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'ApprovalForAll'>>>;
    onNewOwner(fn?: (event: TClientEventsStreamData<TEventArguments<'NewOwner'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'NewOwner'>>>;
    onNewResolver(fn?: (event: TClientEventsStreamData<TEventArguments<'NewResolver'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'NewResolver'>>>;
    onNewTTL(fn?: (event: TClientEventsStreamData<TEventArguments<'NewTTL'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'NewTTL'>>>;
    onTransfer(fn?: (event: TClientEventsStreamData<TEventArguments<'Transfer'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'Transfer'>>>;
    extractLogsApprovalForAll(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'ApprovalForAll'>>[];
    extractLogsNewOwner(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'NewOwner'>>[];
    extractLogsNewResolver(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'NewResolver'>>[];
    extractLogsNewTTL(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'NewTTL'>>[];
    extractLogsTransfer(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'Transfer'>>[];
    getPastLogsApprovalForAll(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            owner?: TAddress;
            operator?: TAddress;
        };
    }): Promise<ITxLogItem<TEventParams<'ApprovalForAll'>>[]>;
    getPastLogsNewOwner(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            node?: TEth.Hex;
            label?: TEth.Hex;
        };
    }): Promise<ITxLogItem<TEventParams<'NewOwner'>>[]>;
    getPastLogsNewResolver(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            node?: TEth.Hex;
        };
    }): Promise<ITxLogItem<TEventParams<'NewResolver'>>[]>;
    getPastLogsNewTTL(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            node?: TEth.Hex;
        };
    }): Promise<ITxLogItem<TEventParams<'NewTTL'>>[]>;
    getPastLogsTransfer(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            node?: TEth.Hex;
        };
    }): Promise<ITxLogItem<TEventParams<'Transfer'>>[]>;
    abi: TAbiItem[];
    storage: EnsRegistryStorageReader;
}
type TSender = TAccount & {
    value?: string | number | bigint;
};
type TEventLogOptions<TParams> = {
    fromBlock?: number | Date;
    toBlock?: number | Date;
    params?: TParams;
};
export type TEnsRegistryTypes = {
    Events: {
        ApprovalForAll: {
            outputParams: {
                owner: TAddress;
                operator: TAddress;
                approved: boolean;
            };
            outputArgs: [owner: TAddress, operator: TAddress, approved: boolean];
        };
        NewOwner: {
            outputParams: {
                node: TEth.Hex;
                label: TEth.Hex;
                owner: TAddress;
            };
            outputArgs: [node: TEth.Hex, label: TEth.Hex, owner: TAddress];
        };
        NewResolver: {
            outputParams: {
                node: TEth.Hex;
                resolver: TAddress;
            };
            outputArgs: [node: TEth.Hex, resolver: TAddress];
        };
        NewTTL: {
            outputParams: {
                node: TEth.Hex;
                ttl: number;
            };
            outputArgs: [node: TEth.Hex, ttl: number];
        };
        Transfer: {
            outputParams: {
                node: TEth.Hex;
                owner: TAddress;
            };
            outputArgs: [node: TEth.Hex, owner: TAddress];
        };
    };
    Methods: {
        isApprovedForAll: {
            method: "isApprovedForAll";
            arguments: [owner: TAddress, operator: TAddress];
        };
        old: {
            method: "old";
            arguments: [];
        };
        owner: {
            method: "owner";
            arguments: [node: TEth.Hex];
        };
        recordExists: {
            method: "recordExists";
            arguments: [node: TEth.Hex];
        };
        resolver: {
            method: "resolver";
            arguments: [node: TEth.Hex];
        };
        setApprovalForAll: {
            method: "setApprovalForAll";
            arguments: [operator: TAddress, approved: boolean];
        };
        setOwner: {
            method: "setOwner";
            arguments: [node: TEth.Hex, owner: TAddress];
        };
        setRecord: {
            method: "setRecord";
            arguments: [node: TEth.Hex, owner: TAddress, resolver: TAddress, ttl: number];
        };
        setResolver: {
            method: "setResolver";
            arguments: [node: TEth.Hex, resolver: TAddress];
        };
        setSubnodeOwner: {
            method: "setSubnodeOwner";
            arguments: [node: TEth.Hex, label: TEth.Hex, owner: TAddress];
        };
        setSubnodeRecord: {
            method: "setSubnodeRecord";
            arguments: [node: TEth.Hex, label: TEth.Hex, owner: TAddress, resolver: TAddress, ttl: number];
        };
        setTTL: {
            method: "setTTL";
            arguments: [node: TEth.Hex, ttl: number];
        };
        ttl: {
            method: "ttl";
            arguments: [node: TEth.Hex];
        };
    };
};
declare class EnsRegistryStorageReader extends ContractStorageReaderBase {
    address: TAddress;
    client: Web3Client;
    explorer: IBlockchainExplorer;
    constructor(address: TAddress, client: Web3Client, explorer: IBlockchainExplorer);
    records(key: TEth.Hex): Promise<{
        owner: TAddress;
        resolver: TAddress;
        ttl: number;
    }>;
    operators(key: TAddress): Promise<Record<string | number, boolean>>;
    old(): Promise<TAddress>;
    $slots: {
        slot: number;
        position: number;
        name: string;
        size: number;
        type: string;
    }[];
}
interface IEnsRegistryTxCaller {
    setApprovalForAll(sender: TSender, operator: TAddress, approved: boolean): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    setOwner(sender: TSender, node: TEth.Hex, owner: TAddress): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    setRecord(sender: TSender, node: TEth.Hex, owner: TAddress, resolver: TAddress, ttl: number): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    setResolver(sender: TSender, node: TEth.Hex, resolver: TAddress): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    setSubnodeOwner(sender: TSender, node: TEth.Hex, label: TEth.Hex, owner: TAddress): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    setSubnodeRecord(sender: TSender, node: TEth.Hex, label: TEth.Hex, owner: TAddress, resolver: TAddress, ttl: number): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    setTTL(sender: TSender, node: TEth.Hex, ttl: number): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
}
interface IEnsRegistryTxData {
    setApprovalForAll(sender: TSender, operator: TAddress, approved: boolean): Promise<TEth.TxLike>;
    setOwner(sender: TSender, node: TEth.Hex, owner: TAddress): Promise<TEth.TxLike>;
    setRecord(sender: TSender, node: TEth.Hex, owner: TAddress, resolver: TAddress, ttl: number): Promise<TEth.TxLike>;
    setResolver(sender: TSender, node: TEth.Hex, resolver: TAddress): Promise<TEth.TxLike>;
    setSubnodeOwner(sender: TSender, node: TEth.Hex, label: TEth.Hex, owner: TAddress): Promise<TEth.TxLike>;
    setSubnodeRecord(sender: TSender, node: TEth.Hex, label: TEth.Hex, owner: TAddress, resolver: TAddress, ttl: number): Promise<TEth.TxLike>;
    setTTL(sender: TSender, node: TEth.Hex, ttl: number): Promise<TEth.TxLike>;
}
type TEvents = TEnsRegistryTypes['Events'];
type TEventParams<TEventName extends keyof TEvents> = Partial<TEvents[TEventName]['outputParams']>;
type TEventArguments<TEventName extends keyof TEvents> = Partial<TEvents[TEventName]['outputArgs']>;
export {};