import { SignedTransaction, SignedTransactionWithProof } from './SignedTransaction';
import { SumMerkleTreeNode, SumMerkleProof, SumMerkleTree } from './merkle';
import { Segment } from './segment';
import { BigNumber } from 'ethers/utils';
import { Hash, Address } from './helpers/types';
import { SegmentedBlock } from './models/SegmentedBlock';
import { PredicatesManager, StateUpdate } from './StateUpdate';
/**
 * @title Block
 * @description Plasma Block
 * If we have 40bit for amount, we need 40 depth tree and 2^40 prime numbers.
 * 2^40 is 1.0995116e+12
 * ETH: 1 in plasma is 1 microether
 *     Plasma's capacity is 1098756 ether
 * ETH: 1 in plasma is 1 gwei
 *     Plasma's capacity is 1098 ether
 *
 * If we have 48bit for amount, we need 48 depth tree and 2^49 prime numbers.
 * 2^48 is 2.8147498e+14(260000000000000)
 * ETH: 1 in plasma is 1 gwei
 *     Plasma's capacity is 260000 ether
 * ETH: 1 in plasma is 10 gwei
 *     Plasma's capacity is 2600000 ether
 *
 * When there are not enough prime numbers, operator don't receive split tx and do merge.
 */
export declare class Block {
    number: number;
    superRoot: string | null;
    timestamp: BigNumber;
    isDepositBlock: boolean;
    txs: SignedTransaction[];
    depositTx?: StateUpdate;
    tree: SumMerkleTree | null;
    numTokens: number;
    confSigMap: Map<string, string[]>;
    constructor(numTokens?: number);
    checkSuperRoot(): string;
    verifySuperRoot(): boolean;
    setSuperRoot(superRoot: string): void;
    setBlockNumber(number: number): void;
    setBlockTimestamp(bn: BigNumber): void;
    setDepositTx(depositTx: StateUpdate): void;
    appendTx(tx: SignedTransaction): void;
    appendConfSig(tx: SignedTransaction, confSig: string): void;
    serialize(): {
        number: number;
        isDepositBlock: boolean;
        depositTx: string | null;
        txs: {
            states: string[];
            tw: string[];
        }[];
        root: string | null;
        numTokens: number;
        superRoot: string | null;
        timestamp: string;
        confSigs: any;
    };
    static deserialize(data: any): Block;
    getBlockNumber(): number;
    getRoot(): Hash;
    getProof(hash: string): SumMerkleProof[];
    getSignedTransaction(hash: string): SignedTransaction;
    getSignedTransactionWithProof(hash: string): SignedTransactionWithProof[];
    getSegmentedBlock(segment: Segment): SegmentedBlock;
    checkInclusion(tx: SignedTransactionWithProof, segment: Segment): boolean;
    /**
     * @description construct merkle tree
     *     by segments of the transaction output
     */
    createTree(): SumMerkleTree;
    createTokenTree(tokenId: BigNumber): SumMerkleTreeNode[];
    getTransactions(): SignedTransaction[];
    getUserTransactions(owner: Address, predicatesManager: PredicatesManager): SignedTransaction[];
    getUserTransactionAndProofs(owner: Address, predicatesManager: PredicatesManager): SignedTransactionWithProof[];
}