import type { OutputData } from './output';
import { InclusionState } from './transaction';
import { InputSigningData, Remainder } from '../client';
import { Transaction, SignedTransactionPayload, TransactionId } from '../block';
import { OutputWithMetadata } from '../models';
import { HexEncodedString } from '../utils';
/**
 * All of the wallet event types.
 */
declare enum WalletEventType {
    /** Nano Ledger has generated an address. */
    LedgerAddressGeneration = 0,
    /** A new output was created. */
    NewOutput = 1,
    /** An output was spent. */
    SpentOutput = 2,
    /** A transaction was included into the ledger. */
    TransactionInclusion = 3,
    /** A progress update while submitting a transaction. */
    TransactionProgress = 4
}
/**
 * The base class for wallet events.
 */
declare abstract class WalletEvent {
    type: WalletEventType;
    /**
     * @param type The type of wallet event.
     */
    constructor(type: WalletEventType);
}
/**
 * A 'ledger address generation' wallet event.
 */
declare class LedgerAddressGenerationWalletEvent extends WalletEvent {
    address: string;
    /**
     * @param address The generated address.
     */
    constructor(address: string);
}
/**
 * A 'new output' wallet event.
 */
declare class NewOutputWalletEvent extends WalletEvent {
    output: OutputData;
    transaction?: SignedTransactionPayload;
    transactionInputs?: OutputWithMetadata[];
    /**
     * @param output The new output.
     * @param transaction The transaction that created the output. Might be pruned and not available.
     * @param transactionInputs The inputs for the transaction that created the output. Might be pruned and not available.
     */
    constructor(output: OutputData, transaction?: SignedTransactionPayload, transactionInputs?: OutputWithMetadata[]);
}
/**
 * A 'spent output' wallet event.
 */
declare class SpentOutputWalletEvent extends WalletEvent {
    output: OutputData;
    /**
     * @param output The spent output.
     */
    constructor(output: OutputData);
}
/**
 * A 'transaction inclusion' wallet event.
 */
declare class TransactionInclusionWalletEvent extends WalletEvent {
    transactionId: TransactionId;
    inclusionState: InclusionState;
    /**
     * @param transactionId The transaction ID.
     * @param inclusionState The inclusion state of the transaction.
     */
    constructor(transactionId: TransactionId, inclusionState: InclusionState);
}
/**
 * All of the transaction progress types.
 */
declare enum TransactionProgressType {
    /** Building a transaction. */
    BuildingTransaction = 0,
    /** Generating remainder value deposit address. */
    GeneratingRemainderDepositAddress = 1,
    /** Prepared transaction. */
    PreparedTransaction = 2,
    /** Signing the transaction. */
    SigningTransaction = 3,
    /** Prepared transaction signing hash hex encoded, required for blindsigning with a Ledger Nano. */
    PreparedTransactionSigningHash = 4,
    /** Prepared block signing input, required for blindsigning with a Ledger Nano. */
    PreparedBlockSigningInput = 5,
    /** Broadcasting. */
    Broadcasting = 6
}
/**
 * A 'transaction progress' wallet event.
 */
declare class TransactionProgressWalletEvent extends WalletEvent {
    progress: TransactionProgress;
    /**
     * @param progress The progress of the transaction.
     */
    constructor(progress: TransactionProgress);
}
/**
 * The base class for transaction progresses.
 */
declare abstract class TransactionProgress {
    type: TransactionProgressType;
    /**
     * @param type The type of transaction progress.
     */
    constructor(type: TransactionProgressType);
}
/**
 * A 'building transaction' progress.
 */
declare class BuildingTransactionProgress extends TransactionProgress {
    constructor();
}
/**
 * A 'generating remainder deposit address' progress.
 */
declare class GeneratingRemainderDepositAddressProgress extends TransactionProgress {
    address: string;
    /**
     * @param address The generated remainder deposit address.
     */
    constructor(address: string);
}
/**
 * A 'prepared transaction' progress.
 */
declare class PreparedTransactionProgress extends TransactionProgress {
    transaction: Transaction;
    inputsData: InputSigningData[];
    remainders?: Remainder[];
    /**
     * @param transaction The prepared transaction.
     * @param inputsData Input signing parameters.
     * @param remainders Remainder outputs parameters.
     */
    constructor(transaction: Transaction, inputsData: InputSigningData[], remainders?: Remainder[]);
}
/**
 * A 'signing transaction' progress.
 */
declare class SigningTransactionProgress extends TransactionProgress {
    constructor();
}
/**
 * A 'prepared transaction hash' progress.
 */
declare class PreparedTransactionSigningHashProgress extends TransactionProgress {
    signingHash: HexEncodedString;
    /**
     * @param signingHash The signing hash of the transaction.
     */
    constructor(signingHash: HexEncodedString);
}
/**
 * A 'prepared block input' progress.
 */
declare class PreparedBlockSigningInputProgress extends TransactionProgress {
    blockSigningInput: HexEncodedString;
    /**
     * @param signingHash The signing hash of the block.
     */
    constructor(signingInput: HexEncodedString);
}
/**
 * A 'broadcasting' progress.
 */
declare class BroadcastingProgress extends TransactionProgress {
    constructor();
}
export { WalletEventType, WalletEvent, LedgerAddressGenerationWalletEvent, NewOutputWalletEvent, SpentOutputWalletEvent, TransactionInclusionWalletEvent, TransactionProgressWalletEvent, TransactionProgress, BuildingTransactionProgress, GeneratingRemainderDepositAddressProgress, PreparedTransactionProgress, SigningTransactionProgress, PreparedTransactionSigningHashProgress, PreparedBlockSigningInputProgress, BroadcastingProgress, TransactionProgressType, };
