/// <reference types="node" />
import EventEmitter from "events";
declare const Network: any;
declare type HWOpts = {
    network: string;
    host: string;
    port: number;
    apiKey?: string;
    memory?: boolean;
    location?: string;
};
declare type WalletInfo = {
    network: 'main' | 'simnet' | 'regtest' | 'testnet';
    wid: number;
    id: string;
    watchOnly: boolean;
    accountDepth: number;
    token: string;
    tokenDepth: number;
    master: MasterInfo;
    balance: BalanceInfo;
};
declare type MasterInfo = {
    encrypted: boolean;
    until?: number;
    iv?: string;
    ciphertext?: string;
    algorithm?: string;
    n?: number;
    r?: number;
    p?: number;
    key?: string;
    mnemonic?: string;
};
declare type BalanceInfo = {
    account: number;
    tx: number;
    coin: number;
    unconfirmed: number;
    confirmed: number;
    lockedUnconfirmed: number;
    lockedConfirmed: number;
};
declare type AccountInfo = {
    name: string;
    initialized: boolean;
    watchOnly: boolean;
    type: string;
    m: number;
    n: number;
    accountIndex: number;
    receiveDepth: number;
    changeDepth: number;
    lookahead: number;
    receiveAddress: string;
    changeAddress: string;
    accountKey: string;
    keys: string[];
    balance: BalanceInfo;
};
/**
 * Standalone hsd wallet module
 * @extends EventEmitter
 */
export default class HW extends EventEmitter {
    /**
     * Instance of the wallet client in hsd
     */
    private _walletClient;
    /**
     * Instance of the wallet db in hsd
     */
    private _wdb;
    /**
     * Current network (default: `main`)
     */
    network: typeof Network;
    /**
     * Create a HW instance.
     * @constructor
     * @param {HWOpts} options
     */
    constructor(options: HWOpts);
    /**
     * Open WalletDB
     * @return {Promise}
     */
    open(): Promise<void>;
    /**
     * Close WalletDB
     * @return {Promise}
     */
    close(): Promise<void>;
    /**
     * Rescan blockchain from a given height.
     * @param {Number?} height
     * @returns {Promise}
     */
    rescan(height?: number): Promise<void>;
    /**
     * Resend all pending transactions.
     * @returns {Promise}
     */
    resend(): Promise<void>;
    /**
     * Backup the wallet db.
     * @param {String} path
     * @returns {Promise}
     */
    backup(path: string): Promise<void>;
    /**
     * Get a list of all walets
     * @returns {Promise<string[]>} Wallet IDs
     */
    getWallets(): Promise<string[]>;
    /**
     * Get wallet
     * @param walletId
     * @returns {Promise<WalletInfo|null>} WalletInfo
     */
    getWallet(walletId: string): Promise<WalletInfo | null>;
    /**
     * Get wallet master
     * @param walletId
     * @returns {Promise<MasterInfo|null>} MasterInfo
     */
    getWalletMaster(walletId: string): Promise<MasterInfo | null>;
    /**
     * Create new wallet
     * @param walletOptions
     * @returns {Promise<WalletInfo>} WalletInfo
     */
    createWallet(walletOptions?: {
        id?: string;
        type?: string;
        master?: string;
        passphrase?: string;
        mnemonic?: string;
        accountKey?: string;
        m?: number;
        n?: number;
        witness?: boolean;
        watchOnly?: boolean;
    }): Promise<WalletInfo>;
    /**
     * List account names and indexes from the db.
     * @param {Number} walletId
     * @returns {Promise<string[]>} - Account IDs
     */
    getAccounts(walletId: string): Promise<string[]>;
    /**
     * Get account names from a specific wallet.
     * @param {String} walletId
     * @param {Number|String} accountIndex
     * @returns {Promise<AccountInfo|null>} - AccountInfo
     */
    getAccount(walletId: string, accountIndex: number | string): Promise<AccountInfo | null>;
    /**
     * Create an account. Requires passphrase if master key is encrypted.
     * @param {String} walletId
     * @param accountOptions
     * @returns {Promise<AccountInfo|null>} - AccountInfo
     */
    createAccount(walletId: string, accountOptions?: {
        passphrase?: string;
        accountKey?: string;
        account?: string;
        witness?: boolean;
        watchOnly?: boolean;
        type?: string;
        m?: number;
        n?: number;
        lookahead?: number;
    }): Promise<AccountInfo | null>;
    /**
     * Change or set master key's passphrase.
     * @param {String} walletId
     * @param {String|Buffer} passphrase
     * @param {String|Buffer} oldPassphrase
     * @returns {Promise}
     */
    setPassphrase(walletId: string, passphrase: string | Buffer, oldPassphrase: string | Buffer): Promise<void>;
    /**
     * Destroy the key by zeroing the
     * privateKey and chainCode. Stop
     * the timer if there is one.
     * @param {String} walletId
     * @returns {Promise}
     */
    lockWallet(walletId: string): Promise<void>;
    /**
     * Decrypt the key and set a timeout to destroy decrypted data.
     * @param {String} walletId
     * @param {Buffer|String} passphrase - Zero this yourself.
     * @param {Number} [timeout=60000] timeout in ms.
     * @returns {Promise} - Returns {@link HDPrivateKey}.
     */
    unlockWallet(walletId: string, passphrase: string | Buffer, timeout?: number): Promise<void>;
    /**
     * Import a keyring (will not exist on derivation chain).
     * Rescanning must be invoked manually.
     * @param {String} walletId
     * @param walletOptions
     * @returns {Promise}
     */
    importKey(walletId: string, walletOptions?: {
        account?: string;
        passphrase?: string;
        publicKey?: Buffer;
        privateKey?: string;
        address?: string;
    }): Promise<void>;
    /**
     * Generate new token
     * @param walletId
     * @param passphrase
     */
    generateNewToken(walletId: string, passphrase: string): Promise<void>;
    /**
     * Send a transaction
     * @param walletId
     * @param passphrase
     * @param txOptions
     * @returns {Promise}.
     */
    sendTx(walletId: string, passphrase: string, txOptions: any): Promise<any>;
    /**
     * Create a transaction
     * @param walletId
     * @param passphrase
     * @param txOptions
     * @param sign
     */
    createTx(walletId: string, passphrase: string, txOptions: any, sign?: boolean): Promise<any>;
    /**
     * Sign a raw transaction
     * @param walletId
     * @param passphrase
     * @param raw
     */
    signTx(walletId: string, passphrase: string, raw: Buffer): Promise<any>;
    /**
     * Zap Wallet TXs
     * @param walletId
     * @param account
     * @param age
     */
    zap(walletId: string, account: string, age: number): Promise<void>;
    /**
     * Abandon Tx
     * @param walletId
     * @param hash
     */
    abandon(walletId: string, hash: string): Promise<void>;
    /**
     * List Blocks
     * @param walletId
     */
    getBlocks(walletId: string): Promise<any>;
    getBlock(walletId: string, height: number): Promise<any>;
    addSharedKey(walletId: string, account: string, accountKey: string): Promise<any>;
    removeSharedKey(walletId: string, account: string, accountKey: string): Promise<any>;
    getKey(walletId: string, address: string): Promise<any>;
    getPrivateKey(walletId: string, passphrase: string, address: string): Promise<any>;
    createReceive(walletId: string, account: string): Promise<any>;
    createChange(walletId: string, account: string): Promise<any>;
    getBalance(walletId: string, account: string): Promise<any>;
    getCoins(walletId: string, account: string): Promise<any[]>;
    getLocked(walletId: string): Promise<any[]>;
    lockCoin(walletId: string, hash: string, coinIndex: number): Promise<void>;
    unlockCoin(walletId: string, hash: string, coinIndex: number): Promise<void>;
    getCoin(walletId: string, hash: string, coinIndex: number): Promise<void>;
    getHistory(walletId: string, account: string): Promise<any[]>;
    getPending(walletId: string, account: string): Promise<any[]>;
    getRange(walletId: string, account: string, rangeOption?: {
        start?: number;
        end?: number;
        limit?: number;
        reverse?: boolean;
    }): Promise<any[]>;
    getLast(walletId: string, account: string, limit: number): Promise<any[]>;
    getTx(walletId: string, hash: Buffer): Promise<any>;
    resendByWallet(walletId: string): Promise<void>;
    getNames(walletId: string): Promise<any[]>;
    getNameStateByName(walletId: string, name: string): Promise<any>;
    getAunctions(walletId: string): Promise<any[]>;
    getAunctionsByName(walletId: string, name: string): Promise<any>;
    getBids(walletId: string, own?: boolean): Promise<any[]>;
    getBidsByName(walletId: string, name: string, _own?: boolean): Promise<any[]>;
    getReveals(walletId: string, own?: boolean): Promise<any[]>;
    getRevealsByName(walletId: string, name: string, _own?: boolean): Promise<any[]>;
    getResourceByName(walletId: string, name: string): Promise<any>;
    generateNonce(walletId: string, name: string, options?: {
        address?: string;
        bid?: number;
    }): Promise<{
        address: any;
        blind: any;
        nonce: any;
        bid: any;
        name: string;
        nameHash: any;
    } | null>;
    importNonce(walletId: string, options?: {
        name?: string;
        address?: string;
        bid?: number;
    }): Promise<any>;
    createOpen(walletId: string, opt?: {
        name?: string;
        force?: boolean;
        passphrase?: string;
        broadcast?: boolean;
        sign?: boolean;
    }): Promise<any>;
    createBid(walletId: string, opt?: {
        name?: string;
        bid?: number;
        lockup?: number;
        passphrase?: string;
        broadcast?: boolean;
        sign?: boolean;
    }): Promise<any>;
    createReveal(walletId: string, opt?: {
        name?: string;
        passphrase?: string;
        broadcast?: boolean;
        sign?: boolean;
    }): Promise<any>;
    createRedeem(walletId: string, opt?: {
        name?: string;
        passphrase?: string;
        broadcast?: boolean;
        sign?: boolean;
    }): Promise<any>;
    createUpdate(walletId: string, opt?: {
        name?: string;
        passphrase?: string;
        broadcast?: boolean;
        sign?: boolean;
        data?: any;
    }): Promise<any>;
    createRenewal(walletId: string, opt?: {
        name?: string;
        passphrase?: string;
        broadcast?: boolean;
        sign?: boolean;
    }): Promise<any>;
    createTransfer(walletId: string, opt?: {
        name?: string;
        address?: string;
        passphrase?: string;
        broadcast?: boolean;
        sign?: boolean;
    }): Promise<any>;
    createCancel(walletId: string, opt?: {
        name?: string;
        passphrase?: string;
        broadcast?: boolean;
        sign?: boolean;
    }): Promise<any>;
    createFinalize(walletId: string, opt?: {
        name?: string;
        passphrase?: string;
        broadcast?: boolean;
        sign?: boolean;
    }): Promise<any>;
    createRevoke(walletId: string, opt?: {
        name?: string;
        passphrase?: string;
        broadcast?: boolean;
        sign?: boolean;
    }): Promise<any>;
}
export {};