import { ICreateTransaction, ICreateTransactionEncrypted, IGenericKeyPair, IKeypair, IKeypairEncrypted, IMasterKey, IMasterKeyEncrypted, INewWalletResponse, IResult } from '../interfaces';
export declare class mgmtClient {
    private passphraseKey;
    private _seedPhrase;
    get seedPhrase(): string | undefined;
    set seedPhrase(value: string | undefined);
    private _masterKey;
    get masterKey(): IMasterKey | undefined;
    set masterKey(value: IMasterKey | undefined);
    constructor();
    /**
     * Init the client without providing a master key or seed phrase
     *
     * @param {string} passphraseKey
     * @return {*}  {IResult<[string, IMasterKeyEncrypted]>}
     * @memberof mgmtClient
     */
    initNew(passphraseKey: string): IResult<INewWalletResponse>;
    /**
     * Init the client with a provided master key
     *
     * @param {IMasterKeyEncrypted} masterKey
     * @param {string} passphraseKey
     * @return {*}  {IResult<void>}
     * @memberof mgmtClient
     */
    fromMasterKey(masterKey: IMasterKeyEncrypted, passphraseKey: string): IResult<void>;
    /**
     * Init the client with a provided seed phrase
     *
     * @param {string} seedPhrase
     * @param {string} passphraseKey
     * @return {*}  {IResult<IMasterKeyEncrypted>}
     * @memberof mgmtClient
     */
    fromSeed(seedPhrase: string, passphraseKey: string): IResult<IMasterKeyEncrypted>;
    /**
     * Get a new address
     *
     * @param {string[]} allAddresses
     * @return {*}  {IResult<IKeypairEncrypted>}
     * @memberof mgmtClient
     */
    getNewKeypair(allAddresses: string[], addressVersion?: null | number): IResult<IKeypairEncrypted>;
    /**
     * Generate a new seed phrase
     *
     * @return {*}  {IResult<string>}
     * @memberof mgmtClient
     */
    getNewSeedPhrase(): IResult<string>;
    /**
     * Get the existing seed phrase from the client
     *
     * @return {*}  {IResult<string>}
     * @memberof mgmtClient
     */
    getSeedPhrase(): IResult<string>;
    /**
     * Test a seed phrase to see if it's valid
     *
     * @param {string} seedPhrase
     * @return {*}  {IResult<void>}
     * @memberof mgmtClient
     */
    testSeedPhrase(seedPhrase: string): IResult<void>;
    /**
     * Encrypt the master key using the passphrase
     *
     * @param {IMasterKey} masterKey
     * @param {Uint8Array} [passphrase]
     * @return {*}  {IResult<IMasterKeyEncrypted>}
     * @memberof mgmtClient
     */
    encryptMasterKey(masterKey: IMasterKey, passphrase?: Uint8Array): IResult<IMasterKeyEncrypted>;
    /**
     * Decrypt the master key using the passphrase
     *
     * @param {IMasterKeyEncrypted} masterKeyEncrypted
     * @param {Uint8Array} [passphrase]
     * @return {*}  {IResult<IMasterKey>}
     * @memberof mgmtClient
     */
    decryptMasterKey(masterKeyEncrypted: IMasterKeyEncrypted, passphrase?: Uint8Array): IResult<IMasterKey>;
    /**
     * Encrypt a key-pair using the passphrase
     *
     * @param {IKeypair} keypair
     * @return {*}  {IResult<IKeypairEncrypted>}
     * @memberof mgmtClient
     */
    encryptKeypair(keypair: IKeypair): IResult<IKeypairEncrypted>;
    /**
     * Decrypt an array of encrypted key-pairs
     *
     * @param {IKeypairEncrypted[]} keypairs - Encrypted key-pair array
     * @return {*}  {IResult<IKeypair[]>}
     * @memberof mgmtClient
     */
    decryptKeypairs(keypairs: IKeypairEncrypted[]): IResult<IKeypair[]>;
    /**
     * Decrypt a key-pair using the passphrase
     *
     * @param {IKeypairEncrypted} keypair
     * @return {*}  {IResult<IKeypair>}
     * @memberof mgmtClient
     */
    decryptKeypair(keypair: IKeypairEncrypted): IResult<IKeypair>;
    /**
     * Generate a new DRUID value
     *
     * @return {*}  {IResult<string>}
     * @memberof mgmtClient
     */
    getNewDRUID(): IResult<string>;
    /**
     * Encrypt a transaction using the passphrase
     *
     * @param {ICreateTransaction} transaction
     * @return {*}  {IResult<ICreateTransactionEncrypted>}
     * @memberof mgmtClient
     */
    encryptTransaction(transaction: ICreateTransaction): IResult<ICreateTransactionEncrypted>;
    /**
     * Return a `[string[], Map<string, IKeypair>]` object from
     * an array of encrypted keypairs
     *
     * @param {IKeypairEncrypted[]} allKeypairs
     * @return {*}  {[string[], Map<string, IKeypair>]}
     * @memberof mgmtClient
     */
    getAllAddressesAndKeypairMap(allKeypairs: IKeypairEncrypted[]): IResult<[string[], Map<string, IKeypair>]>;
    /**
     * Decrypt a transaction using the passphrase
     *
     * @param {ICreateTransactionEncrypted} encryptedTx
     * @return {*}  {IResult<ICreateTransaction>}
     * @memberof mgmtClient
     */
    decryptTransaction(encryptedTx: ICreateTransactionEncrypted): IResult<ICreateTransaction>;
    /**
     * Regenerate addresses from a seed phrase and a set of addresses from UTXO set
     *
     * @param seedPhrase - Seed phrase
     * @param {string[]} addressList
     * @param {number} [seedRegenThreshold=SEED_REGEN_THRES]
     * @return {*}  {IResult<Set<string>>}
     * @memberof mgmtClient
     */
    regenAddresses(seedPhrase: string, addressList: string[], seedRegenThreshold?: number): IResult<IKeypair[]>;
    /**
     * Sign a given message with an array of keypairs
     *
     * @param {IKeypair[]} keypairs
     * @param {string} message
     * @return {*}  {IResult<IGenericKeyPair<string>>}
     * @memberof mgmtClient
     */
    signMessage(keypairs: IKeypair[], message: string): IResult<IGenericKeyPair<string>>;
    verifyMessage(message: string, signatures: IGenericKeyPair<string>, keypairs: IKeypair[]): IResult<boolean>;
    /**
     * Get the existing master key from the client
     *
     * @return {*}  {IResult<IMasterKeyEncrypted>}
     * @memberof mgmtClient
     */
    getMasterKey(): IResult<IMasterKeyEncrypted>;
    /**
     * Save keypairs to localStorage. (Browser)
     *
     * @export
     * @param {string} keypairs IKeypairEncrypted[] flattened to a string
     * @return {*} {void} address of saved keypair
     */
    saveKeypairs(keypairs: IKeypairEncrypted[]): IResult<void>;
    /**
     * Save keypairs to localStorage. (Browser)
     *
     * @export
     * @return {*} {IKeypairEncrypted[]}
     */
    getKeypairs(): IResult<IKeypairEncrypted[]>;
}