import { BinaryWriter, BlockJSON, ECPoint, UInt160, UInt256 } from '@neo-one/client-common-browserify';
import BN from 'bn.js';
import { Account, AccountKey } from './Account';
import { Asset, AssetKey } from './Asset';
import { BlockBase } from './BlockBase';
import { Header, HeaderKey } from './Header';
import { DeserializeWireBaseOptions, DeserializeWireOptions, SerializableJSON, SerializableWire, SerializeJSONContext } from './Serializable';
import { FeeContext, Input, Output, OutputKey, RegisterTransaction, Transaction, TransactionType } from './transaction';
import { Validator } from './Validator';
import { VerifyScript } from './vm';
import { Witness } from './Witness';
export interface BlockAdd {
    readonly version?: number;
    readonly previousHash: UInt256;
    readonly merkleRoot?: UInt256;
    readonly timestamp: number;
    readonly index: number;
    readonly consensusData: BN;
    readonly nextConsensus: UInt160;
    readonly script?: Witness;
    readonly hash?: UInt256;
    readonly transactions: readonly Transaction[];
}
export interface BlockKey {
    readonly hashOrIndex: UInt256 | number;
}
export interface BlockVerifyOptions {
    readonly genesisBlock: Block;
    readonly tryGetBlock: (block: BlockKey) => Promise<Block | undefined>;
    readonly tryGetHeader: (header: HeaderKey) => Promise<Header | undefined>;
    readonly isSpent: (key: OutputKey) => Promise<boolean>;
    readonly getAsset: (key: AssetKey) => Promise<Asset>;
    readonly getOutput: (key: OutputKey) => Promise<Output>;
    readonly tryGetAccount: (key: AccountKey) => Promise<Account | undefined>;
    readonly getValidators: (transactions: readonly Transaction[]) => Promise<readonly ECPoint[]>;
    readonly standbyValidators: readonly ECPoint[];
    readonly getAllValidators: () => Promise<readonly Validator[]>;
    readonly calculateClaimAmount: (inputs: readonly Input[]) => Promise<BN>;
    readonly verifyScript: VerifyScript;
    readonly currentHeight: number;
    readonly governingToken: RegisterTransaction;
    readonly utilityToken: RegisterTransaction;
    readonly fees: {
        [K in TransactionType]?: BN;
    };
    readonly registerValidatorFee: BN;
    readonly completely?: boolean;
}
export declare class Block extends BlockBase implements SerializableWire<Block>, SerializableJSON<BlockJSON> {
    static calculateNetworkFee(context: FeeContext, transactions: readonly Transaction[]): Promise<BN>;
    static deserializeWireBase(options: DeserializeWireBaseOptions): Block;
    static deserializeWire(options: DeserializeWireOptions): Block;
    readonly transactions: readonly Transaction[];
    protected readonly sizeExclusive: () => number;
    private readonly headerInternal;
    constructor({ version, previousHash, timestamp, index, consensusData, nextConsensus, script, hash, transactions, merkleRoot, }: BlockAdd);
    readonly header: Header;
    clone({ transactions, script, }: {
        readonly transactions: readonly Transaction[];
        readonly script: Witness;
    }): Block;
    getNetworkFee(context: FeeContext): Promise<BN>;
    getSystemFee(context: FeeContext): BN;
    verify(options: BlockVerifyOptions): Promise<void>;
    serializeWireBase(writer: BinaryWriter): void;
    serializeJSON(context: SerializeJSONContext): Promise<BlockJSON>;
    private verifyBase;
    private verifyComplete;
    private verifyConsensus;
    private verifyTransactions;
    private verifyNetworkFee;
}