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 namespace EnsEthRegistrarControllerErrors {
    interface CommitmentTooNew {
        type: 'CommitmentTooNew';
        params: {
            commitment: TEth.Hex;
        };
    }
    interface CommitmentTooOld {
        type: 'CommitmentTooOld';
        params: {
            commitment: TEth.Hex;
        };
    }
    interface DurationTooShort {
        type: 'DurationTooShort';
        params: {
            duration: bigint;
        };
    }
    interface InsufficientValue {
        type: 'InsufficientValue';
        params: {};
    }
    interface MaxCommitmentAgeTooHigh {
        type: 'MaxCommitmentAgeTooHigh';
        params: {};
    }
    interface MaxCommitmentAgeTooLow {
        type: 'MaxCommitmentAgeTooLow';
        params: {};
    }
    interface NameNotAvailable {
        type: 'NameNotAvailable';
        params: {
            name: string;
        };
    }
    interface ResolverRequiredWhenDataSupplied {
        type: 'ResolverRequiredWhenDataSupplied';
        params: {};
    }
    interface UnexpiredCommitmentExists {
        type: 'UnexpiredCommitmentExists';
        params: {
            commitment: TEth.Hex;
        };
    }
    type Error = CommitmentTooNew | CommitmentTooOld | DurationTooShort | InsufficientValue | MaxCommitmentAgeTooHigh | MaxCommitmentAgeTooLow | NameNotAvailable | ResolverRequiredWhenDataSupplied | UnexpiredCommitmentExists;
}
export declare class EnsEthRegistrarController extends ContractBase {
    address: TEth.Address;
    client: Web3Client;
    explorer: IBlockchainExplorer;
    constructor(address?: TEth.Address, client?: Web3Client, explorer?: IBlockchainExplorer);
    Types: TEnsEthRegistrarControllerTypes;
    $meta: {
        class: string;
    };
    $constructor(deployer: TSender, _base: TAddress, _prices: TAddress, _minCommitmentAge: bigint, _maxCommitmentAge: bigint, _reverseRegistrar: TAddress, _nameWrapper: TAddress, _ens: TAddress): Promise<TxWriter>;
    MIN_REGISTRATION_DURATION(): Promise<bigint>;
    available(name: string): Promise<boolean>;
    commit(sender: TSender, commitment: TEth.Hex): Promise<TxWriter>;
    commitments(input0: TEth.Hex): Promise<bigint>;
    makeCommitment(name: string, owner: TAddress, duration: bigint, secret: TEth.Hex, resolver: TAddress, data: TEth.Hex[], reverseRecord: boolean, ownerControlledFuses: number): Promise<TEth.Hex>;
    maxCommitmentAge(): Promise<bigint>;
    minCommitmentAge(): Promise<bigint>;
    nameWrapper(): Promise<TAddress>;
    owner(): Promise<TAddress>;
    prices(): Promise<TAddress>;
    recoverFunds(sender: TSender, _token: TAddress, _to: TAddress, _amount: bigint): Promise<TxWriter>;
    register(sender: TSender, name: string, owner: TAddress, duration: bigint, secret: TEth.Hex, resolver: TAddress, data: TEth.Hex[], reverseRecord: boolean, ownerControlledFuses: number): Promise<TxWriter>;
    renew(sender: TSender, name: string, duration: bigint): Promise<TxWriter>;
    renounceOwnership(sender: TSender): Promise<TxWriter>;
    rentPrice(name: string, duration: bigint): Promise<{
        base: bigint;
        premium: bigint;
    }>;
    reverseRegistrar(): Promise<TAddress>;
    supportsInterface(interfaceID: TEth.Hex): Promise<boolean>;
    transferOwnership(sender: TSender, newOwner: TAddress): Promise<TxWriter>;
    valid(name: string): Promise<boolean>;
    withdraw(sender: TSender): Promise<TxWriter>;
    $call(): IEnsEthRegistrarControllerTxCaller;
    $signed(): TOverrideReturns<IEnsEthRegistrarControllerTxCaller, Promise<{
        signed: TEth.Hex;
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
    }>>;
    $data(): IEnsEthRegistrarControllerTxData;
    $gas(): TOverrideReturns<IEnsEthRegistrarControllerTxCaller, Promise<{
        gas?: bigint;
        price?: bigint;
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
    }>>;
    onTransaction<TMethod extends keyof TEnsEthRegistrarControllerTypes['Methods']>(method: TMethod, options: Parameters<ContractBase['$onTransaction']>[0]): SubjectStream<{
        tx: TEth.Tx;
        block: TEth.Block<TEth.Hex>;
        calldata: {
            method: TMethod;
            arguments: TEnsEthRegistrarControllerTypes['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>[]>;
    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'>>>;
    extractLogsNameRegistered(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'NameRegistered'>>[];
    extractLogsNameRenewed(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'NameRenewed'>>[];
    extractLogsOwnershipTransferred(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'OwnershipTransferred'>>[];
    getPastLogsNameRegistered(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {};
    }): Promise<ITxLogItem<TEventParams<'NameRegistered'>>[]>;
    getPastLogsNameRenewed(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {};
    }): Promise<ITxLogItem<TEventParams<'NameRenewed'>>[]>;
    getPastLogsOwnershipTransferred(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            previousOwner?: TAddress;
            newOwner?: TAddress;
        };
    }): Promise<ITxLogItem<TEventParams<'OwnershipTransferred'>>[]>;
    abi: TAbiItem[];
    storage: EnsEthRegistrarControllerStorageReader;
}
type TSender = TAccount & {
    value?: string | number | bigint;
};
type TEventLogOptions<TParams> = {
    fromBlock?: number | Date;
    toBlock?: number | Date;
    params?: TParams;
};
export type TEnsEthRegistrarControllerTypes = {
    Events: {
        NameRegistered: {
            outputParams: {
                name: string;
                label: TEth.Hex;
                owner: TAddress;
                baseCost: bigint;
                premium: bigint;
                expires: bigint;
            };
            outputArgs: [name: string, label: TEth.Hex, owner: TAddress, baseCost: bigint, premium: bigint, expires: bigint];
        };
        NameRenewed: {
            outputParams: {
                name: string;
                label: TEth.Hex;
                cost: bigint;
                expires: bigint;
            };
            outputArgs: [name: string, label: TEth.Hex, cost: bigint, expires: bigint];
        };
        OwnershipTransferred: {
            outputParams: {
                previousOwner: TAddress;
                newOwner: TAddress;
            };
            outputArgs: [previousOwner: TAddress, newOwner: TAddress];
        };
    };
    Methods: {
        MIN_REGISTRATION_DURATION: {
            method: "MIN_REGISTRATION_DURATION";
            arguments: [];
        };
        available: {
            method: "available";
            arguments: [name: string];
        };
        commit: {
            method: "commit";
            arguments: [commitment: TEth.Hex];
        };
        commitments: {
            method: "commitments";
            arguments: [input0: TEth.Hex];
        };
        makeCommitment: {
            method: "makeCommitment";
            arguments: [name: string, owner: TAddress, duration: bigint, secret: TEth.Hex, resolver: TAddress, data: TEth.Hex[], reverseRecord: boolean, ownerControlledFuses: number];
        };
        maxCommitmentAge: {
            method: "maxCommitmentAge";
            arguments: [];
        };
        minCommitmentAge: {
            method: "minCommitmentAge";
            arguments: [];
        };
        nameWrapper: {
            method: "nameWrapper";
            arguments: [];
        };
        owner: {
            method: "owner";
            arguments: [];
        };
        prices: {
            method: "prices";
            arguments: [];
        };
        recoverFunds: {
            method: "recoverFunds";
            arguments: [_token: TAddress, _to: TAddress, _amount: bigint];
        };
        register: {
            method: "register";
            arguments: [name: string, owner: TAddress, duration: bigint, secret: TEth.Hex, resolver: TAddress, data: TEth.Hex[], reverseRecord: boolean, ownerControlledFuses: number];
        };
        renew: {
            method: "renew";
            arguments: [name: string, duration: bigint];
        };
        renounceOwnership: {
            method: "renounceOwnership";
            arguments: [];
        };
        rentPrice: {
            method: "rentPrice";
            arguments: [name: string, duration: bigint];
        };
        reverseRegistrar: {
            method: "reverseRegistrar";
            arguments: [];
        };
        supportsInterface: {
            method: "supportsInterface";
            arguments: [interfaceID: TEth.Hex];
        };
        transferOwnership: {
            method: "transferOwnership";
            arguments: [newOwner: TAddress];
        };
        valid: {
            method: "valid";
            arguments: [name: string];
        };
        withdraw: {
            method: "withdraw";
            arguments: [];
        };
    };
};
declare class EnsEthRegistrarControllerStorageReader extends ContractStorageReaderBase {
    address: TAddress;
    client: Web3Client;
    explorer: IBlockchainExplorer;
    constructor(address: TAddress, client: Web3Client, explorer: IBlockchainExplorer);
    _owner(): Promise<TAddress>;
    commitments(key: TEth.Hex): Promise<bigint>;
    $slots: {
        slot: number;
        position: number;
        name: string;
        size: number;
        type: string;
    }[];
}
interface IEnsEthRegistrarControllerTxCaller {
    commit(sender: TSender, commitment: 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;
    }>;
    register(sender: TSender, name: string, owner: TAddress, duration: bigint, secret: TEth.Hex, resolver: TAddress, data: TEth.Hex[], reverseRecord: boolean, ownerControlledFuses: number): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    renew(sender: TSender, name: string, 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;
    }>;
    transferOwnership(sender: TSender, newOwner: TAddress): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    withdraw(sender: TSender): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
}
interface IEnsEthRegistrarControllerTxData {
    commit(sender: TSender, commitment: TEth.Hex): Promise<TEth.TxLike>;
    recoverFunds(sender: TSender, _token: TAddress, _to: TAddress, _amount: bigint): Promise<TEth.TxLike>;
    register(sender: TSender, name: string, owner: TAddress, duration: bigint, secret: TEth.Hex, resolver: TAddress, data: TEth.Hex[], reverseRecord: boolean, ownerControlledFuses: number): Promise<TEth.TxLike>;
    renew(sender: TSender, name: string, duration: bigint): Promise<TEth.TxLike>;
    renounceOwnership(sender: TSender): Promise<TEth.TxLike>;
    transferOwnership(sender: TSender, newOwner: TAddress): Promise<TEth.TxLike>;
    withdraw(sender: TSender): Promise<TEth.TxLike>;
}
type TEvents = TEnsEthRegistrarControllerTypes['Events'];
type TEventParams<TEventName extends keyof TEvents> = Partial<TEvents[TEventName]['outputParams']>;
type TEventArguments<TEventName extends keyof TEvents> = Partial<TEvents[TEventName]['outputArgs']>;
export {};