import { Proof, ProofSDKType } from "../crypto/proof";
import { Consensus, ConsensusSDKType } from "../version/types";
import { Timestamp, TimestampSDKType } from "../../google/protobuf/timestamp";
import { ValidatorSet, ValidatorSetSDKType } from "./validator";
import { BinaryReader, BinaryWriter } from "../../binary";
export declare const protobufPackage = "tendermint.types";
/** BlockIdFlag indicates which BlcokID the signature is for */
export declare enum BlockIDFlag {
    BLOCK_ID_FLAG_UNKNOWN = 0,
    BLOCK_ID_FLAG_ABSENT = 1,
    BLOCK_ID_FLAG_COMMIT = 2,
    BLOCK_ID_FLAG_NIL = 3,
    UNRECOGNIZED = -1
}
export declare const BlockIDFlagSDKType: typeof BlockIDFlag;
export declare function blockIDFlagFromJSON(object: any): BlockIDFlag;
export declare function blockIDFlagToJSON(object: BlockIDFlag): string;
/** SignedMsgType is a type of signed message in the consensus. */
export declare enum SignedMsgType {
    SIGNED_MSG_TYPE_UNKNOWN = 0,
    /** SIGNED_MSG_TYPE_PREVOTE - Votes */
    SIGNED_MSG_TYPE_PREVOTE = 1,
    SIGNED_MSG_TYPE_PRECOMMIT = 2,
    /** SIGNED_MSG_TYPE_PROPOSAL - Proposals */
    SIGNED_MSG_TYPE_PROPOSAL = 32,
    UNRECOGNIZED = -1
}
export declare const SignedMsgTypeSDKType: typeof SignedMsgType;
export declare function signedMsgTypeFromJSON(object: any): SignedMsgType;
export declare function signedMsgTypeToJSON(object: SignedMsgType): string;
/** PartsetHeader */
export interface PartSetHeader {
    total: number;
    hash: Uint8Array;
}
/** PartsetHeader */
export interface PartSetHeaderSDKType {
    total: number;
    hash: Uint8Array;
}
export interface Part {
    index: number;
    bytes: Uint8Array;
    proof: Proof | undefined;
}
export interface PartSDKType {
    index: number;
    bytes: Uint8Array;
    proof: ProofSDKType | undefined;
}
/** BlockID */
export interface BlockID {
    hash: Uint8Array;
    partSetHeader: PartSetHeader | undefined;
}
/** BlockID */
export interface BlockIDSDKType {
    hash: Uint8Array;
    part_set_header: PartSetHeaderSDKType | undefined;
}
/** Header defines the structure of a block header. */
export interface Header {
    /** basic block info */
    version: Consensus | undefined;
    chainId: string;
    height: bigint;
    time: Timestamp | undefined;
    /** prev block info */
    lastBlockId: BlockID | undefined;
    /** hashes of block data */
    lastCommitHash: Uint8Array;
    dataHash: Uint8Array;
    /** hashes from the app output from the prev block */
    validatorsHash: Uint8Array;
    /** validators for the next block */
    nextValidatorsHash: Uint8Array;
    /** consensus params for current block */
    consensusHash: Uint8Array;
    /** state after txs from the previous block */
    appHash: Uint8Array;
    lastResultsHash: Uint8Array;
    /** consensus info */
    evidenceHash: Uint8Array;
    /** original proposer of the block */
    proposerAddress: Uint8Array;
}
/** Header defines the structure of a block header. */
export interface HeaderSDKType {
    version: ConsensusSDKType | undefined;
    chain_id: string;
    height: bigint;
    time: TimestampSDKType | undefined;
    last_block_id: BlockIDSDKType | undefined;
    last_commit_hash: Uint8Array;
    data_hash: Uint8Array;
    validators_hash: Uint8Array;
    next_validators_hash: Uint8Array;
    consensus_hash: Uint8Array;
    app_hash: Uint8Array;
    last_results_hash: Uint8Array;
    evidence_hash: Uint8Array;
    proposer_address: Uint8Array;
}
/** Data contains the set of transactions included in the block */
export interface Data {
    /**
     * Txs that will be applied by state @ block.Height+1.
     * NOTE: not all txs here are valid.  We're just agreeing on the order first.
     * This means that block.AppHash does not include these txs.
     */
    txs: Uint8Array[];
}
/** Data contains the set of transactions included in the block */
export interface DataSDKType {
    txs: Uint8Array[];
}
/**
 * Vote represents a prevote, precommit, or commit vote from validators for
 * consensus.
 */
export interface Vote {
    type: SignedMsgType;
    height: bigint;
    round: number;
    blockId: BlockID | undefined;
    timestamp: Timestamp | undefined;
    validatorAddress: Uint8Array;
    validatorIndex: number;
    signature: Uint8Array;
}
/**
 * Vote represents a prevote, precommit, or commit vote from validators for
 * consensus.
 */
export interface VoteSDKType {
    type: SignedMsgType;
    height: bigint;
    round: number;
    block_id: BlockIDSDKType | undefined;
    timestamp: TimestampSDKType | undefined;
    validator_address: Uint8Array;
    validator_index: number;
    signature: Uint8Array;
}
/** Commit contains the evidence that a block was committed by a set of validators. */
export interface Commit {
    height: bigint;
    round: number;
    blockId: BlockID | undefined;
    signatures: CommitSig[];
}
/** Commit contains the evidence that a block was committed by a set of validators. */
export interface CommitSDKType {
    height: bigint;
    round: number;
    block_id: BlockIDSDKType | undefined;
    signatures: CommitSigSDKType[];
}
/** CommitSig is a part of the Vote included in a Commit. */
export interface CommitSig {
    blockIdFlag: BlockIDFlag;
    validatorAddress: Uint8Array;
    timestamp: Timestamp | undefined;
    signature: Uint8Array;
}
/** CommitSig is a part of the Vote included in a Commit. */
export interface CommitSigSDKType {
    block_id_flag: BlockIDFlag;
    validator_address: Uint8Array;
    timestamp: TimestampSDKType | undefined;
    signature: Uint8Array;
}
export interface Proposal {
    type: SignedMsgType;
    height: bigint;
    round: number;
    polRound: number;
    blockId: BlockID | undefined;
    timestamp: Timestamp | undefined;
    signature: Uint8Array;
}
export interface ProposalSDKType {
    type: SignedMsgType;
    height: bigint;
    round: number;
    pol_round: number;
    block_id: BlockIDSDKType | undefined;
    timestamp: TimestampSDKType | undefined;
    signature: Uint8Array;
}
export interface SignedHeader {
    header?: Header | undefined;
    commit?: Commit | undefined;
}
export interface SignedHeaderSDKType {
    header?: HeaderSDKType | undefined;
    commit?: CommitSDKType | undefined;
}
export interface LightBlock {
    signedHeader?: SignedHeader | undefined;
    validatorSet?: ValidatorSet | undefined;
}
export interface LightBlockSDKType {
    signed_header?: SignedHeaderSDKType | undefined;
    validator_set?: ValidatorSetSDKType | undefined;
}
export interface BlockMeta {
    blockId: BlockID | undefined;
    blockSize: bigint;
    header: Header | undefined;
    numTxs: bigint;
}
export interface BlockMetaSDKType {
    block_id: BlockIDSDKType | undefined;
    block_size: bigint;
    header: HeaderSDKType | undefined;
    num_txs: bigint;
}
/** TxProof represents a Merkle proof of the presence of a transaction in the Merkle tree. */
export interface TxProof {
    rootHash: Uint8Array;
    data: Uint8Array;
    proof?: Proof | undefined;
}
/** TxProof represents a Merkle proof of the presence of a transaction in the Merkle tree. */
export interface TxProofSDKType {
    root_hash: Uint8Array;
    data: Uint8Array;
    proof?: ProofSDKType | undefined;
}
export declare const PartSetHeader: {
    typeUrl: string;
    encode(message: PartSetHeader, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): PartSetHeader;
    fromJSON(object: any): PartSetHeader;
    toJSON(message: PartSetHeader): unknown;
    fromPartial<I extends Partial<PartSetHeader> & {
        total?: number;
        hash?: Uint8Array;
    } & Record<Exclude<keyof I, keyof PartSetHeader>, never>>(object: I): PartSetHeader;
};
export declare const Part: {
    typeUrl: string;
    encode(message: Part, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): Part;
    fromJSON(object: any): Part;
    toJSON(message: Part): unknown;
    fromPartial<I extends Partial<Part> & {
        index?: number;
        bytes?: Uint8Array;
        proof?: Proof & {
            total: bigint;
            index: bigint;
            leafHash: Uint8Array;
            aunts: Uint8Array[] & Record<Exclude<keyof I["proof"]["aunts"], keyof Uint8Array[]>, never>;
        } & Record<Exclude<keyof I["proof"], keyof Proof>, never>;
    } & Record<Exclude<keyof I, keyof Part>, never>>(object: I): Part;
};
export declare const BlockID: {
    typeUrl: string;
    encode(message: BlockID, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): BlockID;
    fromJSON(object: any): BlockID;
    toJSON(message: BlockID): unknown;
    fromPartial<I extends Partial<BlockID> & {
        hash?: Uint8Array;
        partSetHeader?: PartSetHeader & {
            total: number;
            hash: Uint8Array;
        } & Record<Exclude<keyof I["partSetHeader"], keyof PartSetHeader>, never>;
    } & Record<Exclude<keyof I, keyof BlockID>, never>>(object: I): BlockID;
};
export declare const Header: {
    typeUrl: string;
    encode(message: Header, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): Header;
    fromJSON(object: any): Header;
    toJSON(message: Header): unknown;
    fromPartial<I extends Partial<Header> & {
        version?: Consensus & {
            block: bigint;
            app: bigint;
        } & Record<Exclude<keyof I["version"], keyof Consensus>, never>;
        chainId?: string;
        height?: bigint;
        time?: Timestamp & {
            seconds: bigint;
            nanos: number;
        } & Record<Exclude<keyof I["time"], keyof Timestamp>, never>;
        lastBlockId?: BlockID & {
            hash: Uint8Array;
            partSetHeader: PartSetHeader & {
                total: number;
                hash: Uint8Array;
            } & Record<Exclude<keyof I["lastBlockId"]["partSetHeader"], keyof PartSetHeader>, never>;
        } & Record<Exclude<keyof I["lastBlockId"], keyof BlockID>, never>;
        lastCommitHash?: Uint8Array;
        dataHash?: Uint8Array;
        validatorsHash?: Uint8Array;
        nextValidatorsHash?: Uint8Array;
        consensusHash?: Uint8Array;
        appHash?: Uint8Array;
        lastResultsHash?: Uint8Array;
        evidenceHash?: Uint8Array;
        proposerAddress?: Uint8Array;
    } & Record<Exclude<keyof I, keyof Header>, never>>(object: I): Header;
};
export declare const Data: {
    typeUrl: string;
    encode(message: Data, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): Data;
    fromJSON(object: any): Data;
    toJSON(message: Data): unknown;
    fromPartial<I extends Partial<Data> & {
        txs?: Uint8Array[] & Record<Exclude<keyof I["txs"], keyof Uint8Array[]>, never>;
    } & Record<Exclude<keyof I, "txs">, never>>(object: I): Data;
};
export declare const Vote: {
    typeUrl: string;
    encode(message: Vote, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): Vote;
    fromJSON(object: any): Vote;
    toJSON(message: Vote): unknown;
    fromPartial<I extends Partial<Vote> & {
        type?: SignedMsgType;
        height?: bigint;
        round?: number;
        blockId?: BlockID & {
            hash: Uint8Array;
            partSetHeader: PartSetHeader & {
                total: number;
                hash: Uint8Array;
            } & Record<Exclude<keyof I["blockId"]["partSetHeader"], keyof PartSetHeader>, never>;
        } & Record<Exclude<keyof I["blockId"], keyof BlockID>, never>;
        timestamp?: Timestamp & {
            seconds: bigint;
            nanos: number;
        } & Record<Exclude<keyof I["timestamp"], keyof Timestamp>, never>;
        validatorAddress?: Uint8Array;
        validatorIndex?: number;
        signature?: Uint8Array;
    } & Record<Exclude<keyof I, keyof Vote>, never>>(object: I): Vote;
};
export declare const Commit: {
    typeUrl: string;
    encode(message: Commit, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): Commit;
    fromJSON(object: any): Commit;
    toJSON(message: Commit): unknown;
    fromPartial<I extends Partial<Commit> & {
        height?: bigint;
        round?: number;
        blockId?: BlockID & {
            hash: Uint8Array;
            partSetHeader: PartSetHeader & {
                total: number;
                hash: Uint8Array;
            } & Record<Exclude<keyof I["blockId"]["partSetHeader"], keyof PartSetHeader>, never>;
        } & Record<Exclude<keyof I["blockId"], keyof BlockID>, never>;
        signatures?: CommitSig[] & (CommitSig & {
            blockIdFlag: BlockIDFlag;
            validatorAddress: Uint8Array;
            timestamp: Timestamp & {
                seconds: bigint;
                nanos: number;
            } & Record<Exclude<keyof I["signatures"][number]["timestamp"], keyof Timestamp>, never>;
            signature: Uint8Array;
        } & Record<Exclude<keyof I["signatures"][number], keyof CommitSig>, never>)[] & Record<Exclude<keyof I["signatures"], keyof CommitSig[]>, never>;
    } & Record<Exclude<keyof I, keyof Commit>, never>>(object: I): Commit;
};
export declare const CommitSig: {
    typeUrl: string;
    encode(message: CommitSig, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): CommitSig;
    fromJSON(object: any): CommitSig;
    toJSON(message: CommitSig): unknown;
    fromPartial<I extends Partial<CommitSig> & {
        blockIdFlag?: BlockIDFlag;
        validatorAddress?: Uint8Array;
        timestamp?: Timestamp & {
            seconds: bigint;
            nanos: number;
        } & Record<Exclude<keyof I["timestamp"], keyof Timestamp>, never>;
        signature?: Uint8Array;
    } & Record<Exclude<keyof I, keyof CommitSig>, never>>(object: I): CommitSig;
};
export declare const Proposal: {
    typeUrl: string;
    encode(message: Proposal, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): Proposal;
    fromJSON(object: any): Proposal;
    toJSON(message: Proposal): unknown;
    fromPartial<I extends Partial<Proposal> & {
        type?: SignedMsgType;
        height?: bigint;
        round?: number;
        polRound?: number;
        blockId?: BlockID & {
            hash: Uint8Array;
            partSetHeader: PartSetHeader & {
                total: number;
                hash: Uint8Array;
            } & Record<Exclude<keyof I["blockId"]["partSetHeader"], keyof PartSetHeader>, never>;
        } & Record<Exclude<keyof I["blockId"], keyof BlockID>, never>;
        timestamp?: Timestamp & {
            seconds: bigint;
            nanos: number;
        } & Record<Exclude<keyof I["timestamp"], keyof Timestamp>, never>;
        signature?: Uint8Array;
    } & Record<Exclude<keyof I, keyof Proposal>, never>>(object: I): Proposal;
};
export declare const SignedHeader: {
    typeUrl: string;
    encode(message: SignedHeader, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): SignedHeader;
    fromJSON(object: any): SignedHeader;
    toJSON(message: SignedHeader): unknown;
    fromPartial<I extends Partial<SignedHeader> & {
        header?: Header & {
            version: Consensus & {
                block: bigint;
                app: bigint;
            } & Record<Exclude<keyof I["header"]["version"], keyof Consensus>, never>;
            chainId: string;
            height: bigint;
            time: Timestamp & {
                seconds: bigint;
                nanos: number;
            } & Record<Exclude<keyof I["header"]["time"], keyof Timestamp>, never>;
            lastBlockId: BlockID & {
                hash: Uint8Array;
                partSetHeader: PartSetHeader & {
                    total: number;
                    hash: Uint8Array;
                } & Record<Exclude<keyof I["header"]["lastBlockId"]["partSetHeader"], keyof PartSetHeader>, never>;
            } & Record<Exclude<keyof I["header"]["lastBlockId"], keyof BlockID>, never>;
            lastCommitHash: Uint8Array;
            dataHash: Uint8Array;
            validatorsHash: Uint8Array;
            nextValidatorsHash: Uint8Array;
            consensusHash: Uint8Array;
            appHash: Uint8Array;
            lastResultsHash: Uint8Array;
            evidenceHash: Uint8Array;
            proposerAddress: Uint8Array;
        } & Record<Exclude<keyof I["header"], keyof Header>, never>;
        commit?: Commit & {
            height: bigint;
            round: number;
            blockId: BlockID & {
                hash: Uint8Array;
                partSetHeader: PartSetHeader & {
                    total: number;
                    hash: Uint8Array;
                } & Record<Exclude<keyof I["commit"]["blockId"]["partSetHeader"], keyof PartSetHeader>, never>;
            } & Record<Exclude<keyof I["commit"]["blockId"], keyof BlockID>, never>;
            signatures: CommitSig[] & (CommitSig & {
                blockIdFlag: BlockIDFlag;
                validatorAddress: Uint8Array;
                timestamp: Timestamp & {
                    seconds: bigint;
                    nanos: number;
                } & Record<Exclude<keyof I["commit"]["signatures"][number]["timestamp"], keyof Timestamp>, never>;
                signature: Uint8Array;
            } & Record<Exclude<keyof I["commit"]["signatures"][number], keyof CommitSig>, never>)[] & Record<Exclude<keyof I["commit"]["signatures"], keyof CommitSig[]>, never>;
        } & Record<Exclude<keyof I["commit"], keyof Commit>, never>;
    } & Record<Exclude<keyof I, keyof SignedHeader>, never>>(object: I): SignedHeader;
};
export declare const LightBlock: {
    typeUrl: string;
    encode(message: LightBlock, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): LightBlock;
    fromJSON(object: any): LightBlock;
    toJSON(message: LightBlock): unknown;
    fromPartial<I extends Partial<LightBlock> & {
        signedHeader?: SignedHeader & {
            header?: Header & {
                version: Consensus & {
                    block: bigint;
                    app: bigint;
                } & Record<Exclude<keyof I["signedHeader"]["header"]["version"], keyof Consensus>, never>;
                chainId: string;
                height: bigint;
                time: Timestamp & {
                    seconds: bigint;
                    nanos: number;
                } & Record<Exclude<keyof I["signedHeader"]["header"]["time"], keyof Timestamp>, never>;
                lastBlockId: BlockID & {
                    hash: Uint8Array;
                    partSetHeader: PartSetHeader & {
                        total: number;
                        hash: Uint8Array;
                    } & Record<Exclude<keyof I["signedHeader"]["header"]["lastBlockId"]["partSetHeader"], keyof PartSetHeader>, never>;
                } & Record<Exclude<keyof I["signedHeader"]["header"]["lastBlockId"], keyof BlockID>, never>;
                lastCommitHash: Uint8Array;
                dataHash: Uint8Array;
                validatorsHash: Uint8Array;
                nextValidatorsHash: Uint8Array;
                consensusHash: Uint8Array;
                appHash: Uint8Array;
                lastResultsHash: Uint8Array;
                evidenceHash: Uint8Array;
                proposerAddress: Uint8Array;
            } & Record<Exclude<keyof I["signedHeader"]["header"], keyof Header>, never>;
            commit?: Commit & {
                height: bigint;
                round: number;
                blockId: BlockID & {
                    hash: Uint8Array;
                    partSetHeader: PartSetHeader & {
                        total: number;
                        hash: Uint8Array;
                    } & Record<Exclude<keyof I["signedHeader"]["commit"]["blockId"]["partSetHeader"], keyof PartSetHeader>, never>;
                } & Record<Exclude<keyof I["signedHeader"]["commit"]["blockId"], keyof BlockID>, never>;
                signatures: CommitSig[] & (CommitSig & {
                    blockIdFlag: BlockIDFlag;
                    validatorAddress: Uint8Array;
                    timestamp: Timestamp & {
                        seconds: bigint;
                        nanos: number;
                    } & Record<Exclude<keyof I["signedHeader"]["commit"]["signatures"][number]["timestamp"], keyof Timestamp>, never>;
                    signature: Uint8Array;
                } & Record<Exclude<keyof I["signedHeader"]["commit"]["signatures"][number], keyof CommitSig>, never>)[] & Record<Exclude<keyof I["signedHeader"]["commit"]["signatures"], keyof CommitSig[]>, never>;
            } & Record<Exclude<keyof I["signedHeader"]["commit"], keyof Commit>, never>;
        } & Record<Exclude<keyof I["signedHeader"], keyof SignedHeader>, never>;
        validatorSet?: ValidatorSet & {
            validators: import("./validator").Validator[] & (import("./validator").Validator & {
                address: Uint8Array;
                pubKey: import("../crypto/keys").PublicKey & {
                    ed25519?: Uint8Array;
                    secp256k1?: Uint8Array;
                } & Record<Exclude<keyof I["validatorSet"]["validators"][number]["pubKey"], keyof import("../crypto/keys").PublicKey>, never>;
                votingPower: bigint;
                proposerPriority: bigint;
            } & Record<Exclude<keyof I["validatorSet"]["validators"][number], keyof import("./validator").Validator>, never>)[] & Record<Exclude<keyof I["validatorSet"]["validators"], keyof import("./validator").Validator[]>, never>;
            proposer?: import("./validator").Validator & {
                address: Uint8Array;
                pubKey: import("../crypto/keys").PublicKey & {
                    ed25519?: Uint8Array;
                    secp256k1?: Uint8Array;
                } & Record<Exclude<keyof I["validatorSet"]["proposer"]["pubKey"], keyof import("../crypto/keys").PublicKey>, never>;
                votingPower: bigint;
                proposerPriority: bigint;
            } & Record<Exclude<keyof I["validatorSet"]["proposer"], keyof import("./validator").Validator>, never>;
            totalVotingPower: bigint;
        } & Record<Exclude<keyof I["validatorSet"], keyof ValidatorSet>, never>;
    } & Record<Exclude<keyof I, keyof LightBlock>, never>>(object: I): LightBlock;
};
export declare const BlockMeta: {
    typeUrl: string;
    encode(message: BlockMeta, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): BlockMeta;
    fromJSON(object: any): BlockMeta;
    toJSON(message: BlockMeta): unknown;
    fromPartial<I extends Partial<BlockMeta> & {
        blockId?: BlockID & {
            hash: Uint8Array;
            partSetHeader: PartSetHeader & {
                total: number;
                hash: Uint8Array;
            } & Record<Exclude<keyof I["blockId"]["partSetHeader"], keyof PartSetHeader>, never>;
        } & Record<Exclude<keyof I["blockId"], keyof BlockID>, never>;
        blockSize?: bigint;
        header?: Header & {
            version: Consensus & {
                block: bigint;
                app: bigint;
            } & Record<Exclude<keyof I["header"]["version"], keyof Consensus>, never>;
            chainId: string;
            height: bigint;
            time: Timestamp & {
                seconds: bigint;
                nanos: number;
            } & Record<Exclude<keyof I["header"]["time"], keyof Timestamp>, never>;
            lastBlockId: BlockID & {
                hash: Uint8Array;
                partSetHeader: PartSetHeader & {
                    total: number;
                    hash: Uint8Array;
                } & Record<Exclude<keyof I["header"]["lastBlockId"]["partSetHeader"], keyof PartSetHeader>, never>;
            } & Record<Exclude<keyof I["header"]["lastBlockId"], keyof BlockID>, never>;
            lastCommitHash: Uint8Array;
            dataHash: Uint8Array;
            validatorsHash: Uint8Array;
            nextValidatorsHash: Uint8Array;
            consensusHash: Uint8Array;
            appHash: Uint8Array;
            lastResultsHash: Uint8Array;
            evidenceHash: Uint8Array;
            proposerAddress: Uint8Array;
        } & Record<Exclude<keyof I["header"], keyof Header>, never>;
        numTxs?: bigint;
    } & Record<Exclude<keyof I, keyof BlockMeta>, never>>(object: I): BlockMeta;
};
export declare const TxProof: {
    typeUrl: string;
    encode(message: TxProof, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): TxProof;
    fromJSON(object: any): TxProof;
    toJSON(message: TxProof): unknown;
    fromPartial<I extends Partial<TxProof> & {
        rootHash?: Uint8Array;
        data?: Uint8Array;
        proof?: Proof & {
            total: bigint;
            index: bigint;
            leafHash: Uint8Array;
            aunts: Uint8Array[] & Record<Exclude<keyof I["proof"]["aunts"], keyof Uint8Array[]>, never>;
        } & Record<Exclude<keyof I["proof"], keyof Proof>, never>;
    } & Record<Exclude<keyof I, keyof TxProof>, never>>(object: I): TxProof;
};