import { Duration, DurationAmino } from "../../../../google/protobuf/duration";
import { Height, HeightAmino } from "../../../core/client/v1/client";
import { ProofSpec, ProofSpecAmino } from "../../../../cosmos/ics23/v1/proofs";
import { Timestamp } from "../../../../google/protobuf/timestamp";
import { MerkleRoot, MerkleRootAmino } from "../../../core/commitment/v1/commitment";
import { PublicKey, PublicKeyAmino } from "../../../../tendermint/crypto/keys";
import { BinaryReader, BinaryWriter } from "../../../../binary";
export declare const protobufPackage = "ibc.lightclients.gno.v1";
/**
 * ClientState from Gno tracks the current validator set, latest height,
 * and a possible frozen height.
 */
export interface ClientState {
    chainId: string;
    trustLevel: Fraction | undefined;
    /**
     * duration of the period since the LatestTimestamp during which the
     * submitted headers are valid for upgrade
     */
    trustingPeriod: Duration | undefined;
    /** duration of the staking unbonding period */
    unbondingPeriod: Duration | undefined;
    /** defines how much new (untrusted) header's Time can drift into the future. */
    maxClockDrift: Duration | undefined;
    /** Block height when the client was frozen due to a misbehaviour */
    frozenHeight: Height | undefined;
    /** Latest height the client was updated to */
    latestHeight: Height | undefined;
    /** Proof specifications used in verifying counterparty state */
    proofSpecs: ProofSpec[];
    /**
     * Path at which next upgraded client will be committed.
     * Each element corresponds to the key for a single CommitmentProof in the
     * chained proof. NOTE: ClientState must stored under
     * `{upgradePath}/{upgradeHeight}/clientState` ConsensusState must be stored
     * under `{upgradepath}/{upgradeHeight}/consensusState` For SDK chains using
     * the default upgrade module, upgrade_path should be []string{"upgrade",
     * "upgradedIBCState"}`
     */
    upgradePath: string[];
    /** allow_update_after_expiry is deprecated */
    /** @deprecated */
    allowUpdateAfterExpiry: boolean;
    /** allow_update_after_misbehaviour is deprecated */
    /** @deprecated */
    allowUpdateAfterMisbehaviour: boolean;
    /**
     * In order to distinguish between Gno and Tendermint light clients
     * we add a client type field. This is useful for clients that
     * may support multiple light client types.
     */
    lcType: string;
}
export interface ClientStateProtoMsg {
    typeUrl: "/ibc.lightclients.gno.v1.ClientState";
    value: Uint8Array;
}
/**
 * ClientState from Gno tracks the current validator set, latest height,
 * and a possible frozen height.
 */
export interface ClientStateAmino {
    chain_id?: string;
    trust_level?: FractionAmino | undefined;
    /**
     * duration of the period since the LatestTimestamp during which the
     * submitted headers are valid for upgrade
     */
    trusting_period?: DurationAmino | undefined;
    /** duration of the staking unbonding period */
    unbonding_period?: DurationAmino | undefined;
    /** defines how much new (untrusted) header's Time can drift into the future. */
    max_clock_drift?: DurationAmino | undefined;
    /** Block height when the client was frozen due to a misbehaviour */
    frozen_height?: HeightAmino | undefined;
    /** Latest height the client was updated to */
    latest_height?: HeightAmino | undefined;
    /** Proof specifications used in verifying counterparty state */
    proof_specs?: ProofSpecAmino[];
    /**
     * Path at which next upgraded client will be committed.
     * Each element corresponds to the key for a single CommitmentProof in the
     * chained proof. NOTE: ClientState must stored under
     * `{upgradePath}/{upgradeHeight}/clientState` ConsensusState must be stored
     * under `{upgradepath}/{upgradeHeight}/consensusState` For SDK chains using
     * the default upgrade module, upgrade_path should be []string{"upgrade",
     * "upgradedIBCState"}`
     */
    upgrade_path?: string[];
    /** allow_update_after_expiry is deprecated */
    /** @deprecated */
    allow_update_after_expiry?: boolean;
    /** allow_update_after_misbehaviour is deprecated */
    /** @deprecated */
    allow_update_after_misbehaviour?: boolean;
    /**
     * In order to distinguish between Gno and Tendermint light clients
     * we add a client type field. This is useful for clients that
     * may support multiple light client types.
     */
    lc_type?: string;
}
export interface ClientStateAminoMsg {
    type: "cosmos-sdk/ClientState";
    value: ClientStateAmino;
}
/** ConsensusState defines the consensus state from Gno. */
export interface ConsensusState {
    /**
     * timestamp that corresponds to the block height in which the ConsensusState
     * was stored.
     */
    timestamp: Timestamp | undefined;
    /** commitment root (i.e app hash) */
    root: MerkleRoot | undefined;
    nextValidatorsHash: Uint8Array;
    /**
     * In order to distinguish between Gno and Tendermint light clients
     * we add a client type field. This is useful for clients that
     * may support multiple light client types.
     */
    lcType: string;
}
export interface ConsensusStateProtoMsg {
    typeUrl: "/ibc.lightclients.gno.v1.ConsensusState";
    value: Uint8Array;
}
/** ConsensusState defines the consensus state from Gno. */
export interface ConsensusStateAmino {
    /**
     * timestamp that corresponds to the block height in which the ConsensusState
     * was stored.
     */
    timestamp?: string | undefined;
    /** commitment root (i.e app hash) */
    root?: MerkleRootAmino | undefined;
    next_validators_hash?: string;
    /**
     * In order to distinguish between Gno and Tendermint light clients
     * we add a client type field. This is useful for clients that
     * may support multiple light client types.
     */
    lc_type?: string;
}
export interface ConsensusStateAminoMsg {
    type: "cosmos-sdk/ConsensusState";
    value: ConsensusStateAmino;
}
/**
 * Misbehaviour is a wrapper over two conflicting Headers
 * that implements Misbehaviour interface expected by ICS-02
 */
export interface Misbehaviour {
    /** ClientID is deprecated */
    /** @deprecated */
    clientId: string;
    header1?: Header | undefined;
    header2?: Header | undefined;
}
export interface MisbehaviourProtoMsg {
    typeUrl: "/ibc.lightclients.gno.v1.Misbehaviour";
    value: Uint8Array;
}
/**
 * Misbehaviour is a wrapper over two conflicting Headers
 * that implements Misbehaviour interface expected by ICS-02
 */
export interface MisbehaviourAmino {
    /** ClientID is deprecated */
    /** @deprecated */
    client_id?: string;
    header_1?: HeaderAmino | undefined;
    header_2?: HeaderAmino | undefined;
}
export interface MisbehaviourAminoMsg {
    type: "cosmos-sdk/Misbehaviour";
    value: MisbehaviourAmino;
}
/**
 * Header defines the Tendermint client consensus Header.
 * It encapsulates all the information necessary to update from a trusted
 * Tendermint ConsensusState. The inclusion of TrustedHeight and
 * TrustedValidators allows this update to process correctly, so long as the
 * ConsensusState for the TrustedHeight exists, this removes race conditions
 * among relayers The SignedHeader and ValidatorSet are the new untrusted update
 * fields for the client. The TrustedHeight is the height of a stored
 * ConsensusState on the client that will be used to verify the new untrusted
 * header. The Trusted ConsensusState must be within the unbonding period of
 * current time in order to correctly verify, and the TrustedValidators must
 * hash to TrustedConsensusState.NextValidatorsHash since that is the last
 * trusted validator set at the TrustedHeight.
 */
export interface Header {
    signedHeader?: SignedHeader | undefined;
    validatorSet?: ValidatorSet | undefined;
    trustedHeight: Height | undefined;
    trustedValidators?: ValidatorSet | undefined;
}
export interface HeaderProtoMsg {
    typeUrl: "/ibc.lightclients.gno.v1.Header";
    value: Uint8Array;
}
/**
 * Header defines the Tendermint client consensus Header.
 * It encapsulates all the information necessary to update from a trusted
 * Tendermint ConsensusState. The inclusion of TrustedHeight and
 * TrustedValidators allows this update to process correctly, so long as the
 * ConsensusState for the TrustedHeight exists, this removes race conditions
 * among relayers The SignedHeader and ValidatorSet are the new untrusted update
 * fields for the client. The TrustedHeight is the height of a stored
 * ConsensusState on the client that will be used to verify the new untrusted
 * header. The Trusted ConsensusState must be within the unbonding period of
 * current time in order to correctly verify, and the TrustedValidators must
 * hash to TrustedConsensusState.NextValidatorsHash since that is the last
 * trusted validator set at the TrustedHeight.
 */
export interface HeaderAmino {
    signed_header?: SignedHeaderAmino | undefined;
    validator_set?: ValidatorSetAmino | undefined;
    trusted_height?: HeightAmino | undefined;
    trusted_validators?: ValidatorSetAmino | undefined;
}
export interface HeaderAminoMsg {
    type: "cosmos-sdk/Header";
    value: HeaderAmino;
}
export interface Block {
    header?: GnoHeader | undefined;
    data?: Data | undefined;
    lastCommit?: Commit | undefined;
}
export interface BlockProtoMsg {
    typeUrl: "/ibc.lightclients.gno.v1.Block";
    value: Uint8Array;
}
export interface BlockAmino {
    header?: GnoHeaderAmino | undefined;
    data?: DataAmino | undefined;
    last_commit?: CommitAmino | undefined;
}
export interface BlockAminoMsg {
    type: "cosmos-sdk/Block";
    value: BlockAmino;
}
export interface GnoHeader {
    version: string;
    chainId: string;
    height: bigint;
    time: Timestamp | undefined;
    numTxs: bigint;
    totalTxs: bigint;
    appVersion: string;
    lastBlockId?: BlockID | undefined;
    lastCommitHash: Uint8Array;
    dataHash: Uint8Array;
    validatorsHash: Uint8Array;
    nextValidatorsHash: Uint8Array;
    consensusHash: Uint8Array;
    appHash: Uint8Array;
    lastResultsHash: Uint8Array;
    proposerAddress: string;
}
export interface GnoHeaderProtoMsg {
    typeUrl: "/ibc.lightclients.gno.v1.GnoHeader";
    value: Uint8Array;
}
export interface GnoHeaderAmino {
    version?: string;
    chain_id?: string;
    height?: string;
    time?: string | undefined;
    num_txs?: string;
    total_txs?: string;
    app_version?: string;
    last_block_id?: BlockIDAmino | undefined;
    last_commit_hash?: string;
    data_hash?: string;
    validators_hash?: string;
    next_validators_hash?: string;
    consensus_hash?: string;
    app_hash?: string;
    last_results_hash?: string;
    proposer_address?: string;
}
export interface GnoHeaderAminoMsg {
    type: "cosmos-sdk/GnoHeader";
    value: GnoHeaderAmino;
}
export interface Data {
    txs: Uint8Array[];
}
export interface DataProtoMsg {
    typeUrl: "/ibc.lightclients.gno.v1.Data";
    value: Uint8Array;
}
export interface DataAmino {
    txs?: string[];
}
export interface DataAminoMsg {
    type: "cosmos-sdk/Data";
    value: DataAmino;
}
export interface Commit {
    blockId?: BlockID | undefined;
    precommits: CommitSig[];
}
export interface CommitProtoMsg {
    typeUrl: "/ibc.lightclients.gno.v1.Commit";
    value: Uint8Array;
}
export interface CommitAmino {
    block_id?: BlockIDAmino | undefined;
    precommits?: CommitSigAmino[];
}
export interface CommitAminoMsg {
    type: "cosmos-sdk/Commit";
    value: CommitAmino;
}
export interface BlockID {
    hash: Uint8Array;
    partsHeader?: PartSetHeader | undefined;
}
export interface BlockIDProtoMsg {
    typeUrl: "/ibc.lightclients.gno.v1.BlockID";
    value: Uint8Array;
}
export interface BlockIDAmino {
    hash?: string;
    parts_header?: PartSetHeaderAmino | undefined;
}
export interface BlockIDAminoMsg {
    type: "cosmos-sdk/BlockID";
    value: BlockIDAmino;
}
export interface SignedHeader {
    header?: GnoHeader | undefined;
    commit?: Commit | undefined;
}
export interface SignedHeaderProtoMsg {
    typeUrl: "/ibc.lightclients.gno.v1.SignedHeader";
    value: Uint8Array;
}
export interface SignedHeaderAmino {
    header?: GnoHeaderAmino | undefined;
    commit?: CommitAmino | undefined;
}
export interface SignedHeaderAminoMsg {
    type: "cosmos-sdk/SignedHeader";
    value: SignedHeaderAmino;
}
export interface LightBlock {
    signedHeader?: SignedHeader | undefined;
    validatorSet?: ValidatorSet | undefined;
}
export interface LightBlockProtoMsg {
    typeUrl: "/ibc.lightclients.gno.v1.LightBlock";
    value: Uint8Array;
}
export interface LightBlockAmino {
    signed_header?: SignedHeaderAmino | undefined;
    validator_set?: ValidatorSetAmino | undefined;
}
export interface LightBlockAminoMsg {
    type: "cosmos-sdk/LightBlock";
    value: LightBlockAmino;
}
export interface CommitSig {
    type: number;
    height: bigint;
    round: bigint;
    blockId?: BlockID | undefined;
    timestamp: Timestamp | undefined;
    validatorAddress: string;
    validatorIndex: bigint;
    signature: Uint8Array;
}
export interface CommitSigProtoMsg {
    typeUrl: "/ibc.lightclients.gno.v1.CommitSig";
    value: Uint8Array;
}
export interface CommitSigAmino {
    type?: number;
    height?: string;
    round?: string;
    block_id?: BlockIDAmino | undefined;
    timestamp?: string | undefined;
    validator_address?: string;
    validator_index?: string;
    signature?: string;
}
export interface CommitSigAminoMsg {
    type: "cosmos-sdk/CommitSig";
    value: CommitSigAmino;
}
export interface Vote {
    type: number;
    height: bigint;
    round: bigint;
    blockId?: BlockID | undefined;
    timestamp: Timestamp | undefined;
    validatorAddress: string;
    validatorIndex: bigint;
    signature: Uint8Array;
}
export interface VoteProtoMsg {
    typeUrl: "/ibc.lightclients.gno.v1.Vote";
    value: Uint8Array;
}
export interface VoteAmino {
    type?: number;
    height?: string;
    round?: string;
    block_id?: BlockIDAmino | undefined;
    timestamp?: string | undefined;
    validator_address?: string;
    validator_index?: string;
    signature?: string;
}
export interface VoteAminoMsg {
    type: "cosmos-sdk/Vote";
    value: VoteAmino;
}
export interface PartSet {
}
export interface PartSetProtoMsg {
    typeUrl: "/ibc.lightclients.gno.v1.PartSet";
    value: Uint8Array;
}
export interface PartSetAmino {
}
export interface PartSetAminoMsg {
    type: "cosmos-sdk/PartSet";
    value: PartSetAmino;
}
export interface PartSetHeader {
    total: bigint;
    hash: Uint8Array;
}
export interface PartSetHeaderProtoMsg {
    typeUrl: "/ibc.lightclients.gno.v1.PartSetHeader";
    value: Uint8Array;
}
export interface PartSetHeaderAmino {
    total?: string;
    hash?: string;
}
export interface PartSetHeaderAminoMsg {
    type: "cosmos-sdk/PartSetHeader";
    value: PartSetHeaderAmino;
}
export interface Validator {
    address: string;
    pubKey?: PublicKey | undefined;
    votingPower: bigint;
    proposerPriority: bigint;
}
export interface ValidatorProtoMsg {
    typeUrl: "/ibc.lightclients.gno.v1.Validator";
    value: Uint8Array;
}
export interface ValidatorAmino {
    address?: string;
    pub_key?: PublicKeyAmino | undefined;
    voting_power?: string;
    proposer_priority?: string;
}
export interface ValidatorAminoMsg {
    type: "cosmos-sdk/Validator";
    value: ValidatorAmino;
}
export interface ValidatorSet {
    validators: Validator[];
    proposer?: Validator | undefined;
}
export interface ValidatorSetProtoMsg {
    typeUrl: "/ibc.lightclients.gno.v1.ValidatorSet";
    value: Uint8Array;
}
export interface ValidatorSetAmino {
    validators?: ValidatorAmino[];
    proposer?: ValidatorAmino | undefined;
}
export interface ValidatorSetAminoMsg {
    type: "cosmos-sdk/ValidatorSet";
    value: ValidatorSetAmino;
}
/**
 * Fraction defines the protobuf message type for tmmath.Fraction that only
 * supports positive values.
 */
export interface Fraction {
    numerator: bigint;
    denominator: bigint;
}
export interface FractionProtoMsg {
    typeUrl: "/ibc.lightclients.gno.v1.Fraction";
    value: Uint8Array;
}
/**
 * Fraction defines the protobuf message type for tmmath.Fraction that only
 * supports positive values.
 */
export interface FractionAmino {
    numerator?: string;
    denominator?: string;
}
export interface FractionAminoMsg {
    type: "cosmos-sdk/Fraction";
    value: FractionAmino;
}
export declare const ClientState: {
    typeUrl: string;
    encode(message: ClientState, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): ClientState;
    fromJSON(object: any): ClientState;
    toJSON(message: ClientState): unknown;
    fromPartial(object: Partial<ClientState>): ClientState;
    fromAmino(object: ClientStateAmino): ClientState;
    toAmino(message: ClientState): ClientStateAmino;
    fromAminoMsg(object: ClientStateAminoMsg): ClientState;
    toAminoMsg(message: ClientState): ClientStateAminoMsg;
    fromProtoMsg(message: ClientStateProtoMsg): ClientState;
    toProto(message: ClientState): Uint8Array;
    toProtoMsg(message: ClientState): ClientStateProtoMsg;
};
export declare const ConsensusState: {
    typeUrl: string;
    encode(message: ConsensusState, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): ConsensusState;
    fromJSON(object: any): ConsensusState;
    toJSON(message: ConsensusState): unknown;
    fromPartial(object: Partial<ConsensusState>): ConsensusState;
    fromAmino(object: ConsensusStateAmino): ConsensusState;
    toAmino(message: ConsensusState): ConsensusStateAmino;
    fromAminoMsg(object: ConsensusStateAminoMsg): ConsensusState;
    toAminoMsg(message: ConsensusState): ConsensusStateAminoMsg;
    fromProtoMsg(message: ConsensusStateProtoMsg): ConsensusState;
    toProto(message: ConsensusState): Uint8Array;
    toProtoMsg(message: ConsensusState): ConsensusStateProtoMsg;
};
export declare const Misbehaviour: {
    typeUrl: string;
    encode(message: Misbehaviour, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): Misbehaviour;
    fromJSON(object: any): Misbehaviour;
    toJSON(message: Misbehaviour): unknown;
    fromPartial(object: Partial<Misbehaviour>): Misbehaviour;
    fromAmino(object: MisbehaviourAmino): Misbehaviour;
    toAmino(message: Misbehaviour): MisbehaviourAmino;
    fromAminoMsg(object: MisbehaviourAminoMsg): Misbehaviour;
    toAminoMsg(message: Misbehaviour): MisbehaviourAminoMsg;
    fromProtoMsg(message: MisbehaviourProtoMsg): Misbehaviour;
    toProto(message: Misbehaviour): Uint8Array;
    toProtoMsg(message: Misbehaviour): MisbehaviourProtoMsg;
};
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(object: Partial<Header>): Header;
    fromAmino(object: HeaderAmino): Header;
    toAmino(message: Header): HeaderAmino;
    fromAminoMsg(object: HeaderAminoMsg): Header;
    toAminoMsg(message: Header): HeaderAminoMsg;
    fromProtoMsg(message: HeaderProtoMsg): Header;
    toProto(message: Header): Uint8Array;
    toProtoMsg(message: Header): HeaderProtoMsg;
};
export declare const Block: {
    typeUrl: string;
    encode(message: Block, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): Block;
    fromJSON(object: any): Block;
    toJSON(message: Block): unknown;
    fromPartial(object: Partial<Block>): Block;
    fromAmino(object: BlockAmino): Block;
    toAmino(message: Block): BlockAmino;
    fromAminoMsg(object: BlockAminoMsg): Block;
    toAminoMsg(message: Block): BlockAminoMsg;
    fromProtoMsg(message: BlockProtoMsg): Block;
    toProto(message: Block): Uint8Array;
    toProtoMsg(message: Block): BlockProtoMsg;
};
export declare const GnoHeader: {
    typeUrl: string;
    encode(message: GnoHeader, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): GnoHeader;
    fromJSON(object: any): GnoHeader;
    toJSON(message: GnoHeader): unknown;
    fromPartial(object: Partial<GnoHeader>): GnoHeader;
    fromAmino(object: GnoHeaderAmino): GnoHeader;
    toAmino(message: GnoHeader): GnoHeaderAmino;
    fromAminoMsg(object: GnoHeaderAminoMsg): GnoHeader;
    toAminoMsg(message: GnoHeader): GnoHeaderAminoMsg;
    fromProtoMsg(message: GnoHeaderProtoMsg): GnoHeader;
    toProto(message: GnoHeader): Uint8Array;
    toProtoMsg(message: GnoHeader): GnoHeaderProtoMsg;
};
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(object: Partial<Data>): Data;
    fromAmino(object: DataAmino): Data;
    toAmino(message: Data): DataAmino;
    fromAminoMsg(object: DataAminoMsg): Data;
    toAminoMsg(message: Data): DataAminoMsg;
    fromProtoMsg(message: DataProtoMsg): Data;
    toProto(message: Data): Uint8Array;
    toProtoMsg(message: Data): DataProtoMsg;
};
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(object: Partial<Commit>): Commit;
    fromAmino(object: CommitAmino): Commit;
    toAmino(message: Commit): CommitAmino;
    fromAminoMsg(object: CommitAminoMsg): Commit;
    toAminoMsg(message: Commit): CommitAminoMsg;
    fromProtoMsg(message: CommitProtoMsg): Commit;
    toProto(message: Commit): Uint8Array;
    toProtoMsg(message: Commit): CommitProtoMsg;
};
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(object: Partial<BlockID>): BlockID;
    fromAmino(object: BlockIDAmino): BlockID;
    toAmino(message: BlockID): BlockIDAmino;
    fromAminoMsg(object: BlockIDAminoMsg): BlockID;
    toAminoMsg(message: BlockID): BlockIDAminoMsg;
    fromProtoMsg(message: BlockIDProtoMsg): BlockID;
    toProto(message: BlockID): Uint8Array;
    toProtoMsg(message: BlockID): BlockIDProtoMsg;
};
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(object: Partial<SignedHeader>): SignedHeader;
    fromAmino(object: SignedHeaderAmino): SignedHeader;
    toAmino(message: SignedHeader): SignedHeaderAmino;
    fromAminoMsg(object: SignedHeaderAminoMsg): SignedHeader;
    toAminoMsg(message: SignedHeader): SignedHeaderAminoMsg;
    fromProtoMsg(message: SignedHeaderProtoMsg): SignedHeader;
    toProto(message: SignedHeader): Uint8Array;
    toProtoMsg(message: SignedHeader): SignedHeaderProtoMsg;
};
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(object: Partial<LightBlock>): LightBlock;
    fromAmino(object: LightBlockAmino): LightBlock;
    toAmino(message: LightBlock): LightBlockAmino;
    fromAminoMsg(object: LightBlockAminoMsg): LightBlock;
    toAminoMsg(message: LightBlock): LightBlockAminoMsg;
    fromProtoMsg(message: LightBlockProtoMsg): LightBlock;
    toProto(message: LightBlock): Uint8Array;
    toProtoMsg(message: LightBlock): LightBlockProtoMsg;
};
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(object: Partial<CommitSig>): CommitSig;
    fromAmino(object: CommitSigAmino): CommitSig;
    toAmino(message: CommitSig): CommitSigAmino;
    fromAminoMsg(object: CommitSigAminoMsg): CommitSig;
    toAminoMsg(message: CommitSig): CommitSigAminoMsg;
    fromProtoMsg(message: CommitSigProtoMsg): CommitSig;
    toProto(message: CommitSig): Uint8Array;
    toProtoMsg(message: CommitSig): CommitSigProtoMsg;
};
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(object: Partial<Vote>): Vote;
    fromAmino(object: VoteAmino): Vote;
    toAmino(message: Vote): VoteAmino;
    fromAminoMsg(object: VoteAminoMsg): Vote;
    toAminoMsg(message: Vote): VoteAminoMsg;
    fromProtoMsg(message: VoteProtoMsg): Vote;
    toProto(message: Vote): Uint8Array;
    toProtoMsg(message: Vote): VoteProtoMsg;
};
export declare const PartSet: {
    typeUrl: string;
    encode(_: PartSet, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): PartSet;
    fromJSON(_: any): PartSet;
    toJSON(_: PartSet): unknown;
    fromPartial(_: Partial<PartSet>): PartSet;
    fromAmino(_: PartSetAmino): PartSet;
    toAmino(_: PartSet): PartSetAmino;
    fromAminoMsg(object: PartSetAminoMsg): PartSet;
    toAminoMsg(message: PartSet): PartSetAminoMsg;
    fromProtoMsg(message: PartSetProtoMsg): PartSet;
    toProto(message: PartSet): Uint8Array;
    toProtoMsg(message: PartSet): PartSetProtoMsg;
};
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(object: Partial<PartSetHeader>): PartSetHeader;
    fromAmino(object: PartSetHeaderAmino): PartSetHeader;
    toAmino(message: PartSetHeader): PartSetHeaderAmino;
    fromAminoMsg(object: PartSetHeaderAminoMsg): PartSetHeader;
    toAminoMsg(message: PartSetHeader): PartSetHeaderAminoMsg;
    fromProtoMsg(message: PartSetHeaderProtoMsg): PartSetHeader;
    toProto(message: PartSetHeader): Uint8Array;
    toProtoMsg(message: PartSetHeader): PartSetHeaderProtoMsg;
};
export declare const Validator: {
    typeUrl: string;
    encode(message: Validator, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): Validator;
    fromJSON(object: any): Validator;
    toJSON(message: Validator): unknown;
    fromPartial(object: Partial<Validator>): Validator;
    fromAmino(object: ValidatorAmino): Validator;
    toAmino(message: Validator): ValidatorAmino;
    fromAminoMsg(object: ValidatorAminoMsg): Validator;
    toAminoMsg(message: Validator): ValidatorAminoMsg;
    fromProtoMsg(message: ValidatorProtoMsg): Validator;
    toProto(message: Validator): Uint8Array;
    toProtoMsg(message: Validator): ValidatorProtoMsg;
};
export declare const ValidatorSet: {
    typeUrl: string;
    encode(message: ValidatorSet, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): ValidatorSet;
    fromJSON(object: any): ValidatorSet;
    toJSON(message: ValidatorSet): unknown;
    fromPartial(object: Partial<ValidatorSet>): ValidatorSet;
    fromAmino(object: ValidatorSetAmino): ValidatorSet;
    toAmino(message: ValidatorSet): ValidatorSetAmino;
    fromAminoMsg(object: ValidatorSetAminoMsg): ValidatorSet;
    toAminoMsg(message: ValidatorSet): ValidatorSetAminoMsg;
    fromProtoMsg(message: ValidatorSetProtoMsg): ValidatorSet;
    toProto(message: ValidatorSet): Uint8Array;
    toProtoMsg(message: ValidatorSet): ValidatorSetProtoMsg;
};
export declare const Fraction: {
    typeUrl: string;
    encode(message: Fraction, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): Fraction;
    fromJSON(object: any): Fraction;
    toJSON(message: Fraction): unknown;
    fromPartial(object: Partial<Fraction>): Fraction;
    fromAmino(object: FractionAmino): Fraction;
    toAmino(message: Fraction): FractionAmino;
    fromAminoMsg(object: FractionAminoMsg): Fraction;
    toAminoMsg(message: Fraction): FractionAminoMsg;
    fromProtoMsg(message: FractionProtoMsg): Fraction;
    toProto(message: Fraction): Uint8Array;
    toProtoMsg(message: Fraction): FractionProtoMsg;
};