import { TAddress } from 'dequanto/models/TAddress';
import { TAccount } from 'dequanto/models/TAccount';
import { ClientEventsStream, TClientEventsStreamData } from 'dequanto/clients/ClientEventsStream';
import { ContractBase } from 'dequanto/contracts/ContractBase';
import { ContractStorageReaderBase } from 'dequanto/contracts/ContractStorageReaderBase';
import { TxWriter } from 'dequanto/txs/TxWriter';
import { ITxLogItem } from 'dequanto/txs/receipt/ITxLogItem';
import { Web3Client } from 'dequanto/clients/Web3Client';
import { IBlockchainExplorer } from 'dequanto/explorer/IBlockchainExplorer';
import { SubjectStream } from 'dequanto/class/SubjectStream';
import type { TAbiItem } from 'dequanto/types/TAbi';
import type { TEth } from 'dequanto/models/TEth';
import type { TOverrideReturns } from 'dequanto/utils/types';
export declare class EnsBaseRegistrar extends ContractBase {
    address: TEth.Address;
    client: Web3Client;
    explorer: IBlockchainExplorer;
    constructor(address?: TEth.Address, client?: Web3Client, explorer?: IBlockchainExplorer);
    Types: TEnsBaseRegistrarTypes;
    $meta: {
        class: string;
    };
    $constructor(deployer: TSender, _ens: TAddress, _baseNode: TEth.Hex): Promise<TxWriter>;
    GRACE_PERIOD(): Promise<bigint>;
    addController(sender: TSender, controller: TAddress): Promise<TxWriter>;
    approve(sender: TSender, to: TAddress, tokenId: bigint): Promise<TxWriter>;
    available(id: bigint): Promise<boolean>;
    balanceOf(owner: TAddress): Promise<bigint>;
    baseNode(): Promise<TEth.Hex>;
    controllers(input0: TAddress): Promise<boolean>;
    ens(): Promise<TAddress>;
    getApproved(tokenId: bigint): Promise<TAddress>;
    isApprovedForAll(owner: TAddress, operator: TAddress): Promise<boolean>;
    isOwner(): Promise<boolean>;
    nameExpires(id: bigint): Promise<bigint>;
    owner(): Promise<TAddress>;
    ownerOf(tokenId: bigint): Promise<TAddress>;
    reclaim(sender: TSender, id: bigint, owner: TAddress): Promise<TxWriter>;
    register(sender: TSender, id: bigint, owner: TAddress, duration: bigint): Promise<TxWriter>;
    registerOnly(sender: TSender, id: bigint, owner: TAddress, duration: bigint): Promise<TxWriter>;
    removeController(sender: TSender, controller: TAddress): Promise<TxWriter>;
    renew(sender: TSender, id: bigint, duration: bigint): Promise<TxWriter>;
    renounceOwnership(sender: TSender): Promise<TxWriter>;
    safeTransferFrom(sender: TSender, from: TAddress, to: TAddress, tokenId: bigint): Promise<TxWriter>;
    safeTransferFrom(sender: TSender, from: TAddress, to: TAddress, tokenId: bigint, _data: TEth.Hex): Promise<TxWriter>;
    setApprovalForAll(sender: TSender, to: TAddress, approved: boolean): Promise<TxWriter>;
    setResolver(sender: TSender, resolver: TAddress): Promise<TxWriter>;
    supportsInterface(interfaceID: TEth.Hex): Promise<boolean>;
    transferFrom(sender: TSender, from: TAddress, to: TAddress, tokenId: bigint): Promise<TxWriter>;
    transferOwnership(sender: TSender, newOwner: TAddress): Promise<TxWriter>;
    $call(): IEnsBaseRegistrarTxCaller;
    $signed(): TOverrideReturns<IEnsBaseRegistrarTxCaller, Promise<{
        signed: TEth.Hex;
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
    }>>;
    $data(): IEnsBaseRegistrarTxData;
    $gas(): TOverrideReturns<IEnsBaseRegistrarTxCaller, Promise<{
        gas?: bigint;
        price?: bigint;
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
    }>>;
    onTransaction<TMethod extends keyof TEnsBaseRegistrarTypes['Methods']>(method: TMethod, options: Parameters<ContractBase['$onTransaction']>[0]): SubjectStream<{
        tx: TEth.Tx;
        block: TEth.Block<TEth.Hex>;
        calldata: {
            method: TMethod;
            arguments: TEnsBaseRegistrarTypes['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'>>>;
    onControllerAdded(fn?: (event: TClientEventsStreamData<TEventArguments<'ControllerAdded'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'ControllerAdded'>>>;
    onControllerRemoved(fn?: (event: TClientEventsStreamData<TEventArguments<'ControllerRemoved'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'ControllerRemoved'>>>;
    onNameMigrated(fn?: (event: TClientEventsStreamData<TEventArguments<'NameMigrated'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'NameMigrated'>>>;
    onNameRegistered(fn?: (event: TClientEventsStreamData<TEventArguments<'NameRegistered'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'NameRegistered'>>>;
    onNameRenewed(fn?: (event: TClientEventsStreamData<TEventArguments<'NameRenewed'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'NameRenewed'>>>;
    onOwnershipTransferred(fn?: (event: TClientEventsStreamData<TEventArguments<'OwnershipTransferred'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'OwnershipTransferred'>>>;
    onTransfer(fn?: (event: TClientEventsStreamData<TEventArguments<'Transfer'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'Transfer'>>>;
    extractLogsApproval(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'Approval'>>[];
    extractLogsApprovalForAll(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'ApprovalForAll'>>[];
    extractLogsControllerAdded(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'ControllerAdded'>>[];
    extractLogsControllerRemoved(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'ControllerRemoved'>>[];
    extractLogsNameMigrated(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'NameMigrated'>>[];
    extractLogsNameRegistered(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'NameRegistered'>>[];
    extractLogsNameRenewed(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'NameRenewed'>>[];
    extractLogsOwnershipTransferred(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'OwnershipTransferred'>>[];
    extractLogsTransfer(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'Transfer'>>[];
    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?: {
            owner?: TAddress;
            operator?: TAddress;
        };
    }): Promise<ITxLogItem<TEventParams<'ApprovalForAll'>>[]>;
    getPastLogsControllerAdded(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            controller?: TAddress;
        };
    }): Promise<ITxLogItem<TEventParams<'ControllerAdded'>>[]>;
    getPastLogsControllerRemoved(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            controller?: TAddress;
        };
    }): Promise<ITxLogItem<TEventParams<'ControllerRemoved'>>[]>;
    getPastLogsNameMigrated(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            id?: bigint;
            owner?: TAddress;
        };
    }): Promise<ITxLogItem<TEventParams<'NameMigrated'>>[]>;
    getPastLogsNameRegistered(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            id?: bigint;
            owner?: TAddress;
        };
    }): Promise<ITxLogItem<TEventParams<'NameRegistered'>>[]>;
    getPastLogsNameRenewed(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            id?: bigint;
        };
    }): Promise<ITxLogItem<TEventParams<'NameRenewed'>>[]>;
    getPastLogsOwnershipTransferred(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            previousOwner?: TAddress;
            newOwner?: TAddress;
        };
    }): Promise<ITxLogItem<TEventParams<'OwnershipTransferred'>>[]>;
    getPastLogsTransfer(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            from?: TAddress;
            to?: TAddress;
            tokenId?: bigint;
        };
    }): Promise<ITxLogItem<TEventParams<'Transfer'>>[]>;
    abi: TAbiItem[];
    storage: EnsBaseRegistrarStorageReader;
}
type TSender = TAccount & {
    value?: string | number | bigint;
};
type TEventLogOptions<TParams> = {
    fromBlock?: number | Date;
    toBlock?: number | Date;
    params?: TParams;
};
export type TEnsBaseRegistrarTypes = {
    Events: {
        Approval: {
            outputParams: {
                owner: TAddress;
                approved: TAddress;
                tokenId: bigint;
            };
            outputArgs: [owner: TAddress, approved: TAddress, tokenId: bigint];
        };
        ApprovalForAll: {
            outputParams: {
                owner: TAddress;
                operator: TAddress;
                approved: boolean;
            };
            outputArgs: [owner: TAddress, operator: TAddress, approved: boolean];
        };
        ControllerAdded: {
            outputParams: {
                controller: TAddress;
            };
            outputArgs: [controller: TAddress];
        };
        ControllerRemoved: {
            outputParams: {
                controller: TAddress;
            };
            outputArgs: [controller: TAddress];
        };
        NameMigrated: {
            outputParams: {
                id: bigint;
                owner: TAddress;
                expires: bigint;
            };
            outputArgs: [id: bigint, owner: TAddress, expires: bigint];
        };
        NameRegistered: {
            outputParams: {
                id: bigint;
                owner: TAddress;
                expires: bigint;
            };
            outputArgs: [id: bigint, owner: TAddress, expires: bigint];
        };
        NameRenewed: {
            outputParams: {
                id: bigint;
                expires: bigint;
            };
            outputArgs: [id: bigint, expires: bigint];
        };
        OwnershipTransferred: {
            outputParams: {
                previousOwner: TAddress;
                newOwner: TAddress;
            };
            outputArgs: [previousOwner: TAddress, newOwner: TAddress];
        };
        Transfer: {
            outputParams: {
                from: TAddress;
                to: TAddress;
                tokenId: bigint;
            };
            outputArgs: [from: TAddress, to: TAddress, tokenId: bigint];
        };
    };
    Methods: {
        GRACE_PERIOD: {
            method: "GRACE_PERIOD";
            arguments: [];
        };
        addController: {
            method: "addController";
            arguments: [controller: TAddress];
        };
        approve: {
            method: "approve";
            arguments: [to: TAddress, tokenId: bigint];
        };
        available: {
            method: "available";
            arguments: [id: bigint];
        };
        balanceOf: {
            method: "balanceOf";
            arguments: [owner: TAddress];
        };
        baseNode: {
            method: "baseNode";
            arguments: [];
        };
        controllers: {
            method: "controllers";
            arguments: [input0: TAddress];
        };
        ens: {
            method: "ens";
            arguments: [];
        };
        getApproved: {
            method: "getApproved";
            arguments: [tokenId: bigint];
        };
        isApprovedForAll: {
            method: "isApprovedForAll";
            arguments: [owner: TAddress, operator: TAddress];
        };
        isOwner: {
            method: "isOwner";
            arguments: [];
        };
        nameExpires: {
            method: "nameExpires";
            arguments: [id: bigint];
        };
        owner: {
            method: "owner";
            arguments: [];
        };
        ownerOf: {
            method: "ownerOf";
            arguments: [tokenId: bigint];
        };
        reclaim: {
            method: "reclaim";
            arguments: [id: bigint, owner: TAddress];
        };
        register: {
            method: "register";
            arguments: [id: bigint, owner: TAddress, duration: bigint];
        };
        registerOnly: {
            method: "registerOnly";
            arguments: [id: bigint, owner: TAddress, duration: bigint];
        };
        removeController: {
            method: "removeController";
            arguments: [controller: TAddress];
        };
        renew: {
            method: "renew";
            arguments: [id: bigint, duration: bigint];
        };
        renounceOwnership: {
            method: "renounceOwnership";
            arguments: [];
        };
        safeTransferFrom: {
            method: "safeTransferFrom";
            arguments: [from: TAddress, to: TAddress, tokenId: bigint] | [from: TAddress, to: TAddress, tokenId: bigint, _data: TEth.Hex];
        };
        setApprovalForAll: {
            method: "setApprovalForAll";
            arguments: [to: TAddress, approved: boolean];
        };
        setResolver: {
            method: "setResolver";
            arguments: [resolver: TAddress];
        };
        supportsInterface: {
            method: "supportsInterface";
            arguments: [interfaceID: TEth.Hex];
        };
        transferFrom: {
            method: "transferFrom";
            arguments: [from: TAddress, to: TAddress, tokenId: bigint];
        };
        transferOwnership: {
            method: "transferOwnership";
            arguments: [newOwner: TAddress];
        };
    };
};
declare class EnsBaseRegistrarStorageReader extends ContractStorageReaderBase {
    address: TAddress;
    client: Web3Client;
    explorer: IBlockchainExplorer;
    constructor(address: TAddress, client: Web3Client, explorer: IBlockchainExplorer);
    _owner(): Promise<TAddress>;
    ens(): Promise<TAddress>;
    baseNode(): Promise<TEth.Hex>;
    controllers(key: TAddress): Promise<boolean>;
    _supportedInterfaces(key: TEth.Hex): Promise<boolean>;
    _tokenOwner(key: bigint): Promise<TAddress>;
    _tokenApprovals(key: bigint): Promise<TAddress>;
    _ownedTokensCount(key: TAddress): Promise<bigint>;
    _operatorApprovals(key: TAddress): Promise<Record<string | number, boolean>>;
    expiries(key: bigint): Promise<number>;
    $slots: {
        slot: number;
        position: number;
        name: string;
        size: number;
        type: string;
    }[];
}
interface IEnsBaseRegistrarTxCaller {
    addController(sender: TSender, controller: TAddress): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    approve(sender: TSender, to: TAddress, tokenId: bigint): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    reclaim(sender: TSender, id: bigint, owner: TAddress): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    register(sender: TSender, id: bigint, owner: TAddress, duration: bigint): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    registerOnly(sender: TSender, id: bigint, owner: TAddress, duration: bigint): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    removeController(sender: TSender, controller: TAddress): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    renew(sender: TSender, id: 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;
    }>;
    safeTransferFrom(sender: TSender, from: TAddress, to: TAddress, tokenId: bigint): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    safeTransferFrom(sender: TSender, from: TAddress, to: TAddress, tokenId: bigint, _data: TEth.Hex): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    setApprovalForAll(sender: TSender, to: TAddress, approved: boolean): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    setResolver(sender: TSender, resolver: TAddress): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    transferFrom(sender: TSender, from: TAddress, to: TAddress, tokenId: bigint): 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;
    }>;
}
interface IEnsBaseRegistrarTxData {
    addController(sender: TSender, controller: TAddress): Promise<TEth.TxLike>;
    approve(sender: TSender, to: TAddress, tokenId: bigint): Promise<TEth.TxLike>;
    reclaim(sender: TSender, id: bigint, owner: TAddress): Promise<TEth.TxLike>;
    register(sender: TSender, id: bigint, owner: TAddress, duration: bigint): Promise<TEth.TxLike>;
    registerOnly(sender: TSender, id: bigint, owner: TAddress, duration: bigint): Promise<TEth.TxLike>;
    removeController(sender: TSender, controller: TAddress): Promise<TEth.TxLike>;
    renew(sender: TSender, id: bigint, duration: bigint): Promise<TEth.TxLike>;
    renounceOwnership(sender: TSender): Promise<TEth.TxLike>;
    safeTransferFrom(sender: TSender, from: TAddress, to: TAddress, tokenId: bigint): Promise<TEth.TxLike>;
    safeTransferFrom(sender: TSender, from: TAddress, to: TAddress, tokenId: bigint, _data: TEth.Hex): Promise<TEth.TxLike>;
    setApprovalForAll(sender: TSender, to: TAddress, approved: boolean): Promise<TEth.TxLike>;
    setResolver(sender: TSender, resolver: TAddress): Promise<TEth.TxLike>;
    transferFrom(sender: TSender, from: TAddress, to: TAddress, tokenId: bigint): Promise<TEth.TxLike>;
    transferOwnership(sender: TSender, newOwner: TAddress): Promise<TEth.TxLike>;
}
type TEvents = TEnsBaseRegistrarTypes['Events'];
type TEventParams<TEventName extends keyof TEvents> = Partial<TEvents[TEventName]['outputParams']>;
type TEventArguments<TEventName extends keyof TEvents> = Partial<TEvents[TEventName]['outputArgs']>;
export {};