import * as Dbcp from '@evan.network/dbcp';
export declare class NameResolver extends Dbcp.NameResolver {
    constructor(options: any);
    /**
     * tries to claim node ownership from parent nodes owner, this assumes, that the parent node owner
     * is a registar, that supports claiming address from it (FIFS registrar or PayableRegistrar)
     *
     * @param      {string}         name           domain name to set (plain text)
     * @param      {string}         accountId      account, that executes the transaction
     * @param      {string}         domainOwnerId  owner of the new domain, fallbacks to accountId
     * @param      {string|number}  value          (optional) value to send (if registrar is payable)
     * @return     {Promise<void>}  resolved when done
     */
    claimAddress(name: string, accountId: string, domainOwnerId?: string, value?: string): Promise<void>;
    /**
     * registers a permanent domain via registrar, can only be done by registrar owner
     *
     * @param      {string}         name           domain name to set (plain text)
     * @param      {string}         accountId      account, that executes the transaction, has to be
     *                                             registrar owner
     * @param      {string}         domainOwnerId  owner of the new domain, fallbacks to accountId
     * @return     {Promise<void>}  resolved when done
     */
    claimPermanentAddress(name: string, accountId: string, domainOwnerId?: string): Promise<void>;
    /**
     * claim funds for domain
     *
     * @param      {string}         name       ENS address of a domain owned by a registrar (e.g.
     *                                         'sample.payable.test.evan')
     * @param      {string}         accountId  account that performs the action (needs proper
     *                                         permisions for registrar)
     * @return     {Promise<void>}  resolved when done
     */
    claimFunds(name: string, accountId: string): Promise<void>;
    /**
     * get price for domain (if domain is payable)
     *
     * @param      {string}           name    a domain to check price for (e.g.
     *                                        'sample.payable.test.evan')
     * @return     {Promise<string>}  price in Wei
     */
    getPrice(name: string): Promise<string>;
    /**
     * get timestamp, when domain will stop resolval
     *
     * @param      {string}           name        domain to get valid until for
     * @return     {Promise<number>}  js timestamp, when resolver lookup will expire
     */
    getValidUntil(name: string): Promise<number>;
    /**
     * set price for a registrar at a domain
     *
     * @param      {string}         name       ENS address of a domain owned by a registrar (e.g.
     *                                         'sample.payable.test.evan')
     * @param      {string}         accountId  account that performs the action (needs proper
     *                                         permisions for registrar)
     * @param      {number|string}  newPrice   new price in Wei
     * @return     {Promise<void>}  resolved when done
     */
    setPrice(name: string, accountId: string, newPrice: number | string): Promise<void>;
    /**
     * set duration, that an address is valid; resolval stops after this, depending on configuration
     * of the ENS an extra period, where owner is still available, can be granted; notice that this
     * can only be done by parent owner of given domain
     *
     * @param      {string}         name        domain to set valid until for
     * @param      {string}         accountId   account that performs the action; must be parent owner
     *                                          of given domain
     * @param      {number|string}  validUntil  js timestamp, when name resolution stops
     * @return     {Promise<void>}  resolved when done
     */
    setValidUntil(name: string, accountId: string, validUntil: number | string): Promise<void>;
}
