import { Vote, VoteSDKType, LightBlock, LightBlockSDKType } from "./types";
import { Timestamp, TimestampSDKType } from "../../google/protobuf/timestamp";
import { Validator, ValidatorSDKType } from "./validator";
import { BinaryReader, BinaryWriter } from "../../binary";
export declare const protobufPackage = "tendermint.types";
export interface Evidence {
    duplicateVoteEvidence?: DuplicateVoteEvidence | undefined;
    lightClientAttackEvidence?: LightClientAttackEvidence | undefined;
}
export interface EvidenceSDKType {
    duplicate_vote_evidence?: DuplicateVoteEvidenceSDKType | undefined;
    light_client_attack_evidence?: LightClientAttackEvidenceSDKType | undefined;
}
/** DuplicateVoteEvidence contains evidence of a validator signed two conflicting votes. */
export interface DuplicateVoteEvidence {
    voteA?: Vote | undefined;
    voteB?: Vote | undefined;
    totalVotingPower: bigint;
    validatorPower: bigint;
    timestamp: Timestamp | undefined;
}
/** DuplicateVoteEvidence contains evidence of a validator signed two conflicting votes. */
export interface DuplicateVoteEvidenceSDKType {
    vote_a?: VoteSDKType | undefined;
    vote_b?: VoteSDKType | undefined;
    total_voting_power: bigint;
    validator_power: bigint;
    timestamp: TimestampSDKType | undefined;
}
/** LightClientAttackEvidence contains evidence of a set of validators attempting to mislead a light client. */
export interface LightClientAttackEvidence {
    conflictingBlock?: LightBlock | undefined;
    commonHeight: bigint;
    byzantineValidators: Validator[];
    totalVotingPower: bigint;
    timestamp: Timestamp | undefined;
}
/** LightClientAttackEvidence contains evidence of a set of validators attempting to mislead a light client. */
export interface LightClientAttackEvidenceSDKType {
    conflicting_block?: LightBlockSDKType | undefined;
    common_height: bigint;
    byzantine_validators: ValidatorSDKType[];
    total_voting_power: bigint;
    timestamp: TimestampSDKType | undefined;
}
export interface EvidenceList {
    evidence: Evidence[];
}
export interface EvidenceListSDKType {
    evidence: EvidenceSDKType[];
}
export declare const Evidence: {
    typeUrl: string;
    encode(message: Evidence, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): Evidence;
    fromJSON(object: any): Evidence;
    toJSON(message: Evidence): unknown;
    fromPartial<I extends Partial<Evidence> & {
        duplicateVoteEvidence?: DuplicateVoteEvidence & {
            voteA?: Vote & {
                type: import("./types").SignedMsgType;
                height: bigint;
                round: number;
                blockId: import("./types").BlockID & {
                    hash: Uint8Array;
                    partSetHeader: import("./types").PartSetHeader & {
                        total: number;
                        hash: Uint8Array;
                    } & Record<Exclude<keyof I["duplicateVoteEvidence"]["voteA"]["blockId"]["partSetHeader"], keyof import("./types").PartSetHeader>, never>;
                } & Record<Exclude<keyof I["duplicateVoteEvidence"]["voteA"]["blockId"], keyof import("./types").BlockID>, never>;
                timestamp: Timestamp & {
                    seconds: bigint;
                    nanos: number;
                } & Record<Exclude<keyof I["duplicateVoteEvidence"]["voteA"]["timestamp"], keyof Timestamp>, never>;
                validatorAddress: Uint8Array;
                validatorIndex: number;
                signature: Uint8Array;
            } & Record<Exclude<keyof I["duplicateVoteEvidence"]["voteA"], keyof Vote>, never>;
            voteB?: Vote & {
                type: import("./types").SignedMsgType;
                height: bigint;
                round: number;
                blockId: import("./types").BlockID & {
                    hash: Uint8Array;
                    partSetHeader: import("./types").PartSetHeader & {
                        total: number;
                        hash: Uint8Array;
                    } & Record<Exclude<keyof I["duplicateVoteEvidence"]["voteB"]["blockId"]["partSetHeader"], keyof import("./types").PartSetHeader>, never>;
                } & Record<Exclude<keyof I["duplicateVoteEvidence"]["voteB"]["blockId"], keyof import("./types").BlockID>, never>;
                timestamp: Timestamp & {
                    seconds: bigint;
                    nanos: number;
                } & Record<Exclude<keyof I["duplicateVoteEvidence"]["voteB"]["timestamp"], keyof Timestamp>, never>;
                validatorAddress: Uint8Array;
                validatorIndex: number;
                signature: Uint8Array;
            } & Record<Exclude<keyof I["duplicateVoteEvidence"]["voteB"], keyof Vote>, never>;
            totalVotingPower: bigint;
            validatorPower: bigint;
            timestamp: Timestamp & {
                seconds: bigint;
                nanos: number;
            } & Record<Exclude<keyof I["duplicateVoteEvidence"]["timestamp"], keyof Timestamp>, never>;
        } & Record<Exclude<keyof I["duplicateVoteEvidence"], keyof DuplicateVoteEvidence>, never>;
        lightClientAttackEvidence?: LightClientAttackEvidence & {
            conflictingBlock?: LightBlock & {
                signedHeader?: import("./types").SignedHeader & {
                    header?: import("./types").Header & {
                        version: import("../version/types").Consensus & {
                            block: bigint;
                            app: bigint;
                        } & Record<Exclude<keyof I["lightClientAttackEvidence"]["conflictingBlock"]["signedHeader"]["header"]["version"], keyof import("../version/types").Consensus>, never>;
                        chainId: string;
                        height: bigint;
                        time: Timestamp & {
                            seconds: bigint;
                            nanos: number;
                        } & Record<Exclude<keyof I["lightClientAttackEvidence"]["conflictingBlock"]["signedHeader"]["header"]["time"], keyof Timestamp>, never>;
                        lastBlockId: import("./types").BlockID & {
                            hash: Uint8Array;
                            partSetHeader: import("./types").PartSetHeader & {
                                total: number;
                                hash: Uint8Array;
                            } & Record<Exclude<keyof I["lightClientAttackEvidence"]["conflictingBlock"]["signedHeader"]["header"]["lastBlockId"]["partSetHeader"], keyof import("./types").PartSetHeader>, never>;
                        } & Record<Exclude<keyof I["lightClientAttackEvidence"]["conflictingBlock"]["signedHeader"]["header"]["lastBlockId"], keyof import("./types").BlockID>, never>;
                        lastCommitHash: Uint8Array;
                        dataHash: Uint8Array;
                        validatorsHash: Uint8Array;
                        nextValidatorsHash: Uint8Array;
                        consensusHash: Uint8Array;
                        appHash: Uint8Array;
                        lastResultsHash: Uint8Array;
                        evidenceHash: Uint8Array;
                        proposerAddress: Uint8Array;
                    } & Record<Exclude<keyof I["lightClientAttackEvidence"]["conflictingBlock"]["signedHeader"]["header"], keyof import("./types").Header>, never>;
                    commit?: import("./types").Commit & {
                        height: bigint;
                        round: number;
                        blockId: import("./types").BlockID & {
                            hash: Uint8Array;
                            partSetHeader: import("./types").PartSetHeader & {
                                total: number;
                                hash: Uint8Array;
                            } & Record<Exclude<keyof I["lightClientAttackEvidence"]["conflictingBlock"]["signedHeader"]["commit"]["blockId"]["partSetHeader"], keyof import("./types").PartSetHeader>, never>;
                        } & Record<Exclude<keyof I["lightClientAttackEvidence"]["conflictingBlock"]["signedHeader"]["commit"]["blockId"], keyof import("./types").BlockID>, never>;
                        signatures: import("./types").CommitSig[] & (import("./types").CommitSig & {
                            blockIdFlag: import("./types").BlockIDFlag;
                            validatorAddress: Uint8Array;
                            timestamp: Timestamp & {
                                seconds: bigint;
                                nanos: number;
                            } & Record<Exclude<keyof I["lightClientAttackEvidence"]["conflictingBlock"]["signedHeader"]["commit"]["signatures"][number]["timestamp"], keyof Timestamp>, never>;
                            signature: Uint8Array;
                        } & Record<Exclude<keyof I["lightClientAttackEvidence"]["conflictingBlock"]["signedHeader"]["commit"]["signatures"][number], keyof import("./types").CommitSig>, never>)[] & Record<Exclude<keyof I["lightClientAttackEvidence"]["conflictingBlock"]["signedHeader"]["commit"]["signatures"], keyof import("./types").CommitSig[]>, never>;
                    } & Record<Exclude<keyof I["lightClientAttackEvidence"]["conflictingBlock"]["signedHeader"]["commit"], keyof import("./types").Commit>, never>;
                } & Record<Exclude<keyof I["lightClientAttackEvidence"]["conflictingBlock"]["signedHeader"], keyof import("./types").SignedHeader>, never>;
                validatorSet?: import("./validator").ValidatorSet & {
                    validators: Validator[] & (Validator & {
                        address: Uint8Array;
                        pubKey: import("../crypto/keys").PublicKey & {
                            ed25519?: Uint8Array;
                            secp256k1?: Uint8Array;
                        } & Record<Exclude<keyof I["lightClientAttackEvidence"]["conflictingBlock"]["validatorSet"]["validators"][number]["pubKey"], keyof import("../crypto/keys").PublicKey>, never>;
                        votingPower: bigint;
                        proposerPriority: bigint;
                    } & Record<Exclude<keyof I["lightClientAttackEvidence"]["conflictingBlock"]["validatorSet"]["validators"][number], keyof Validator>, never>)[] & Record<Exclude<keyof I["lightClientAttackEvidence"]["conflictingBlock"]["validatorSet"]["validators"], keyof Validator[]>, never>;
                    proposer?: Validator & {
                        address: Uint8Array;
                        pubKey: import("../crypto/keys").PublicKey & {
                            ed25519?: Uint8Array;
                            secp256k1?: Uint8Array;
                        } & Record<Exclude<keyof I["lightClientAttackEvidence"]["conflictingBlock"]["validatorSet"]["proposer"]["pubKey"], keyof import("../crypto/keys").PublicKey>, never>;
                        votingPower: bigint;
                        proposerPriority: bigint;
                    } & Record<Exclude<keyof I["lightClientAttackEvidence"]["conflictingBlock"]["validatorSet"]["proposer"], keyof Validator>, never>;
                    totalVotingPower: bigint;
                } & Record<Exclude<keyof I["lightClientAttackEvidence"]["conflictingBlock"]["validatorSet"], keyof import("./validator").ValidatorSet>, never>;
            } & Record<Exclude<keyof I["lightClientAttackEvidence"]["conflictingBlock"], keyof LightBlock>, never>;
            commonHeight: bigint;
            byzantineValidators: Validator[] & (Validator & {
                address: Uint8Array;
                pubKey: import("../crypto/keys").PublicKey & {
                    ed25519?: Uint8Array;
                    secp256k1?: Uint8Array;
                } & Record<Exclude<keyof I["lightClientAttackEvidence"]["byzantineValidators"][number]["pubKey"], keyof import("../crypto/keys").PublicKey>, never>;
                votingPower: bigint;
                proposerPriority: bigint;
            } & Record<Exclude<keyof I["lightClientAttackEvidence"]["byzantineValidators"][number], keyof Validator>, never>)[] & Record<Exclude<keyof I["lightClientAttackEvidence"]["byzantineValidators"], keyof Validator[]>, never>;
            totalVotingPower: bigint;
            timestamp: Timestamp & {
                seconds: bigint;
                nanos: number;
            } & Record<Exclude<keyof I["lightClientAttackEvidence"]["timestamp"], keyof Timestamp>, never>;
        } & Record<Exclude<keyof I["lightClientAttackEvidence"], keyof LightClientAttackEvidence>, never>;
    } & Record<Exclude<keyof I, keyof Evidence>, never>>(object: I): Evidence;
};
export declare const DuplicateVoteEvidence: {
    typeUrl: string;
    encode(message: DuplicateVoteEvidence, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): DuplicateVoteEvidence;
    fromJSON(object: any): DuplicateVoteEvidence;
    toJSON(message: DuplicateVoteEvidence): unknown;
    fromPartial<I extends Partial<DuplicateVoteEvidence> & {
        voteA?: Vote & {
            type: import("./types").SignedMsgType;
            height: bigint;
            round: number;
            blockId: import("./types").BlockID & {
                hash: Uint8Array;
                partSetHeader: import("./types").PartSetHeader & {
                    total: number;
                    hash: Uint8Array;
                } & Record<Exclude<keyof I["voteA"]["blockId"]["partSetHeader"], keyof import("./types").PartSetHeader>, never>;
            } & Record<Exclude<keyof I["voteA"]["blockId"], keyof import("./types").BlockID>, never>;
            timestamp: Timestamp & {
                seconds: bigint;
                nanos: number;
            } & Record<Exclude<keyof I["voteA"]["timestamp"], keyof Timestamp>, never>;
            validatorAddress: Uint8Array;
            validatorIndex: number;
            signature: Uint8Array;
        } & Record<Exclude<keyof I["voteA"], keyof Vote>, never>;
        voteB?: Vote & {
            type: import("./types").SignedMsgType;
            height: bigint;
            round: number;
            blockId: import("./types").BlockID & {
                hash: Uint8Array;
                partSetHeader: import("./types").PartSetHeader & {
                    total: number;
                    hash: Uint8Array;
                } & Record<Exclude<keyof I["voteB"]["blockId"]["partSetHeader"], keyof import("./types").PartSetHeader>, never>;
            } & Record<Exclude<keyof I["voteB"]["blockId"], keyof import("./types").BlockID>, never>;
            timestamp: Timestamp & {
                seconds: bigint;
                nanos: number;
            } & Record<Exclude<keyof I["voteB"]["timestamp"], keyof Timestamp>, never>;
            validatorAddress: Uint8Array;
            validatorIndex: number;
            signature: Uint8Array;
        } & Record<Exclude<keyof I["voteB"], keyof Vote>, never>;
        totalVotingPower?: bigint;
        validatorPower?: bigint;
        timestamp?: Timestamp & {
            seconds: bigint;
            nanos: number;
        } & Record<Exclude<keyof I["timestamp"], keyof Timestamp>, never>;
    } & Record<Exclude<keyof I, keyof DuplicateVoteEvidence>, never>>(object: I): DuplicateVoteEvidence;
};
export declare const LightClientAttackEvidence: {
    typeUrl: string;
    encode(message: LightClientAttackEvidence, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): LightClientAttackEvidence;
    fromJSON(object: any): LightClientAttackEvidence;
    toJSON(message: LightClientAttackEvidence): unknown;
    fromPartial<I extends Partial<LightClientAttackEvidence> & {
        conflictingBlock?: LightBlock & {
            signedHeader?: import("./types").SignedHeader & {
                header?: import("./types").Header & {
                    version: import("../version/types").Consensus & {
                        block: bigint;
                        app: bigint;
                    } & Record<Exclude<keyof I["conflictingBlock"]["signedHeader"]["header"]["version"], keyof import("../version/types").Consensus>, never>;
                    chainId: string;
                    height: bigint;
                    time: Timestamp & {
                        seconds: bigint;
                        nanos: number;
                    } & Record<Exclude<keyof I["conflictingBlock"]["signedHeader"]["header"]["time"], keyof Timestamp>, never>;
                    lastBlockId: import("./types").BlockID & {
                        hash: Uint8Array;
                        partSetHeader: import("./types").PartSetHeader & {
                            total: number;
                            hash: Uint8Array;
                        } & Record<Exclude<keyof I["conflictingBlock"]["signedHeader"]["header"]["lastBlockId"]["partSetHeader"], keyof import("./types").PartSetHeader>, never>;
                    } & Record<Exclude<keyof I["conflictingBlock"]["signedHeader"]["header"]["lastBlockId"], keyof import("./types").BlockID>, never>;
                    lastCommitHash: Uint8Array;
                    dataHash: Uint8Array;
                    validatorsHash: Uint8Array;
                    nextValidatorsHash: Uint8Array;
                    consensusHash: Uint8Array;
                    appHash: Uint8Array;
                    lastResultsHash: Uint8Array;
                    evidenceHash: Uint8Array;
                    proposerAddress: Uint8Array;
                } & Record<Exclude<keyof I["conflictingBlock"]["signedHeader"]["header"], keyof import("./types").Header>, never>;
                commit?: import("./types").Commit & {
                    height: bigint;
                    round: number;
                    blockId: import("./types").BlockID & {
                        hash: Uint8Array;
                        partSetHeader: import("./types").PartSetHeader & {
                            total: number;
                            hash: Uint8Array;
                        } & Record<Exclude<keyof I["conflictingBlock"]["signedHeader"]["commit"]["blockId"]["partSetHeader"], keyof import("./types").PartSetHeader>, never>;
                    } & Record<Exclude<keyof I["conflictingBlock"]["signedHeader"]["commit"]["blockId"], keyof import("./types").BlockID>, never>;
                    signatures: import("./types").CommitSig[] & (import("./types").CommitSig & {
                        blockIdFlag: import("./types").BlockIDFlag;
                        validatorAddress: Uint8Array;
                        timestamp: Timestamp & {
                            seconds: bigint;
                            nanos: number;
                        } & Record<Exclude<keyof I["conflictingBlock"]["signedHeader"]["commit"]["signatures"][number]["timestamp"], keyof Timestamp>, never>;
                        signature: Uint8Array;
                    } & Record<Exclude<keyof I["conflictingBlock"]["signedHeader"]["commit"]["signatures"][number], keyof import("./types").CommitSig>, never>)[] & Record<Exclude<keyof I["conflictingBlock"]["signedHeader"]["commit"]["signatures"], keyof import("./types").CommitSig[]>, never>;
                } & Record<Exclude<keyof I["conflictingBlock"]["signedHeader"]["commit"], keyof import("./types").Commit>, never>;
            } & Record<Exclude<keyof I["conflictingBlock"]["signedHeader"], keyof import("./types").SignedHeader>, never>;
            validatorSet?: import("./validator").ValidatorSet & {
                validators: Validator[] & (Validator & {
                    address: Uint8Array;
                    pubKey: import("../crypto/keys").PublicKey & {
                        ed25519?: Uint8Array;
                        secp256k1?: Uint8Array;
                    } & Record<Exclude<keyof I["conflictingBlock"]["validatorSet"]["validators"][number]["pubKey"], keyof import("../crypto/keys").PublicKey>, never>;
                    votingPower: bigint;
                    proposerPriority: bigint;
                } & Record<Exclude<keyof I["conflictingBlock"]["validatorSet"]["validators"][number], keyof Validator>, never>)[] & Record<Exclude<keyof I["conflictingBlock"]["validatorSet"]["validators"], keyof Validator[]>, never>;
                proposer?: Validator & {
                    address: Uint8Array;
                    pubKey: import("../crypto/keys").PublicKey & {
                        ed25519?: Uint8Array;
                        secp256k1?: Uint8Array;
                    } & Record<Exclude<keyof I["conflictingBlock"]["validatorSet"]["proposer"]["pubKey"], keyof import("../crypto/keys").PublicKey>, never>;
                    votingPower: bigint;
                    proposerPriority: bigint;
                } & Record<Exclude<keyof I["conflictingBlock"]["validatorSet"]["proposer"], keyof Validator>, never>;
                totalVotingPower: bigint;
            } & Record<Exclude<keyof I["conflictingBlock"]["validatorSet"], keyof import("./validator").ValidatorSet>, never>;
        } & Record<Exclude<keyof I["conflictingBlock"], keyof LightBlock>, never>;
        commonHeight?: bigint;
        byzantineValidators?: Validator[] & (Validator & {
            address: Uint8Array;
            pubKey: import("../crypto/keys").PublicKey & {
                ed25519?: Uint8Array;
                secp256k1?: Uint8Array;
            } & Record<Exclude<keyof I["byzantineValidators"][number]["pubKey"], keyof import("../crypto/keys").PublicKey>, never>;
            votingPower: bigint;
            proposerPriority: bigint;
        } & Record<Exclude<keyof I["byzantineValidators"][number], keyof Validator>, never>)[] & Record<Exclude<keyof I["byzantineValidators"], keyof Validator[]>, never>;
        totalVotingPower?: bigint;
        timestamp?: Timestamp & {
            seconds: bigint;
            nanos: number;
        } & Record<Exclude<keyof I["timestamp"], keyof Timestamp>, never>;
    } & Record<Exclude<keyof I, keyof LightClientAttackEvidence>, never>>(object: I): LightClientAttackEvidence;
};
export declare const EvidenceList: {
    typeUrl: string;
    encode(message: EvidenceList, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): EvidenceList;
    fromJSON(object: any): EvidenceList;
    toJSON(message: EvidenceList): unknown;
    fromPartial<I extends Partial<EvidenceList> & {
        evidence?: Evidence[] & (Evidence & {
            duplicateVoteEvidence?: DuplicateVoteEvidence & {
                voteA?: Vote & {
                    type: import("./types").SignedMsgType;
                    height: bigint;
                    round: number;
                    blockId: import("./types").BlockID & {
                        hash: Uint8Array;
                        partSetHeader: import("./types").PartSetHeader & {
                            total: number;
                            hash: Uint8Array;
                        } & Record<Exclude<keyof I["evidence"][number]["duplicateVoteEvidence"]["voteA"]["blockId"]["partSetHeader"], keyof import("./types").PartSetHeader>, never>;
                    } & Record<Exclude<keyof I["evidence"][number]["duplicateVoteEvidence"]["voteA"]["blockId"], keyof import("./types").BlockID>, never>;
                    timestamp: Timestamp & {
                        seconds: bigint;
                        nanos: number;
                    } & Record<Exclude<keyof I["evidence"][number]["duplicateVoteEvidence"]["voteA"]["timestamp"], keyof Timestamp>, never>;
                    validatorAddress: Uint8Array;
                    validatorIndex: number;
                    signature: Uint8Array;
                } & Record<Exclude<keyof I["evidence"][number]["duplicateVoteEvidence"]["voteA"], keyof Vote>, never>;
                voteB?: Vote & {
                    type: import("./types").SignedMsgType;
                    height: bigint;
                    round: number;
                    blockId: import("./types").BlockID & {
                        hash: Uint8Array;
                        partSetHeader: import("./types").PartSetHeader & {
                            total: number;
                            hash: Uint8Array;
                        } & Record<Exclude<keyof I["evidence"][number]["duplicateVoteEvidence"]["voteB"]["blockId"]["partSetHeader"], keyof import("./types").PartSetHeader>, never>;
                    } & Record<Exclude<keyof I["evidence"][number]["duplicateVoteEvidence"]["voteB"]["blockId"], keyof import("./types").BlockID>, never>;
                    timestamp: Timestamp & {
                        seconds: bigint;
                        nanos: number;
                    } & Record<Exclude<keyof I["evidence"][number]["duplicateVoteEvidence"]["voteB"]["timestamp"], keyof Timestamp>, never>;
                    validatorAddress: Uint8Array;
                    validatorIndex: number;
                    signature: Uint8Array;
                } & Record<Exclude<keyof I["evidence"][number]["duplicateVoteEvidence"]["voteB"], keyof Vote>, never>;
                totalVotingPower: bigint;
                validatorPower: bigint;
                timestamp: Timestamp & {
                    seconds: bigint;
                    nanos: number;
                } & Record<Exclude<keyof I["evidence"][number]["duplicateVoteEvidence"]["timestamp"], keyof Timestamp>, never>;
            } & Record<Exclude<keyof I["evidence"][number]["duplicateVoteEvidence"], keyof DuplicateVoteEvidence>, never>;
            lightClientAttackEvidence?: LightClientAttackEvidence & {
                conflictingBlock?: LightBlock & {
                    signedHeader?: import("./types").SignedHeader & {
                        header?: import("./types").Header & {
                            version: import("../version/types").Consensus & {
                                block: bigint;
                                app: bigint;
                            } & Record<Exclude<keyof I["evidence"][number]["lightClientAttackEvidence"]["conflictingBlock"]["signedHeader"]["header"]["version"], keyof import("../version/types").Consensus>, never>;
                            chainId: string;
                            height: bigint;
                            time: Timestamp & {
                                seconds: bigint;
                                nanos: number;
                            } & Record<Exclude<keyof I["evidence"][number]["lightClientAttackEvidence"]["conflictingBlock"]["signedHeader"]["header"]["time"], keyof Timestamp>, never>;
                            lastBlockId: import("./types").BlockID & {
                                hash: Uint8Array;
                                partSetHeader: import("./types").PartSetHeader & {
                                    total: number;
                                    hash: Uint8Array;
                                } & Record<Exclude<keyof I["evidence"][number]["lightClientAttackEvidence"]["conflictingBlock"]["signedHeader"]["header"]["lastBlockId"]["partSetHeader"], keyof import("./types").PartSetHeader>, never>;
                            } & Record<Exclude<keyof I["evidence"][number]["lightClientAttackEvidence"]["conflictingBlock"]["signedHeader"]["header"]["lastBlockId"], keyof import("./types").BlockID>, never>;
                            lastCommitHash: Uint8Array;
                            dataHash: Uint8Array;
                            validatorsHash: Uint8Array;
                            nextValidatorsHash: Uint8Array;
                            consensusHash: Uint8Array;
                            appHash: Uint8Array;
                            lastResultsHash: Uint8Array;
                            evidenceHash: Uint8Array;
                            proposerAddress: Uint8Array;
                        } & Record<Exclude<keyof I["evidence"][number]["lightClientAttackEvidence"]["conflictingBlock"]["signedHeader"]["header"], keyof import("./types").Header>, never>;
                        commit?: import("./types").Commit & {
                            height: bigint;
                            round: number;
                            blockId: import("./types").BlockID & {
                                hash: Uint8Array;
                                partSetHeader: import("./types").PartSetHeader & {
                                    total: number;
                                    hash: Uint8Array;
                                } & Record<Exclude<keyof I["evidence"][number]["lightClientAttackEvidence"]["conflictingBlock"]["signedHeader"]["commit"]["blockId"]["partSetHeader"], keyof import("./types").PartSetHeader>, never>;
                            } & Record<Exclude<keyof I["evidence"][number]["lightClientAttackEvidence"]["conflictingBlock"]["signedHeader"]["commit"]["blockId"], keyof import("./types").BlockID>, never>;
                            signatures: import("./types").CommitSig[] & (import("./types").CommitSig & {
                                blockIdFlag: import("./types").BlockIDFlag;
                                validatorAddress: Uint8Array;
                                timestamp: Timestamp & {
                                    seconds: bigint;
                                    nanos: number;
                                } & Record<Exclude<keyof I["evidence"][number]["lightClientAttackEvidence"]["conflictingBlock"]["signedHeader"]["commit"]["signatures"][number]["timestamp"], keyof Timestamp>, never>;
                                signature: Uint8Array;
                            } & Record<Exclude<keyof I["evidence"][number]["lightClientAttackEvidence"]["conflictingBlock"]["signedHeader"]["commit"]["signatures"][number], keyof import("./types").CommitSig>, never>)[] & Record<Exclude<keyof I["evidence"][number]["lightClientAttackEvidence"]["conflictingBlock"]["signedHeader"]["commit"]["signatures"], keyof import("./types").CommitSig[]>, never>;
                        } & Record<Exclude<keyof I["evidence"][number]["lightClientAttackEvidence"]["conflictingBlock"]["signedHeader"]["commit"], keyof import("./types").Commit>, never>;
                    } & Record<Exclude<keyof I["evidence"][number]["lightClientAttackEvidence"]["conflictingBlock"]["signedHeader"], keyof import("./types").SignedHeader>, never>;
                    validatorSet?: import("./validator").ValidatorSet & {
                        validators: Validator[] & (Validator & {
                            address: Uint8Array;
                            pubKey: import("../crypto/keys").PublicKey & {
                                ed25519?: Uint8Array;
                                secp256k1?: Uint8Array;
                            } & Record<Exclude<keyof I["evidence"][number]["lightClientAttackEvidence"]["conflictingBlock"]["validatorSet"]["validators"][number]["pubKey"], keyof import("../crypto/keys").PublicKey>, never>;
                            votingPower: bigint;
                            proposerPriority: bigint;
                        } & Record<Exclude<keyof I["evidence"][number]["lightClientAttackEvidence"]["conflictingBlock"]["validatorSet"]["validators"][number], keyof Validator>, never>)[] & Record<Exclude<keyof I["evidence"][number]["lightClientAttackEvidence"]["conflictingBlock"]["validatorSet"]["validators"], keyof Validator[]>, never>;
                        proposer?: Validator & {
                            address: Uint8Array;
                            pubKey: import("../crypto/keys").PublicKey & {
                                ed25519?: Uint8Array;
                                secp256k1?: Uint8Array;
                            } & Record<Exclude<keyof I["evidence"][number]["lightClientAttackEvidence"]["conflictingBlock"]["validatorSet"]["proposer"]["pubKey"], keyof import("../crypto/keys").PublicKey>, never>;
                            votingPower: bigint;
                            proposerPriority: bigint;
                        } & Record<Exclude<keyof I["evidence"][number]["lightClientAttackEvidence"]["conflictingBlock"]["validatorSet"]["proposer"], keyof Validator>, never>;
                        totalVotingPower: bigint;
                    } & Record<Exclude<keyof I["evidence"][number]["lightClientAttackEvidence"]["conflictingBlock"]["validatorSet"], keyof import("./validator").ValidatorSet>, never>;
                } & Record<Exclude<keyof I["evidence"][number]["lightClientAttackEvidence"]["conflictingBlock"], keyof LightBlock>, never>;
                commonHeight: bigint;
                byzantineValidators: Validator[] & (Validator & {
                    address: Uint8Array;
                    pubKey: import("../crypto/keys").PublicKey & {
                        ed25519?: Uint8Array;
                        secp256k1?: Uint8Array;
                    } & Record<Exclude<keyof I["evidence"][number]["lightClientAttackEvidence"]["byzantineValidators"][number]["pubKey"], keyof import("../crypto/keys").PublicKey>, never>;
                    votingPower: bigint;
                    proposerPriority: bigint;
                } & Record<Exclude<keyof I["evidence"][number]["lightClientAttackEvidence"]["byzantineValidators"][number], keyof Validator>, never>)[] & Record<Exclude<keyof I["evidence"][number]["lightClientAttackEvidence"]["byzantineValidators"], keyof Validator[]>, never>;
                totalVotingPower: bigint;
                timestamp: Timestamp & {
                    seconds: bigint;
                    nanos: number;
                } & Record<Exclude<keyof I["evidence"][number]["lightClientAttackEvidence"]["timestamp"], keyof Timestamp>, never>;
            } & Record<Exclude<keyof I["evidence"][number]["lightClientAttackEvidence"], keyof LightClientAttackEvidence>, never>;
        } & Record<Exclude<keyof I["evidence"][number], keyof Evidence>, never>)[] & Record<Exclude<keyof I["evidence"], keyof Evidence[]>, never>;
    } & Record<Exclude<keyof I, "evidence">, never>>(object: I): EvidenceList;
};