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 EnsPublicResolver extends ContractBase {
    address: TEth.Address;
    client: Web3Client;
    explorer: IBlockchainExplorer;
    constructor(address?: TEth.Address, client?: Web3Client, explorer?: IBlockchainExplorer);
    Types: TEnsPublicResolverTypes;
    $meta: {
        class: string;
    };
    $constructor(deployer: TSender, _ens: TAddress, wrapperAddress: TAddress, _trustedETHController: TAddress, _trustedReverseRegistrar: TAddress): Promise<TxWriter>;
    ABI(node: TEth.Hex, contentTypes: bigint): Promise<[bigint, TEth.Hex]>;
    addr(node: TEth.Hex): Promise<TAddress>;
    addr(node: TEth.Hex, coinType: bigint): Promise<TEth.Hex>;
    approve(sender: TSender, node: TEth.Hex, delegate: TAddress, approved: boolean): Promise<TxWriter>;
    clearRecords(sender: TSender, node: TEth.Hex): Promise<TxWriter>;
    contenthash(node: TEth.Hex): Promise<TEth.Hex>;
    dnsRecord(node: TEth.Hex, name: TEth.Hex, resource: number): Promise<TEth.Hex>;
    hasDNSRecords(node: TEth.Hex, name: TEth.Hex): Promise<boolean>;
    interfaceImplementer(node: TEth.Hex, interfaceID: TEth.Hex): Promise<TAddress>;
    isApprovedFor(owner: TAddress, node: TEth.Hex, delegate: TAddress): Promise<boolean>;
    isApprovedForAll(account: TAddress, operator: TAddress): Promise<boolean>;
    multicall(sender: TSender, data: TEth.Hex[]): Promise<TxWriter>;
    multicallWithNodeCheck(sender: TSender, nodehash: TEth.Hex, data: TEth.Hex[]): Promise<TxWriter>;
    name(node: TEth.Hex): Promise<string>;
    pubkey(node: TEth.Hex): Promise<{
        x: TEth.Hex;
        y: TEth.Hex;
    }>;
    recordVersions(input0: TEth.Hex): Promise<number>;
    setABI(sender: TSender, node: TEth.Hex, contentType: bigint, data: TEth.Hex): Promise<TxWriter>;
    setAddr(sender: TSender, node: TEth.Hex, coinType: bigint, a: TEth.Hex): Promise<TxWriter>;
    setAddr(sender: TSender, node: TEth.Hex, a: TAddress): Promise<TxWriter>;
    setApprovalForAll(sender: TSender, operator: TAddress, approved: boolean): Promise<TxWriter>;
    setContenthash(sender: TSender, node: TEth.Hex, hash: TEth.Hex): Promise<TxWriter>;
    setDNSRecords(sender: TSender, node: TEth.Hex, data: TEth.Hex): Promise<TxWriter>;
    setInterface(sender: TSender, node: TEth.Hex, interfaceID: TEth.Hex, implementer: TAddress): Promise<TxWriter>;
    setName(sender: TSender, node: TEth.Hex, newName: string): Promise<TxWriter>;
    setPubkey(sender: TSender, node: TEth.Hex, x: TEth.Hex, y: TEth.Hex): Promise<TxWriter>;
    setText(sender: TSender, node: TEth.Hex, key: string, value: string): Promise<TxWriter>;
    setZonehash(sender: TSender, node: TEth.Hex, hash: TEth.Hex): Promise<TxWriter>;
    supportsInterface(interfaceID: TEth.Hex): Promise<boolean>;
    text(node: TEth.Hex, key: string): Promise<string>;
    zonehash(node: TEth.Hex): Promise<TEth.Hex>;
    $call(): IEnsPublicResolverTxCaller;
    $signed(): TOverrideReturns<IEnsPublicResolverTxCaller, Promise<{
        signed: TEth.Hex;
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
    }>>;
    $data(): IEnsPublicResolverTxData;
    $gas(): TOverrideReturns<IEnsPublicResolverTxCaller, Promise<{
        gas?: bigint;
        price?: bigint;
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
    }>>;
    onTransaction<TMethod extends keyof TEnsPublicResolverTypes['Methods']>(method: TMethod, options: Parameters<ContractBase['$onTransaction']>[0]): SubjectStream<{
        tx: TEth.Tx;
        block: TEth.Block<TEth.Hex>;
        calldata: {
            method: TMethod;
            arguments: TEnsPublicResolverTypes['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>[]>;
    onABIChanged(fn?: (event: TClientEventsStreamData<TEventArguments<'ABIChanged'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'ABIChanged'>>>;
    onAddrChanged(fn?: (event: TClientEventsStreamData<TEventArguments<'AddrChanged'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'AddrChanged'>>>;
    onAddressChanged(fn?: (event: TClientEventsStreamData<TEventArguments<'AddressChanged'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'AddressChanged'>>>;
    onApprovalForAll(fn?: (event: TClientEventsStreamData<TEventArguments<'ApprovalForAll'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'ApprovalForAll'>>>;
    onApproved(fn?: (event: TClientEventsStreamData<TEventArguments<'Approved'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'Approved'>>>;
    onContenthashChanged(fn?: (event: TClientEventsStreamData<TEventArguments<'ContenthashChanged'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'ContenthashChanged'>>>;
    onDNSRecordChanged(fn?: (event: TClientEventsStreamData<TEventArguments<'DNSRecordChanged'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'DNSRecordChanged'>>>;
    onDNSRecordDeleted(fn?: (event: TClientEventsStreamData<TEventArguments<'DNSRecordDeleted'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'DNSRecordDeleted'>>>;
    onDNSZonehashChanged(fn?: (event: TClientEventsStreamData<TEventArguments<'DNSZonehashChanged'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'DNSZonehashChanged'>>>;
    onInterfaceChanged(fn?: (event: TClientEventsStreamData<TEventArguments<'InterfaceChanged'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'InterfaceChanged'>>>;
    onNameChanged(fn?: (event: TClientEventsStreamData<TEventArguments<'NameChanged'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'NameChanged'>>>;
    onPubkeyChanged(fn?: (event: TClientEventsStreamData<TEventArguments<'PubkeyChanged'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'PubkeyChanged'>>>;
    onTextChanged(fn?: (event: TClientEventsStreamData<TEventArguments<'TextChanged'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'TextChanged'>>>;
    onVersionChanged(fn?: (event: TClientEventsStreamData<TEventArguments<'VersionChanged'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'VersionChanged'>>>;
    extractLogsABIChanged(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'ABIChanged'>>[];
    extractLogsAddrChanged(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'AddrChanged'>>[];
    extractLogsAddressChanged(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'AddressChanged'>>[];
    extractLogsApprovalForAll(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'ApprovalForAll'>>[];
    extractLogsApproved(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'Approved'>>[];
    extractLogsContenthashChanged(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'ContenthashChanged'>>[];
    extractLogsDNSRecordChanged(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'DNSRecordChanged'>>[];
    extractLogsDNSRecordDeleted(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'DNSRecordDeleted'>>[];
    extractLogsDNSZonehashChanged(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'DNSZonehashChanged'>>[];
    extractLogsInterfaceChanged(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'InterfaceChanged'>>[];
    extractLogsNameChanged(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'NameChanged'>>[];
    extractLogsPubkeyChanged(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'PubkeyChanged'>>[];
    extractLogsTextChanged(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'TextChanged'>>[];
    extractLogsVersionChanged(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'VersionChanged'>>[];
    getPastLogsABIChanged(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            node?: TEth.Hex;
            contentType?: bigint;
        };
    }): Promise<ITxLogItem<TEventParams<'ABIChanged'>>[]>;
    getPastLogsAddrChanged(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            node?: TEth.Hex;
        };
    }): Promise<ITxLogItem<TEventParams<'AddrChanged'>>[]>;
    getPastLogsAddressChanged(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            node?: TEth.Hex;
        };
    }): Promise<ITxLogItem<TEventParams<'AddressChanged'>>[]>;
    getPastLogsApprovalForAll(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            owner?: TAddress;
            operator?: TAddress;
        };
    }): Promise<ITxLogItem<TEventParams<'ApprovalForAll'>>[]>;
    getPastLogsApproved(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {};
    }): Promise<ITxLogItem<TEventParams<'Approved'>>[]>;
    getPastLogsContenthashChanged(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            node?: TEth.Hex;
        };
    }): Promise<ITxLogItem<TEventParams<'ContenthashChanged'>>[]>;
    getPastLogsDNSRecordChanged(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            node?: TEth.Hex;
        };
    }): Promise<ITxLogItem<TEventParams<'DNSRecordChanged'>>[]>;
    getPastLogsDNSRecordDeleted(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            node?: TEth.Hex;
        };
    }): Promise<ITxLogItem<TEventParams<'DNSRecordDeleted'>>[]>;
    getPastLogsDNSZonehashChanged(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            node?: TEth.Hex;
        };
    }): Promise<ITxLogItem<TEventParams<'DNSZonehashChanged'>>[]>;
    getPastLogsInterfaceChanged(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            node?: TEth.Hex;
            interfaceID?: TEth.Hex;
        };
    }): Promise<ITxLogItem<TEventParams<'InterfaceChanged'>>[]>;
    getPastLogsNameChanged(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            node?: TEth.Hex;
        };
    }): Promise<ITxLogItem<TEventParams<'NameChanged'>>[]>;
    getPastLogsPubkeyChanged(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            node?: TEth.Hex;
        };
    }): Promise<ITxLogItem<TEventParams<'PubkeyChanged'>>[]>;
    getPastLogsTextChanged(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            node?: TEth.Hex;
            indexedKey?: string;
        };
    }): Promise<ITxLogItem<TEventParams<'TextChanged'>>[]>;
    getPastLogsVersionChanged(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            node?: TEth.Hex;
        };
    }): Promise<ITxLogItem<TEventParams<'VersionChanged'>>[]>;
    abi: TAbiItem[];
    storage: EnsPublicResolverStorageReader;
}
type TSender = TAccount & {
    value?: string | number | bigint;
};
type TEventLogOptions<TParams> = {
    fromBlock?: number | Date;
    toBlock?: number | Date;
    params?: TParams;
};
export type TEnsPublicResolverTypes = {
    Events: {
        ABIChanged: {
            outputParams: {
                node: TEth.Hex;
                contentType: bigint;
            };
            outputArgs: [node: TEth.Hex, contentType: bigint];
        };
        AddrChanged: {
            outputParams: {
                node: TEth.Hex;
                a: TAddress;
            };
            outputArgs: [node: TEth.Hex, a: TAddress];
        };
        AddressChanged: {
            outputParams: {
                node: TEth.Hex;
                coinType: bigint;
                newAddress: TEth.Hex;
            };
            outputArgs: [node: TEth.Hex, coinType: bigint, newAddress: TEth.Hex];
        };
        ApprovalForAll: {
            outputParams: {
                owner: TAddress;
                operator: TAddress;
                approved: boolean;
            };
            outputArgs: [owner: TAddress, operator: TAddress, approved: boolean];
        };
        Approved: {
            outputParams: {
                owner: TAddress;
                node: TEth.Hex;
                delegate: TAddress;
                approved: boolean;
            };
            outputArgs: [owner: TAddress, node: TEth.Hex, delegate: TAddress, approved: boolean];
        };
        ContenthashChanged: {
            outputParams: {
                node: TEth.Hex;
                hash: TEth.Hex;
            };
            outputArgs: [node: TEth.Hex, hash: TEth.Hex];
        };
        DNSRecordChanged: {
            outputParams: {
                node: TEth.Hex;
                name: TEth.Hex;
                resource: number;
                record: TEth.Hex;
            };
            outputArgs: [node: TEth.Hex, name: TEth.Hex, resource: number, record: TEth.Hex];
        };
        DNSRecordDeleted: {
            outputParams: {
                node: TEth.Hex;
                name: TEth.Hex;
                resource: number;
            };
            outputArgs: [node: TEth.Hex, name: TEth.Hex, resource: number];
        };
        DNSZonehashChanged: {
            outputParams: {
                node: TEth.Hex;
                lastzonehash: TEth.Hex;
                zonehash: TEth.Hex;
            };
            outputArgs: [node: TEth.Hex, lastzonehash: TEth.Hex, zonehash: TEth.Hex];
        };
        InterfaceChanged: {
            outputParams: {
                node: TEth.Hex;
                interfaceID: TEth.Hex;
                implementer: TAddress;
            };
            outputArgs: [node: TEth.Hex, interfaceID: TEth.Hex, implementer: TAddress];
        };
        NameChanged: {
            outputParams: {
                node: TEth.Hex;
                name: string;
            };
            outputArgs: [node: TEth.Hex, name: string];
        };
        PubkeyChanged: {
            outputParams: {
                node: TEth.Hex;
                x: TEth.Hex;
                y: TEth.Hex;
            };
            outputArgs: [node: TEth.Hex, x: TEth.Hex, y: TEth.Hex];
        };
        TextChanged: {
            outputParams: {
                node: TEth.Hex;
                indexedKey: string;
                key: string;
                value: string;
            };
            outputArgs: [node: TEth.Hex, indexedKey: string, key: string, value: string];
        };
        VersionChanged: {
            outputParams: {
                node: TEth.Hex;
                newVersion: number;
            };
            outputArgs: [node: TEth.Hex, newVersion: number];
        };
    };
    Methods: {
        ABI: {
            method: "ABI";
            arguments: [node: TEth.Hex, contentTypes: bigint];
        };
        addr: {
            method: "addr";
            arguments: [node: TEth.Hex] | [node: TEth.Hex, coinType: bigint];
        };
        approve: {
            method: "approve";
            arguments: [node: TEth.Hex, delegate: TAddress, approved: boolean];
        };
        clearRecords: {
            method: "clearRecords";
            arguments: [node: TEth.Hex];
        };
        contenthash: {
            method: "contenthash";
            arguments: [node: TEth.Hex];
        };
        dnsRecord: {
            method: "dnsRecord";
            arguments: [node: TEth.Hex, name: TEth.Hex, resource: number];
        };
        hasDNSRecords: {
            method: "hasDNSRecords";
            arguments: [node: TEth.Hex, name: TEth.Hex];
        };
        interfaceImplementer: {
            method: "interfaceImplementer";
            arguments: [node: TEth.Hex, interfaceID: TEth.Hex];
        };
        isApprovedFor: {
            method: "isApprovedFor";
            arguments: [owner: TAddress, node: TEth.Hex, delegate: TAddress];
        };
        isApprovedForAll: {
            method: "isApprovedForAll";
            arguments: [account: TAddress, operator: TAddress];
        };
        multicall: {
            method: "multicall";
            arguments: [data: TEth.Hex[]];
        };
        multicallWithNodeCheck: {
            method: "multicallWithNodeCheck";
            arguments: [nodehash: TEth.Hex, data: TEth.Hex[]];
        };
        name: {
            method: "name";
            arguments: [node: TEth.Hex];
        };
        pubkey: {
            method: "pubkey";
            arguments: [node: TEth.Hex];
        };
        recordVersions: {
            method: "recordVersions";
            arguments: [input0: TEth.Hex];
        };
        setABI: {
            method: "setABI";
            arguments: [node: TEth.Hex, contentType: bigint, data: TEth.Hex];
        };
        setAddr: {
            method: "setAddr";
            arguments: [node: TEth.Hex, coinType: bigint, a: TEth.Hex] | [node: TEth.Hex, a: TAddress];
        };
        setApprovalForAll: {
            method: "setApprovalForAll";
            arguments: [operator: TAddress, approved: boolean];
        };
        setContenthash: {
            method: "setContenthash";
            arguments: [node: TEth.Hex, hash: TEth.Hex];
        };
        setDNSRecords: {
            method: "setDNSRecords";
            arguments: [node: TEth.Hex, data: TEth.Hex];
        };
        setInterface: {
            method: "setInterface";
            arguments: [node: TEth.Hex, interfaceID: TEth.Hex, implementer: TAddress];
        };
        setName: {
            method: "setName";
            arguments: [node: TEth.Hex, newName: string];
        };
        setPubkey: {
            method: "setPubkey";
            arguments: [node: TEth.Hex, x: TEth.Hex, y: TEth.Hex];
        };
        setText: {
            method: "setText";
            arguments: [node: TEth.Hex, key: string, value: string];
        };
        setZonehash: {
            method: "setZonehash";
            arguments: [node: TEth.Hex, hash: TEth.Hex];
        };
        supportsInterface: {
            method: "supportsInterface";
            arguments: [interfaceID: TEth.Hex];
        };
        text: {
            method: "text";
            arguments: [node: TEth.Hex, key: string];
        };
        zonehash: {
            method: "zonehash";
            arguments: [node: TEth.Hex];
        };
    };
};
declare class EnsPublicResolverStorageReader extends ContractStorageReaderBase {
    address: TAddress;
    client: Web3Client;
    explorer: IBlockchainExplorer;
    constructor(address: TAddress, client: Web3Client, explorer: IBlockchainExplorer);
    recordVersions(key: TEth.Hex): Promise<number>;
    versionable_abis(key: number): Promise<Record<string | number, Record<string | number, TEth.Hex>>>;
    versionable_addresses(key: number): Promise<Record<string | number, Record<string | number, TEth.Hex>>>;
    versionable_hashes(key: number): Promise<Record<string | number, TEth.Hex>>;
    versionable_zonehashes(key: number): Promise<Record<string | number, TEth.Hex>>;
    versionable_records(key: number): Promise<Record<string | number, Record<string | number, Record<string | number, TEth.Hex>>>>;
    versionable_nameEntriesCount(key: number): Promise<Record<string | number, Record<string | number, number>>>;
    versionable_interfaces(key: number): Promise<Record<string | number, Record<string | number, TAddress>>>;
    versionable_names(key: number): Promise<Record<string | number, string>>;
    versionable_pubkeys(key: number): Promise<Record<string | number, {
        x: TEth.Hex;
        y: TEth.Hex;
    }>>;
    versionable_texts(key: number): Promise<Record<string | number, Record<string | number, string>>>;
    _operatorApprovals(key: TAddress): Promise<Record<string | number, boolean>>;
    _tokenApprovals(key: TAddress): Promise<Record<string | number, Record<string | number, boolean>>>;
    $slots: {
        slot: number;
        position: number;
        name: string;
        size: any;
        type: string;
    }[];
}
interface IEnsPublicResolverTxCaller {
    approve(sender: TSender, node: TEth.Hex, delegate: TAddress, approved: boolean): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    clearRecords(sender: TSender, node: TEth.Hex): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    multicall(sender: TSender, data: TEth.Hex[]): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    multicallWithNodeCheck(sender: TSender, nodehash: TEth.Hex, data: TEth.Hex[]): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    setABI(sender: TSender, node: TEth.Hex, contentType: bigint, data: TEth.Hex): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    setAddr(sender: TSender, node: TEth.Hex, coinType: bigint, a: TEth.Hex): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    setAddr(sender: TSender, node: TEth.Hex, a: TAddress): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    setApprovalForAll(sender: TSender, operator: TAddress, approved: boolean): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    setContenthash(sender: TSender, node: TEth.Hex, hash: TEth.Hex): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    setDNSRecords(sender: TSender, node: TEth.Hex, data: TEth.Hex): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    setInterface(sender: TSender, node: TEth.Hex, interfaceID: TEth.Hex, implementer: TAddress): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    setName(sender: TSender, node: TEth.Hex, newName: string): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    setPubkey(sender: TSender, node: TEth.Hex, x: TEth.Hex, y: TEth.Hex): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    setText(sender: TSender, node: TEth.Hex, key: string, value: string): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    setZonehash(sender: TSender, node: TEth.Hex, hash: TEth.Hex): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
}
interface IEnsPublicResolverTxData {
    approve(sender: TSender, node: TEth.Hex, delegate: TAddress, approved: boolean): Promise<TEth.TxLike>;
    clearRecords(sender: TSender, node: TEth.Hex): Promise<TEth.TxLike>;
    multicall(sender: TSender, data: TEth.Hex[]): Promise<TEth.TxLike>;
    multicallWithNodeCheck(sender: TSender, nodehash: TEth.Hex, data: TEth.Hex[]): Promise<TEth.TxLike>;
    setABI(sender: TSender, node: TEth.Hex, contentType: bigint, data: TEth.Hex): Promise<TEth.TxLike>;
    setAddr(sender: TSender, node: TEth.Hex, coinType: bigint, a: TEth.Hex): Promise<TEth.TxLike>;
    setAddr(sender: TSender, node: TEth.Hex, a: TAddress): Promise<TEth.TxLike>;
    setApprovalForAll(sender: TSender, operator: TAddress, approved: boolean): Promise<TEth.TxLike>;
    setContenthash(sender: TSender, node: TEth.Hex, hash: TEth.Hex): Promise<TEth.TxLike>;
    setDNSRecords(sender: TSender, node: TEth.Hex, data: TEth.Hex): Promise<TEth.TxLike>;
    setInterface(sender: TSender, node: TEth.Hex, interfaceID: TEth.Hex, implementer: TAddress): Promise<TEth.TxLike>;
    setName(sender: TSender, node: TEth.Hex, newName: string): Promise<TEth.TxLike>;
    setPubkey(sender: TSender, node: TEth.Hex, x: TEth.Hex, y: TEth.Hex): Promise<TEth.TxLike>;
    setText(sender: TSender, node: TEth.Hex, key: string, value: string): Promise<TEth.TxLike>;
    setZonehash(sender: TSender, node: TEth.Hex, hash: TEth.Hex): Promise<TEth.TxLike>;
}
type TEvents = TEnsPublicResolverTypes['Events'];
type TEventParams<TEventName extends keyof TEvents> = Partial<TEvents[TEventName]['outputParams']>;
type TEventArguments<TEventName extends keyof TEvents> = Partial<TEvents[TEventName]['outputArgs']>;
export {};