import { ChainType, IAddressDelta, IAddressMetaData, IMempoolEntry, IOptions, ISend, ISendManyOptions, ISendResult, IUTXO, SweepResult } from "./Types";
import { WalletAssets } from "./blockchain/assetOps";
import { getBaseCurrencyByNetwork } from "./getBaseCurrencyByNetwork";
export declare class Wallet {
    rpc: any;
    _mnemonic: string;
    _passphrase: string;
    network: ChainType;
    addressObjects: Array<IAddressMetaData>;
    receiveAddress: string;
    changeAddress: string;
    assetChangeAddress: string;
    addressPosition: number;
    baseCurrency: string;
    offlineMode: boolean;
    /**
     * High-level asset operations (issue/reissue/freeze/tag) and queries,
     * backed by `@neuraiproject/neurai-assets`. Initialised lazily on first
     * access so the constructor stays cheap.
     */
    private _assets;
    get assets(): WalletAssets;
    setBaseCurrency(currency: string): void;
    getBaseCurrency(): string;
    /**
     * Sweeping a private key means to send all the funds the address holds to your your wallet.
     * The private key you sweep does not become a part of your wallet.
     *
     * NOTE: the address you sweep needs to cointain enough XNA to pay for the transaction
     *
     * @param WIF the private key of the address that you want move funds from
     * @returns either a string, that is the transaction id or null if there were no funds to send
     */
    sweep(WIF: string, onlineMode: boolean): Promise<SweepResult>;
    getAddressObjects(): IAddressMetaData[];
    getAddresses(): Array<string>;
    init(options: IOptions): Promise<void>;
    hasHistory(addresses: Array<string>): Promise<boolean>;
    _getCandidateAddresses(external: boolean, excludeAddresses?: string[]): string[];
    _findFirstUnusedAddress(addresses: string[]): Promise<string>;
    _getFirstUnusedAddress(external: boolean, excludeAddresses?: string[]): Promise<string>;
    getHistory(): Promise<IAddressDelta[]>;
    getMempool(): Promise<IMempoolEntry[]>;
    getReceiveAddress(): Promise<string>;
    getChangeAddress(): Promise<string>;
    getAssetChangeAddress(): Promise<string>;
    /**
     *
     * @param assetName if present, only return UTXOs for that asset, otherwise for all assets
     * @returns UTXOs for assets
     */
    getAssetUTXOs(assetName?: string): Promise<IUTXO[]>;
    getUTXOs(): Promise<IUTXO[]>;
    getPrivateKeyByAddress(address: string): string | {
        seedKey: string;
        publicKey: string;
    };
    sendRawTransaction(raw: string): Promise<string>;
    send(options: ISend): Promise<ISendResult>;
    sendMany({ outputs, assetName }: ISendManyOptions): Promise<ISendResult>;
    /**
     * Build (but do not broadcast) a single-output transaction.
     * Returns an `ISendResult` with `signedTransaction` ready to broadcast.
     */
    createTransaction(options: ISend): Promise<ISendResult>;
    /**
     * Build (but do not broadcast) a multi-output transaction.
     */
    createSendManyTransaction(options: {
        assetName?: string;
        outputs: {
            [key: string]: number;
        };
        wallet?: Wallet;
        forcedUTXOs?: import("./Types").IForcedUTXO[];
        forcedChangeAddressAssets?: string;
        forcedChangeAddressBaseCurrency?: string;
    }): Promise<ISendResult>;
    /**
     * This method checks if an UTXO is being spent in the mempool.
     * rpc getaddressutxos will list available UTXOs on the chain.
     * BUT an UTXO can be being spent by a transaction in mempool.
     *
     * @param utxo
     * @returns boolean true if utxo is being spent in mempool, false if not
     */
    isSpentInMempool(utxo: IUTXO): Promise<boolean>;
    getAssets(): Promise<any>;
    getBalance(): Promise<number>;
    issueRoot(params: Parameters<WalletAssets["issueRoot"]>[0]): Promise<import("./blockchain/assetOps").AssetOpResult>;
    issueSub(params: Parameters<WalletAssets["issueSub"]>[0]): Promise<import("./blockchain/assetOps").AssetOpResult>;
    issueDepin(params: Parameters<WalletAssets["issueDepin"]>[0]): Promise<import("./blockchain/assetOps").AssetOpResult>;
    issueUnique(params: Parameters<WalletAssets["issueUnique"]>[0]): Promise<import("./blockchain/assetOps").AssetOpResult>;
    issueQualifier(params: Parameters<WalletAssets["issueQualifier"]>[0]): Promise<import("./blockchain/assetOps").AssetOpResult>;
    issueRestricted(params: Parameters<WalletAssets["issueRestricted"]>[0]): Promise<import("./blockchain/assetOps").AssetOpResult>;
    reissue(params: Parameters<WalletAssets["reissue"]>[0]): Promise<import("./blockchain/assetOps").AssetOpResult>;
    reissueRestricted(params: Parameters<WalletAssets["reissueRestricted"]>[0]): Promise<import("./blockchain/assetOps").AssetOpResult>;
    tagAddresses(params: Parameters<WalletAssets["tagAddresses"]>[0]): Promise<import("./blockchain/assetOps").AssetOpResult>;
    untagAddresses(params: Parameters<WalletAssets["untagAddresses"]>[0]): Promise<import("./blockchain/assetOps").AssetOpResult>;
    freezeAddresses(params: Parameters<WalletAssets["freezeAddresses"]>[0]): Promise<import("./blockchain/assetOps").AssetOpResult>;
    unfreezeAddresses(params: Parameters<WalletAssets["unfreezeAddresses"]>[0]): Promise<import("./blockchain/assetOps").AssetOpResult>;
    freezeAssetGlobally(params: Parameters<WalletAssets["freezeAssetGlobally"]>[0]): Promise<import("./blockchain/assetOps").AssetOpResult>;
    unfreezeAssetGlobally(params: Parameters<WalletAssets["unfreezeAssetGlobally"]>[0]): Promise<import("./blockchain/assetOps").AssetOpResult>;
    convertMempoolEntryToUTXO(mempoolEntry: IMempoolEntry): Promise<IUTXO>;
    /**
     * Get list of spendable UTXOs in mempool.
     * Note: a UTXO in mempool can already be "being spent"
     * @param mempool (optional)
     * @returns list of UTXOs in mempool ready to spend
     */
    getUTXOsInMempool(mempool?: IMempoolEntry[]): Promise<IUTXO[]>;
}
declare const _default: {
    createInstance: typeof createInstance;
    getBaseCurrencyByNetwork: typeof getBaseCurrencyByNetwork;
};
export default _default;
export declare function createInstance(options: IOptions): Promise<Wallet>;
