Variable v1Const

v1: {
    MerklePath: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MerklePath;
        encode(message: MerklePath, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: MerklePathAmino): MerklePath;
        fromAminoMsg(object: MerklePathAminoMsg): MerklePath;
        fromPartial(object: {
            keyPath?: string[];
        }): MerklePath;
        fromProtoMsg(message: MerklePathProtoMsg): MerklePath;
        toAmino(message: MerklePath): MerklePathAmino;
        toAminoMsg(message: MerklePath): MerklePathAminoMsg;
        toProto(message: MerklePath): Uint8Array;
        toProtoMsg(message: MerklePath): MerklePathProtoMsg;
    };
    MerklePrefix: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MerklePrefix;
        encode(message: MerklePrefix, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: MerklePrefixAmino): MerklePrefix;
        fromAminoMsg(object: MerklePrefixAminoMsg): MerklePrefix;
        fromPartial(object: {
            keyPrefix?: Uint8Array;
        }): MerklePrefix;
        fromProtoMsg(message: MerklePrefixProtoMsg): MerklePrefix;
        toAmino(message: MerklePrefix): MerklePrefixAmino;
        toAminoMsg(message: MerklePrefix): MerklePrefixAminoMsg;
        toProto(message: MerklePrefix): Uint8Array;
        toProtoMsg(message: MerklePrefix): MerklePrefixProtoMsg;
    };
    MerkleProof: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MerkleProof;
        encode(message: MerkleProof, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: MerkleProofAmino): MerkleProof;
        fromAminoMsg(object: MerkleProofAminoMsg): MerkleProof;
        fromPartial(object: {
            proofs?: {
                batch?: {
                    entries?: {
                        exist?: ...;
                        nonexist?: ...;
                    }[];
                };
                compressed?: {
                    entries?: {
                        exist?: ...;
                        nonexist?: ...;
                    }[];
                    lookupInners?: {
                        hash?: ...;
                        prefix?: ...;
                        suffix?: ...;
                    }[];
                };
                exist?: {
                    key?: Uint8Array;
                    leaf?: {
                        hash?: (...) | (...);
                        length?: (...) | (...);
                        prefix?: (...) | (...);
                        prehashKey?: (...) | (...);
                        prehashValue?: (...) | (...);
                    };
                    path?: {
                        hash?: ...;
                        prefix?: ...;
                        suffix?: ...;
                    }[];
                    value?: Uint8Array;
                };
                nonexist?: {
                    key?: Uint8Array;
                    left?: {
                        key?: (...) | (...);
                        leaf?: (...) | (...);
                        path?: (...) | (...);
                        value?: (...) | (...);
                    };
                    right?: {
                        key?: (...) | (...);
                        leaf?: (...) | (...);
                        path?: (...) | (...);
                        value?: (...) | (...);
                    };
                };
            }[];
        }): MerkleProof;
        fromProtoMsg(message: MerkleProofProtoMsg): MerkleProof;
        toAmino(message: MerkleProof): MerkleProofAmino;
        toAminoMsg(message: MerkleProof): MerkleProofAminoMsg;
        toProto(message: MerkleProof): Uint8Array;
        toProtoMsg(message: MerkleProof): MerkleProofProtoMsg;
    };
    MerkleRoot: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MerkleRoot;
        encode(message: MerkleRoot, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: MerkleRootAmino): MerkleRoot;
        fromAminoMsg(object: MerkleRootAminoMsg): MerkleRoot;
        fromPartial(object: {
            hash?: Uint8Array;
        }): MerkleRoot;
        fromProtoMsg(message: MerkleRootProtoMsg): MerkleRoot;
        toAmino(message: MerkleRoot): MerkleRootAmino;
        toAminoMsg(message: MerkleRoot): MerkleRootAminoMsg;
        toProto(message: MerkleRoot): Uint8Array;
        toProtoMsg(message: MerkleRoot): MerkleRootProtoMsg;
    };
} = ...