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 namespace EnsNameWrapperErrors {
    interface CannotUpgrade {
        type: 'CannotUpgrade';
        params: {};
    }
    interface IncompatibleParent {
        type: 'IncompatibleParent';
        params: {};
    }
    interface IncorrectTargetOwner {
        type: 'IncorrectTargetOwner';
        params: {
            owner: TAddress;
        };
    }
    interface IncorrectTokenType {
        type: 'IncorrectTokenType';
        params: {};
    }
    interface LabelMismatch {
        type: 'LabelMismatch';
        params: {
            labelHash: TEth.Hex;
            expectedLabelhash: TEth.Hex;
        };
    }
    interface LabelTooLong {
        type: 'LabelTooLong';
        params: {
            label: string;
        };
    }
    interface LabelTooShort {
        type: 'LabelTooShort';
        params: {};
    }
    interface NameIsNotWrapped {
        type: 'NameIsNotWrapped';
        params: {};
    }
    interface OperationProhibited {
        type: 'OperationProhibited';
        params: {
            node: TEth.Hex;
        };
    }
    interface Unauthorised {
        type: 'Unauthorised';
        params: {
            node: TEth.Hex;
            addr: TAddress;
        };
    }
    type Error = CannotUpgrade | IncompatibleParent | IncorrectTargetOwner | IncorrectTokenType | LabelMismatch | LabelTooLong | LabelTooShort | NameIsNotWrapped | OperationProhibited | Unauthorised;
}
export declare class EnsNameWrapper extends ContractBase {
    address: TEth.Address;
    client: Web3Client;
    explorer: IBlockchainExplorer;
    constructor(address?: TEth.Address, client?: Web3Client, explorer?: IBlockchainExplorer);
    Types: TEnsNameWrapperTypes;
    $meta: {
        class: string;
    };
    $constructor(deployer: TSender, _ens: TAddress, _registrar: TAddress, _metadataService: TAddress): Promise<TxWriter>;
    _tokens(input0: bigint): Promise<bigint>;
    allFusesBurned(node: TEth.Hex, fuseMask: number): Promise<boolean>;
    approve(sender: TSender, to: TAddress, tokenId: bigint): Promise<TxWriter>;
    balanceOf(account: TAddress, id: bigint): Promise<bigint>;
    balanceOfBatch(accounts: TAddress[], ids: bigint[]): Promise<bigint[]>;
    canExtendSubnames(node: TEth.Hex, addr: TAddress): Promise<boolean>;
    canModifyName(node: TEth.Hex, addr: TAddress): Promise<boolean>;
    controllers(input0: TAddress): Promise<boolean>;
    ens(): Promise<TAddress>;
    extendExpiry(sender: TSender, parentNode: TEth.Hex, labelhash: TEth.Hex, expiry: number): Promise<TxWriter>;
    getApproved(id: bigint): Promise<TAddress>;
    getData(id: bigint): Promise<{
        owner: TAddress;
        fuses: number;
        expiry: number;
    }>;
    isApprovedForAll(account: TAddress, operator: TAddress): Promise<boolean>;
    isWrapped(parentNode: TEth.Hex, labelhash: TEth.Hex): Promise<boolean>;
    isWrapped(node: TEth.Hex): Promise<boolean>;
    metadataService(): Promise<TAddress>;
    name(): Promise<string>;
    names(input0: TEth.Hex): Promise<TEth.Hex>;
    onERC721Received(sender: TSender, to: TAddress, input1: TAddress, tokenId: bigint, data: TEth.Hex): Promise<TxWriter>;
    owner(): Promise<TAddress>;
    ownerOf(id: bigint): Promise<TAddress>;
    recoverFunds(sender: TSender, _token: TAddress, _to: TAddress, _amount: bigint): Promise<TxWriter>;
    registerAndWrapETH2LD(sender: TSender, label: string, wrappedOwner: TAddress, duration: bigint, resolver: TAddress, ownerControlledFuses: number): Promise<TxWriter>;
    registrar(): Promise<TAddress>;
    renew(sender: TSender, tokenId: bigint, duration: bigint): Promise<TxWriter>;
    renounceOwnership(sender: TSender): Promise<TxWriter>;
    safeBatchTransferFrom(sender: TSender, from: TAddress, to: TAddress, ids: bigint[], amounts: bigint[], data: TEth.Hex): Promise<TxWriter>;
    safeTransferFrom(sender: TSender, from: TAddress, to: TAddress, id: bigint, amount: bigint, data: TEth.Hex): Promise<TxWriter>;
    setApprovalForAll(sender: TSender, operator: TAddress, approved: boolean): Promise<TxWriter>;
    setChildFuses(sender: TSender, parentNode: TEth.Hex, labelhash: TEth.Hex, fuses: number, expiry: number): Promise<TxWriter>;
    setController(sender: TSender, controller: TAddress, active: boolean): Promise<TxWriter>;
    setFuses(sender: TSender, node: TEth.Hex, ownerControlledFuses: number): Promise<TxWriter>;
    setMetadataService(sender: TSender, _metadataService: 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, parentNode: TEth.Hex, label: string, owner: TAddress, fuses: number, expiry: number): Promise<TxWriter>;
    setSubnodeRecord(sender: TSender, parentNode: TEth.Hex, label: string, owner: TAddress, resolver: TAddress, ttl: number, fuses: number, expiry: number): Promise<TxWriter>;
    setTTL(sender: TSender, node: TEth.Hex, ttl: number): Promise<TxWriter>;
    setUpgradeContract(sender: TSender, _upgradeAddress: TAddress): Promise<TxWriter>;
    supportsInterface(interfaceId: TEth.Hex): Promise<boolean>;
    transferOwnership(sender: TSender, newOwner: TAddress): Promise<TxWriter>;
    unwrap(sender: TSender, parentNode: TEth.Hex, labelhash: TEth.Hex, controller: TAddress): Promise<TxWriter>;
    unwrapETH2LD(sender: TSender, labelhash: TEth.Hex, registrant: TAddress, controller: TAddress): Promise<TxWriter>;
    upgrade(sender: TSender, name: TEth.Hex, extraData: TEth.Hex): Promise<TxWriter>;
    upgradeContract(): Promise<TAddress>;
    uri(tokenId: bigint): Promise<string>;
    wrap(sender: TSender, name: TEth.Hex, wrappedOwner: TAddress, resolver: TAddress): Promise<TxWriter>;
    wrapETH2LD(sender: TSender, label: string, wrappedOwner: TAddress, ownerControlledFuses: number, resolver: TAddress): Promise<TxWriter>;
    $call(): IEnsNameWrapperTxCaller;
    $signed(): TOverrideReturns<IEnsNameWrapperTxCaller, Promise<{
        signed: TEth.Hex;
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
    }>>;
    $data(): IEnsNameWrapperTxData;
    $gas(): TOverrideReturns<IEnsNameWrapperTxCaller, Promise<{
        gas?: bigint;
        price?: bigint;
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
    }>>;
    onTransaction<TMethod extends keyof TEnsNameWrapperTypes['Methods']>(method: TMethod, options: Parameters<ContractBase['$onTransaction']>[0]): SubjectStream<{
        tx: TEth.Tx;
        block: TEth.Block<TEth.Hex>;
        calldata: {
            method: TMethod;
            arguments: TEnsNameWrapperTypes['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'>>>;
    onApprovalForAll(fn?: (event: TClientEventsStreamData<TEventArguments<'ApprovalForAll'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'ApprovalForAll'>>>;
    onControllerChanged(fn?: (event: TClientEventsStreamData<TEventArguments<'ControllerChanged'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'ControllerChanged'>>>;
    onExpiryExtended(fn?: (event: TClientEventsStreamData<TEventArguments<'ExpiryExtended'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'ExpiryExtended'>>>;
    onFusesSet(fn?: (event: TClientEventsStreamData<TEventArguments<'FusesSet'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'FusesSet'>>>;
    onNameUnwrapped(fn?: (event: TClientEventsStreamData<TEventArguments<'NameUnwrapped'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'NameUnwrapped'>>>;
    onNameWrapped(fn?: (event: TClientEventsStreamData<TEventArguments<'NameWrapped'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'NameWrapped'>>>;
    onOwnershipTransferred(fn?: (event: TClientEventsStreamData<TEventArguments<'OwnershipTransferred'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'OwnershipTransferred'>>>;
    onTransferBatch(fn?: (event: TClientEventsStreamData<TEventArguments<'TransferBatch'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'TransferBatch'>>>;
    onTransferSingle(fn?: (event: TClientEventsStreamData<TEventArguments<'TransferSingle'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'TransferSingle'>>>;
    onURI(fn?: (event: TClientEventsStreamData<TEventArguments<'URI'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'URI'>>>;
    extractLogsApproval(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'Approval'>>[];
    extractLogsApprovalForAll(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'ApprovalForAll'>>[];
    extractLogsControllerChanged(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'ControllerChanged'>>[];
    extractLogsExpiryExtended(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'ExpiryExtended'>>[];
    extractLogsFusesSet(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'FusesSet'>>[];
    extractLogsNameUnwrapped(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'NameUnwrapped'>>[];
    extractLogsNameWrapped(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'NameWrapped'>>[];
    extractLogsOwnershipTransferred(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'OwnershipTransferred'>>[];
    extractLogsTransferBatch(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'TransferBatch'>>[];
    extractLogsTransferSingle(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'TransferSingle'>>[];
    extractLogsURI(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'URI'>>[];
    getPastLogsApproval(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            owner?: TAddress;
            approved?: TAddress;
            tokenId?: bigint;
        };
    }): Promise<ITxLogItem<TEventParams<'Approval'>>[]>;
    getPastLogsApprovalForAll(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            account?: TAddress;
            operator?: TAddress;
        };
    }): Promise<ITxLogItem<TEventParams<'ApprovalForAll'>>[]>;
    getPastLogsControllerChanged(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            controller?: TAddress;
        };
    }): Promise<ITxLogItem<TEventParams<'ControllerChanged'>>[]>;
    getPastLogsExpiryExtended(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            node?: TEth.Hex;
        };
    }): Promise<ITxLogItem<TEventParams<'ExpiryExtended'>>[]>;
    getPastLogsFusesSet(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            node?: TEth.Hex;
        };
    }): Promise<ITxLogItem<TEventParams<'FusesSet'>>[]>;
    getPastLogsNameUnwrapped(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            node?: TEth.Hex;
        };
    }): Promise<ITxLogItem<TEventParams<'NameUnwrapped'>>[]>;
    getPastLogsNameWrapped(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            node?: TEth.Hex;
        };
    }): Promise<ITxLogItem<TEventParams<'NameWrapped'>>[]>;
    getPastLogsOwnershipTransferred(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            previousOwner?: TAddress;
            newOwner?: TAddress;
        };
    }): Promise<ITxLogItem<TEventParams<'OwnershipTransferred'>>[]>;
    getPastLogsTransferBatch(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            operator?: TAddress;
            from?: TAddress;
            to?: TAddress;
        };
    }): Promise<ITxLogItem<TEventParams<'TransferBatch'>>[]>;
    getPastLogsTransferSingle(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            operator?: TAddress;
            from?: TAddress;
            to?: TAddress;
        };
    }): Promise<ITxLogItem<TEventParams<'TransferSingle'>>[]>;
    getPastLogsURI(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {};
    }): Promise<ITxLogItem<TEventParams<'URI'>>[]>;
    abi: TAbiItem[];
    storage: EnsNameWrapperStorageReader;
}
type TSender = TAccount & {
    value?: string | number | bigint;
};
type TEventLogOptions<TParams> = {
    fromBlock?: number | Date;
    toBlock?: number | Date;
    params?: TParams;
};
export type TEnsNameWrapperTypes = {
    Events: {
        Approval: {
            outputParams: {
                owner: TAddress;
                approved: TAddress;
                tokenId: bigint;
            };
            outputArgs: [owner: TAddress, approved: TAddress, tokenId: bigint];
        };
        ApprovalForAll: {
            outputParams: {
                account: TAddress;
                operator: TAddress;
                approved: boolean;
            };
            outputArgs: [account: TAddress, operator: TAddress, approved: boolean];
        };
        ControllerChanged: {
            outputParams: {
                controller: TAddress;
                active: boolean;
            };
            outputArgs: [controller: TAddress, active: boolean];
        };
        ExpiryExtended: {
            outputParams: {
                node: TEth.Hex;
                expiry: number;
            };
            outputArgs: [node: TEth.Hex, expiry: number];
        };
        FusesSet: {
            outputParams: {
                node: TEth.Hex;
                fuses: number;
            };
            outputArgs: [node: TEth.Hex, fuses: number];
        };
        NameUnwrapped: {
            outputParams: {
                node: TEth.Hex;
                owner: TAddress;
            };
            outputArgs: [node: TEth.Hex, owner: TAddress];
        };
        NameWrapped: {
            outputParams: {
                node: TEth.Hex;
                name: TEth.Hex;
                owner: TAddress;
                fuses: number;
                expiry: number;
            };
            outputArgs: [node: TEth.Hex, name: TEth.Hex, owner: TAddress, fuses: number, expiry: number];
        };
        OwnershipTransferred: {
            outputParams: {
                previousOwner: TAddress;
                newOwner: TAddress;
            };
            outputArgs: [previousOwner: TAddress, newOwner: TAddress];
        };
        TransferBatch: {
            outputParams: {
                operator: TAddress;
                from: TAddress;
                to: TAddress;
                ids: bigint[];
                values: bigint[];
            };
            outputArgs: [operator: TAddress, from: TAddress, to: TAddress, ids: bigint[], values: bigint[]];
        };
        TransferSingle: {
            outputParams: {
                operator: TAddress;
                from: TAddress;
                to: TAddress;
                id: bigint;
                value: bigint;
            };
            outputArgs: [operator: TAddress, from: TAddress, to: TAddress, id: bigint, value: bigint];
        };
        URI: {
            outputParams: {
                value: string;
                id: bigint;
            };
            outputArgs: [value: string, id: bigint];
        };
    };
    Methods: {
        _tokens: {
            method: "_tokens";
            arguments: [input0: bigint];
        };
        allFusesBurned: {
            method: "allFusesBurned";
            arguments: [node: TEth.Hex, fuseMask: number];
        };
        approve: {
            method: "approve";
            arguments: [to: TAddress, tokenId: bigint];
        };
        balanceOf: {
            method: "balanceOf";
            arguments: [account: TAddress, id: bigint];
        };
        balanceOfBatch: {
            method: "balanceOfBatch";
            arguments: [accounts: TAddress[], ids: bigint[]];
        };
        canExtendSubnames: {
            method: "canExtendSubnames";
            arguments: [node: TEth.Hex, addr: TAddress];
        };
        canModifyName: {
            method: "canModifyName";
            arguments: [node: TEth.Hex, addr: TAddress];
        };
        controllers: {
            method: "controllers";
            arguments: [input0: TAddress];
        };
        ens: {
            method: "ens";
            arguments: [];
        };
        extendExpiry: {
            method: "extendExpiry";
            arguments: [parentNode: TEth.Hex, labelhash: TEth.Hex, expiry: number];
        };
        getApproved: {
            method: "getApproved";
            arguments: [id: bigint];
        };
        getData: {
            method: "getData";
            arguments: [id: bigint];
        };
        isApprovedForAll: {
            method: "isApprovedForAll";
            arguments: [account: TAddress, operator: TAddress];
        };
        isWrapped: {
            method: "isWrapped";
            arguments: [parentNode: TEth.Hex, labelhash: TEth.Hex] | [node: TEth.Hex];
        };
        metadataService: {
            method: "metadataService";
            arguments: [];
        };
        name: {
            method: "name";
            arguments: [];
        };
        names: {
            method: "names";
            arguments: [input0: TEth.Hex];
        };
        onERC721Received: {
            method: "onERC721Received";
            arguments: [to: TAddress, input1: TAddress, tokenId: bigint, data: TEth.Hex];
        };
        owner: {
            method: "owner";
            arguments: [];
        };
        ownerOf: {
            method: "ownerOf";
            arguments: [id: bigint];
        };
        recoverFunds: {
            method: "recoverFunds";
            arguments: [_token: TAddress, _to: TAddress, _amount: bigint];
        };
        registerAndWrapETH2LD: {
            method: "registerAndWrapETH2LD";
            arguments: [label: string, wrappedOwner: TAddress, duration: bigint, resolver: TAddress, ownerControlledFuses: number];
        };
        registrar: {
            method: "registrar";
            arguments: [];
        };
        renew: {
            method: "renew";
            arguments: [tokenId: bigint, duration: bigint];
        };
        renounceOwnership: {
            method: "renounceOwnership";
            arguments: [];
        };
        safeBatchTransferFrom: {
            method: "safeBatchTransferFrom";
            arguments: [from: TAddress, to: TAddress, ids: bigint[], amounts: bigint[], data: TEth.Hex];
        };
        safeTransferFrom: {
            method: "safeTransferFrom";
            arguments: [from: TAddress, to: TAddress, id: bigint, amount: bigint, data: TEth.Hex];
        };
        setApprovalForAll: {
            method: "setApprovalForAll";
            arguments: [operator: TAddress, approved: boolean];
        };
        setChildFuses: {
            method: "setChildFuses";
            arguments: [parentNode: TEth.Hex, labelhash: TEth.Hex, fuses: number, expiry: number];
        };
        setController: {
            method: "setController";
            arguments: [controller: TAddress, active: boolean];
        };
        setFuses: {
            method: "setFuses";
            arguments: [node: TEth.Hex, ownerControlledFuses: number];
        };
        setMetadataService: {
            method: "setMetadataService";
            arguments: [_metadataService: 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: [parentNode: TEth.Hex, label: string, owner: TAddress, fuses: number, expiry: number];
        };
        setSubnodeRecord: {
            method: "setSubnodeRecord";
            arguments: [parentNode: TEth.Hex, label: string, owner: TAddress, resolver: TAddress, ttl: number, fuses: number, expiry: number];
        };
        setTTL: {
            method: "setTTL";
            arguments: [node: TEth.Hex, ttl: number];
        };
        setUpgradeContract: {
            method: "setUpgradeContract";
            arguments: [_upgradeAddress: TAddress];
        };
        supportsInterface: {
            method: "supportsInterface";
            arguments: [interfaceId: TEth.Hex];
        };
        transferOwnership: {
            method: "transferOwnership";
            arguments: [newOwner: TAddress];
        };
        unwrap: {
            method: "unwrap";
            arguments: [parentNode: TEth.Hex, labelhash: TEth.Hex, controller: TAddress];
        };
        unwrapETH2LD: {
            method: "unwrapETH2LD";
            arguments: [labelhash: TEth.Hex, registrant: TAddress, controller: TAddress];
        };
        upgrade: {
            method: "upgrade";
            arguments: [name: TEth.Hex, extraData: TEth.Hex];
        };
        upgradeContract: {
            method: "upgradeContract";
            arguments: [];
        };
        uri: {
            method: "uri";
            arguments: [tokenId: bigint];
        };
        wrap: {
            method: "wrap";
            arguments: [name: TEth.Hex, wrappedOwner: TAddress, resolver: TAddress];
        };
        wrapETH2LD: {
            method: "wrapETH2LD";
            arguments: [label: string, wrappedOwner: TAddress, ownerControlledFuses: number, resolver: TAddress];
        };
    };
};
declare class EnsNameWrapperStorageReader extends ContractStorageReaderBase {
    address: TAddress;
    client: Web3Client;
    explorer: IBlockchainExplorer;
    constructor(address: TAddress, client: Web3Client, explorer: IBlockchainExplorer);
    _owner(): Promise<TAddress>;
    _tokens(key: bigint): Promise<bigint>;
    _operatorApprovals(key: TAddress): Promise<Record<string | number, boolean>>;
    _tokenApprovals(key: bigint): Promise<TAddress>;
    controllers(key: TAddress): Promise<boolean>;
    metadataService(): Promise<TAddress>;
    names(key: TEth.Hex): Promise<TEth.Hex>;
    upgradeContract(): Promise<TAddress>;
    $slots: {
        slot: number;
        position: number;
        name: string;
        size: number;
        type: string;
    }[];
}
interface IEnsNameWrapperTxCaller {
    approve(sender: TSender, to: TAddress, tokenId: bigint): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    extendExpiry(sender: TSender, parentNode: TEth.Hex, labelhash: TEth.Hex, expiry: number): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    onERC721Received(sender: TSender, to: TAddress, input1: TAddress, tokenId: bigint, data: TEth.Hex): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    recoverFunds(sender: TSender, _token: TAddress, _to: TAddress, _amount: bigint): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    registerAndWrapETH2LD(sender: TSender, label: string, wrappedOwner: TAddress, duration: bigint, resolver: TAddress, ownerControlledFuses: number): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    renew(sender: TSender, tokenId: bigint, duration: bigint): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    renounceOwnership(sender: TSender): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    safeBatchTransferFrom(sender: TSender, from: TAddress, to: TAddress, ids: bigint[], amounts: bigint[], data: TEth.Hex): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    safeTransferFrom(sender: TSender, from: TAddress, to: TAddress, id: bigint, amount: bigint, data: TEth.Hex): 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;
    }>;
    setChildFuses(sender: TSender, parentNode: TEth.Hex, labelhash: TEth.Hex, fuses: number, expiry: number): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    setController(sender: TSender, controller: TAddress, active: boolean): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    setFuses(sender: TSender, node: TEth.Hex, ownerControlledFuses: number): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    setMetadataService(sender: TSender, _metadataService: 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, parentNode: TEth.Hex, label: string, owner: TAddress, fuses: number, expiry: number): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    setSubnodeRecord(sender: TSender, parentNode: TEth.Hex, label: string, owner: TAddress, resolver: TAddress, ttl: number, fuses: number, expiry: 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;
    }>;
    setUpgradeContract(sender: TSender, _upgradeAddress: TAddress): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    transferOwnership(sender: TSender, newOwner: TAddress): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    unwrap(sender: TSender, parentNode: TEth.Hex, labelhash: TEth.Hex, controller: TAddress): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    unwrapETH2LD(sender: TSender, labelhash: TEth.Hex, registrant: TAddress, controller: TAddress): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    upgrade(sender: TSender, name: TEth.Hex, extraData: TEth.Hex): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    wrap(sender: TSender, name: TEth.Hex, wrappedOwner: TAddress, resolver: TAddress): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    wrapETH2LD(sender: TSender, label: string, wrappedOwner: TAddress, ownerControlledFuses: number, resolver: TAddress): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
}
interface IEnsNameWrapperTxData {
    approve(sender: TSender, to: TAddress, tokenId: bigint): Promise<TEth.TxLike>;
    extendExpiry(sender: TSender, parentNode: TEth.Hex, labelhash: TEth.Hex, expiry: number): Promise<TEth.TxLike>;
    onERC721Received(sender: TSender, to: TAddress, input1: TAddress, tokenId: bigint, data: TEth.Hex): Promise<TEth.TxLike>;
    recoverFunds(sender: TSender, _token: TAddress, _to: TAddress, _amount: bigint): Promise<TEth.TxLike>;
    registerAndWrapETH2LD(sender: TSender, label: string, wrappedOwner: TAddress, duration: bigint, resolver: TAddress, ownerControlledFuses: number): Promise<TEth.TxLike>;
    renew(sender: TSender, tokenId: bigint, duration: bigint): Promise<TEth.TxLike>;
    renounceOwnership(sender: TSender): Promise<TEth.TxLike>;
    safeBatchTransferFrom(sender: TSender, from: TAddress, to: TAddress, ids: bigint[], amounts: bigint[], data: TEth.Hex): Promise<TEth.TxLike>;
    safeTransferFrom(sender: TSender, from: TAddress, to: TAddress, id: bigint, amount: bigint, data: TEth.Hex): Promise<TEth.TxLike>;
    setApprovalForAll(sender: TSender, operator: TAddress, approved: boolean): Promise<TEth.TxLike>;
    setChildFuses(sender: TSender, parentNode: TEth.Hex, labelhash: TEth.Hex, fuses: number, expiry: number): Promise<TEth.TxLike>;
    setController(sender: TSender, controller: TAddress, active: boolean): Promise<TEth.TxLike>;
    setFuses(sender: TSender, node: TEth.Hex, ownerControlledFuses: number): Promise<TEth.TxLike>;
    setMetadataService(sender: TSender, _metadataService: 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, parentNode: TEth.Hex, label: string, owner: TAddress, fuses: number, expiry: number): Promise<TEth.TxLike>;
    setSubnodeRecord(sender: TSender, parentNode: TEth.Hex, label: string, owner: TAddress, resolver: TAddress, ttl: number, fuses: number, expiry: number): Promise<TEth.TxLike>;
    setTTL(sender: TSender, node: TEth.Hex, ttl: number): Promise<TEth.TxLike>;
    setUpgradeContract(sender: TSender, _upgradeAddress: TAddress): Promise<TEth.TxLike>;
    transferOwnership(sender: TSender, newOwner: TAddress): Promise<TEth.TxLike>;
    unwrap(sender: TSender, parentNode: TEth.Hex, labelhash: TEth.Hex, controller: TAddress): Promise<TEth.TxLike>;
    unwrapETH2LD(sender: TSender, labelhash: TEth.Hex, registrant: TAddress, controller: TAddress): Promise<TEth.TxLike>;
    upgrade(sender: TSender, name: TEth.Hex, extraData: TEth.Hex): Promise<TEth.TxLike>;
    wrap(sender: TSender, name: TEth.Hex, wrappedOwner: TAddress, resolver: TAddress): Promise<TEth.TxLike>;
    wrapETH2LD(sender: TSender, label: string, wrappedOwner: TAddress, ownerControlledFuses: number, resolver: TAddress): Promise<TEth.TxLike>;
}
type TEvents = TEnsNameWrapperTypes['Events'];
type TEventParams<TEventName extends keyof TEvents> = Partial<TEvents[TEventName]['outputParams']>;
type TEventArguments<TEventName extends keyof TEvents> = Partial<TEvents[TEventName]['outputArgs']>;
export {};