import { WalletMethodHandler } from './wallet-method-handler';
import { Balance, SyncOptions, SendParams, SendNativeTokenParams, SendNftParams, AccountOutputParams, FilterOptions, CreateNativeTokenParams, MintNftParams, OutputData, OutputParams, OutputsToClaim, TransactionWithMetadata, TransactionOptions, ParticipationOverview, ParticipationEventId, ParticipationEventStatus, ParticipationEventType, ParticipationEventWithNodes, ParticipationEventRegistrationOptions, ParticipationEventMap, SignedTransactionData, PreparedTransaction, ConsolidationParams, CreateDelegationTransaction, BeginStakingParams, SendManaParams } from '../types/wallet';
import { Client, Node, Burn, PreparedTransactionData } from '../client';
import { Output, FoundryOutput, PreparedCreateNativeTokenTransaction, u64, u256, NftId, TokenId, OutputId, AccountId, FoundryId, TransactionId, NumericString, Bech32Address, DelegationId, BlockId } from '../types';
import { WalletOptions, WalletEventType, WalletEvent, CreateDelegationParams } from '../types/wallet';
import { Auth, ClientOptions, LedgerNanoStatus } from '../types/client';
import { SecretManager } from '../secret_manager';
import { PreparedCreateDelegationTransaction } from '../types/wallet/create-delegation-transaction';
/** The Wallet class. */
export declare class Wallet {
    private methodHandler;
    /**
     * @param methodHandler The Rust method handler created in `WalletMethodHandler.create()`.
     */
    constructor(methodHandler: WalletMethodHandler);
    /**
     * @param options The wallet options.
     */
    static create(options: WalletOptions): Promise<Wallet>;
    /**
     * Backup the data to a Stronghold snapshot.
     */
    backupToStrongholdSnapshot(destination: string, password: string): Promise<void>;
    /**
     * Change the Stronghold password.
     */
    changeStrongholdPassword(currentPassword: string, newPassword: string): Promise<void>;
    /**
     * Clear the Stronghold password from memory.
     */
    clearStrongholdPassword(): Promise<void>;
    /**
     * Destroy the Wallet and drop its database connection.
     */
    destroy(): Promise<void>;
    /**
     * Emit a provided event for testing of the event system.
     */
    emitTestEvent(event: WalletEvent): Promise<void>;
    /**
     * Get client.
     */
    getClient(): Promise<Client>;
    /**
     * Get secret manager.
     */
    getSecretManager(): Promise<SecretManager>;
    /**
     * Get the status for a Ledger Nano.
     */
    getLedgerNanoStatus(): Promise<LedgerNanoStatus>;
    /**
     * Check if the Stronghold password has been set.
     */
    isStrongholdPasswordAvailable(): Promise<boolean>;
    /**
     * Listen to wallet events with a callback. An empty array will listen to all possible events.
     */
    listen(eventTypes: WalletEventType[], callback: (error: Error, event: WalletEvent) => void): Promise<void>;
    /**
     * Clear the callbacks for provided events. An empty array will clear all listeners.
     */
    clearListeners(eventTypes: WalletEventType[]): Promise<void>;
    /**
     * Restore a backup from a Stronghold file
     * Replaces client_options, coin_type, secret_manager and accounts. Returns an error if accounts were already created
     * If Stronghold is used as secret_manager, the existing Stronghold file will be overwritten. If a mnemonic was
     * stored, it will be gone.
     * if ignore_if_coin_type_mismatch is provided client options will not be restored
     * if ignore_if_coin_type_mismatch == true, client options coin type and accounts will not be restored if the cointype doesn't match
     * If a bech32 hrp is provided to ignore_if_bech32_hrp_mismatch, that doesn't match the one of the current address, the wallet will not be restored.
     */
    restoreFromStrongholdSnapshot(source: string, password: string, ignoreIfCoinTypeMismatch?: boolean, ignoreIfBech32Mismatch?: string): Promise<void>;
    /**
     * Set ClientOptions.
     */
    setClientOptions(clientOptions: ClientOptions): Promise<void>;
    /**
     * Set the Stronghold password.
     */
    setStrongholdPassword(password: string): Promise<void>;
    /**
     * Set the interval after which the Stronghold password gets cleared from memory.
     */
    setStrongholdPasswordClearInterval(intervalInMilliseconds?: number): Promise<void>;
    /**
     * Start the background syncing process for all accounts.
     */
    startBackgroundSync(options?: SyncOptions, intervalInMilliseconds?: number): Promise<void>;
    /**
     * Stop the background syncing process for all accounts.
     */
    stopBackgroundSync(): Promise<void>;
    /**
     * Store a mnemonic in the Stronghold snapshot.
     */
    storeMnemonic(mnemonic: string): Promise<void>;
    /**
     * Update the authentication for the provided node.
     */
    updateNodeAuth(url: string, auth?: Auth): Promise<void>;
    /**
     * Returns the accounts of the wallet.
     *
     * @returns The accounts of the wallet.
     */
    accounts(): Promise<OutputData[]>;
    /**
     * A generic function that can be used to burn native tokens, nfts, foundries and accounts.
     * @param burn The outputs or native tokens to burn
     * @param transactionOptions Additional transaction options.
     * @returns The transaction.
     */
    burn(burn: Burn, transactionOptions?: TransactionOptions): Promise<TransactionWithMetadata>;
    /**
     * A generic function that can be used to prepare to burn native tokens, nfts, foundries and accounts.
     * @param burn The outputs or native tokens to burn
     * @param transactionOptions Additional transaction options
     * @returns The prepared transaction.
     */
    prepareBurn(burn: Burn, transactionOptions?: TransactionOptions): Promise<PreparedTransaction>;
    /**
     * Burn native tokens. This doesn't require the foundry output which minted them, but will not increase
     * the foundries `melted_tokens` field, which makes it impossible to destroy the foundry output. Therefore it's
     * recommended to use melting, if the foundry output is available.
     * @param tokenId The native token id.
     * @param burnAmount The to be burned amount.
     * @param transactionOptions Additional transaction options.
     * @returns The prepared transaction.
     */
    prepareBurnNativeToken(tokenId: TokenId, burnAmount: u256, transactionOptions?: TransactionOptions): Promise<PreparedTransaction>;
    /**
     * Burn an nft output.
     * @param nftId The NftId.
     * @param transactionOptions Additional transaction options.
     * @returns The prepared transaction.
     */
    prepareBurnNft(nftId: NftId, transactionOptions?: TransactionOptions): Promise<PreparedTransaction>;
    /**
     * Claim basic or nft outputs that have additional unlock conditions
     * to their `AddressUnlockCondition` from the wallet.
     * @param outputIds The outputs to claim.
     * @returns The resulting transaction.
     */
    claimOutputs(outputIds: OutputId[]): Promise<TransactionWithMetadata>;
    /**
     * Claim basic or nft outputs that have additional unlock conditions
     * to their `AddressUnlockCondition` from the wallet.
     * @param outputIds The outputs to claim.
     * @returns The prepared transaction.
     */
    prepareClaimOutputs(outputIds: OutputId[]): Promise<PreparedTransaction>;
    /**
     * Consolidate basic outputs with only an `AddressUnlockCondition` from a wallet
     * by sending them to an own address again if the output amount is greater or
     * equal to the output consolidation threshold.
     * @param params Consolidation options.
     * @returns The consolidation transaction.
     */
    consolidateOutputs(params: ConsolidationParams): Promise<TransactionWithMetadata>;
    /**
     * Consolidate basic outputs with only an `AddressUnlockCondition` from a wallet
     * by sending them to an own address again if the output amount is greater or
     * equal to the output consolidation threshold.
     * @param params Consolidation options.
     * @returns The prepared consolidation transaction.
     */
    prepareConsolidateOutputs(params: ConsolidationParams): Promise<PreparedTransaction>;
    /**
     * Creates an account output.
     * @param params The account output options.
     * @param transactionOptions Additional transaction options.
     * @returns The transaction.
     */
    createAccountOutput(params?: AccountOutputParams, transactionOptions?: TransactionOptions): Promise<TransactionWithMetadata>;
    /**
     * Creates an account output.
     * @param params The account output options.
     * @param transactionOptions Additional transaction options.
     * @returns The prepared transaction.
     */
    prepareCreateAccountOutput(params?: AccountOutputParams, transactionOptions?: TransactionOptions): Promise<PreparedTransaction>;
    /**
     * Melt native tokens. This happens with the foundry output which minted them, by increasing its
     * `melted_tokens` field.
     * @param tokenId The native token id.
     * @param meltAmount To be melted amount.
     * @param transactionOptions Additional transaction options.
     * @returns The transaction.
     */
    meltNativeToken(tokenId: TokenId, meltAmount: bigint, transactionOptions?: TransactionOptions): Promise<TransactionWithMetadata>;
    /**
     * Melt native tokens. This happens with the foundry output which minted them, by increasing its
     * `melted_tokens` field.
     * @param tokenId The native token id.
     * @param meltAmount To be melted amount.
     * @param transactionOptions Additional transaction options.
     * @returns The prepared transaction.
     */
    prepareMeltNativeToken(tokenId: TokenId, meltAmount: u256, transactionOptions?: TransactionOptions): Promise<PreparedTransaction>;
    /**
     * Deregister a participation event.
     *
     * @param eventId The id of the participation event to deregister.
     */
    deregisterParticipationEvent(eventId: ParticipationEventId): Promise<void>;
    /**
     * Destroy an account output.
     *
     * @param accountId The AccountId.
     * @param transactionOptions Additional transaction options.
     * @returns The prepared transaction.
     */
    prepareDestroyAccount(accountId: AccountId, transactionOptions?: TransactionOptions): Promise<PreparedTransaction>;
    /**
     * Function to destroy a foundry output with a circulating supply of 0.
     * Native tokens in the foundry (minted by other foundries) will be transacted to the controlling account.
     * @param foundryId The FoundryId.
     * @param transactionOptions Additional transaction options.
     * @returns The prepared transaction.
     */
    prepareDestroyFoundry(foundryId: FoundryId, transactionOptions?: TransactionOptions): Promise<PreparedTransaction>;
    /**
     * Get the account balance.
     *
     * @returns The account balance.
     */
    getBalance(): Promise<Balance>;
    /**
     * Converts hex encoded or decimal strings of amounts to `bigint`
     * for the balance payload.
     */
    private adjustBalancePayload;
    /**
     * Get the data for an output.
     * @param outputId The output to get.
     * @returns The `OutputData`.
     */
    getOutput(outputId: OutputId): Promise<OutputData>;
    /**
     * Get a participation event.
     *
     * @param eventId The ID of the event to get.
     */
    getParticipationEvent(eventId: ParticipationEventId): Promise<ParticipationEventWithNodes>;
    /**
     * Get IDs of participation events of a certain type.
     *
     * @param node The node to get events from.
     * @param eventType The type of events to get.
     */
    getParticipationEventIds(node: Node, eventType?: ParticipationEventType): Promise<ParticipationEventId[]>;
    /**
     * Get all participation events.
     */
    getParticipationEvents(): Promise<ParticipationEventMap>;
    /**
     * Get the participation event status by its ID.
     *
     * @param eventId The ID of the event status to get.
     */
    getParticipationEventStatus(eventId: ParticipationEventId): Promise<ParticipationEventStatus>;
    /**
     * Get a `FoundryOutput` by native token ID. It will try to get the foundry from
     * the account, if it isn't in the wallet it will try to get it from the node.
     *
     * @param tokenId The native token ID to get the foundry for.
     * @returns The `FoundryOutput` that minted the token.
     */
    getFoundryOutput(tokenId: TokenId): Promise<FoundryOutput>;
    /**
     * Get outputs with additional unlock conditions.
     *
     * @param outputs The type of outputs to claim.
     * @returns The output IDs of the unlockable outputs.
     */
    claimableOutputs(outputs: OutputsToClaim): Promise<OutputId[]>;
    /**
     * Get a transaction stored in the wallet.
     *
     * @param transactionId The ID of the transaction to get.
     * @returns The transaction.
     */
    getTransaction(transactionId: TransactionId): Promise<TransactionWithMetadata>;
    /**
     * Get the transaction with inputs of an incoming transaction stored in the wallet
     * List might not be complete, if the node pruned the data already
     *
     * @param transactionId The ID of the transaction to get.
     * @returns The transaction.
     */
    getIncomingTransaction(transactionId: TransactionId): Promise<TransactionWithMetadata>;
    /**
     * Get the address of the wallet.
     *
     * @returns The address.
     */
    address(): Promise<Bech32Address>;
    /**
     * List all outputs of the wallet.
     *
     * @param filterOptions Options to filter the to be returned outputs.
     * @returns The outputs with metadata.
     */
    outputs(filterOptions?: FilterOptions): Promise<OutputData[]>;
    /**
     * List all the pending transactions of the wallet.
     *
     * @returns The transactions.
     */
    pendingTransactions(): Promise<TransactionWithMetadata[]>;
    /**
     * Returns the implicit account creation address of the wallet if it is Ed25519 based.
     *
     * @returns The implicit account creation address.
     */
    implicitAccountCreationAddress(): Promise<Bech32Address>;
    /**
     * Transitions an implicit account to an account.
     *
     * @param outputId Identifier of the implicit account output.
     * @returns The created transaction.
     */
    implicitAccountTransition(outputId: OutputId): Promise<TransactionWithMetadata>;
    /**
     * Prepares to transition an implicit account to an account.
     *
     * @param outputId Identifier of the implicit account output.
     * @returns The prepared transaction.
     */
    prepareImplicitAccountTransition(outputId: OutputId): Promise<PreparedTransaction>;
    /**
     * Returns the implicit accounts of the wallet.
     *
     * @returns The implicit accounts of the wallet.
     */
    implicitAccounts(): Promise<OutputData[]>;
    /**
     * List all incoming transactions of the wallet.
     *
     * @returns The incoming transactions with their inputs.
     */
    incomingTransactions(): Promise<TransactionWithMetadata[]>;
    /**
     * List all the transactions of the wallet.
     *
     * @returns The transactions.
     */
    transactions(): Promise<TransactionWithMetadata[]>;
    /**
     * List all the unspent outputs of the wallet.
     *
     * @param filterOptions Options to filter the to be returned outputs.
     * @returns The outputs with metadata.
     */
    unspentOutputs(filterOptions?: FilterOptions): Promise<OutputData[]>;
    /**
     * Mint additional native tokens.
     *
     * @param tokenId The native token id.
     * @param mintAmount To be minted amount.
     * @param transactionOptions Additional transaction options.
     * @returns The minting transaction.
     */
    mintNativeToken(tokenId: TokenId, mintAmount: bigint, transactionOptions?: TransactionOptions): Promise<TransactionWithMetadata>;
    /**
     * Mint additional native tokens.
     *
     * @param tokenId The native token id.
     * @param mintAmount To be minted amount.
     * @param transactionOptions Additional transaction options.
     * @returns The prepared minting transaction.
     */
    prepareMintNativeToken(tokenId: string, mintAmount: u256, transactionOptions?: TransactionOptions): Promise<PreparedTransaction>;
    /**
     * Create a native token.
     *
     * @param params The options for creating a native token.
     * @param transactionOptions Additional transaction options.
     * @returns The created transaction.
     */
    createNativeToken(params: CreateNativeTokenParams, transactionOptions?: TransactionOptions): Promise<TransactionWithMetadata>;
    /**
     * Create a native token.
     *
     * @param params The options for creating a native token.
     * @param transactionOptions Additional transaction options.
     * @returns The created transaction and the token ID.
     */
    prepareCreateNativeToken(params: CreateNativeTokenParams, transactionOptions?: TransactionOptions): Promise<PreparedCreateNativeTokenTransaction>;
    /**
     * Mint NFTs.
     *
     * @param params The options for minting nfts.
     * @param transactionOptions Additional transaction options.
     * @returns The minting transaction.
     */
    mintNfts(params: MintNftParams[], transactionOptions?: TransactionOptions): Promise<TransactionWithMetadata>;
    /**
     * Mint NFTs.
     *
     * @param params The options for minting nfts.
     * @param transactionOptions Additional transaction options.
     * @returns The prepared minting transaction.
     */
    prepareMintNfts(params: MintNftParams[], transactionOptions?: TransactionOptions): Promise<PreparedTransaction>;
    /**
     * Prepare an output for sending, useful for offline signing.
     *
     * @param options The options for preparing an output. If the amount is
     * below the minimum required storage deposit, by default the remaining
     * amount will automatically be added with a `StorageDepositReturn` `UnlockCondition`,
     * when setting the `ReturnStrategy` to `gift`, the full minimum required
     * storage deposit will be sent to the recipient. When the assets contain
     * an nft id, the data from the existing `NftOutput` will be used, just with
     * the address unlock conditions replaced.
     * @param transactionOptions Additional transaction options.
     * @returns The prepared output.
     */
    prepareOutput(params: OutputParams, transactionOptions?: TransactionOptions): Promise<Output>;
    /**
     * Prepare to send base coins, useful for offline signing.
     *
     * @param params Address with amounts to send.
     * @param options Additional transaction options.
     * @returns The prepared transaction data.
     */
    prepareSend(params: SendParams[], options?: TransactionOptions): Promise<PreparedTransaction>;
    /**
     * Create a delegation.
     *
     * @param params The options for creating a delegation.
     * @param transactionOptions Additional transaction options.
     * @returns The created transaction and the delegation ID.
     */
    createDelegation(params: CreateDelegationParams, transactionOptions?: TransactionOptions): Promise<CreateDelegationTransaction>;
    /**
     * Prepare a transaction to create a delegation.
     *
     * @param params The options for creating a delegation.
     * @param transactionOptions Additional transaction options.
     * @returns The prepared transaction and the delegation ID.
     */
    prepareCreateDelegation(params: CreateDelegationParams, transactionOptions?: TransactionOptions): Promise<PreparedCreateDelegationTransaction>;
    /**
     * Delay a delegation's claiming.
     *
     * @param delegationId The id of the delegation to delay.
     * @param reclaimExcess Indicates whether excess value over the minimum storage requirements
     * will be moved to a basic output that is unlockable by the same address which controls the delegation.
     * Otherwise it will be added to a new delegation. In this manner, one can delegate for one epoch at a time and
     * never lose out on any rewards.
     * @returns The created transaction.
     */
    delayDelegationClaiming(delegationId: DelegationId, reclaimExcess: boolean): Promise<TransactionWithMetadata>;
    /**
     * Prepare a transaction to delay a delegation's claiming.
     *
     * @param delegationId The id of the delegation to delay.
     * @param reclaimExcess Whether any excess funds should be reclaimed, or put into a new delegation.
     * @returns The prepared transaction.
     */
    prepareDelayDelegationClaiming(delegationId: DelegationId, reclaimExcess: boolean): Promise<PreparedTransaction>;
    /**
     * Begin staking.
     *
     * @param params The options for beginning staking.
     * @param transactionOptions Additional transaction options.
     * @returns The created transaction.
     */
    beginStaking(params: BeginStakingParams, transactionOptions?: TransactionOptions): Promise<TransactionWithMetadata>;
    /**
     * Prepare a transaction to begin staking.
     *
     * @param params The options for beginning staking.
     * @param transactionOptions Additional transaction options.
     * @returns The prepared transaction.
     */
    prepareBeginStaking(params: BeginStakingParams, transactionOptions?: TransactionOptions): Promise<PreparedTransaction>;
    /**
     * Extend staking period.
     *
     * @param accountId The ID of the staking account.
     * @param additionalEpochs The number of epochs to add to the staking period.
     * @returns The created transaction.
     */
    extendStaking(accountId: AccountId, additionalEpochs: number): Promise<TransactionWithMetadata>;
    /**
     * Prepare a transaction to extend a staking period.
     *
     * @param accountId The ID of the staking account.
     * @param additionalEpochs The number of epochs to add to the staking period.
     * @returns The prepared transaction.
     */
    prepareExtendStaking(accountId: AccountId, additionalEpochs: number): Promise<PreparedTransaction>;
    /**
     * End staking and claim rewards.
     *
     * @param accountId The ID of the staking account.
     * @returns The created transaction.
     */
    endStaking(accountId: AccountId): Promise<TransactionWithMetadata>;
    /**
     * Prepare a transaction to end staking and claim rewards.
     *
     * @param accountId The ID of the staking account.
     * @returns The prepared transaction.
     */
    prepareEndStaking(accountId: AccountId): Promise<PreparedTransaction>;
    /**
     * Announce a staking account's candidacy for the staking period.
     *
     * @param accountId The ID of the account to announce candidacy.
     * @returns The submitted block ID.
     */
    announceCandidacy(accountId: AccountId): Promise<BlockId>;
    /**
     * Send outputs in a transaction.
     *
     * @param outputs The outputs to send.
     * @param transactionOptions Additional transaction options.
     * @returns The sent transaction.
     */
    sendOutputs(outputs: Output[], options?: TransactionOptions): Promise<TransactionWithMetadata>;
    /**
     * Prepare a transaction, useful for offline signing.
     *
     * @param outputs Outputs to use in the transaction.
     * @param options Additional transaction options.
     * @returns The prepared transaction data.
     */
    prepareSendOutputs(outputs: Output[], options?: TransactionOptions): Promise<PreparedTransaction>;
    /**
     * Register participation events.
     *
     * @param options Options to register participation events.
     * @returns A mapping between event IDs and their corresponding event data.
     */
    registerParticipationEvents(options: ParticipationEventRegistrationOptions): Promise<ParticipationEventMap>;
    /**
     * Checks the transaction state for a provided transaction id until it's accepted. Interval in milliseconds.
     */
    waitForTransactionAcceptance(transactionId: TransactionId, interval?: number, maxAttempts?: number): Promise<void>;
    /**
     * Send base coins to an address.
     *
     * @param amount Amount of coins.
     * @param address Receiving address.
     * @param transactionOptions Additional transaction options.
     * @returns The sent transaction.
     */
    send(amount: u64 | NumericString, address: Bech32Address, transactionOptions?: TransactionOptions): Promise<TransactionWithMetadata>;
    /**
     * Send base coins with amounts from input addresses.
     *
     * @param params Addresses with amounts.
     * @param transactionOptions Additional transaction options.
     * @returns The sent transaction.
     */
    sendWithParams(params: SendParams[], transactionOptions?: TransactionOptions): Promise<TransactionWithMetadata>;
    /**
     * Send native tokens.
     *
     * @param params Addresses amounts and native tokens.
     * @param transactionOptions Additional transaction options.
     * @returns The transaction.
     */
    sendNativeTokens(params: SendNativeTokenParams[], transactionOptions?: TransactionOptions): Promise<TransactionWithMetadata>;
    /**
     * Send native tokens.
     *
     * @param params Addresses amounts and native tokens.
     * @param transactionOptions Additional transaction options.
     * @returns The prepared transaction.
     */
    prepareSendNativeTokens(params: SendNativeTokenParams[], transactionOptions?: TransactionOptions): Promise<PreparedTransaction>;
    /**
     * Send NFT.
     *
     * @param params Addresses and nft ids.
     * @param transactionOptions Additional transaction options.
     * @returns The transaction.
     */
    sendNft(params: SendNftParams[], transactionOptions?: TransactionOptions): Promise<TransactionWithMetadata>;
    /**
     * Send NFT.
     *
     * @param params Addresses and nft ids.
     * @param transactionOptions Additional transaction options.
     * @returns The prepared transaction.
     */
    prepareSendNft(params: SendNftParams[], transactionOptions?: TransactionOptions): Promise<PreparedTransaction>;
    /**
     * Send mana.
     *
     * @param params Amount, Address, and Return Strategy.
     * @param transactionOptions Additional transaction options.
     * @returns The sent transaction.
     */
    sendMana(params: SendManaParams, transactionOptions?: TransactionOptions): Promise<TransactionWithMetadata>;
    /**
     * Prepare to send mana.
     *
     * @param params Amount, Address, and Return Strategy.
     * @param transactionOptions Additional transaction options.
     * @returns The prepared transaction.
     */
    prepareSendMana(params: SendManaParams, transactionOptions?: TransactionOptions): Promise<PreparedTransaction>;
    /**
     * Set the alias for the account
     *
     * @param alias The account alias to set.
     */
    setAlias(alias: string): Promise<void>;
    /**
     * Set the fallback SyncOptions for account syncing.
     * If storage is enabled, will persist during restarts.
     *
     * @param options The sync options to set.
     */
    setDefaultSyncOptions(options: SyncOptions): Promise<void>;
    /**
     * Sign a prepared transaction, useful for offline signing.
     *
     * @param preparedTransactionData The prepared transaction data to sign.
     * @returns The signed transaction.
     */
    signTransaction(preparedTransactionData: PreparedTransactionData): Promise<SignedTransactionData>;
    /**
     * Sign a prepared transaction, and send it.
     *
     * @param preparedTransactionData The prepared transaction data to sign and submit.
     * @returns The transaction.
     */
    signAndSubmitTransaction(preparedTransactionData: PreparedTransactionData): Promise<TransactionWithMetadata>;
    /**
     * Validate the transaction, submit it to a node and store it in the wallet.
     *
     * @param signedTransactionData A signed transaction to submit and store.
     * @returns The sent transaction.
     */
    submitAndStoreTransaction(signedTransactionData: SignedTransactionData): Promise<TransactionWithMetadata>;
    /**
     * Sync the account by fetching new information from the nodes.
     * Will also reissue pending transactions if necessary.
     * A custom default can be set using setDefaultSyncOptions.
     *
     * @param options Optional synchronization options.
     * @returns The account balance.
     */
    sync(options?: SyncOptions): Promise<Balance>;
    /**
     * Prepare a vote.
     *
     * @param eventId The participation event ID.
     * @param answers Answers for a voting event, can be empty.
     * @returns An instance of `PreparedTransaction`.
     */
    prepareVote(eventId?: ParticipationEventId, answers?: number[]): Promise<PreparedTransaction>;
    /**
     * Prepare stop participating in an event.
     *
     * @param eventId The event ID to stop participating in.
     * @returns An instance of `PreparedTransaction`.
     */
    prepareStopParticipating(eventId: ParticipationEventId): Promise<PreparedTransaction>;
    /**
     * Calculates the voting overview of a wallet.
     *
     * @param eventIds Optional, filters participations only for provided events.
     * @returns An instance of `ParticipationOverview`
     */
    getParticipationOverview(eventIds?: ParticipationEventId[]): Promise<ParticipationOverview>;
    /**
     * Prepare to increase the voting power.
     *
     * @param amount The amount to increase the voting power by.
     * @returns An instance of `PreparedTransaction`.
     */
    prepareIncreaseVotingPower(amount: NumericString): Promise<PreparedTransaction>;
    /**
     * Prepare to decrease the voting power.
     *
     * @param amount The amount to decrease the voting power by.
     * @returns An instance of `PreparedTransaction`.
     */
    prepareDecreaseVotingPower(amount: NumericString): Promise<PreparedTransaction>;
}
