@sparkdreamnft/sparkdreamjs 0.0.10 → 0.0.12

package/sparkdream/bundle.d.ts

@@ -645,12 +645,14 @@ export declare namespace sparkdream {
             };
             MsgCreatePost: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _180.MsgCreatePost, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _180.MsgCreatePost;
                 fromPartial(object: import("../helpers").DeepPartial<_180.MsgCreatePost>): _180.MsgCreatePost;
                 fromAmino(object: _180.MsgCreatePostAmino): _180.MsgCreatePost;
                 toAmino(message: _180.MsgCreatePost): _180.MsgCreatePostAmino;
                 fromAminoMsg(object: _180.MsgCreatePostAminoMsg): _180.MsgCreatePost;
+                toAminoMsg(message: _180.MsgCreatePost): _180.MsgCreatePostAminoMsg;
                 fromProtoMsg(message: _180.MsgCreatePostProtoMsg): _180.MsgCreatePost;
                 toProto(message: _180.MsgCreatePost): Uint8Array;
                 toProtoMsg(message: _180.MsgCreatePost): _180.MsgCreatePostProtoMsg;
@@ -669,12 +671,14 @@ export declare namespace sparkdream {
             };
             MsgUpdatePost: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _180.MsgUpdatePost, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _180.MsgUpdatePost;
                 fromPartial(object: import("../helpers").DeepPartial<_180.MsgUpdatePost>): _180.MsgUpdatePost;
                 fromAmino(object: _180.MsgUpdatePostAmino): _180.MsgUpdatePost;
                 toAmino(message: _180.MsgUpdatePost): _180.MsgUpdatePostAmino;
                 fromAminoMsg(object: _180.MsgUpdatePostAminoMsg): _180.MsgUpdatePost;
+                toAminoMsg(message: _180.MsgUpdatePost): _180.MsgUpdatePostAminoMsg;
                 fromProtoMsg(message: _180.MsgUpdatePostProtoMsg): _180.MsgUpdatePost;
                 toProto(message: _180.MsgUpdatePost): Uint8Array;
                 toProtoMsg(message: _180.MsgUpdatePost): _180.MsgUpdatePostProtoMsg;
@@ -693,12 +697,14 @@ export declare namespace sparkdream {
             };
             MsgDeletePost: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _180.MsgDeletePost, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _180.MsgDeletePost;
                 fromPartial(object: import("../helpers").DeepPartial<_180.MsgDeletePost>): _180.MsgDeletePost;
                 fromAmino(object: _180.MsgDeletePostAmino): _180.MsgDeletePost;
                 toAmino(message: _180.MsgDeletePost): _180.MsgDeletePostAmino;
                 fromAminoMsg(object: _180.MsgDeletePostAminoMsg): _180.MsgDeletePost;
+                toAminoMsg(message: _180.MsgDeletePost): _180.MsgDeletePostAminoMsg;
                 fromProtoMsg(message: _180.MsgDeletePostProtoMsg): _180.MsgDeletePost;
                 toProto(message: _180.MsgDeletePost): Uint8Array;
                 toProtoMsg(message: _180.MsgDeletePost): _180.MsgDeletePostProtoMsg;
@@ -717,12 +723,14 @@ export declare namespace sparkdream {
             };
             MsgHidePost: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _180.MsgHidePost, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _180.MsgHidePost;
                 fromPartial(object: import("../helpers").DeepPartial<_180.MsgHidePost>): _180.MsgHidePost;
                 fromAmino(object: _180.MsgHidePostAmino): _180.MsgHidePost;
                 toAmino(message: _180.MsgHidePost): _180.MsgHidePostAmino;
                 fromAminoMsg(object: _180.MsgHidePostAminoMsg): _180.MsgHidePost;
+                toAminoMsg(message: _180.MsgHidePost): _180.MsgHidePostAminoMsg;
                 fromProtoMsg(message: _180.MsgHidePostProtoMsg): _180.MsgHidePost;
                 toProto(message: _180.MsgHidePost): Uint8Array;
                 toProtoMsg(message: _180.MsgHidePost): _180.MsgHidePostProtoMsg;
@@ -741,12 +749,14 @@ export declare namespace sparkdream {
             };
             MsgUnhidePost: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _180.MsgUnhidePost, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _180.MsgUnhidePost;
                 fromPartial(object: import("../helpers").DeepPartial<_180.MsgUnhidePost>): _180.MsgUnhidePost;
                 fromAmino(object: _180.MsgUnhidePostAmino): _180.MsgUnhidePost;
                 toAmino(message: _180.MsgUnhidePost): _180.MsgUnhidePostAmino;
                 fromAminoMsg(object: _180.MsgUnhidePostAminoMsg): _180.MsgUnhidePost;
+                toAminoMsg(message: _180.MsgUnhidePost): _180.MsgUnhidePostAminoMsg;
                 fromProtoMsg(message: _180.MsgUnhidePostProtoMsg): _180.MsgUnhidePost;
                 toProto(message: _180.MsgUnhidePost): Uint8Array;
                 toProtoMsg(message: _180.MsgUnhidePost): _180.MsgUnhidePostProtoMsg;
@@ -765,12 +775,14 @@ export declare namespace sparkdream {
             };
             MsgCreateReply: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _180.MsgCreateReply, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _180.MsgCreateReply;
                 fromPartial(object: import("../helpers").DeepPartial<_180.MsgCreateReply>): _180.MsgCreateReply;
                 fromAmino(object: _180.MsgCreateReplyAmino): _180.MsgCreateReply;
                 toAmino(message: _180.MsgCreateReply): _180.MsgCreateReplyAmino;
                 fromAminoMsg(object: _180.MsgCreateReplyAminoMsg): _180.MsgCreateReply;
+                toAminoMsg(message: _180.MsgCreateReply): _180.MsgCreateReplyAminoMsg;
                 fromProtoMsg(message: _180.MsgCreateReplyProtoMsg): _180.MsgCreateReply;
                 toProto(message: _180.MsgCreateReply): Uint8Array;
                 toProtoMsg(message: _180.MsgCreateReply): _180.MsgCreateReplyProtoMsg;
@@ -789,12 +801,14 @@ export declare namespace sparkdream {
             };
             MsgUpdateReply: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _180.MsgUpdateReply, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _180.MsgUpdateReply;
                 fromPartial(object: import("../helpers").DeepPartial<_180.MsgUpdateReply>): _180.MsgUpdateReply;
                 fromAmino(object: _180.MsgUpdateReplyAmino): _180.MsgUpdateReply;
                 toAmino(message: _180.MsgUpdateReply): _180.MsgUpdateReplyAmino;
                 fromAminoMsg(object: _180.MsgUpdateReplyAminoMsg): _180.MsgUpdateReply;
+                toAminoMsg(message: _180.MsgUpdateReply): _180.MsgUpdateReplyAminoMsg;
                 fromProtoMsg(message: _180.MsgUpdateReplyProtoMsg): _180.MsgUpdateReply;
                 toProto(message: _180.MsgUpdateReply): Uint8Array;
                 toProtoMsg(message: _180.MsgUpdateReply): _180.MsgUpdateReplyProtoMsg;
@@ -813,12 +827,14 @@ export declare namespace sparkdream {
             };
             MsgDeleteReply: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _180.MsgDeleteReply, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _180.MsgDeleteReply;
                 fromPartial(object: import("../helpers").DeepPartial<_180.MsgDeleteReply>): _180.MsgDeleteReply;
                 fromAmino(object: _180.MsgDeleteReplyAmino): _180.MsgDeleteReply;
                 toAmino(message: _180.MsgDeleteReply): _180.MsgDeleteReplyAmino;
                 fromAminoMsg(object: _180.MsgDeleteReplyAminoMsg): _180.MsgDeleteReply;
+                toAminoMsg(message: _180.MsgDeleteReply): _180.MsgDeleteReplyAminoMsg;
                 fromProtoMsg(message: _180.MsgDeleteReplyProtoMsg): _180.MsgDeleteReply;
                 toProto(message: _180.MsgDeleteReply): Uint8Array;
                 toProtoMsg(message: _180.MsgDeleteReply): _180.MsgDeleteReplyProtoMsg;
@@ -837,12 +853,14 @@ export declare namespace sparkdream {
             };
             MsgHideReply: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _180.MsgHideReply, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _180.MsgHideReply;
                 fromPartial(object: import("../helpers").DeepPartial<_180.MsgHideReply>): _180.MsgHideReply;
                 fromAmino(object: _180.MsgHideReplyAmino): _180.MsgHideReply;
                 toAmino(message: _180.MsgHideReply): _180.MsgHideReplyAmino;
                 fromAminoMsg(object: _180.MsgHideReplyAminoMsg): _180.MsgHideReply;
+                toAminoMsg(message: _180.MsgHideReply): _180.MsgHideReplyAminoMsg;
                 fromProtoMsg(message: _180.MsgHideReplyProtoMsg): _180.MsgHideReply;
                 toProto(message: _180.MsgHideReply): Uint8Array;
                 toProtoMsg(message: _180.MsgHideReply): _180.MsgHideReplyProtoMsg;
@@ -861,12 +879,14 @@ export declare namespace sparkdream {
             };
             MsgUnhideReply: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _180.MsgUnhideReply, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _180.MsgUnhideReply;
                 fromPartial(object: import("../helpers").DeepPartial<_180.MsgUnhideReply>): _180.MsgUnhideReply;
                 fromAmino(object: _180.MsgUnhideReplyAmino): _180.MsgUnhideReply;
                 toAmino(message: _180.MsgUnhideReply): _180.MsgUnhideReplyAmino;
                 fromAminoMsg(object: _180.MsgUnhideReplyAminoMsg): _180.MsgUnhideReply;
+                toAminoMsg(message: _180.MsgUnhideReply): _180.MsgUnhideReplyAminoMsg;
                 fromProtoMsg(message: _180.MsgUnhideReplyProtoMsg): _180.MsgUnhideReply;
                 toProto(message: _180.MsgUnhideReply): Uint8Array;
                 toProtoMsg(message: _180.MsgUnhideReply): _180.MsgUnhideReplyProtoMsg;
@@ -885,12 +905,14 @@ export declare namespace sparkdream {
             };
             MsgReact: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _180.MsgReact, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _180.MsgReact;
                 fromPartial(object: import("../helpers").DeepPartial<_180.MsgReact>): _180.MsgReact;
                 fromAmino(object: _180.MsgReactAmino): _180.MsgReact;
                 toAmino(message: _180.MsgReact): _180.MsgReactAmino;
                 fromAminoMsg(object: _180.MsgReactAminoMsg): _180.MsgReact;
+                toAminoMsg(message: _180.MsgReact): _180.MsgReactAminoMsg;
                 fromProtoMsg(message: _180.MsgReactProtoMsg): _180.MsgReact;
                 toProto(message: _180.MsgReact): Uint8Array;
                 toProtoMsg(message: _180.MsgReact): _180.MsgReactProtoMsg;
@@ -909,12 +931,14 @@ export declare namespace sparkdream {
             };
             MsgRemoveReaction: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _180.MsgRemoveReaction, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _180.MsgRemoveReaction;
                 fromPartial(object: import("../helpers").DeepPartial<_180.MsgRemoveReaction>): _180.MsgRemoveReaction;
                 fromAmino(object: _180.MsgRemoveReactionAmino): _180.MsgRemoveReaction;
                 toAmino(message: _180.MsgRemoveReaction): _180.MsgRemoveReactionAmino;
                 fromAminoMsg(object: _180.MsgRemoveReactionAminoMsg): _180.MsgRemoveReaction;
+                toAminoMsg(message: _180.MsgRemoveReaction): _180.MsgRemoveReactionAminoMsg;
                 fromProtoMsg(message: _180.MsgRemoveReactionProtoMsg): _180.MsgRemoveReaction;
                 toProto(message: _180.MsgRemoveReaction): Uint8Array;
                 toProtoMsg(message: _180.MsgRemoveReaction): _180.MsgRemoveReactionProtoMsg;
@@ -933,12 +957,14 @@ export declare namespace sparkdream {
             };
             MsgPinPost: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _180.MsgPinPost, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _180.MsgPinPost;
                 fromPartial(object: import("../helpers").DeepPartial<_180.MsgPinPost>): _180.MsgPinPost;
                 fromAmino(object: _180.MsgPinPostAmino): _180.MsgPinPost;
                 toAmino(message: _180.MsgPinPost): _180.MsgPinPostAmino;
                 fromAminoMsg(object: _180.MsgPinPostAminoMsg): _180.MsgPinPost;
+                toAminoMsg(message: _180.MsgPinPost): _180.MsgPinPostAminoMsg;
                 fromProtoMsg(message: _180.MsgPinPostProtoMsg): _180.MsgPinPost;
                 toProto(message: _180.MsgPinPost): Uint8Array;
                 toProtoMsg(message: _180.MsgPinPost): _180.MsgPinPostProtoMsg;
@@ -957,12 +983,14 @@ export declare namespace sparkdream {
             };
             MsgPinReply: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _180.MsgPinReply, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _180.MsgPinReply;
                 fromPartial(object: import("../helpers").DeepPartial<_180.MsgPinReply>): _180.MsgPinReply;
                 fromAmino(object: _180.MsgPinReplyAmino): _180.MsgPinReply;
                 toAmino(message: _180.MsgPinReply): _180.MsgPinReplyAmino;
                 fromAminoMsg(object: _180.MsgPinReplyAminoMsg): _180.MsgPinReply;
+                toAminoMsg(message: _180.MsgPinReply): _180.MsgPinReplyAminoMsg;
                 fromProtoMsg(message: _180.MsgPinReplyProtoMsg): _180.MsgPinReply;
                 toProto(message: _180.MsgPinReply): Uint8Array;
                 toProtoMsg(message: _180.MsgPinReply): _180.MsgPinReplyProtoMsg;
@@ -2105,12 +2133,14 @@ export declare namespace sparkdream {
             };
             MsgCreateCollection: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _187.MsgCreateCollection, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _187.MsgCreateCollection;
                 fromPartial(object: import("../helpers").DeepPartial<_187.MsgCreateCollection>): _187.MsgCreateCollection;
                 fromAmino(object: _187.MsgCreateCollectionAmino): _187.MsgCreateCollection;
                 toAmino(message: _187.MsgCreateCollection): _187.MsgCreateCollectionAmino;
                 fromAminoMsg(object: _187.MsgCreateCollectionAminoMsg): _187.MsgCreateCollection;
+                toAminoMsg(message: _187.MsgCreateCollection): _187.MsgCreateCollectionAminoMsg;
                 fromProtoMsg(message: _187.MsgCreateCollectionProtoMsg): _187.MsgCreateCollection;
                 toProto(message: _187.MsgCreateCollection): Uint8Array;
                 toProtoMsg(message: _187.MsgCreateCollection): _187.MsgCreateCollectionProtoMsg;
@@ -2129,12 +2159,14 @@ export declare namespace sparkdream {
             };
             MsgUpdateCollection: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _187.MsgUpdateCollection, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _187.MsgUpdateCollection;
                 fromPartial(object: import("../helpers").DeepPartial<_187.MsgUpdateCollection>): _187.MsgUpdateCollection;
                 fromAmino(object: _187.MsgUpdateCollectionAmino): _187.MsgUpdateCollection;
                 toAmino(message: _187.MsgUpdateCollection): _187.MsgUpdateCollectionAmino;
                 fromAminoMsg(object: _187.MsgUpdateCollectionAminoMsg): _187.MsgUpdateCollection;
+                toAminoMsg(message: _187.MsgUpdateCollection): _187.MsgUpdateCollectionAminoMsg;
                 fromProtoMsg(message: _187.MsgUpdateCollectionProtoMsg): _187.MsgUpdateCollection;
                 toProto(message: _187.MsgUpdateCollection): Uint8Array;
                 toProtoMsg(message: _187.MsgUpdateCollection): _187.MsgUpdateCollectionProtoMsg;
@@ -2153,12 +2185,14 @@ export declare namespace sparkdream {
             };
             MsgDeleteCollection: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _187.MsgDeleteCollection, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _187.MsgDeleteCollection;
                 fromPartial(object: import("../helpers").DeepPartial<_187.MsgDeleteCollection>): _187.MsgDeleteCollection;
                 fromAmino(object: _187.MsgDeleteCollectionAmino): _187.MsgDeleteCollection;
                 toAmino(message: _187.MsgDeleteCollection): _187.MsgDeleteCollectionAmino;
                 fromAminoMsg(object: _187.MsgDeleteCollectionAminoMsg): _187.MsgDeleteCollection;
+                toAminoMsg(message: _187.MsgDeleteCollection): _187.MsgDeleteCollectionAminoMsg;
                 fromProtoMsg(message: _187.MsgDeleteCollectionProtoMsg): _187.MsgDeleteCollection;
                 toProto(message: _187.MsgDeleteCollection): Uint8Array;
                 toProtoMsg(message: _187.MsgDeleteCollection): _187.MsgDeleteCollectionProtoMsg;
@@ -2177,12 +2211,14 @@ export declare namespace sparkdream {
             };
             MsgAddItem: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _187.MsgAddItem, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _187.MsgAddItem;
                 fromPartial(object: import("../helpers").DeepPartial<_187.MsgAddItem>): _187.MsgAddItem;
                 fromAmino(object: _187.MsgAddItemAmino): _187.MsgAddItem;
                 toAmino(message: _187.MsgAddItem): _187.MsgAddItemAmino;
                 fromAminoMsg(object: _187.MsgAddItemAminoMsg): _187.MsgAddItem;
+                toAminoMsg(message: _187.MsgAddItem): _187.MsgAddItemAminoMsg;
                 fromProtoMsg(message: _187.MsgAddItemProtoMsg): _187.MsgAddItem;
                 toProto(message: _187.MsgAddItem): Uint8Array;
                 toProtoMsg(message: _187.MsgAddItem): _187.MsgAddItemProtoMsg;
@@ -2201,12 +2237,14 @@ export declare namespace sparkdream {
             };
             MsgAddItems: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _187.MsgAddItems, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _187.MsgAddItems;
                 fromPartial(object: import("../helpers").DeepPartial<_187.MsgAddItems>): _187.MsgAddItems;
                 fromAmino(object: _187.MsgAddItemsAmino): _187.MsgAddItems;
                 toAmino(message: _187.MsgAddItems): _187.MsgAddItemsAmino;
                 fromAminoMsg(object: _187.MsgAddItemsAminoMsg): _187.MsgAddItems;
+                toAminoMsg(message: _187.MsgAddItems): _187.MsgAddItemsAminoMsg;
                 fromProtoMsg(message: _187.MsgAddItemsProtoMsg): _187.MsgAddItems;
                 toProto(message: _187.MsgAddItems): Uint8Array;
                 toProtoMsg(message: _187.MsgAddItems): _187.MsgAddItemsProtoMsg;
@@ -2225,12 +2263,14 @@ export declare namespace sparkdream {
             };
             MsgUpdateItem: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _187.MsgUpdateItem, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _187.MsgUpdateItem;
                 fromPartial(object: import("../helpers").DeepPartial<_187.MsgUpdateItem>): _187.MsgUpdateItem;
                 fromAmino(object: _187.MsgUpdateItemAmino): _187.MsgUpdateItem;
                 toAmino(message: _187.MsgUpdateItem): _187.MsgUpdateItemAmino;
                 fromAminoMsg(object: _187.MsgUpdateItemAminoMsg): _187.MsgUpdateItem;
+                toAminoMsg(message: _187.MsgUpdateItem): _187.MsgUpdateItemAminoMsg;
                 fromProtoMsg(message: _187.MsgUpdateItemProtoMsg): _187.MsgUpdateItem;
                 toProto(message: _187.MsgUpdateItem): Uint8Array;
                 toProtoMsg(message: _187.MsgUpdateItem): _187.MsgUpdateItemProtoMsg;
@@ -2249,12 +2289,14 @@ export declare namespace sparkdream {
             };
             MsgRemoveItem: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _187.MsgRemoveItem, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _187.MsgRemoveItem;
                 fromPartial(object: import("../helpers").DeepPartial<_187.MsgRemoveItem>): _187.MsgRemoveItem;
                 fromAmino(object: _187.MsgRemoveItemAmino): _187.MsgRemoveItem;
                 toAmino(message: _187.MsgRemoveItem): _187.MsgRemoveItemAmino;
                 fromAminoMsg(object: _187.MsgRemoveItemAminoMsg): _187.MsgRemoveItem;
+                toAminoMsg(message: _187.MsgRemoveItem): _187.MsgRemoveItemAminoMsg;
                 fromProtoMsg(message: _187.MsgRemoveItemProtoMsg): _187.MsgRemoveItem;
                 toProto(message: _187.MsgRemoveItem): Uint8Array;
                 toProtoMsg(message: _187.MsgRemoveItem): _187.MsgRemoveItemProtoMsg;
@@ -2273,12 +2315,14 @@ export declare namespace sparkdream {
             };
             MsgRemoveItems: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _187.MsgRemoveItems, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _187.MsgRemoveItems;
                 fromPartial(object: import("../helpers").DeepPartial<_187.MsgRemoveItems>): _187.MsgRemoveItems;
                 fromAmino(object: _187.MsgRemoveItemsAmino): _187.MsgRemoveItems;
                 toAmino(message: _187.MsgRemoveItems): _187.MsgRemoveItemsAmino;
                 fromAminoMsg(object: _187.MsgRemoveItemsAminoMsg): _187.MsgRemoveItems;
+                toAminoMsg(message: _187.MsgRemoveItems): _187.MsgRemoveItemsAminoMsg;
                 fromProtoMsg(message: _187.MsgRemoveItemsProtoMsg): _187.MsgRemoveItems;
                 toProto(message: _187.MsgRemoveItems): Uint8Array;
                 toProtoMsg(message: _187.MsgRemoveItems): _187.MsgRemoveItemsProtoMsg;
@@ -2297,12 +2341,14 @@ export declare namespace sparkdream {
             };
             MsgReorderItem: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _187.MsgReorderItem, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _187.MsgReorderItem;
                 fromPartial(object: import("../helpers").DeepPartial<_187.MsgReorderItem>): _187.MsgReorderItem;
                 fromAmino(object: _187.MsgReorderItemAmino): _187.MsgReorderItem;
                 toAmino(message: _187.MsgReorderItem): _187.MsgReorderItemAmino;
                 fromAminoMsg(object: _187.MsgReorderItemAminoMsg): _187.MsgReorderItem;
+                toAminoMsg(message: _187.MsgReorderItem): _187.MsgReorderItemAminoMsg;
                 fromProtoMsg(message: _187.MsgReorderItemProtoMsg): _187.MsgReorderItem;
                 toProto(message: _187.MsgReorderItem): Uint8Array;
                 toProtoMsg(message: _187.MsgReorderItem): _187.MsgReorderItemProtoMsg;
@@ -2321,12 +2367,14 @@ export declare namespace sparkdream {
             };
             MsgAddCollaborator: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _187.MsgAddCollaborator, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _187.MsgAddCollaborator;
                 fromPartial(object: import("../helpers").DeepPartial<_187.MsgAddCollaborator>): _187.MsgAddCollaborator;
                 fromAmino(object: _187.MsgAddCollaboratorAmino): _187.MsgAddCollaborator;
                 toAmino(message: _187.MsgAddCollaborator): _187.MsgAddCollaboratorAmino;
                 fromAminoMsg(object: _187.MsgAddCollaboratorAminoMsg): _187.MsgAddCollaborator;
+                toAminoMsg(message: _187.MsgAddCollaborator): _187.MsgAddCollaboratorAminoMsg;
                 fromProtoMsg(message: _187.MsgAddCollaboratorProtoMsg): _187.MsgAddCollaborator;
                 toProto(message: _187.MsgAddCollaborator): Uint8Array;
                 toProtoMsg(message: _187.MsgAddCollaborator): _187.MsgAddCollaboratorProtoMsg;
@@ -2345,12 +2393,14 @@ export declare namespace sparkdream {
             };
             MsgRemoveCollaborator: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _187.MsgRemoveCollaborator, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _187.MsgRemoveCollaborator;
                 fromPartial(object: import("../helpers").DeepPartial<_187.MsgRemoveCollaborator>): _187.MsgRemoveCollaborator;
                 fromAmino(object: _187.MsgRemoveCollaboratorAmino): _187.MsgRemoveCollaborator;
                 toAmino(message: _187.MsgRemoveCollaborator): _187.MsgRemoveCollaboratorAmino;
                 fromAminoMsg(object: _187.MsgRemoveCollaboratorAminoMsg): _187.MsgRemoveCollaborator;
+                toAminoMsg(message: _187.MsgRemoveCollaborator): _187.MsgRemoveCollaboratorAminoMsg;
                 fromProtoMsg(message: _187.MsgRemoveCollaboratorProtoMsg): _187.MsgRemoveCollaborator;
                 toProto(message: _187.MsgRemoveCollaborator): Uint8Array;
                 toProtoMsg(message: _187.MsgRemoveCollaborator): _187.MsgRemoveCollaboratorProtoMsg;
@@ -2369,12 +2419,14 @@ export declare namespace sparkdream {
             };
             MsgUpdateCollaboratorRole: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _187.MsgUpdateCollaboratorRole, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _187.MsgUpdateCollaboratorRole;
                 fromPartial(object: import("../helpers").DeepPartial<_187.MsgUpdateCollaboratorRole>): _187.MsgUpdateCollaboratorRole;
                 fromAmino(object: _187.MsgUpdateCollaboratorRoleAmino): _187.MsgUpdateCollaboratorRole;
                 toAmino(message: _187.MsgUpdateCollaboratorRole): _187.MsgUpdateCollaboratorRoleAmino;
                 fromAminoMsg(object: _187.MsgUpdateCollaboratorRoleAminoMsg): _187.MsgUpdateCollaboratorRole;
+                toAminoMsg(message: _187.MsgUpdateCollaboratorRole): _187.MsgUpdateCollaboratorRoleAminoMsg;
                 fromProtoMsg(message: _187.MsgUpdateCollaboratorRoleProtoMsg): _187.MsgUpdateCollaboratorRole;
                 toProto(message: _187.MsgUpdateCollaboratorRole): Uint8Array;
                 toProtoMsg(message: _187.MsgUpdateCollaboratorRole): _187.MsgUpdateCollaboratorRoleProtoMsg;
@@ -2393,12 +2445,14 @@ export declare namespace sparkdream {
             };
             MsgRateCollection: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _187.MsgRateCollection, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _187.MsgRateCollection;
                 fromPartial(object: import("../helpers").DeepPartial<_187.MsgRateCollection>): _187.MsgRateCollection;
                 fromAmino(object: _187.MsgRateCollectionAmino): _187.MsgRateCollection;
                 toAmino(message: _187.MsgRateCollection): _187.MsgRateCollectionAmino;
                 fromAminoMsg(object: _187.MsgRateCollectionAminoMsg): _187.MsgRateCollection;
+                toAminoMsg(message: _187.MsgRateCollection): _187.MsgRateCollectionAminoMsg;
                 fromProtoMsg(message: _187.MsgRateCollectionProtoMsg): _187.MsgRateCollection;
                 toProto(message: _187.MsgRateCollection): Uint8Array;
                 toProtoMsg(message: _187.MsgRateCollection): _187.MsgRateCollectionProtoMsg;
@@ -2417,12 +2471,14 @@ export declare namespace sparkdream {
             };
             MsgChallengeReview: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _187.MsgChallengeReview, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _187.MsgChallengeReview;
                 fromPartial(object: import("../helpers").DeepPartial<_187.MsgChallengeReview>): _187.MsgChallengeReview;
                 fromAmino(object: _187.MsgChallengeReviewAmino): _187.MsgChallengeReview;
                 toAmino(message: _187.MsgChallengeReview): _187.MsgChallengeReviewAmino;
                 fromAminoMsg(object: _187.MsgChallengeReviewAminoMsg): _187.MsgChallengeReview;
+                toAminoMsg(message: _187.MsgChallengeReview): _187.MsgChallengeReviewAminoMsg;
                 fromProtoMsg(message: _187.MsgChallengeReviewProtoMsg): _187.MsgChallengeReview;
                 toProto(message: _187.MsgChallengeReview): Uint8Array;
                 toProtoMsg(message: _187.MsgChallengeReview): _187.MsgChallengeReviewProtoMsg;
@@ -2441,12 +2497,14 @@ export declare namespace sparkdream {
             };
             MsgRequestSponsorship: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _187.MsgRequestSponsorship, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _187.MsgRequestSponsorship;
                 fromPartial(object: import("../helpers").DeepPartial<_187.MsgRequestSponsorship>): _187.MsgRequestSponsorship;
                 fromAmino(object: _187.MsgRequestSponsorshipAmino): _187.MsgRequestSponsorship;
                 toAmino(message: _187.MsgRequestSponsorship): _187.MsgRequestSponsorshipAmino;
                 fromAminoMsg(object: _187.MsgRequestSponsorshipAminoMsg): _187.MsgRequestSponsorship;
+                toAminoMsg(message: _187.MsgRequestSponsorship): _187.MsgRequestSponsorshipAminoMsg;
                 fromProtoMsg(message: _187.MsgRequestSponsorshipProtoMsg): _187.MsgRequestSponsorship;
                 toProto(message: _187.MsgRequestSponsorship): Uint8Array;
                 toProtoMsg(message: _187.MsgRequestSponsorship): _187.MsgRequestSponsorshipProtoMsg;
@@ -2465,12 +2523,14 @@ export declare namespace sparkdream {
             };
             MsgCancelSponsorshipRequest: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _187.MsgCancelSponsorshipRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _187.MsgCancelSponsorshipRequest;
                 fromPartial(object: import("../helpers").DeepPartial<_187.MsgCancelSponsorshipRequest>): _187.MsgCancelSponsorshipRequest;
                 fromAmino(object: _187.MsgCancelSponsorshipRequestAmino): _187.MsgCancelSponsorshipRequest;
                 toAmino(message: _187.MsgCancelSponsorshipRequest): _187.MsgCancelSponsorshipRequestAmino;
                 fromAminoMsg(object: _187.MsgCancelSponsorshipRequestAminoMsg): _187.MsgCancelSponsorshipRequest;
+                toAminoMsg(message: _187.MsgCancelSponsorshipRequest): _187.MsgCancelSponsorshipRequestAminoMsg;
                 fromProtoMsg(message: _187.MsgCancelSponsorshipRequestProtoMsg): _187.MsgCancelSponsorshipRequest;
                 toProto(message: _187.MsgCancelSponsorshipRequest): Uint8Array;
                 toProtoMsg(message: _187.MsgCancelSponsorshipRequest): _187.MsgCancelSponsorshipRequestProtoMsg;
@@ -2489,12 +2549,14 @@ export declare namespace sparkdream {
             };
             MsgSponsorCollection: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _187.MsgSponsorCollection, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _187.MsgSponsorCollection;
                 fromPartial(object: import("../helpers").DeepPartial<_187.MsgSponsorCollection>): _187.MsgSponsorCollection;
                 fromAmino(object: _187.MsgSponsorCollectionAmino): _187.MsgSponsorCollection;
                 toAmino(message: _187.MsgSponsorCollection): _187.MsgSponsorCollectionAmino;
                 fromAminoMsg(object: _187.MsgSponsorCollectionAminoMsg): _187.MsgSponsorCollection;
+                toAminoMsg(message: _187.MsgSponsorCollection): _187.MsgSponsorCollectionAminoMsg;
                 fromProtoMsg(message: _187.MsgSponsorCollectionProtoMsg): _187.MsgSponsorCollection;
                 toProto(message: _187.MsgSponsorCollection): Uint8Array;
                 toProtoMsg(message: _187.MsgSponsorCollection): _187.MsgSponsorCollectionProtoMsg;
@@ -2539,12 +2601,14 @@ export declare namespace sparkdream {
             };
             MsgUpvoteContent: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _187.MsgUpvoteContent, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _187.MsgUpvoteContent;
                 fromPartial(object: import("../helpers").DeepPartial<_187.MsgUpvoteContent>): _187.MsgUpvoteContent;
                 fromAmino(object: _187.MsgUpvoteContentAmino): _187.MsgUpvoteContent;
                 toAmino(message: _187.MsgUpvoteContent): _187.MsgUpvoteContentAmino;
                 fromAminoMsg(object: _187.MsgUpvoteContentAminoMsg): _187.MsgUpvoteContent;
+                toAminoMsg(message: _187.MsgUpvoteContent): _187.MsgUpvoteContentAminoMsg;
                 fromProtoMsg(message: _187.MsgUpvoteContentProtoMsg): _187.MsgUpvoteContent;
                 toProto(message: _187.MsgUpvoteContent): Uint8Array;
                 toProtoMsg(message: _187.MsgUpvoteContent): _187.MsgUpvoteContentProtoMsg;
@@ -2563,12 +2627,14 @@ export declare namespace sparkdream {
             };
             MsgDownvoteContent: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _187.MsgDownvoteContent, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _187.MsgDownvoteContent;
                 fromPartial(object: import("../helpers").DeepPartial<_187.MsgDownvoteContent>): _187.MsgDownvoteContent;
                 fromAmino(object: _187.MsgDownvoteContentAmino): _187.MsgDownvoteContent;
                 toAmino(message: _187.MsgDownvoteContent): _187.MsgDownvoteContentAmino;
                 fromAminoMsg(object: _187.MsgDownvoteContentAminoMsg): _187.MsgDownvoteContent;
+                toAminoMsg(message: _187.MsgDownvoteContent): _187.MsgDownvoteContentAminoMsg;
                 fromProtoMsg(message: _187.MsgDownvoteContentProtoMsg): _187.MsgDownvoteContent;
                 toProto(message: _187.MsgDownvoteContent): Uint8Array;
                 toProtoMsg(message: _187.MsgDownvoteContent): _187.MsgDownvoteContentProtoMsg;
@@ -2587,12 +2653,14 @@ export declare namespace sparkdream {
             };
             MsgFlagContent: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _187.MsgFlagContent, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _187.MsgFlagContent;
                 fromPartial(object: import("../helpers").DeepPartial<_187.MsgFlagContent>): _187.MsgFlagContent;
                 fromAmino(object: _187.MsgFlagContentAmino): _187.MsgFlagContent;
                 toAmino(message: _187.MsgFlagContent): _187.MsgFlagContentAmino;
                 fromAminoMsg(object: _187.MsgFlagContentAminoMsg): _187.MsgFlagContent;
+                toAminoMsg(message: _187.MsgFlagContent): _187.MsgFlagContentAminoMsg;
                 fromProtoMsg(message: _187.MsgFlagContentProtoMsg): _187.MsgFlagContent;
                 toProto(message: _187.MsgFlagContent): Uint8Array;
                 toProtoMsg(message: _187.MsgFlagContent): _187.MsgFlagContentProtoMsg;
@@ -2611,12 +2679,14 @@ export declare namespace sparkdream {
             };
             MsgHideContent: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _187.MsgHideContent, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _187.MsgHideContent;
                 fromPartial(object: import("../helpers").DeepPartial<_187.MsgHideContent>): _187.MsgHideContent;
                 fromAmino(object: _187.MsgHideContentAmino): _187.MsgHideContent;
                 toAmino(message: _187.MsgHideContent): _187.MsgHideContentAmino;
                 fromAminoMsg(object: _187.MsgHideContentAminoMsg): _187.MsgHideContent;
+                toAminoMsg(message: _187.MsgHideContent): _187.MsgHideContentAminoMsg;
                 fromProtoMsg(message: _187.MsgHideContentProtoMsg): _187.MsgHideContent;
                 toProto(message: _187.MsgHideContent): Uint8Array;
                 toProtoMsg(message: _187.MsgHideContent): _187.MsgHideContentProtoMsg;
@@ -2635,12 +2705,14 @@ export declare namespace sparkdream {
             };
             MsgAppealHide: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _187.MsgAppealHide, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _187.MsgAppealHide;
                 fromPartial(object: import("../helpers").DeepPartial<_187.MsgAppealHide>): _187.MsgAppealHide;
                 fromAmino(object: _187.MsgAppealHideAmino): _187.MsgAppealHide;
                 toAmino(message: _187.MsgAppealHide): _187.MsgAppealHideAmino;
                 fromAminoMsg(object: _187.MsgAppealHideAminoMsg): _187.MsgAppealHide;
+                toAminoMsg(message: _187.MsgAppealHide): _187.MsgAppealHideAminoMsg;
                 fromProtoMsg(message: _187.MsgAppealHideProtoMsg): _187.MsgAppealHide;
                 toProto(message: _187.MsgAppealHide): Uint8Array;
                 toProtoMsg(message: _187.MsgAppealHide): _187.MsgAppealHideProtoMsg;
@@ -2659,12 +2731,14 @@ export declare namespace sparkdream {
             };
             MsgEndorseCollection: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _187.MsgEndorseCollection, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _187.MsgEndorseCollection;
                 fromPartial(object: import("../helpers").DeepPartial<_187.MsgEndorseCollection>): _187.MsgEndorseCollection;
                 fromAmino(object: _187.MsgEndorseCollectionAmino): _187.MsgEndorseCollection;
                 toAmino(message: _187.MsgEndorseCollection): _187.MsgEndorseCollectionAmino;
                 fromAminoMsg(object: _187.MsgEndorseCollectionAminoMsg): _187.MsgEndorseCollection;
+                toAminoMsg(message: _187.MsgEndorseCollection): _187.MsgEndorseCollectionAminoMsg;
                 fromProtoMsg(message: _187.MsgEndorseCollectionProtoMsg): _187.MsgEndorseCollection;
                 toProto(message: _187.MsgEndorseCollection): Uint8Array;
                 toProtoMsg(message: _187.MsgEndorseCollection): _187.MsgEndorseCollectionProtoMsg;
@@ -2683,12 +2757,14 @@ export declare namespace sparkdream {
             };
             MsgSetSeekingEndorsement: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _187.MsgSetSeekingEndorsement, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _187.MsgSetSeekingEndorsement;
                 fromPartial(object: import("../helpers").DeepPartial<_187.MsgSetSeekingEndorsement>): _187.MsgSetSeekingEndorsement;
                 fromAmino(object: _187.MsgSetSeekingEndorsementAmino): _187.MsgSetSeekingEndorsement;
                 toAmino(message: _187.MsgSetSeekingEndorsement): _187.MsgSetSeekingEndorsementAmino;
                 fromAminoMsg(object: _187.MsgSetSeekingEndorsementAminoMsg): _187.MsgSetSeekingEndorsement;
+                toAminoMsg(message: _187.MsgSetSeekingEndorsement): _187.MsgSetSeekingEndorsementAminoMsg;
                 fromProtoMsg(message: _187.MsgSetSeekingEndorsementProtoMsg): _187.MsgSetSeekingEndorsement;
                 toProto(message: _187.MsgSetSeekingEndorsement): Uint8Array;
                 toProtoMsg(message: _187.MsgSetSeekingEndorsement): _187.MsgSetSeekingEndorsementProtoMsg;
@@ -2707,12 +2783,14 @@ export declare namespace sparkdream {
             };
             MsgPinCollection: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _187.MsgPinCollection, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _187.MsgPinCollection;
                 fromPartial(object: import("../helpers").DeepPartial<_187.MsgPinCollection>): _187.MsgPinCollection;
                 fromAmino(object: _187.MsgPinCollectionAmino): _187.MsgPinCollection;
                 toAmino(message: _187.MsgPinCollection): _187.MsgPinCollectionAmino;
                 fromAminoMsg(object: _187.MsgPinCollectionAminoMsg): _187.MsgPinCollection;
+                toAminoMsg(message: _187.MsgPinCollection): _187.MsgPinCollectionAminoMsg;
                 fromProtoMsg(message: _187.MsgPinCollectionProtoMsg): _187.MsgPinCollection;
                 toProto(message: _187.MsgPinCollection): Uint8Array;
                 toProtoMsg(message: _187.MsgPinCollection): _187.MsgPinCollectionProtoMsg;
@@ -3418,6 +3496,8 @@ export declare namespace sparkdream {
                 params(request?: _198.QueryParamsRequest): Promise<_198.QueryParamsResponse>;
                 getPolicyPermissions(request: _198.QueryGetPolicyPermissionsRequest): Promise<_198.QueryGetPolicyPermissionsResponse>;
                 listPolicyPermissions(request?: _198.QueryAllPolicyPermissionsRequest): Promise<_198.QueryAllPolicyPermissionsResponse>;
+                getDecisionPolicy(request: _198.QueryGetDecisionPolicyRequest): Promise<_198.QueryGetDecisionPolicyResponse>;
+                listDecisionPolicies(request?: _198.QueryAllDecisionPoliciesRequest): Promise<_198.QueryAllDecisionPoliciesResponse>;
                 getGroup(request: _198.QueryGetGroupRequest): Promise<_198.QueryGetGroupResponse>;
                 listGroups(request?: _198.QueryAllGroupRequest): Promise<_198.QueryAllGroupResponse>;
                 getCouncilMembers(request: _198.QueryGetCouncilMembersRequest): Promise<_198.QueryGetCouncilMembersResponse>;
@@ -3843,12 +3923,14 @@ export declare namespace sparkdream {
             };
             MsgCreatePolicyPermissions: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _199.MsgCreatePolicyPermissions, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _199.MsgCreatePolicyPermissions;
                 fromPartial(object: import("../helpers").DeepPartial<_199.MsgCreatePolicyPermissions>): _199.MsgCreatePolicyPermissions;
                 fromAmino(object: _199.MsgCreatePolicyPermissionsAmino): _199.MsgCreatePolicyPermissions;
                 toAmino(message: _199.MsgCreatePolicyPermissions): _199.MsgCreatePolicyPermissionsAmino;
                 fromAminoMsg(object: _199.MsgCreatePolicyPermissionsAminoMsg): _199.MsgCreatePolicyPermissions;
+                toAminoMsg(message: _199.MsgCreatePolicyPermissions): _199.MsgCreatePolicyPermissionsAminoMsg;
                 fromProtoMsg(message: _199.MsgCreatePolicyPermissionsProtoMsg): _199.MsgCreatePolicyPermissions;
                 toProto(message: _199.MsgCreatePolicyPermissions): Uint8Array;
                 toProtoMsg(message: _199.MsgCreatePolicyPermissions): _199.MsgCreatePolicyPermissionsProtoMsg;
@@ -3867,12 +3949,14 @@ export declare namespace sparkdream {
             };
             MsgUpdatePolicyPermissions: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _199.MsgUpdatePolicyPermissions, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _199.MsgUpdatePolicyPermissions;
                 fromPartial(object: import("../helpers").DeepPartial<_199.MsgUpdatePolicyPermissions>): _199.MsgUpdatePolicyPermissions;
                 fromAmino(object: _199.MsgUpdatePolicyPermissionsAmino): _199.MsgUpdatePolicyPermissions;
                 toAmino(message: _199.MsgUpdatePolicyPermissions): _199.MsgUpdatePolicyPermissionsAmino;
                 fromAminoMsg(object: _199.MsgUpdatePolicyPermissionsAminoMsg): _199.MsgUpdatePolicyPermissions;
+                toAminoMsg(message: _199.MsgUpdatePolicyPermissions): _199.MsgUpdatePolicyPermissionsAminoMsg;
                 fromProtoMsg(message: _199.MsgUpdatePolicyPermissionsProtoMsg): _199.MsgUpdatePolicyPermissions;
                 toProto(message: _199.MsgUpdatePolicyPermissions): Uint8Array;
                 toProtoMsg(message: _199.MsgUpdatePolicyPermissions): _199.MsgUpdatePolicyPermissionsProtoMsg;
@@ -3891,12 +3975,14 @@ export declare namespace sparkdream {
             };
             MsgDeletePolicyPermissions: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _199.MsgDeletePolicyPermissions, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _199.MsgDeletePolicyPermissions;
                 fromPartial(object: import("../helpers").DeepPartial<_199.MsgDeletePolicyPermissions>): _199.MsgDeletePolicyPermissions;
                 fromAmino(object: _199.MsgDeletePolicyPermissionsAmino): _199.MsgDeletePolicyPermissions;
                 toAmino(message: _199.MsgDeletePolicyPermissions): _199.MsgDeletePolicyPermissionsAmino;
                 fromAminoMsg(object: _199.MsgDeletePolicyPermissionsAminoMsg): _199.MsgDeletePolicyPermissions;
+                toAminoMsg(message: _199.MsgDeletePolicyPermissions): _199.MsgDeletePolicyPermissionsAminoMsg;
                 fromProtoMsg(message: _199.MsgDeletePolicyPermissionsProtoMsg): _199.MsgDeletePolicyPermissions;
                 toProto(message: _199.MsgDeletePolicyPermissions): Uint8Array;
                 toProtoMsg(message: _199.MsgDeletePolicyPermissions): _199.MsgDeletePolicyPermissionsProtoMsg;
@@ -3915,12 +4001,14 @@ export declare namespace sparkdream {
             };
             MsgRegisterGroup: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _199.MsgRegisterGroup, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _199.MsgRegisterGroup;
                 fromPartial(object: import("../helpers").DeepPartial<_199.MsgRegisterGroup>): _199.MsgRegisterGroup;
                 fromAmino(object: _199.MsgRegisterGroupAmino): _199.MsgRegisterGroup;
                 toAmino(message: _199.MsgRegisterGroup): _199.MsgRegisterGroupAmino;
                 fromAminoMsg(object: _199.MsgRegisterGroupAminoMsg): _199.MsgRegisterGroup;
+                toAminoMsg(message: _199.MsgRegisterGroup): _199.MsgRegisterGroupAminoMsg;
                 fromProtoMsg(message: _199.MsgRegisterGroupProtoMsg): _199.MsgRegisterGroup;
                 toProto(message: _199.MsgRegisterGroup): Uint8Array;
                 toProtoMsg(message: _199.MsgRegisterGroup): _199.MsgRegisterGroupProtoMsg;
@@ -3939,12 +4027,14 @@ export declare namespace sparkdream {
             };
             MsgRenewGroup: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _199.MsgRenewGroup, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _199.MsgRenewGroup;
                 fromPartial(object: import("../helpers").DeepPartial<_199.MsgRenewGroup>): _199.MsgRenewGroup;
                 fromAmino(object: _199.MsgRenewGroupAmino): _199.MsgRenewGroup;
                 toAmino(message: _199.MsgRenewGroup): _199.MsgRenewGroupAmino;
                 fromAminoMsg(object: _199.MsgRenewGroupAminoMsg): _199.MsgRenewGroup;
+                toAminoMsg(message: _199.MsgRenewGroup): _199.MsgRenewGroupAminoMsg;
                 fromProtoMsg(message: _199.MsgRenewGroupProtoMsg): _199.MsgRenewGroup;
                 toProto(message: _199.MsgRenewGroup): Uint8Array;
                 toProtoMsg(message: _199.MsgRenewGroup): _199.MsgRenewGroupProtoMsg;
@@ -3963,12 +4053,14 @@ export declare namespace sparkdream {
             };
             MsgUpdateGroupConfig: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _199.MsgUpdateGroupConfig, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _199.MsgUpdateGroupConfig;
                 fromPartial(object: import("../helpers").DeepPartial<_199.MsgUpdateGroupConfig>): _199.MsgUpdateGroupConfig;
                 fromAmino(object: _199.MsgUpdateGroupConfigAmino): _199.MsgUpdateGroupConfig;
                 toAmino(message: _199.MsgUpdateGroupConfig): _199.MsgUpdateGroupConfigAmino;
                 fromAminoMsg(object: _199.MsgUpdateGroupConfigAminoMsg): _199.MsgUpdateGroupConfig;
+                toAminoMsg(message: _199.MsgUpdateGroupConfig): _199.MsgUpdateGroupConfigAminoMsg;
                 fromProtoMsg(message: _199.MsgUpdateGroupConfigProtoMsg): _199.MsgUpdateGroupConfig;
                 toProto(message: _199.MsgUpdateGroupConfig): Uint8Array;
                 toProtoMsg(message: _199.MsgUpdateGroupConfig): _199.MsgUpdateGroupConfigProtoMsg;
@@ -3987,12 +4079,14 @@ export declare namespace sparkdream {
             };
             MsgUpdateGroupMembers: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _199.MsgUpdateGroupMembers, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _199.MsgUpdateGroupMembers;
                 fromPartial(object: import("../helpers").DeepPartial<_199.MsgUpdateGroupMembers>): _199.MsgUpdateGroupMembers;
                 fromAmino(object: _199.MsgUpdateGroupMembersAmino): _199.MsgUpdateGroupMembers;
                 toAmino(message: _199.MsgUpdateGroupMembers): _199.MsgUpdateGroupMembersAmino;
                 fromAminoMsg(object: _199.MsgUpdateGroupMembersAminoMsg): _199.MsgUpdateGroupMembers;
+                toAminoMsg(message: _199.MsgUpdateGroupMembers): _199.MsgUpdateGroupMembersAminoMsg;
                 fromProtoMsg(message: _199.MsgUpdateGroupMembersProtoMsg): _199.MsgUpdateGroupMembers;
                 toProto(message: _199.MsgUpdateGroupMembers): Uint8Array;
                 toProtoMsg(message: _199.MsgUpdateGroupMembers): _199.MsgUpdateGroupMembersProtoMsg;
@@ -4011,12 +4105,14 @@ export declare namespace sparkdream {
             };
             MsgForceUpgrade: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _199.MsgForceUpgrade, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _199.MsgForceUpgrade;
                 fromPartial(object: import("../helpers").DeepPartial<_199.MsgForceUpgrade>): _199.MsgForceUpgrade;
                 fromAmino(object: _199.MsgForceUpgradeAmino): _199.MsgForceUpgrade;
                 toAmino(message: _199.MsgForceUpgrade): _199.MsgForceUpgradeAmino;
                 fromAminoMsg(object: _199.MsgForceUpgradeAminoMsg): _199.MsgForceUpgrade;
+                toAminoMsg(message: _199.MsgForceUpgrade): _199.MsgForceUpgradeAminoMsg;
                 fromProtoMsg(message: _199.MsgForceUpgradeProtoMsg): _199.MsgForceUpgrade;
                 toProto(message: _199.MsgForceUpgrade): Uint8Array;
                 toProtoMsg(message: _199.MsgForceUpgrade): _199.MsgForceUpgradeProtoMsg;
@@ -4059,12 +4155,14 @@ export declare namespace sparkdream {
             };
             MsgDeleteGroup: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _199.MsgDeleteGroup, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _199.MsgDeleteGroup;
                 fromPartial(object: import("../helpers").DeepPartial<_199.MsgDeleteGroup>): _199.MsgDeleteGroup;
                 fromAmino(object: _199.MsgDeleteGroupAmino): _199.MsgDeleteGroup;
                 toAmino(message: _199.MsgDeleteGroup): _199.MsgDeleteGroupAmino;
                 fromAminoMsg(object: _199.MsgDeleteGroupAminoMsg): _199.MsgDeleteGroup;
+                toAminoMsg(message: _199.MsgDeleteGroup): _199.MsgDeleteGroupAminoMsg;
                 fromProtoMsg(message: _199.MsgDeleteGroupProtoMsg): _199.MsgDeleteGroup;
                 toProto(message: _199.MsgDeleteGroup): Uint8Array;
                 toProtoMsg(message: _199.MsgDeleteGroup): _199.MsgDeleteGroupProtoMsg;
@@ -4083,12 +4181,14 @@ export declare namespace sparkdream {
             };
             MsgVetoGroupProposals: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _199.MsgVetoGroupProposals, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _199.MsgVetoGroupProposals;
                 fromPartial(object: import("../helpers").DeepPartial<_199.MsgVetoGroupProposals>): _199.MsgVetoGroupProposals;
                 fromAmino(object: _199.MsgVetoGroupProposalsAmino): _199.MsgVetoGroupProposals;
                 toAmino(message: _199.MsgVetoGroupProposals): _199.MsgVetoGroupProposalsAmino;
                 fromAminoMsg(object: _199.MsgVetoGroupProposalsAminoMsg): _199.MsgVetoGroupProposals;
+                toAminoMsg(message: _199.MsgVetoGroupProposals): _199.MsgVetoGroupProposalsAminoMsg;
                 fromProtoMsg(message: _199.MsgVetoGroupProposalsProtoMsg): _199.MsgVetoGroupProposals;
                 toProto(message: _199.MsgVetoGroupProposals): Uint8Array;
                 toProtoMsg(message: _199.MsgVetoGroupProposals): _199.MsgVetoGroupProposalsProtoMsg;
@@ -4107,12 +4207,14 @@ export declare namespace sparkdream {
             };
             MsgSubmitProposal: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _199.MsgSubmitProposal, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _199.MsgSubmitProposal;
                 fromPartial(object: import("../helpers").DeepPartial<_199.MsgSubmitProposal>): _199.MsgSubmitProposal;
                 fromAmino(object: _199.MsgSubmitProposalAmino): _199.MsgSubmitProposal;
                 toAmino(message: _199.MsgSubmitProposal): _199.MsgSubmitProposalAmino;
                 fromAminoMsg(object: _199.MsgSubmitProposalAminoMsg): _199.MsgSubmitProposal;
+                toAminoMsg(message: _199.MsgSubmitProposal): _199.MsgSubmitProposalAminoMsg;
                 fromProtoMsg(message: _199.MsgSubmitProposalProtoMsg): _199.MsgSubmitProposal;
                 toProto(message: _199.MsgSubmitProposal): Uint8Array;
                 toProtoMsg(message: _199.MsgSubmitProposal): _199.MsgSubmitProposalProtoMsg;
@@ -4131,12 +4233,14 @@ export declare namespace sparkdream {
             };
             MsgVoteProposal: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _199.MsgVoteProposal, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _199.MsgVoteProposal;
                 fromPartial(object: import("../helpers").DeepPartial<_199.MsgVoteProposal>): _199.MsgVoteProposal;
                 fromAmino(object: _199.MsgVoteProposalAmino): _199.MsgVoteProposal;
                 toAmino(message: _199.MsgVoteProposal): _199.MsgVoteProposalAmino;
                 fromAminoMsg(object: _199.MsgVoteProposalAminoMsg): _199.MsgVoteProposal;
+                toAminoMsg(message: _199.MsgVoteProposal): _199.MsgVoteProposalAminoMsg;
                 fromProtoMsg(message: _199.MsgVoteProposalProtoMsg): _199.MsgVoteProposal;
                 toProto(message: _199.MsgVoteProposal): Uint8Array;
                 toProtoMsg(message: _199.MsgVoteProposal): _199.MsgVoteProposalProtoMsg;
@@ -4155,12 +4259,14 @@ export declare namespace sparkdream {
             };
             MsgExecuteProposal: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _199.MsgExecuteProposal, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _199.MsgExecuteProposal;
                 fromPartial(object: import("../helpers").DeepPartial<_199.MsgExecuteProposal>): _199.MsgExecuteProposal;
                 fromAmino(object: _199.MsgExecuteProposalAmino): _199.MsgExecuteProposal;
                 toAmino(message: _199.MsgExecuteProposal): _199.MsgExecuteProposalAmino;
                 fromAminoMsg(object: _199.MsgExecuteProposalAminoMsg): _199.MsgExecuteProposal;
+                toAminoMsg(message: _199.MsgExecuteProposal): _199.MsgExecuteProposalAminoMsg;
                 fromProtoMsg(message: _199.MsgExecuteProposalProtoMsg): _199.MsgExecuteProposal;
                 toProto(message: _199.MsgExecuteProposal): Uint8Array;
                 toProtoMsg(message: _199.MsgExecuteProposal): _199.MsgExecuteProposalProtoMsg;
@@ -4327,6 +4433,66 @@ export declare namespace sparkdream {
                 toProto(message: _198.QueryAllPolicyPermissionsResponse): Uint8Array;
                 toProtoMsg(message: _198.QueryAllPolicyPermissionsResponse): _198.QueryAllPolicyPermissionsResponseProtoMsg;
             };
+            QueryGetDecisionPolicyRequest: {
+                typeUrl: string;
+                encode(message: _198.QueryGetDecisionPolicyRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _198.QueryGetDecisionPolicyRequest;
+                fromPartial(object: import("../helpers").DeepPartial<_198.QueryGetDecisionPolicyRequest>): _198.QueryGetDecisionPolicyRequest;
+                fromAmino(object: _198.QueryGetDecisionPolicyRequestAmino): _198.QueryGetDecisionPolicyRequest;
+                toAmino(message: _198.QueryGetDecisionPolicyRequest): _198.QueryGetDecisionPolicyRequestAmino;
+                fromAminoMsg(object: _198.QueryGetDecisionPolicyRequestAminoMsg): _198.QueryGetDecisionPolicyRequest;
+                fromProtoMsg(message: _198.QueryGetDecisionPolicyRequestProtoMsg): _198.QueryGetDecisionPolicyRequest;
+                toProto(message: _198.QueryGetDecisionPolicyRequest): Uint8Array;
+                toProtoMsg(message: _198.QueryGetDecisionPolicyRequest): _198.QueryGetDecisionPolicyRequestProtoMsg;
+            };
+            QueryGetDecisionPolicyResponse: {
+                typeUrl: string;
+                encode(message: _198.QueryGetDecisionPolicyResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _198.QueryGetDecisionPolicyResponse;
+                fromPartial(object: import("../helpers").DeepPartial<_198.QueryGetDecisionPolicyResponse>): _198.QueryGetDecisionPolicyResponse;
+                fromAmino(object: _198.QueryGetDecisionPolicyResponseAmino): _198.QueryGetDecisionPolicyResponse;
+                toAmino(message: _198.QueryGetDecisionPolicyResponse): _198.QueryGetDecisionPolicyResponseAmino;
+                fromAminoMsg(object: _198.QueryGetDecisionPolicyResponseAminoMsg): _198.QueryGetDecisionPolicyResponse;
+                fromProtoMsg(message: _198.QueryGetDecisionPolicyResponseProtoMsg): _198.QueryGetDecisionPolicyResponse;
+                toProto(message: _198.QueryGetDecisionPolicyResponse): Uint8Array;
+                toProtoMsg(message: _198.QueryGetDecisionPolicyResponse): _198.QueryGetDecisionPolicyResponseProtoMsg;
+            };
+            DecisionPolicyEntry: {
+                typeUrl: string;
+                encode(message: _198.DecisionPolicyEntry, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _198.DecisionPolicyEntry;
+                fromPartial(object: import("../helpers").DeepPartial<_198.DecisionPolicyEntry>): _198.DecisionPolicyEntry;
+                fromAmino(object: _198.DecisionPolicyEntryAmino): _198.DecisionPolicyEntry;
+                toAmino(message: _198.DecisionPolicyEntry): _198.DecisionPolicyEntryAmino;
+                fromAminoMsg(object: _198.DecisionPolicyEntryAminoMsg): _198.DecisionPolicyEntry;
+                fromProtoMsg(message: _198.DecisionPolicyEntryProtoMsg): _198.DecisionPolicyEntry;
+                toProto(message: _198.DecisionPolicyEntry): Uint8Array;
+                toProtoMsg(message: _198.DecisionPolicyEntry): _198.DecisionPolicyEntryProtoMsg;
+            };
+            QueryAllDecisionPoliciesRequest: {
+                typeUrl: string;
+                encode(message: _198.QueryAllDecisionPoliciesRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _198.QueryAllDecisionPoliciesRequest;
+                fromPartial(object: import("../helpers").DeepPartial<_198.QueryAllDecisionPoliciesRequest>): _198.QueryAllDecisionPoliciesRequest;
+                fromAmino(object: _198.QueryAllDecisionPoliciesRequestAmino): _198.QueryAllDecisionPoliciesRequest;
+                toAmino(message: _198.QueryAllDecisionPoliciesRequest): _198.QueryAllDecisionPoliciesRequestAmino;
+                fromAminoMsg(object: _198.QueryAllDecisionPoliciesRequestAminoMsg): _198.QueryAllDecisionPoliciesRequest;
+                fromProtoMsg(message: _198.QueryAllDecisionPoliciesRequestProtoMsg): _198.QueryAllDecisionPoliciesRequest;
+                toProto(message: _198.QueryAllDecisionPoliciesRequest): Uint8Array;
+                toProtoMsg(message: _198.QueryAllDecisionPoliciesRequest): _198.QueryAllDecisionPoliciesRequestProtoMsg;
+            };
+            QueryAllDecisionPoliciesResponse: {
+                typeUrl: string;
+                encode(message: _198.QueryAllDecisionPoliciesResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _198.QueryAllDecisionPoliciesResponse;
+                fromPartial(object: import("../helpers").DeepPartial<_198.QueryAllDecisionPoliciesResponse>): _198.QueryAllDecisionPoliciesResponse;
+                fromAmino(object: _198.QueryAllDecisionPoliciesResponseAmino): _198.QueryAllDecisionPoliciesResponse;
+                toAmino(message: _198.QueryAllDecisionPoliciesResponse): _198.QueryAllDecisionPoliciesResponseAmino;
+                fromAminoMsg(object: _198.QueryAllDecisionPoliciesResponseAminoMsg): _198.QueryAllDecisionPoliciesResponse;
+                fromProtoMsg(message: _198.QueryAllDecisionPoliciesResponseProtoMsg): _198.QueryAllDecisionPoliciesResponse;
+                toProto(message: _198.QueryAllDecisionPoliciesResponse): Uint8Array;
+                toProtoMsg(message: _198.QueryAllDecisionPoliciesResponse): _198.QueryAllDecisionPoliciesResponseProtoMsg;
+            };
             QueryGetGroupRequest: {
                 typeUrl: string;
                 encode(message: _198.QueryGetGroupRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
@@ -5572,12 +5738,14 @@ export declare namespace sparkdream {
             };
             MsgRegisterPeer: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _210.MsgRegisterPeer, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _210.MsgRegisterPeer;
                 fromPartial(object: import("../helpers").DeepPartial<_210.MsgRegisterPeer>): _210.MsgRegisterPeer;
                 fromAmino(object: _210.MsgRegisterPeerAmino): _210.MsgRegisterPeer;
                 toAmino(message: _210.MsgRegisterPeer): _210.MsgRegisterPeerAmino;
                 fromAminoMsg(object: _210.MsgRegisterPeerAminoMsg): _210.MsgRegisterPeer;
+                toAminoMsg(message: _210.MsgRegisterPeer): _210.MsgRegisterPeerAminoMsg;
                 fromProtoMsg(message: _210.MsgRegisterPeerProtoMsg): _210.MsgRegisterPeer;
                 toProto(message: _210.MsgRegisterPeer): Uint8Array;
                 toProtoMsg(message: _210.MsgRegisterPeer): _210.MsgRegisterPeerProtoMsg;
@@ -5596,12 +5764,14 @@ export declare namespace sparkdream {
             };
             MsgRemovePeer: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _210.MsgRemovePeer, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _210.MsgRemovePeer;
                 fromPartial(object: import("../helpers").DeepPartial<_210.MsgRemovePeer>): _210.MsgRemovePeer;
                 fromAmino(object: _210.MsgRemovePeerAmino): _210.MsgRemovePeer;
                 toAmino(message: _210.MsgRemovePeer): _210.MsgRemovePeerAmino;
                 fromAminoMsg(object: _210.MsgRemovePeerAminoMsg): _210.MsgRemovePeer;
+                toAminoMsg(message: _210.MsgRemovePeer): _210.MsgRemovePeerAminoMsg;
                 fromProtoMsg(message: _210.MsgRemovePeerProtoMsg): _210.MsgRemovePeer;
                 toProto(message: _210.MsgRemovePeer): Uint8Array;
                 toProtoMsg(message: _210.MsgRemovePeer): _210.MsgRemovePeerProtoMsg;
@@ -5620,12 +5790,14 @@ export declare namespace sparkdream {
             };
             MsgSuspendPeer: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _210.MsgSuspendPeer, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _210.MsgSuspendPeer;
                 fromPartial(object: import("../helpers").DeepPartial<_210.MsgSuspendPeer>): _210.MsgSuspendPeer;
                 fromAmino(object: _210.MsgSuspendPeerAmino): _210.MsgSuspendPeer;
                 toAmino(message: _210.MsgSuspendPeer): _210.MsgSuspendPeerAmino;
                 fromAminoMsg(object: _210.MsgSuspendPeerAminoMsg): _210.MsgSuspendPeer;
+                toAminoMsg(message: _210.MsgSuspendPeer): _210.MsgSuspendPeerAminoMsg;
                 fromProtoMsg(message: _210.MsgSuspendPeerProtoMsg): _210.MsgSuspendPeer;
                 toProto(message: _210.MsgSuspendPeer): Uint8Array;
                 toProtoMsg(message: _210.MsgSuspendPeer): _210.MsgSuspendPeerProtoMsg;
@@ -5644,12 +5816,14 @@ export declare namespace sparkdream {
             };
             MsgResumePeer: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _210.MsgResumePeer, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _210.MsgResumePeer;
                 fromPartial(object: import("../helpers").DeepPartial<_210.MsgResumePeer>): _210.MsgResumePeer;
                 fromAmino(object: _210.MsgResumePeerAmino): _210.MsgResumePeer;
                 toAmino(message: _210.MsgResumePeer): _210.MsgResumePeerAmino;
                 fromAminoMsg(object: _210.MsgResumePeerAminoMsg): _210.MsgResumePeer;
+                toAminoMsg(message: _210.MsgResumePeer): _210.MsgResumePeerAminoMsg;
                 fromProtoMsg(message: _210.MsgResumePeerProtoMsg): _210.MsgResumePeer;
                 toProto(message: _210.MsgResumePeer): Uint8Array;
                 toProtoMsg(message: _210.MsgResumePeer): _210.MsgResumePeerProtoMsg;
@@ -5668,12 +5842,14 @@ export declare namespace sparkdream {
             };
             MsgUpdatePeerPolicy: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _210.MsgUpdatePeerPolicy, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _210.MsgUpdatePeerPolicy;
                 fromPartial(object: import("../helpers").DeepPartial<_210.MsgUpdatePeerPolicy>): _210.MsgUpdatePeerPolicy;
                 fromAmino(object: _210.MsgUpdatePeerPolicyAmino): _210.MsgUpdatePeerPolicy;
                 toAmino(message: _210.MsgUpdatePeerPolicy): _210.MsgUpdatePeerPolicyAmino;
                 fromAminoMsg(object: _210.MsgUpdatePeerPolicyAminoMsg): _210.MsgUpdatePeerPolicy;
+                toAminoMsg(message: _210.MsgUpdatePeerPolicy): _210.MsgUpdatePeerPolicyAminoMsg;
                 fromProtoMsg(message: _210.MsgUpdatePeerPolicyProtoMsg): _210.MsgUpdatePeerPolicy;
                 toProto(message: _210.MsgUpdatePeerPolicy): Uint8Array;
                 toProtoMsg(message: _210.MsgUpdatePeerPolicy): _210.MsgUpdatePeerPolicyProtoMsg;
@@ -5692,12 +5868,14 @@ export declare namespace sparkdream {
             };
             MsgRegisterBridge: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _210.MsgRegisterBridge, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _210.MsgRegisterBridge;
                 fromPartial(object: import("../helpers").DeepPartial<_210.MsgRegisterBridge>): _210.MsgRegisterBridge;
                 fromAmino(object: _210.MsgRegisterBridgeAmino): _210.MsgRegisterBridge;
                 toAmino(message: _210.MsgRegisterBridge): _210.MsgRegisterBridgeAmino;
                 fromAminoMsg(object: _210.MsgRegisterBridgeAminoMsg): _210.MsgRegisterBridge;
+                toAminoMsg(message: _210.MsgRegisterBridge): _210.MsgRegisterBridgeAminoMsg;
                 fromProtoMsg(message: _210.MsgRegisterBridgeProtoMsg): _210.MsgRegisterBridge;
                 toProto(message: _210.MsgRegisterBridge): Uint8Array;
                 toProtoMsg(message: _210.MsgRegisterBridge): _210.MsgRegisterBridgeProtoMsg;
@@ -5716,12 +5894,14 @@ export declare namespace sparkdream {
             };
             MsgRevokeBridge: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _210.MsgRevokeBridge, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _210.MsgRevokeBridge;
                 fromPartial(object: import("../helpers").DeepPartial<_210.MsgRevokeBridge>): _210.MsgRevokeBridge;
                 fromAmino(object: _210.MsgRevokeBridgeAmino): _210.MsgRevokeBridge;
                 toAmino(message: _210.MsgRevokeBridge): _210.MsgRevokeBridgeAmino;
                 fromAminoMsg(object: _210.MsgRevokeBridgeAminoMsg): _210.MsgRevokeBridge;
+                toAminoMsg(message: _210.MsgRevokeBridge): _210.MsgRevokeBridgeAminoMsg;
                 fromProtoMsg(message: _210.MsgRevokeBridgeProtoMsg): _210.MsgRevokeBridge;
                 toProto(message: _210.MsgRevokeBridge): Uint8Array;
                 toProtoMsg(message: _210.MsgRevokeBridge): _210.MsgRevokeBridgeProtoMsg;
@@ -5740,12 +5920,14 @@ export declare namespace sparkdream {
             };
             MsgSlashBridge: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _210.MsgSlashBridge, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _210.MsgSlashBridge;
                 fromPartial(object: import("../helpers").DeepPartial<_210.MsgSlashBridge>): _210.MsgSlashBridge;
                 fromAmino(object: _210.MsgSlashBridgeAmino): _210.MsgSlashBridge;
                 toAmino(message: _210.MsgSlashBridge): _210.MsgSlashBridgeAmino;
                 fromAminoMsg(object: _210.MsgSlashBridgeAminoMsg): _210.MsgSlashBridge;
+                toAminoMsg(message: _210.MsgSlashBridge): _210.MsgSlashBridgeAminoMsg;
                 fromProtoMsg(message: _210.MsgSlashBridgeProtoMsg): _210.MsgSlashBridge;
                 toProto(message: _210.MsgSlashBridge): Uint8Array;
                 toProtoMsg(message: _210.MsgSlashBridge): _210.MsgSlashBridgeProtoMsg;
@@ -5764,12 +5946,14 @@ export declare namespace sparkdream {
             };
             MsgUpdateBridge: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _210.MsgUpdateBridge, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _210.MsgUpdateBridge;
                 fromPartial(object: import("../helpers").DeepPartial<_210.MsgUpdateBridge>): _210.MsgUpdateBridge;
                 fromAmino(object: _210.MsgUpdateBridgeAmino): _210.MsgUpdateBridge;
                 toAmino(message: _210.MsgUpdateBridge): _210.MsgUpdateBridgeAmino;
                 fromAminoMsg(object: _210.MsgUpdateBridgeAminoMsg): _210.MsgUpdateBridge;
+                toAminoMsg(message: _210.MsgUpdateBridge): _210.MsgUpdateBridgeAminoMsg;
                 fromProtoMsg(message: _210.MsgUpdateBridgeProtoMsg): _210.MsgUpdateBridge;
                 toProto(message: _210.MsgUpdateBridge): Uint8Array;
                 toProtoMsg(message: _210.MsgUpdateBridge): _210.MsgUpdateBridgeProtoMsg;
@@ -5788,12 +5972,14 @@ export declare namespace sparkdream {
             };
             MsgUnbondBridge: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _210.MsgUnbondBridge, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _210.MsgUnbondBridge;
                 fromPartial(object: import("../helpers").DeepPartial<_210.MsgUnbondBridge>): _210.MsgUnbondBridge;
                 fromAmino(object: _210.MsgUnbondBridgeAmino): _210.MsgUnbondBridge;
                 toAmino(message: _210.MsgUnbondBridge): _210.MsgUnbondBridgeAmino;
                 fromAminoMsg(object: _210.MsgUnbondBridgeAminoMsg): _210.MsgUnbondBridge;
+                toAminoMsg(message: _210.MsgUnbondBridge): _210.MsgUnbondBridgeAminoMsg;
                 fromProtoMsg(message: _210.MsgUnbondBridgeProtoMsg): _210.MsgUnbondBridge;
                 toProto(message: _210.MsgUnbondBridge): Uint8Array;
                 toProtoMsg(message: _210.MsgUnbondBridge): _210.MsgUnbondBridgeProtoMsg;
@@ -5812,12 +5998,14 @@ export declare namespace sparkdream {
             };
             MsgTopUpBridgeStake: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _210.MsgTopUpBridgeStake, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _210.MsgTopUpBridgeStake;
                 fromPartial(object: import("../helpers").DeepPartial<_210.MsgTopUpBridgeStake>): _210.MsgTopUpBridgeStake;
                 fromAmino(object: _210.MsgTopUpBridgeStakeAmino): _210.MsgTopUpBridgeStake;
                 toAmino(message: _210.MsgTopUpBridgeStake): _210.MsgTopUpBridgeStakeAmino;
                 fromAminoMsg(object: _210.MsgTopUpBridgeStakeAminoMsg): _210.MsgTopUpBridgeStake;
+                toAminoMsg(message: _210.MsgTopUpBridgeStake): _210.MsgTopUpBridgeStakeAminoMsg;
                 fromProtoMsg(message: _210.MsgTopUpBridgeStakeProtoMsg): _210.MsgTopUpBridgeStake;
                 toProto(message: _210.MsgTopUpBridgeStake): Uint8Array;
                 toProtoMsg(message: _210.MsgTopUpBridgeStake): _210.MsgTopUpBridgeStakeProtoMsg;
@@ -5836,12 +6024,14 @@ export declare namespace sparkdream {
             };
             MsgSubmitFederatedContent: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _210.MsgSubmitFederatedContent, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _210.MsgSubmitFederatedContent;
                 fromPartial(object: import("../helpers").DeepPartial<_210.MsgSubmitFederatedContent>): _210.MsgSubmitFederatedContent;
                 fromAmino(object: _210.MsgSubmitFederatedContentAmino): _210.MsgSubmitFederatedContent;
                 toAmino(message: _210.MsgSubmitFederatedContent): _210.MsgSubmitFederatedContentAmino;
                 fromAminoMsg(object: _210.MsgSubmitFederatedContentAminoMsg): _210.MsgSubmitFederatedContent;
+                toAminoMsg(message: _210.MsgSubmitFederatedContent): _210.MsgSubmitFederatedContentAminoMsg;
                 fromProtoMsg(message: _210.MsgSubmitFederatedContentProtoMsg): _210.MsgSubmitFederatedContent;
                 toProto(message: _210.MsgSubmitFederatedContent): Uint8Array;
                 toProtoMsg(message: _210.MsgSubmitFederatedContent): _210.MsgSubmitFederatedContentProtoMsg;
@@ -5860,12 +6050,14 @@ export declare namespace sparkdream {
             };
             MsgFederateContent: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _210.MsgFederateContent, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _210.MsgFederateContent;
                 fromPartial(object: import("../helpers").DeepPartial<_210.MsgFederateContent>): _210.MsgFederateContent;
                 fromAmino(object: _210.MsgFederateContentAmino): _210.MsgFederateContent;
                 toAmino(message: _210.MsgFederateContent): _210.MsgFederateContentAmino;
                 fromAminoMsg(object: _210.MsgFederateContentAminoMsg): _210.MsgFederateContent;
+                toAminoMsg(message: _210.MsgFederateContent): _210.MsgFederateContentAminoMsg;
                 fromProtoMsg(message: _210.MsgFederateContentProtoMsg): _210.MsgFederateContent;
                 toProto(message: _210.MsgFederateContent): Uint8Array;
                 toProtoMsg(message: _210.MsgFederateContent): _210.MsgFederateContentProtoMsg;
@@ -5884,12 +6076,14 @@ export declare namespace sparkdream {
             };
             MsgAttestOutbound: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _210.MsgAttestOutbound, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _210.MsgAttestOutbound;
                 fromPartial(object: import("../helpers").DeepPartial<_210.MsgAttestOutbound>): _210.MsgAttestOutbound;
                 fromAmino(object: _210.MsgAttestOutboundAmino): _210.MsgAttestOutbound;
                 toAmino(message: _210.MsgAttestOutbound): _210.MsgAttestOutboundAmino;
                 fromAminoMsg(object: _210.MsgAttestOutboundAminoMsg): _210.MsgAttestOutbound;
+                toAminoMsg(message: _210.MsgAttestOutbound): _210.MsgAttestOutboundAminoMsg;
                 fromProtoMsg(message: _210.MsgAttestOutboundProtoMsg): _210.MsgAttestOutbound;
                 toProto(message: _210.MsgAttestOutbound): Uint8Array;
                 toProtoMsg(message: _210.MsgAttestOutbound): _210.MsgAttestOutboundProtoMsg;
@@ -5908,12 +6102,14 @@ export declare namespace sparkdream {
             };
             MsgModerateContent: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _210.MsgModerateContent, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _210.MsgModerateContent;
                 fromPartial(object: import("../helpers").DeepPartial<_210.MsgModerateContent>): _210.MsgModerateContent;
                 fromAmino(object: _210.MsgModerateContentAmino): _210.MsgModerateContent;
                 toAmino(message: _210.MsgModerateContent): _210.MsgModerateContentAmino;
                 fromAminoMsg(object: _210.MsgModerateContentAminoMsg): _210.MsgModerateContent;
+                toAminoMsg(message: _210.MsgModerateContent): _210.MsgModerateContentAminoMsg;
                 fromProtoMsg(message: _210.MsgModerateContentProtoMsg): _210.MsgModerateContent;
                 toProto(message: _210.MsgModerateContent): Uint8Array;
                 toProtoMsg(message: _210.MsgModerateContent): _210.MsgModerateContentProtoMsg;
@@ -5932,12 +6128,14 @@ export declare namespace sparkdream {
             };
             MsgLinkIdentity: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _210.MsgLinkIdentity, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _210.MsgLinkIdentity;
                 fromPartial(object: import("../helpers").DeepPartial<_210.MsgLinkIdentity>): _210.MsgLinkIdentity;
                 fromAmino(object: _210.MsgLinkIdentityAmino): _210.MsgLinkIdentity;
                 toAmino(message: _210.MsgLinkIdentity): _210.MsgLinkIdentityAmino;
                 fromAminoMsg(object: _210.MsgLinkIdentityAminoMsg): _210.MsgLinkIdentity;
+                toAminoMsg(message: _210.MsgLinkIdentity): _210.MsgLinkIdentityAminoMsg;
                 fromProtoMsg(message: _210.MsgLinkIdentityProtoMsg): _210.MsgLinkIdentity;
                 toProto(message: _210.MsgLinkIdentity): Uint8Array;
                 toProtoMsg(message: _210.MsgLinkIdentity): _210.MsgLinkIdentityProtoMsg;
@@ -5956,12 +6154,14 @@ export declare namespace sparkdream {
             };
             MsgUnlinkIdentity: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _210.MsgUnlinkIdentity, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _210.MsgUnlinkIdentity;
                 fromPartial(object: import("../helpers").DeepPartial<_210.MsgUnlinkIdentity>): _210.MsgUnlinkIdentity;
                 fromAmino(object: _210.MsgUnlinkIdentityAmino): _210.MsgUnlinkIdentity;
                 toAmino(message: _210.MsgUnlinkIdentity): _210.MsgUnlinkIdentityAmino;
                 fromAminoMsg(object: _210.MsgUnlinkIdentityAminoMsg): _210.MsgUnlinkIdentity;
+                toAminoMsg(message: _210.MsgUnlinkIdentity): _210.MsgUnlinkIdentityAminoMsg;
                 fromProtoMsg(message: _210.MsgUnlinkIdentityProtoMsg): _210.MsgUnlinkIdentity;
                 toProto(message: _210.MsgUnlinkIdentity): Uint8Array;
                 toProtoMsg(message: _210.MsgUnlinkIdentity): _210.MsgUnlinkIdentityProtoMsg;
@@ -5980,12 +6180,14 @@ export declare namespace sparkdream {
             };
             MsgConfirmIdentityLink: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _210.MsgConfirmIdentityLink, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _210.MsgConfirmIdentityLink;
                 fromPartial(object: import("../helpers").DeepPartial<_210.MsgConfirmIdentityLink>): _210.MsgConfirmIdentityLink;
                 fromAmino(object: _210.MsgConfirmIdentityLinkAmino): _210.MsgConfirmIdentityLink;
                 toAmino(message: _210.MsgConfirmIdentityLink): _210.MsgConfirmIdentityLinkAmino;
                 fromAminoMsg(object: _210.MsgConfirmIdentityLinkAminoMsg): _210.MsgConfirmIdentityLink;
+                toAminoMsg(message: _210.MsgConfirmIdentityLink): _210.MsgConfirmIdentityLinkAminoMsg;
                 fromProtoMsg(message: _210.MsgConfirmIdentityLinkProtoMsg): _210.MsgConfirmIdentityLink;
                 toProto(message: _210.MsgConfirmIdentityLink): Uint8Array;
                 toProtoMsg(message: _210.MsgConfirmIdentityLink): _210.MsgConfirmIdentityLinkProtoMsg;
@@ -6004,12 +6206,14 @@ export declare namespace sparkdream {
             };
             MsgRequestReputationAttestation: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _210.MsgRequestReputationAttestation, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _210.MsgRequestReputationAttestation;
                 fromPartial(object: import("../helpers").DeepPartial<_210.MsgRequestReputationAttestation>): _210.MsgRequestReputationAttestation;
                 fromAmino(object: _210.MsgRequestReputationAttestationAmino): _210.MsgRequestReputationAttestation;
                 toAmino(message: _210.MsgRequestReputationAttestation): _210.MsgRequestReputationAttestationAmino;
                 fromAminoMsg(object: _210.MsgRequestReputationAttestationAminoMsg): _210.MsgRequestReputationAttestation;
+                toAminoMsg(message: _210.MsgRequestReputationAttestation): _210.MsgRequestReputationAttestationAminoMsg;
                 fromProtoMsg(message: _210.MsgRequestReputationAttestationProtoMsg): _210.MsgRequestReputationAttestation;
                 toProto(message: _210.MsgRequestReputationAttestation): Uint8Array;
                 toProtoMsg(message: _210.MsgRequestReputationAttestation): _210.MsgRequestReputationAttestationProtoMsg;
@@ -6028,12 +6232,14 @@ export declare namespace sparkdream {
             };
             MsgVerifyContent: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _210.MsgVerifyContent, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _210.MsgVerifyContent;
                 fromPartial(object: import("../helpers").DeepPartial<_210.MsgVerifyContent>): _210.MsgVerifyContent;
                 fromAmino(object: _210.MsgVerifyContentAmino): _210.MsgVerifyContent;
                 toAmino(message: _210.MsgVerifyContent): _210.MsgVerifyContentAmino;
                 fromAminoMsg(object: _210.MsgVerifyContentAminoMsg): _210.MsgVerifyContent;
+                toAminoMsg(message: _210.MsgVerifyContent): _210.MsgVerifyContentAminoMsg;
                 fromProtoMsg(message: _210.MsgVerifyContentProtoMsg): _210.MsgVerifyContent;
                 toProto(message: _210.MsgVerifyContent): Uint8Array;
                 toProtoMsg(message: _210.MsgVerifyContent): _210.MsgVerifyContentProtoMsg;
@@ -6052,12 +6258,14 @@ export declare namespace sparkdream {
             };
             MsgChallengeVerification: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _210.MsgChallengeVerification, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _210.MsgChallengeVerification;
                 fromPartial(object: import("../helpers").DeepPartial<_210.MsgChallengeVerification>): _210.MsgChallengeVerification;
                 fromAmino(object: _210.MsgChallengeVerificationAmino): _210.MsgChallengeVerification;
                 toAmino(message: _210.MsgChallengeVerification): _210.MsgChallengeVerificationAmino;
                 fromAminoMsg(object: _210.MsgChallengeVerificationAminoMsg): _210.MsgChallengeVerification;
+                toAminoMsg(message: _210.MsgChallengeVerification): _210.MsgChallengeVerificationAminoMsg;
                 fromProtoMsg(message: _210.MsgChallengeVerificationProtoMsg): _210.MsgChallengeVerification;
                 toProto(message: _210.MsgChallengeVerification): Uint8Array;
                 toProtoMsg(message: _210.MsgChallengeVerification): _210.MsgChallengeVerificationProtoMsg;
@@ -6076,12 +6284,14 @@ export declare namespace sparkdream {
             };
             MsgSubmitArbiterHash: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _210.MsgSubmitArbiterHash, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _210.MsgSubmitArbiterHash;
                 fromPartial(object: import("../helpers").DeepPartial<_210.MsgSubmitArbiterHash>): _210.MsgSubmitArbiterHash;
                 fromAmino(object: _210.MsgSubmitArbiterHashAmino): _210.MsgSubmitArbiterHash;
                 toAmino(message: _210.MsgSubmitArbiterHash): _210.MsgSubmitArbiterHashAmino;
                 fromAminoMsg(object: _210.MsgSubmitArbiterHashAminoMsg): _210.MsgSubmitArbiterHash;
+                toAminoMsg(message: _210.MsgSubmitArbiterHash): _210.MsgSubmitArbiterHashAminoMsg;
                 fromProtoMsg(message: _210.MsgSubmitArbiterHashProtoMsg): _210.MsgSubmitArbiterHash;
                 toProto(message: _210.MsgSubmitArbiterHash): Uint8Array;
                 toProtoMsg(message: _210.MsgSubmitArbiterHash): _210.MsgSubmitArbiterHashProtoMsg;
@@ -6100,12 +6310,14 @@ export declare namespace sparkdream {
             };
             MsgEscalateChallenge: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _210.MsgEscalateChallenge, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _210.MsgEscalateChallenge;
                 fromPartial(object: import("../helpers").DeepPartial<_210.MsgEscalateChallenge>): _210.MsgEscalateChallenge;
                 fromAmino(object: _210.MsgEscalateChallengeAmino): _210.MsgEscalateChallenge;
                 toAmino(message: _210.MsgEscalateChallenge): _210.MsgEscalateChallengeAmino;
                 fromAminoMsg(object: _210.MsgEscalateChallengeAminoMsg): _210.MsgEscalateChallenge;
+                toAminoMsg(message: _210.MsgEscalateChallenge): _210.MsgEscalateChallengeAminoMsg;
                 fromProtoMsg(message: _210.MsgEscalateChallengeProtoMsg): _210.MsgEscalateChallenge;
                 toProto(message: _210.MsgEscalateChallenge): Uint8Array;
                 toProtoMsg(message: _210.MsgEscalateChallenge): _210.MsgEscalateChallengeProtoMsg;
@@ -6124,12 +6336,14 @@ export declare namespace sparkdream {
             };
             MsgUpdateOperationalParams: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _210.MsgUpdateOperationalParams, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _210.MsgUpdateOperationalParams;
                 fromPartial(object: import("../helpers").DeepPartial<_210.MsgUpdateOperationalParams>): _210.MsgUpdateOperationalParams;
                 fromAmino(object: _210.MsgUpdateOperationalParamsAmino): _210.MsgUpdateOperationalParams;
                 toAmino(message: _210.MsgUpdateOperationalParams): _210.MsgUpdateOperationalParamsAmino;
                 fromAminoMsg(object: _210.MsgUpdateOperationalParamsAminoMsg): _210.MsgUpdateOperationalParams;
+                toAminoMsg(message: _210.MsgUpdateOperationalParams): _210.MsgUpdateOperationalParamsAminoMsg;
                 fromProtoMsg(message: _210.MsgUpdateOperationalParamsProtoMsg): _210.MsgUpdateOperationalParams;
                 toProto(message: _210.MsgUpdateOperationalParams): Uint8Array;
                 toProtoMsg(message: _210.MsgUpdateOperationalParams): _210.MsgUpdateOperationalParamsProtoMsg;
@@ -7485,12 +7699,14 @@ export declare namespace sparkdream {
             };
             MsgCreatePost: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _228.MsgCreatePost, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _228.MsgCreatePost;
                 fromPartial(object: import("../helpers").DeepPartial<_228.MsgCreatePost>): _228.MsgCreatePost;
                 fromAmino(object: _228.MsgCreatePostAmino): _228.MsgCreatePost;
                 toAmino(message: _228.MsgCreatePost): _228.MsgCreatePostAmino;
                 fromAminoMsg(object: _228.MsgCreatePostAminoMsg): _228.MsgCreatePost;
+                toAminoMsg(message: _228.MsgCreatePost): _228.MsgCreatePostAminoMsg;
                 fromProtoMsg(message: _228.MsgCreatePostProtoMsg): _228.MsgCreatePost;
                 toProto(message: _228.MsgCreatePost): Uint8Array;
                 toProtoMsg(message: _228.MsgCreatePost): _228.MsgCreatePostProtoMsg;
@@ -7509,12 +7725,14 @@ export declare namespace sparkdream {
             };
             MsgEditPost: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _228.MsgEditPost, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _228.MsgEditPost;
                 fromPartial(object: import("../helpers").DeepPartial<_228.MsgEditPost>): _228.MsgEditPost;
                 fromAmino(object: _228.MsgEditPostAmino): _228.MsgEditPost;
                 toAmino(message: _228.MsgEditPost): _228.MsgEditPostAmino;
                 fromAminoMsg(object: _228.MsgEditPostAminoMsg): _228.MsgEditPost;
+                toAminoMsg(message: _228.MsgEditPost): _228.MsgEditPostAminoMsg;
                 fromProtoMsg(message: _228.MsgEditPostProtoMsg): _228.MsgEditPost;
                 toProto(message: _228.MsgEditPost): Uint8Array;
                 toProtoMsg(message: _228.MsgEditPost): _228.MsgEditPostProtoMsg;
@@ -7533,12 +7751,14 @@ export declare namespace sparkdream {
             };
             MsgDeletePost: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _228.MsgDeletePost, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _228.MsgDeletePost;
                 fromPartial(object: import("../helpers").DeepPartial<_228.MsgDeletePost>): _228.MsgDeletePost;
                 fromAmino(object: _228.MsgDeletePostAmino): _228.MsgDeletePost;
                 toAmino(message: _228.MsgDeletePost): _228.MsgDeletePostAmino;
                 fromAminoMsg(object: _228.MsgDeletePostAminoMsg): _228.MsgDeletePost;
+                toAminoMsg(message: _228.MsgDeletePost): _228.MsgDeletePostAminoMsg;
                 fromProtoMsg(message: _228.MsgDeletePostProtoMsg): _228.MsgDeletePost;
                 toProto(message: _228.MsgDeletePost): Uint8Array;
                 toProtoMsg(message: _228.MsgDeletePost): _228.MsgDeletePostProtoMsg;
@@ -7557,12 +7777,14 @@ export declare namespace sparkdream {
             };
             MsgFreezeThread: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _228.MsgFreezeThread, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _228.MsgFreezeThread;
                 fromPartial(object: import("../helpers").DeepPartial<_228.MsgFreezeThread>): _228.MsgFreezeThread;
                 fromAmino(object: _228.MsgFreezeThreadAmino): _228.MsgFreezeThread;
                 toAmino(message: _228.MsgFreezeThread): _228.MsgFreezeThreadAmino;
                 fromAminoMsg(object: _228.MsgFreezeThreadAminoMsg): _228.MsgFreezeThread;
+                toAminoMsg(message: _228.MsgFreezeThread): _228.MsgFreezeThreadAminoMsg;
                 fromProtoMsg(message: _228.MsgFreezeThreadProtoMsg): _228.MsgFreezeThread;
                 toProto(message: _228.MsgFreezeThread): Uint8Array;
                 toProtoMsg(message: _228.MsgFreezeThread): _228.MsgFreezeThreadProtoMsg;
@@ -7581,12 +7803,14 @@ export declare namespace sparkdream {
             };
             MsgUnarchiveThread: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _228.MsgUnarchiveThread, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _228.MsgUnarchiveThread;
                 fromPartial(object: import("../helpers").DeepPartial<_228.MsgUnarchiveThread>): _228.MsgUnarchiveThread;
                 fromAmino(object: _228.MsgUnarchiveThreadAmino): _228.MsgUnarchiveThread;
                 toAmino(message: _228.MsgUnarchiveThread): _228.MsgUnarchiveThreadAmino;
                 fromAminoMsg(object: _228.MsgUnarchiveThreadAminoMsg): _228.MsgUnarchiveThread;
+                toAminoMsg(message: _228.MsgUnarchiveThread): _228.MsgUnarchiveThreadAminoMsg;
                 fromProtoMsg(message: _228.MsgUnarchiveThreadProtoMsg): _228.MsgUnarchiveThread;
                 toProto(message: _228.MsgUnarchiveThread): Uint8Array;
                 toProtoMsg(message: _228.MsgUnarchiveThread): _228.MsgUnarchiveThreadProtoMsg;
@@ -7605,12 +7829,14 @@ export declare namespace sparkdream {
             };
             MsgPinPost: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _228.MsgPinPost, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _228.MsgPinPost;
                 fromPartial(object: import("../helpers").DeepPartial<_228.MsgPinPost>): _228.MsgPinPost;
                 fromAmino(object: _228.MsgPinPostAmino): _228.MsgPinPost;
                 toAmino(message: _228.MsgPinPost): _228.MsgPinPostAmino;
                 fromAminoMsg(object: _228.MsgPinPostAminoMsg): _228.MsgPinPost;
+                toAminoMsg(message: _228.MsgPinPost): _228.MsgPinPostAminoMsg;
                 fromProtoMsg(message: _228.MsgPinPostProtoMsg): _228.MsgPinPost;
                 toProto(message: _228.MsgPinPost): Uint8Array;
                 toProtoMsg(message: _228.MsgPinPost): _228.MsgPinPostProtoMsg;
@@ -7629,12 +7855,14 @@ export declare namespace sparkdream {
             };
             MsgUnpinPost: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _228.MsgUnpinPost, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _228.MsgUnpinPost;
                 fromPartial(object: import("../helpers").DeepPartial<_228.MsgUnpinPost>): _228.MsgUnpinPost;
                 fromAmino(object: _228.MsgUnpinPostAmino): _228.MsgUnpinPost;
                 toAmino(message: _228.MsgUnpinPost): _228.MsgUnpinPostAmino;
                 fromAminoMsg(object: _228.MsgUnpinPostAminoMsg): _228.MsgUnpinPost;
+                toAminoMsg(message: _228.MsgUnpinPost): _228.MsgUnpinPostAminoMsg;
                 fromProtoMsg(message: _228.MsgUnpinPostProtoMsg): _228.MsgUnpinPost;
                 toProto(message: _228.MsgUnpinPost): Uint8Array;
                 toProtoMsg(message: _228.MsgUnpinPost): _228.MsgUnpinPostProtoMsg;
@@ -7653,12 +7881,14 @@ export declare namespace sparkdream {
             };
             MsgLockThread: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _228.MsgLockThread, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _228.MsgLockThread;
                 fromPartial(object: import("../helpers").DeepPartial<_228.MsgLockThread>): _228.MsgLockThread;
                 fromAmino(object: _228.MsgLockThreadAmino): _228.MsgLockThread;
                 toAmino(message: _228.MsgLockThread): _228.MsgLockThreadAmino;
                 fromAminoMsg(object: _228.MsgLockThreadAminoMsg): _228.MsgLockThread;
+                toAminoMsg(message: _228.MsgLockThread): _228.MsgLockThreadAminoMsg;
                 fromProtoMsg(message: _228.MsgLockThreadProtoMsg): _228.MsgLockThread;
                 toProto(message: _228.MsgLockThread): Uint8Array;
                 toProtoMsg(message: _228.MsgLockThread): _228.MsgLockThreadProtoMsg;
@@ -7677,12 +7907,14 @@ export declare namespace sparkdream {
             };
             MsgUnlockThread: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _228.MsgUnlockThread, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _228.MsgUnlockThread;
                 fromPartial(object: import("../helpers").DeepPartial<_228.MsgUnlockThread>): _228.MsgUnlockThread;
                 fromAmino(object: _228.MsgUnlockThreadAmino): _228.MsgUnlockThread;
                 toAmino(message: _228.MsgUnlockThread): _228.MsgUnlockThreadAmino;
                 fromAminoMsg(object: _228.MsgUnlockThreadAminoMsg): _228.MsgUnlockThread;
+                toAminoMsg(message: _228.MsgUnlockThread): _228.MsgUnlockThreadAminoMsg;
                 fromProtoMsg(message: _228.MsgUnlockThreadProtoMsg): _228.MsgUnlockThread;
                 toProto(message: _228.MsgUnlockThread): Uint8Array;
                 toProtoMsg(message: _228.MsgUnlockThread): _228.MsgUnlockThreadProtoMsg;
@@ -7701,12 +7933,14 @@ export declare namespace sparkdream {
             };
             MsgMoveThread: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _228.MsgMoveThread, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _228.MsgMoveThread;
                 fromPartial(object: import("../helpers").DeepPartial<_228.MsgMoveThread>): _228.MsgMoveThread;
                 fromAmino(object: _228.MsgMoveThreadAmino): _228.MsgMoveThread;
                 toAmino(message: _228.MsgMoveThread): _228.MsgMoveThreadAmino;
                 fromAminoMsg(object: _228.MsgMoveThreadAminoMsg): _228.MsgMoveThread;
+                toAminoMsg(message: _228.MsgMoveThread): _228.MsgMoveThreadAminoMsg;
                 fromProtoMsg(message: _228.MsgMoveThreadProtoMsg): _228.MsgMoveThread;
                 toProto(message: _228.MsgMoveThread): Uint8Array;
                 toProtoMsg(message: _228.MsgMoveThread): _228.MsgMoveThreadProtoMsg;
@@ -7725,12 +7959,14 @@ export declare namespace sparkdream {
             };
             MsgFollowThread: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _228.MsgFollowThread, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _228.MsgFollowThread;
                 fromPartial(object: import("../helpers").DeepPartial<_228.MsgFollowThread>): _228.MsgFollowThread;
                 fromAmino(object: _228.MsgFollowThreadAmino): _228.MsgFollowThread;
                 toAmino(message: _228.MsgFollowThread): _228.MsgFollowThreadAmino;
                 fromAminoMsg(object: _228.MsgFollowThreadAminoMsg): _228.MsgFollowThread;
+                toAminoMsg(message: _228.MsgFollowThread): _228.MsgFollowThreadAminoMsg;
                 fromProtoMsg(message: _228.MsgFollowThreadProtoMsg): _228.MsgFollowThread;
                 toProto(message: _228.MsgFollowThread): Uint8Array;
                 toProtoMsg(message: _228.MsgFollowThread): _228.MsgFollowThreadProtoMsg;
@@ -7749,12 +7985,14 @@ export declare namespace sparkdream {
             };
             MsgUnfollowThread: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _228.MsgUnfollowThread, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _228.MsgUnfollowThread;
                 fromPartial(object: import("../helpers").DeepPartial<_228.MsgUnfollowThread>): _228.MsgUnfollowThread;
                 fromAmino(object: _228.MsgUnfollowThreadAmino): _228.MsgUnfollowThread;
                 toAmino(message: _228.MsgUnfollowThread): _228.MsgUnfollowThreadAmino;
                 fromAminoMsg(object: _228.MsgUnfollowThreadAminoMsg): _228.MsgUnfollowThread;
+                toAminoMsg(message: _228.MsgUnfollowThread): _228.MsgUnfollowThreadAminoMsg;
                 fromProtoMsg(message: _228.MsgUnfollowThreadProtoMsg): _228.MsgUnfollowThread;
                 toProto(message: _228.MsgUnfollowThread): Uint8Array;
                 toProtoMsg(message: _228.MsgUnfollowThread): _228.MsgUnfollowThreadProtoMsg;
@@ -7773,12 +8011,14 @@ export declare namespace sparkdream {
             };
             MsgUpvotePost: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _228.MsgUpvotePost, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _228.MsgUpvotePost;
                 fromPartial(object: import("../helpers").DeepPartial<_228.MsgUpvotePost>): _228.MsgUpvotePost;
                 fromAmino(object: _228.MsgUpvotePostAmino): _228.MsgUpvotePost;
                 toAmino(message: _228.MsgUpvotePost): _228.MsgUpvotePostAmino;
                 fromAminoMsg(object: _228.MsgUpvotePostAminoMsg): _228.MsgUpvotePost;
+                toAminoMsg(message: _228.MsgUpvotePost): _228.MsgUpvotePostAminoMsg;
                 fromProtoMsg(message: _228.MsgUpvotePostProtoMsg): _228.MsgUpvotePost;
                 toProto(message: _228.MsgUpvotePost): Uint8Array;
                 toProtoMsg(message: _228.MsgUpvotePost): _228.MsgUpvotePostProtoMsg;
@@ -7797,12 +8037,14 @@ export declare namespace sparkdream {
             };
             MsgDownvotePost: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _228.MsgDownvotePost, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _228.MsgDownvotePost;
                 fromPartial(object: import("../helpers").DeepPartial<_228.MsgDownvotePost>): _228.MsgDownvotePost;
                 fromAmino(object: _228.MsgDownvotePostAmino): _228.MsgDownvotePost;
                 toAmino(message: _228.MsgDownvotePost): _228.MsgDownvotePostAmino;
                 fromAminoMsg(object: _228.MsgDownvotePostAminoMsg): _228.MsgDownvotePost;
+                toAminoMsg(message: _228.MsgDownvotePost): _228.MsgDownvotePostAminoMsg;
                 fromProtoMsg(message: _228.MsgDownvotePostProtoMsg): _228.MsgDownvotePost;
                 toProto(message: _228.MsgDownvotePost): Uint8Array;
                 toProtoMsg(message: _228.MsgDownvotePost): _228.MsgDownvotePostProtoMsg;
@@ -7821,12 +8063,14 @@ export declare namespace sparkdream {
             };
             MsgFlagPost: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _228.MsgFlagPost, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _228.MsgFlagPost;
                 fromPartial(object: import("../helpers").DeepPartial<_228.MsgFlagPost>): _228.MsgFlagPost;
                 fromAmino(object: _228.MsgFlagPostAmino): _228.MsgFlagPost;
                 toAmino(message: _228.MsgFlagPost): _228.MsgFlagPostAmino;
                 fromAminoMsg(object: _228.MsgFlagPostAminoMsg): _228.MsgFlagPost;
+                toAminoMsg(message: _228.MsgFlagPost): _228.MsgFlagPostAminoMsg;
                 fromProtoMsg(message: _228.MsgFlagPostProtoMsg): _228.MsgFlagPost;
                 toProto(message: _228.MsgFlagPost): Uint8Array;
                 toProtoMsg(message: _228.MsgFlagPost): _228.MsgFlagPostProtoMsg;
@@ -7845,12 +8089,14 @@ export declare namespace sparkdream {
             };
             MsgDismissFlags: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _228.MsgDismissFlags, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _228.MsgDismissFlags;
                 fromPartial(object: import("../helpers").DeepPartial<_228.MsgDismissFlags>): _228.MsgDismissFlags;
                 fromAmino(object: _228.MsgDismissFlagsAmino): _228.MsgDismissFlags;
                 toAmino(message: _228.MsgDismissFlags): _228.MsgDismissFlagsAmino;
                 fromAminoMsg(object: _228.MsgDismissFlagsAminoMsg): _228.MsgDismissFlags;
+                toAminoMsg(message: _228.MsgDismissFlags): _228.MsgDismissFlagsAminoMsg;
                 fromProtoMsg(message: _228.MsgDismissFlagsProtoMsg): _228.MsgDismissFlags;
                 toProto(message: _228.MsgDismissFlags): Uint8Array;
                 toProtoMsg(message: _228.MsgDismissFlags): _228.MsgDismissFlagsProtoMsg;
@@ -7869,12 +8115,14 @@ export declare namespace sparkdream {
             };
             MsgHidePost: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _228.MsgHidePost, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _228.MsgHidePost;
                 fromPartial(object: import("../helpers").DeepPartial<_228.MsgHidePost>): _228.MsgHidePost;
                 fromAmino(object: _228.MsgHidePostAmino): _228.MsgHidePost;
                 toAmino(message: _228.MsgHidePost): _228.MsgHidePostAmino;
                 fromAminoMsg(object: _228.MsgHidePostAminoMsg): _228.MsgHidePost;
+                toAminoMsg(message: _228.MsgHidePost): _228.MsgHidePostAminoMsg;
                 fromProtoMsg(message: _228.MsgHidePostProtoMsg): _228.MsgHidePost;
                 toProto(message: _228.MsgHidePost): Uint8Array;
                 toProtoMsg(message: _228.MsgHidePost): _228.MsgHidePostProtoMsg;
@@ -7893,12 +8141,14 @@ export declare namespace sparkdream {
             };
             MsgAppealPost: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _228.MsgAppealPost, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _228.MsgAppealPost;
                 fromPartial(object: import("../helpers").DeepPartial<_228.MsgAppealPost>): _228.MsgAppealPost;
                 fromAmino(object: _228.MsgAppealPostAmino): _228.MsgAppealPost;
                 toAmino(message: _228.MsgAppealPost): _228.MsgAppealPostAmino;
                 fromAminoMsg(object: _228.MsgAppealPostAminoMsg): _228.MsgAppealPost;
+                toAminoMsg(message: _228.MsgAppealPost): _228.MsgAppealPostAminoMsg;
                 fromProtoMsg(message: _228.MsgAppealPostProtoMsg): _228.MsgAppealPost;
                 toProto(message: _228.MsgAppealPost): Uint8Array;
                 toProtoMsg(message: _228.MsgAppealPost): _228.MsgAppealPostProtoMsg;
@@ -7917,12 +8167,14 @@ export declare namespace sparkdream {
             };
             MsgAppealThreadLock: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _228.MsgAppealThreadLock, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _228.MsgAppealThreadLock;
                 fromPartial(object: import("../helpers").DeepPartial<_228.MsgAppealThreadLock>): _228.MsgAppealThreadLock;
                 fromAmino(object: _228.MsgAppealThreadLockAmino): _228.MsgAppealThreadLock;
                 toAmino(message: _228.MsgAppealThreadLock): _228.MsgAppealThreadLockAmino;
                 fromAminoMsg(object: _228.MsgAppealThreadLockAminoMsg): _228.MsgAppealThreadLock;
+                toAminoMsg(message: _228.MsgAppealThreadLock): _228.MsgAppealThreadLockAminoMsg;
                 fromProtoMsg(message: _228.MsgAppealThreadLockProtoMsg): _228.MsgAppealThreadLock;
                 toProto(message: _228.MsgAppealThreadLock): Uint8Array;
                 toProtoMsg(message: _228.MsgAppealThreadLock): _228.MsgAppealThreadLockProtoMsg;
@@ -7941,12 +8193,14 @@ export declare namespace sparkdream {
             };
             MsgAppealThreadMove: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _228.MsgAppealThreadMove, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _228.MsgAppealThreadMove;
                 fromPartial(object: import("../helpers").DeepPartial<_228.MsgAppealThreadMove>): _228.MsgAppealThreadMove;
                 fromAmino(object: _228.MsgAppealThreadMoveAmino): _228.MsgAppealThreadMove;
                 toAmino(message: _228.MsgAppealThreadMove): _228.MsgAppealThreadMoveAmino;
                 fromAminoMsg(object: _228.MsgAppealThreadMoveAminoMsg): _228.MsgAppealThreadMove;
+                toAminoMsg(message: _228.MsgAppealThreadMove): _228.MsgAppealThreadMoveAminoMsg;
                 fromProtoMsg(message: _228.MsgAppealThreadMoveProtoMsg): _228.MsgAppealThreadMove;
                 toProto(message: _228.MsgAppealThreadMove): Uint8Array;
                 toProtoMsg(message: _228.MsgAppealThreadMove): _228.MsgAppealThreadMoveProtoMsg;
@@ -7965,12 +8219,14 @@ export declare namespace sparkdream {
             };
             MsgCreateBounty: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _228.MsgCreateBounty, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _228.MsgCreateBounty;
                 fromPartial(object: import("../helpers").DeepPartial<_228.MsgCreateBounty>): _228.MsgCreateBounty;
                 fromAmino(object: _228.MsgCreateBountyAmino): _228.MsgCreateBounty;
                 toAmino(message: _228.MsgCreateBounty): _228.MsgCreateBountyAmino;
                 fromAminoMsg(object: _228.MsgCreateBountyAminoMsg): _228.MsgCreateBounty;
+                toAminoMsg(message: _228.MsgCreateBounty): _228.MsgCreateBountyAminoMsg;
                 fromProtoMsg(message: _228.MsgCreateBountyProtoMsg): _228.MsgCreateBounty;
                 toProto(message: _228.MsgCreateBounty): Uint8Array;
                 toProtoMsg(message: _228.MsgCreateBounty): _228.MsgCreateBountyProtoMsg;
@@ -7989,12 +8245,14 @@ export declare namespace sparkdream {
             };
             MsgAwardBounty: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _228.MsgAwardBounty, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _228.MsgAwardBounty;
                 fromPartial(object: import("../helpers").DeepPartial<_228.MsgAwardBounty>): _228.MsgAwardBounty;
                 fromAmino(object: _228.MsgAwardBountyAmino): _228.MsgAwardBounty;
                 toAmino(message: _228.MsgAwardBounty): _228.MsgAwardBountyAmino;
                 fromAminoMsg(object: _228.MsgAwardBountyAminoMsg): _228.MsgAwardBounty;
+                toAminoMsg(message: _228.MsgAwardBounty): _228.MsgAwardBountyAminoMsg;
                 fromProtoMsg(message: _228.MsgAwardBountyProtoMsg): _228.MsgAwardBounty;
                 toProto(message: _228.MsgAwardBounty): Uint8Array;
                 toProtoMsg(message: _228.MsgAwardBounty): _228.MsgAwardBountyProtoMsg;
@@ -8013,12 +8271,14 @@ export declare namespace sparkdream {
             };
             MsgIncreaseBounty: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _228.MsgIncreaseBounty, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _228.MsgIncreaseBounty;
                 fromPartial(object: import("../helpers").DeepPartial<_228.MsgIncreaseBounty>): _228.MsgIncreaseBounty;
                 fromAmino(object: _228.MsgIncreaseBountyAmino): _228.MsgIncreaseBounty;
                 toAmino(message: _228.MsgIncreaseBounty): _228.MsgIncreaseBountyAmino;
                 fromAminoMsg(object: _228.MsgIncreaseBountyAminoMsg): _228.MsgIncreaseBounty;
+                toAminoMsg(message: _228.MsgIncreaseBounty): _228.MsgIncreaseBountyAminoMsg;
                 fromProtoMsg(message: _228.MsgIncreaseBountyProtoMsg): _228.MsgIncreaseBounty;
                 toProto(message: _228.MsgIncreaseBounty): Uint8Array;
                 toProtoMsg(message: _228.MsgIncreaseBounty): _228.MsgIncreaseBountyProtoMsg;
@@ -8037,12 +8297,14 @@ export declare namespace sparkdream {
             };
             MsgCancelBounty: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _228.MsgCancelBounty, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _228.MsgCancelBounty;
                 fromPartial(object: import("../helpers").DeepPartial<_228.MsgCancelBounty>): _228.MsgCancelBounty;
                 fromAmino(object: _228.MsgCancelBountyAmino): _228.MsgCancelBounty;
                 toAmino(message: _228.MsgCancelBounty): _228.MsgCancelBountyAmino;
                 fromAminoMsg(object: _228.MsgCancelBountyAminoMsg): _228.MsgCancelBounty;
+                toAminoMsg(message: _228.MsgCancelBounty): _228.MsgCancelBountyAminoMsg;
                 fromProtoMsg(message: _228.MsgCancelBountyProtoMsg): _228.MsgCancelBounty;
                 toProto(message: _228.MsgCancelBounty): Uint8Array;
                 toProtoMsg(message: _228.MsgCancelBounty): _228.MsgCancelBountyProtoMsg;
@@ -8061,12 +8323,14 @@ export declare namespace sparkdream {
             };
             MsgAssignBountyToReply: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _228.MsgAssignBountyToReply, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _228.MsgAssignBountyToReply;
                 fromPartial(object: import("../helpers").DeepPartial<_228.MsgAssignBountyToReply>): _228.MsgAssignBountyToReply;
                 fromAmino(object: _228.MsgAssignBountyToReplyAmino): _228.MsgAssignBountyToReply;
                 toAmino(message: _228.MsgAssignBountyToReply): _228.MsgAssignBountyToReplyAmino;
                 fromAminoMsg(object: _228.MsgAssignBountyToReplyAminoMsg): _228.MsgAssignBountyToReply;
+                toAminoMsg(message: _228.MsgAssignBountyToReply): _228.MsgAssignBountyToReplyAminoMsg;
                 fromProtoMsg(message: _228.MsgAssignBountyToReplyProtoMsg): _228.MsgAssignBountyToReply;
                 toProto(message: _228.MsgAssignBountyToReply): Uint8Array;
                 toProtoMsg(message: _228.MsgAssignBountyToReply): _228.MsgAssignBountyToReplyProtoMsg;
@@ -8085,12 +8349,14 @@ export declare namespace sparkdream {
             };
             MsgPinReply: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _228.MsgPinReply, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _228.MsgPinReply;
                 fromPartial(object: import("../helpers").DeepPartial<_228.MsgPinReply>): _228.MsgPinReply;
                 fromAmino(object: _228.MsgPinReplyAmino): _228.MsgPinReply;
                 toAmino(message: _228.MsgPinReply): _228.MsgPinReplyAmino;
                 fromAminoMsg(object: _228.MsgPinReplyAminoMsg): _228.MsgPinReply;
+                toAminoMsg(message: _228.MsgPinReply): _228.MsgPinReplyAminoMsg;
                 fromProtoMsg(message: _228.MsgPinReplyProtoMsg): _228.MsgPinReply;
                 toProto(message: _228.MsgPinReply): Uint8Array;
                 toProtoMsg(message: _228.MsgPinReply): _228.MsgPinReplyProtoMsg;
@@ -8109,12 +8375,14 @@ export declare namespace sparkdream {
             };
             MsgUnpinReply: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _228.MsgUnpinReply, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _228.MsgUnpinReply;
                 fromPartial(object: import("../helpers").DeepPartial<_228.MsgUnpinReply>): _228.MsgUnpinReply;
                 fromAmino(object: _228.MsgUnpinReplyAmino): _228.MsgUnpinReply;
                 toAmino(message: _228.MsgUnpinReply): _228.MsgUnpinReplyAmino;
                 fromAminoMsg(object: _228.MsgUnpinReplyAminoMsg): _228.MsgUnpinReply;
+                toAminoMsg(message: _228.MsgUnpinReply): _228.MsgUnpinReplyAminoMsg;
                 fromProtoMsg(message: _228.MsgUnpinReplyProtoMsg): _228.MsgUnpinReply;
                 toProto(message: _228.MsgUnpinReply): Uint8Array;
                 toProtoMsg(message: _228.MsgUnpinReply): _228.MsgUnpinReplyProtoMsg;
@@ -8133,12 +8401,14 @@ export declare namespace sparkdream {
             };
             MsgDisputePin: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _228.MsgDisputePin, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _228.MsgDisputePin;
                 fromPartial(object: import("../helpers").DeepPartial<_228.MsgDisputePin>): _228.MsgDisputePin;
                 fromAmino(object: _228.MsgDisputePinAmino): _228.MsgDisputePin;
                 toAmino(message: _228.MsgDisputePin): _228.MsgDisputePinAmino;
                 fromAminoMsg(object: _228.MsgDisputePinAminoMsg): _228.MsgDisputePin;
+                toAminoMsg(message: _228.MsgDisputePin): _228.MsgDisputePinAminoMsg;
                 fromProtoMsg(message: _228.MsgDisputePinProtoMsg): _228.MsgDisputePin;
                 toProto(message: _228.MsgDisputePin): Uint8Array;
                 toProtoMsg(message: _228.MsgDisputePin): _228.MsgDisputePinProtoMsg;
@@ -8157,12 +8427,14 @@ export declare namespace sparkdream {
             };
             MsgMarkAcceptedReply: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _228.MsgMarkAcceptedReply, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _228.MsgMarkAcceptedReply;
                 fromPartial(object: import("../helpers").DeepPartial<_228.MsgMarkAcceptedReply>): _228.MsgMarkAcceptedReply;
                 fromAmino(object: _228.MsgMarkAcceptedReplyAmino): _228.MsgMarkAcceptedReply;
                 toAmino(message: _228.MsgMarkAcceptedReply): _228.MsgMarkAcceptedReplyAmino;
                 fromAminoMsg(object: _228.MsgMarkAcceptedReplyAminoMsg): _228.MsgMarkAcceptedReply;
+                toAminoMsg(message: _228.MsgMarkAcceptedReply): _228.MsgMarkAcceptedReplyAminoMsg;
                 fromProtoMsg(message: _228.MsgMarkAcceptedReplyProtoMsg): _228.MsgMarkAcceptedReply;
                 toProto(message: _228.MsgMarkAcceptedReply): Uint8Array;
                 toProtoMsg(message: _228.MsgMarkAcceptedReply): _228.MsgMarkAcceptedReplyProtoMsg;
@@ -8181,12 +8453,14 @@ export declare namespace sparkdream {
             };
             MsgConfirmProposedReply: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _228.MsgConfirmProposedReply, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _228.MsgConfirmProposedReply;
                 fromPartial(object: import("../helpers").DeepPartial<_228.MsgConfirmProposedReply>): _228.MsgConfirmProposedReply;
                 fromAmino(object: _228.MsgConfirmProposedReplyAmino): _228.MsgConfirmProposedReply;
                 toAmino(message: _228.MsgConfirmProposedReply): _228.MsgConfirmProposedReplyAmino;
                 fromAminoMsg(object: _228.MsgConfirmProposedReplyAminoMsg): _228.MsgConfirmProposedReply;
+                toAminoMsg(message: _228.MsgConfirmProposedReply): _228.MsgConfirmProposedReplyAminoMsg;
                 fromProtoMsg(message: _228.MsgConfirmProposedReplyProtoMsg): _228.MsgConfirmProposedReply;
                 toProto(message: _228.MsgConfirmProposedReply): Uint8Array;
                 toProtoMsg(message: _228.MsgConfirmProposedReply): _228.MsgConfirmProposedReplyProtoMsg;
@@ -8205,12 +8479,14 @@ export declare namespace sparkdream {
             };
             MsgRejectProposedReply: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _228.MsgRejectProposedReply, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _228.MsgRejectProposedReply;
                 fromPartial(object: import("../helpers").DeepPartial<_228.MsgRejectProposedReply>): _228.MsgRejectProposedReply;
                 fromAmino(object: _228.MsgRejectProposedReplyAmino): _228.MsgRejectProposedReply;
                 toAmino(message: _228.MsgRejectProposedReply): _228.MsgRejectProposedReplyAmino;
                 fromAminoMsg(object: _228.MsgRejectProposedReplyAminoMsg): _228.MsgRejectProposedReply;
+                toAminoMsg(message: _228.MsgRejectProposedReply): _228.MsgRejectProposedReplyAminoMsg;
                 fromProtoMsg(message: _228.MsgRejectProposedReplyProtoMsg): _228.MsgRejectProposedReply;
                 toProto(message: _228.MsgRejectProposedReply): Uint8Array;
                 toProtoMsg(message: _228.MsgRejectProposedReply): _228.MsgRejectProposedReplyProtoMsg;
@@ -8229,12 +8505,14 @@ export declare namespace sparkdream {
             };
             MsgSetForumPaused: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _228.MsgSetForumPaused, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _228.MsgSetForumPaused;
                 fromPartial(object: import("../helpers").DeepPartial<_228.MsgSetForumPaused>): _228.MsgSetForumPaused;
                 fromAmino(object: _228.MsgSetForumPausedAmino): _228.MsgSetForumPaused;
                 toAmino(message: _228.MsgSetForumPaused): _228.MsgSetForumPausedAmino;
                 fromAminoMsg(object: _228.MsgSetForumPausedAminoMsg): _228.MsgSetForumPaused;
+                toAminoMsg(message: _228.MsgSetForumPaused): _228.MsgSetForumPausedAminoMsg;
                 fromProtoMsg(message: _228.MsgSetForumPausedProtoMsg): _228.MsgSetForumPaused;
                 toProto(message: _228.MsgSetForumPaused): Uint8Array;
                 toProtoMsg(message: _228.MsgSetForumPaused): _228.MsgSetForumPausedProtoMsg;
@@ -8253,12 +8531,14 @@ export declare namespace sparkdream {
             };
             MsgSetModerationPaused: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _228.MsgSetModerationPaused, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _228.MsgSetModerationPaused;
                 fromPartial(object: import("../helpers").DeepPartial<_228.MsgSetModerationPaused>): _228.MsgSetModerationPaused;
                 fromAmino(object: _228.MsgSetModerationPausedAmino): _228.MsgSetModerationPaused;
                 toAmino(message: _228.MsgSetModerationPaused): _228.MsgSetModerationPausedAmino;
                 fromAminoMsg(object: _228.MsgSetModerationPausedAminoMsg): _228.MsgSetModerationPaused;
+                toAminoMsg(message: _228.MsgSetModerationPaused): _228.MsgSetModerationPausedAminoMsg;
                 fromProtoMsg(message: _228.MsgSetModerationPausedProtoMsg): _228.MsgSetModerationPaused;
                 toProto(message: _228.MsgSetModerationPaused): Uint8Array;
                 toProtoMsg(message: _228.MsgSetModerationPaused): _228.MsgSetModerationPausedProtoMsg;
@@ -9776,12 +10056,14 @@ export declare namespace sparkdream {
             };
             MsgCreateMarket: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _237.MsgCreateMarket, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _237.MsgCreateMarket;
                 fromPartial(object: import("../helpers").DeepPartial<_237.MsgCreateMarket>): _237.MsgCreateMarket;
                 fromAmino(object: _237.MsgCreateMarketAmino): _237.MsgCreateMarket;
                 toAmino(message: _237.MsgCreateMarket): _237.MsgCreateMarketAmino;
                 fromAminoMsg(object: _237.MsgCreateMarketAminoMsg): _237.MsgCreateMarket;
+                toAminoMsg(message: _237.MsgCreateMarket): _237.MsgCreateMarketAminoMsg;
                 fromProtoMsg(message: _237.MsgCreateMarketProtoMsg): _237.MsgCreateMarket;
                 toProto(message: _237.MsgCreateMarket): Uint8Array;
                 toProtoMsg(message: _237.MsgCreateMarket): _237.MsgCreateMarketProtoMsg;
@@ -9800,12 +10082,14 @@ export declare namespace sparkdream {
             };
             MsgTrade: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _237.MsgTrade, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _237.MsgTrade;
                 fromPartial(object: import("../helpers").DeepPartial<_237.MsgTrade>): _237.MsgTrade;
                 fromAmino(object: _237.MsgTradeAmino): _237.MsgTrade;
                 toAmino(message: _237.MsgTrade): _237.MsgTradeAmino;
                 fromAminoMsg(object: _237.MsgTradeAminoMsg): _237.MsgTrade;
+                toAminoMsg(message: _237.MsgTrade): _237.MsgTradeAminoMsg;
                 fromProtoMsg(message: _237.MsgTradeProtoMsg): _237.MsgTrade;
                 toProto(message: _237.MsgTrade): Uint8Array;
                 toProtoMsg(message: _237.MsgTrade): _237.MsgTradeProtoMsg;
@@ -9824,12 +10108,14 @@ export declare namespace sparkdream {
             };
             MsgRedeem: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _237.MsgRedeem, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _237.MsgRedeem;
                 fromPartial(object: import("../helpers").DeepPartial<_237.MsgRedeem>): _237.MsgRedeem;
                 fromAmino(object: _237.MsgRedeemAmino): _237.MsgRedeem;
                 toAmino(message: _237.MsgRedeem): _237.MsgRedeemAmino;
                 fromAminoMsg(object: _237.MsgRedeemAminoMsg): _237.MsgRedeem;
+                toAminoMsg(message: _237.MsgRedeem): _237.MsgRedeemAminoMsg;
                 fromProtoMsg(message: _237.MsgRedeemProtoMsg): _237.MsgRedeem;
                 toProto(message: _237.MsgRedeem): Uint8Array;
                 toProtoMsg(message: _237.MsgRedeem): _237.MsgRedeemProtoMsg;
@@ -9874,12 +10160,14 @@ export declare namespace sparkdream {
             };
             MsgWithdrawLiquidity: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _237.MsgWithdrawLiquidity, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _237.MsgWithdrawLiquidity;
                 fromPartial(object: import("../helpers").DeepPartial<_237.MsgWithdrawLiquidity>): _237.MsgWithdrawLiquidity;
                 fromAmino(object: _237.MsgWithdrawLiquidityAmino): _237.MsgWithdrawLiquidity;
                 toAmino(message: _237.MsgWithdrawLiquidity): _237.MsgWithdrawLiquidityAmino;
                 fromAminoMsg(object: _237.MsgWithdrawLiquidityAminoMsg): _237.MsgWithdrawLiquidity;
+                toAminoMsg(message: _237.MsgWithdrawLiquidity): _237.MsgWithdrawLiquidityAminoMsg;
                 fromProtoMsg(message: _237.MsgWithdrawLiquidityProtoMsg): _237.MsgWithdrawLiquidity;
                 toProto(message: _237.MsgWithdrawLiquidity): Uint8Array;
                 toProtoMsg(message: _237.MsgWithdrawLiquidity): _237.MsgWithdrawLiquidityProtoMsg;
@@ -10074,6 +10362,8 @@ export declare namespace sparkdream {
                 names(request: _244.QueryNamesRequest): Promise<_244.QueryNamesResponse>;
                 getDispute(request: _244.QueryGetDisputeRequest): Promise<_244.QueryGetDisputeResponse>;
                 listDispute(request?: _244.QueryAllDisputeRequest): Promise<_244.QueryAllDisputeResponse>;
+                getOwnerInfo(request: _244.QueryGetOwnerInfoRequest): Promise<_244.QueryGetOwnerInfoResponse>;
+                targets(request: _244.QueryTargetsRequest): Promise<_244.QueryTargetsResponse>;
             };
             LCDQueryClient: typeof _515.LCDQueryClient;
             registry: ReadonlyArray<[string, import("..").TelescopeGeneratedType<any, any, any>]>;
@@ -10112,6 +10402,22 @@ export declare namespace sparkdream {
                         typeUrl: string;
                         value: Uint8Array<ArrayBufferLike>;
                     };
+                    setDisplayName(value: _245.MsgSetDisplayName): {
+                        typeUrl: string;
+                        value: Uint8Array<ArrayBufferLike>;
+                    };
+                    setTarget(value: _245.MsgSetTarget): {
+                        typeUrl: string;
+                        value: Uint8Array<ArrayBufferLike>;
+                    };
+                    acceptTarget(value: _245.MsgAcceptTarget): {
+                        typeUrl: string;
+                        value: Uint8Array<ArrayBufferLike>;
+                    };
+                    transferName(value: _245.MsgTransferName): {
+                        typeUrl: string;
+                        value: Uint8Array<ArrayBufferLike>;
+                    };
                 };
                 withTypeUrl: {
                     updateParams(value: _245.MsgUpdateParams): {
@@ -10146,6 +10452,22 @@ export declare namespace sparkdream {
                         typeUrl: string;
                         value: _245.MsgUpdateName;
                     };
+                    setDisplayName(value: _245.MsgSetDisplayName): {
+                        typeUrl: string;
+                        value: _245.MsgSetDisplayName;
+                    };
+                    setTarget(value: _245.MsgSetTarget): {
+                        typeUrl: string;
+                        value: _245.MsgSetTarget;
+                    };
+                    acceptTarget(value: _245.MsgAcceptTarget): {
+                        typeUrl: string;
+                        value: _245.MsgAcceptTarget;
+                    };
+                    transferName(value: _245.MsgTransferName): {
+                        typeUrl: string;
+                        value: _245.MsgTransferName;
+                    };
                 };
                 fromPartial: {
                     updateParams(value: _245.MsgUpdateParams): {
@@ -10180,6 +10502,22 @@ export declare namespace sparkdream {
                         typeUrl: string;
                         value: _245.MsgUpdateName;
                     };
+                    setDisplayName(value: _245.MsgSetDisplayName): {
+                        typeUrl: string;
+                        value: _245.MsgSetDisplayName;
+                    };
+                    setTarget(value: _245.MsgSetTarget): {
+                        typeUrl: string;
+                        value: _245.MsgSetTarget;
+                    };
+                    acceptTarget(value: _245.MsgAcceptTarget): {
+                        typeUrl: string;
+                        value: _245.MsgAcceptTarget;
+                    };
+                    transferName(value: _245.MsgTransferName): {
+                        typeUrl: string;
+                        value: _245.MsgTransferName;
+                    };
                 };
             };
             AminoConverter: {
@@ -10223,6 +10561,26 @@ export declare namespace sparkdream {
                     toAmino: (message: _245.MsgUpdateName) => _245.MsgUpdateNameAmino;
                     fromAmino: (object: _245.MsgUpdateNameAmino) => _245.MsgUpdateName;
                 };
+                "/sparkdream.name.v1.MsgSetDisplayName": {
+                    aminoType: string;
+                    toAmino: (message: _245.MsgSetDisplayName) => _245.MsgSetDisplayNameAmino;
+                    fromAmino: (object: _245.MsgSetDisplayNameAmino) => _245.MsgSetDisplayName;
+                };
+                "/sparkdream.name.v1.MsgSetTarget": {
+                    aminoType: string;
+                    toAmino: (message: _245.MsgSetTarget) => _245.MsgSetTargetAmino;
+                    fromAmino: (object: _245.MsgSetTargetAmino) => _245.MsgSetTarget;
+                };
+                "/sparkdream.name.v1.MsgAcceptTarget": {
+                    aminoType: string;
+                    toAmino: (message: _245.MsgAcceptTarget) => _245.MsgAcceptTargetAmino;
+                    fromAmino: (object: _245.MsgAcceptTargetAmino) => _245.MsgAcceptTarget;
+                };
+                "/sparkdream.name.v1.MsgTransferName": {
+                    aminoType: string;
+                    toAmino: (message: _245.MsgTransferName) => _245.MsgTransferNameAmino;
+                    fromAmino: (object: _245.MsgTransferNameAmino) => _245.MsgTransferName;
+                };
             };
             MsgUpdateParams: {
                 typeUrl: string;
@@ -10278,12 +10636,14 @@ export declare namespace sparkdream {
             };
             MsgRegisterName: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _245.MsgRegisterName, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _245.MsgRegisterName;
                 fromPartial(object: import("../helpers").DeepPartial<_245.MsgRegisterName>): _245.MsgRegisterName;
                 fromAmino(object: _245.MsgRegisterNameAmino): _245.MsgRegisterName;
                 toAmino(message: _245.MsgRegisterName): _245.MsgRegisterNameAmino;
                 fromAminoMsg(object: _245.MsgRegisterNameAminoMsg): _245.MsgRegisterName;
+                toAminoMsg(message: _245.MsgRegisterName): _245.MsgRegisterNameAminoMsg;
                 fromProtoMsg(message: _245.MsgRegisterNameProtoMsg): _245.MsgRegisterName;
                 toProto(message: _245.MsgRegisterName): Uint8Array;
                 toProtoMsg(message: _245.MsgRegisterName): _245.MsgRegisterNameProtoMsg;
@@ -10302,12 +10662,14 @@ export declare namespace sparkdream {
             };
             MsgSetPrimary: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _245.MsgSetPrimary, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _245.MsgSetPrimary;
                 fromPartial(object: import("../helpers").DeepPartial<_245.MsgSetPrimary>): _245.MsgSetPrimary;
                 fromAmino(object: _245.MsgSetPrimaryAmino): _245.MsgSetPrimary;
                 toAmino(message: _245.MsgSetPrimary): _245.MsgSetPrimaryAmino;
                 fromAminoMsg(object: _245.MsgSetPrimaryAminoMsg): _245.MsgSetPrimary;
+                toAminoMsg(message: _245.MsgSetPrimary): _245.MsgSetPrimaryAminoMsg;
                 fromProtoMsg(message: _245.MsgSetPrimaryProtoMsg): _245.MsgSetPrimary;
                 toProto(message: _245.MsgSetPrimary): Uint8Array;
                 toProtoMsg(message: _245.MsgSetPrimary): _245.MsgSetPrimaryProtoMsg;
@@ -10326,12 +10688,14 @@ export declare namespace sparkdream {
             };
             MsgFileDispute: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _245.MsgFileDispute, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _245.MsgFileDispute;
                 fromPartial(object: import("../helpers").DeepPartial<_245.MsgFileDispute>): _245.MsgFileDispute;
                 fromAmino(object: _245.MsgFileDisputeAmino): _245.MsgFileDispute;
                 toAmino(message: _245.MsgFileDispute): _245.MsgFileDisputeAmino;
                 fromAminoMsg(object: _245.MsgFileDisputeAminoMsg): _245.MsgFileDispute;
+                toAminoMsg(message: _245.MsgFileDispute): _245.MsgFileDisputeAminoMsg;
                 fromProtoMsg(message: _245.MsgFileDisputeProtoMsg): _245.MsgFileDispute;
                 toProto(message: _245.MsgFileDispute): Uint8Array;
                 toProtoMsg(message: _245.MsgFileDispute): _245.MsgFileDisputeProtoMsg;
@@ -10376,12 +10740,14 @@ export declare namespace sparkdream {
             };
             MsgResolveDispute: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _245.MsgResolveDispute, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _245.MsgResolveDispute;
                 fromPartial(object: import("../helpers").DeepPartial<_245.MsgResolveDispute>): _245.MsgResolveDispute;
                 fromAmino(object: _245.MsgResolveDisputeAmino): _245.MsgResolveDispute;
                 toAmino(message: _245.MsgResolveDispute): _245.MsgResolveDisputeAmino;
                 fromAminoMsg(object: _245.MsgResolveDisputeAminoMsg): _245.MsgResolveDispute;
+                toAminoMsg(message: _245.MsgResolveDispute): _245.MsgResolveDisputeAminoMsg;
                 fromProtoMsg(message: _245.MsgResolveDisputeProtoMsg): _245.MsgResolveDispute;
                 toProto(message: _245.MsgResolveDispute): Uint8Array;
                 toProtoMsg(message: _245.MsgResolveDispute): _245.MsgResolveDisputeProtoMsg;
@@ -10400,12 +10766,14 @@ export declare namespace sparkdream {
             };
             MsgUpdateName: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _245.MsgUpdateName, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _245.MsgUpdateName;
                 fromPartial(object: import("../helpers").DeepPartial<_245.MsgUpdateName>): _245.MsgUpdateName;
                 fromAmino(object: _245.MsgUpdateNameAmino): _245.MsgUpdateName;
                 toAmino(message: _245.MsgUpdateName): _245.MsgUpdateNameAmino;
                 fromAminoMsg(object: _245.MsgUpdateNameAminoMsg): _245.MsgUpdateName;
+                toAminoMsg(message: _245.MsgUpdateName): _245.MsgUpdateNameAminoMsg;
                 fromProtoMsg(message: _245.MsgUpdateNameProtoMsg): _245.MsgUpdateName;
                 toProto(message: _245.MsgUpdateName): Uint8Array;
                 toProtoMsg(message: _245.MsgUpdateName): _245.MsgUpdateNameProtoMsg;
@@ -10422,6 +10790,110 @@ export declare namespace sparkdream {
                 toProto(message: _245.MsgUpdateNameResponse): Uint8Array;
                 toProtoMsg(message: _245.MsgUpdateNameResponse): _245.MsgUpdateNameResponseProtoMsg;
             };
+            MsgSetDisplayName: {
+                typeUrl: string;
+                aminoType: string;
+                encode(message: _245.MsgSetDisplayName, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _245.MsgSetDisplayName;
+                fromPartial(object: import("../helpers").DeepPartial<_245.MsgSetDisplayName>): _245.MsgSetDisplayName;
+                fromAmino(object: _245.MsgSetDisplayNameAmino): _245.MsgSetDisplayName;
+                toAmino(message: _245.MsgSetDisplayName): _245.MsgSetDisplayNameAmino;
+                fromAminoMsg(object: _245.MsgSetDisplayNameAminoMsg): _245.MsgSetDisplayName;
+                toAminoMsg(message: _245.MsgSetDisplayName): _245.MsgSetDisplayNameAminoMsg;
+                fromProtoMsg(message: _245.MsgSetDisplayNameProtoMsg): _245.MsgSetDisplayName;
+                toProto(message: _245.MsgSetDisplayName): Uint8Array;
+                toProtoMsg(message: _245.MsgSetDisplayName): _245.MsgSetDisplayNameProtoMsg;
+            };
+            MsgSetDisplayNameResponse: {
+                typeUrl: string;
+                encode(_: _245.MsgSetDisplayNameResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _245.MsgSetDisplayNameResponse;
+                fromPartial(_: import("../helpers").DeepPartial<_245.MsgSetDisplayNameResponse>): _245.MsgSetDisplayNameResponse;
+                fromAmino(_: _245.MsgSetDisplayNameResponseAmino): _245.MsgSetDisplayNameResponse;
+                toAmino(_: _245.MsgSetDisplayNameResponse): _245.MsgSetDisplayNameResponseAmino;
+                fromAminoMsg(object: _245.MsgSetDisplayNameResponseAminoMsg): _245.MsgSetDisplayNameResponse;
+                fromProtoMsg(message: _245.MsgSetDisplayNameResponseProtoMsg): _245.MsgSetDisplayNameResponse;
+                toProto(message: _245.MsgSetDisplayNameResponse): Uint8Array;
+                toProtoMsg(message: _245.MsgSetDisplayNameResponse): _245.MsgSetDisplayNameResponseProtoMsg;
+            };
+            MsgSetTarget: {
+                typeUrl: string;
+                aminoType: string;
+                encode(message: _245.MsgSetTarget, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _245.MsgSetTarget;
+                fromPartial(object: import("../helpers").DeepPartial<_245.MsgSetTarget>): _245.MsgSetTarget;
+                fromAmino(object: _245.MsgSetTargetAmino): _245.MsgSetTarget;
+                toAmino(message: _245.MsgSetTarget): _245.MsgSetTargetAmino;
+                fromAminoMsg(object: _245.MsgSetTargetAminoMsg): _245.MsgSetTarget;
+                toAminoMsg(message: _245.MsgSetTarget): _245.MsgSetTargetAminoMsg;
+                fromProtoMsg(message: _245.MsgSetTargetProtoMsg): _245.MsgSetTarget;
+                toProto(message: _245.MsgSetTarget): Uint8Array;
+                toProtoMsg(message: _245.MsgSetTarget): _245.MsgSetTargetProtoMsg;
+            };
+            MsgSetTargetResponse: {
+                typeUrl: string;
+                encode(_: _245.MsgSetTargetResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _245.MsgSetTargetResponse;
+                fromPartial(_: import("../helpers").DeepPartial<_245.MsgSetTargetResponse>): _245.MsgSetTargetResponse;
+                fromAmino(_: _245.MsgSetTargetResponseAmino): _245.MsgSetTargetResponse;
+                toAmino(_: _245.MsgSetTargetResponse): _245.MsgSetTargetResponseAmino;
+                fromAminoMsg(object: _245.MsgSetTargetResponseAminoMsg): _245.MsgSetTargetResponse;
+                fromProtoMsg(message: _245.MsgSetTargetResponseProtoMsg): _245.MsgSetTargetResponse;
+                toProto(message: _245.MsgSetTargetResponse): Uint8Array;
+                toProtoMsg(message: _245.MsgSetTargetResponse): _245.MsgSetTargetResponseProtoMsg;
+            };
+            MsgAcceptTarget: {
+                typeUrl: string;
+                aminoType: string;
+                encode(message: _245.MsgAcceptTarget, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _245.MsgAcceptTarget;
+                fromPartial(object: import("../helpers").DeepPartial<_245.MsgAcceptTarget>): _245.MsgAcceptTarget;
+                fromAmino(object: _245.MsgAcceptTargetAmino): _245.MsgAcceptTarget;
+                toAmino(message: _245.MsgAcceptTarget): _245.MsgAcceptTargetAmino;
+                fromAminoMsg(object: _245.MsgAcceptTargetAminoMsg): _245.MsgAcceptTarget;
+                toAminoMsg(message: _245.MsgAcceptTarget): _245.MsgAcceptTargetAminoMsg;
+                fromProtoMsg(message: _245.MsgAcceptTargetProtoMsg): _245.MsgAcceptTarget;
+                toProto(message: _245.MsgAcceptTarget): Uint8Array;
+                toProtoMsg(message: _245.MsgAcceptTarget): _245.MsgAcceptTargetProtoMsg;
+            };
+            MsgAcceptTargetResponse: {
+                typeUrl: string;
+                encode(_: _245.MsgAcceptTargetResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _245.MsgAcceptTargetResponse;
+                fromPartial(_: import("../helpers").DeepPartial<_245.MsgAcceptTargetResponse>): _245.MsgAcceptTargetResponse;
+                fromAmino(_: _245.MsgAcceptTargetResponseAmino): _245.MsgAcceptTargetResponse;
+                toAmino(_: _245.MsgAcceptTargetResponse): _245.MsgAcceptTargetResponseAmino;
+                fromAminoMsg(object: _245.MsgAcceptTargetResponseAminoMsg): _245.MsgAcceptTargetResponse;
+                fromProtoMsg(message: _245.MsgAcceptTargetResponseProtoMsg): _245.MsgAcceptTargetResponse;
+                toProto(message: _245.MsgAcceptTargetResponse): Uint8Array;
+                toProtoMsg(message: _245.MsgAcceptTargetResponse): _245.MsgAcceptTargetResponseProtoMsg;
+            };
+            MsgTransferName: {
+                typeUrl: string;
+                aminoType: string;
+                encode(message: _245.MsgTransferName, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _245.MsgTransferName;
+                fromPartial(object: import("../helpers").DeepPartial<_245.MsgTransferName>): _245.MsgTransferName;
+                fromAmino(object: _245.MsgTransferNameAmino): _245.MsgTransferName;
+                toAmino(message: _245.MsgTransferName): _245.MsgTransferNameAmino;
+                fromAminoMsg(object: _245.MsgTransferNameAminoMsg): _245.MsgTransferName;
+                toAminoMsg(message: _245.MsgTransferName): _245.MsgTransferNameAminoMsg;
+                fromProtoMsg(message: _245.MsgTransferNameProtoMsg): _245.MsgTransferName;
+                toProto(message: _245.MsgTransferName): Uint8Array;
+                toProtoMsg(message: _245.MsgTransferName): _245.MsgTransferNameProtoMsg;
+            };
+            MsgTransferNameResponse: {
+                typeUrl: string;
+                encode(_: _245.MsgTransferNameResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _245.MsgTransferNameResponse;
+                fromPartial(_: import("../helpers").DeepPartial<_245.MsgTransferNameResponse>): _245.MsgTransferNameResponse;
+                fromAmino(_: _245.MsgTransferNameResponseAmino): _245.MsgTransferNameResponse;
+                toAmino(_: _245.MsgTransferNameResponse): _245.MsgTransferNameResponseAmino;
+                fromAminoMsg(object: _245.MsgTransferNameResponseAminoMsg): _245.MsgTransferNameResponse;
+                fromProtoMsg(message: _245.MsgTransferNameResponseProtoMsg): _245.MsgTransferNameResponse;
+                toProto(message: _245.MsgTransferNameResponse): Uint8Array;
+                toProtoMsg(message: _245.MsgTransferNameResponse): _245.MsgTransferNameResponseProtoMsg;
+            };
             QueryParamsRequest: {
                 typeUrl: string;
                 encode(_: _244.QueryParamsRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
@@ -10566,6 +11038,54 @@ export declare namespace sparkdream {
                 toProto(message: _244.QueryAllDisputeResponse): Uint8Array;
                 toProtoMsg(message: _244.QueryAllDisputeResponse): _244.QueryAllDisputeResponseProtoMsg;
             };
+            QueryGetOwnerInfoRequest: {
+                typeUrl: string;
+                encode(message: _244.QueryGetOwnerInfoRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _244.QueryGetOwnerInfoRequest;
+                fromPartial(object: import("../helpers").DeepPartial<_244.QueryGetOwnerInfoRequest>): _244.QueryGetOwnerInfoRequest;
+                fromAmino(object: _244.QueryGetOwnerInfoRequestAmino): _244.QueryGetOwnerInfoRequest;
+                toAmino(message: _244.QueryGetOwnerInfoRequest): _244.QueryGetOwnerInfoRequestAmino;
+                fromAminoMsg(object: _244.QueryGetOwnerInfoRequestAminoMsg): _244.QueryGetOwnerInfoRequest;
+                fromProtoMsg(message: _244.QueryGetOwnerInfoRequestProtoMsg): _244.QueryGetOwnerInfoRequest;
+                toProto(message: _244.QueryGetOwnerInfoRequest): Uint8Array;
+                toProtoMsg(message: _244.QueryGetOwnerInfoRequest): _244.QueryGetOwnerInfoRequestProtoMsg;
+            };
+            QueryGetOwnerInfoResponse: {
+                typeUrl: string;
+                encode(message: _244.QueryGetOwnerInfoResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _244.QueryGetOwnerInfoResponse;
+                fromPartial(object: import("../helpers").DeepPartial<_244.QueryGetOwnerInfoResponse>): _244.QueryGetOwnerInfoResponse;
+                fromAmino(object: _244.QueryGetOwnerInfoResponseAmino): _244.QueryGetOwnerInfoResponse;
+                toAmino(message: _244.QueryGetOwnerInfoResponse): _244.QueryGetOwnerInfoResponseAmino;
+                fromAminoMsg(object: _244.QueryGetOwnerInfoResponseAminoMsg): _244.QueryGetOwnerInfoResponse;
+                fromProtoMsg(message: _244.QueryGetOwnerInfoResponseProtoMsg): _244.QueryGetOwnerInfoResponse;
+                toProto(message: _244.QueryGetOwnerInfoResponse): Uint8Array;
+                toProtoMsg(message: _244.QueryGetOwnerInfoResponse): _244.QueryGetOwnerInfoResponseProtoMsg;
+            };
+            QueryTargetsRequest: {
+                typeUrl: string;
+                encode(message: _244.QueryTargetsRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _244.QueryTargetsRequest;
+                fromPartial(object: import("../helpers").DeepPartial<_244.QueryTargetsRequest>): _244.QueryTargetsRequest;
+                fromAmino(object: _244.QueryTargetsRequestAmino): _244.QueryTargetsRequest;
+                toAmino(message: _244.QueryTargetsRequest): _244.QueryTargetsRequestAmino;
+                fromAminoMsg(object: _244.QueryTargetsRequestAminoMsg): _244.QueryTargetsRequest;
+                fromProtoMsg(message: _244.QueryTargetsRequestProtoMsg): _244.QueryTargetsRequest;
+                toProto(message: _244.QueryTargetsRequest): Uint8Array;
+                toProtoMsg(message: _244.QueryTargetsRequest): _244.QueryTargetsRequestProtoMsg;
+            };
+            QueryTargetsResponse: {
+                typeUrl: string;
+                encode(message: _244.QueryTargetsResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _244.QueryTargetsResponse;
+                fromPartial(object: import("../helpers").DeepPartial<_244.QueryTargetsResponse>): _244.QueryTargetsResponse;
+                fromAmino(object: _244.QueryTargetsResponseAmino): _244.QueryTargetsResponse;
+                toAmino(message: _244.QueryTargetsResponse): _244.QueryTargetsResponseAmino;
+                fromAminoMsg(object: _244.QueryTargetsResponseAminoMsg): _244.QueryTargetsResponse;
+                fromProtoMsg(message: _244.QueryTargetsResponseProtoMsg): _244.QueryTargetsResponse;
+                toProto(message: _244.QueryTargetsResponse): Uint8Array;
+                toProtoMsg(message: _244.QueryTargetsResponse): _244.QueryTargetsResponseProtoMsg;
+            };
             Params: {
                 typeUrl: string;
                 aminoType: string;
@@ -10767,6 +11287,7 @@ export declare namespace sparkdream {
                 memberReports(request?: _264.QueryMemberReportsRequest): Promise<_264.QueryMemberReportsResponse>;
                 memberWarnings(request: _264.QueryMemberWarningsRequest): Promise<_264.QueryMemberWarningsResponse>;
                 memberStanding(request: _264.QueryMemberStandingRequest): Promise<_264.QueryMemberStandingResponse>;
+                requiredInvitationStake(request: _264.QueryRequiredInvitationStakeRequest): Promise<_264.QueryRequiredInvitationStakeResponse>;
             };
             LCDQueryClient: typeof _516.LCDQueryClient;
             registry: ReadonlyArray<[string, import("..").TelescopeGeneratedType<any, any, any>]>;
@@ -11638,12 +12159,14 @@ export declare namespace sparkdream {
             };
             MsgInviteMember: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _271.MsgInviteMember, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _271.MsgInviteMember;
                 fromPartial(object: import("../helpers").DeepPartial<_271.MsgInviteMember>): _271.MsgInviteMember;
                 fromAmino(object: _271.MsgInviteMemberAmino): _271.MsgInviteMember;
                 toAmino(message: _271.MsgInviteMember): _271.MsgInviteMemberAmino;
                 fromAminoMsg(object: _271.MsgInviteMemberAminoMsg): _271.MsgInviteMember;
+                toAminoMsg(message: _271.MsgInviteMember): _271.MsgInviteMemberAminoMsg;
                 fromProtoMsg(message: _271.MsgInviteMemberProtoMsg): _271.MsgInviteMember;
                 toProto(message: _271.MsgInviteMember): Uint8Array;
                 toProtoMsg(message: _271.MsgInviteMember): _271.MsgInviteMemberProtoMsg;
@@ -11662,12 +12185,14 @@ export declare namespace sparkdream {
             };
             MsgAcceptInvitation: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _271.MsgAcceptInvitation, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _271.MsgAcceptInvitation;
                 fromPartial(object: import("../helpers").DeepPartial<_271.MsgAcceptInvitation>): _271.MsgAcceptInvitation;
                 fromAmino(object: _271.MsgAcceptInvitationAmino): _271.MsgAcceptInvitation;
                 toAmino(message: _271.MsgAcceptInvitation): _271.MsgAcceptInvitationAmino;
                 fromAminoMsg(object: _271.MsgAcceptInvitationAminoMsg): _271.MsgAcceptInvitation;
+                toAminoMsg(message: _271.MsgAcceptInvitation): _271.MsgAcceptInvitationAminoMsg;
                 fromProtoMsg(message: _271.MsgAcceptInvitationProtoMsg): _271.MsgAcceptInvitation;
                 toProto(message: _271.MsgAcceptInvitation): Uint8Array;
                 toProtoMsg(message: _271.MsgAcceptInvitation): _271.MsgAcceptInvitationProtoMsg;
@@ -11686,12 +12211,14 @@ export declare namespace sparkdream {
             };
             MsgTransferDream: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _271.MsgTransferDream, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _271.MsgTransferDream;
                 fromPartial(object: import("../helpers").DeepPartial<_271.MsgTransferDream>): _271.MsgTransferDream;
                 fromAmino(object: _271.MsgTransferDreamAmino): _271.MsgTransferDream;
                 toAmino(message: _271.MsgTransferDream): _271.MsgTransferDreamAmino;
                 fromAminoMsg(object: _271.MsgTransferDreamAminoMsg): _271.MsgTransferDream;
+                toAminoMsg(message: _271.MsgTransferDream): _271.MsgTransferDreamAminoMsg;
                 fromProtoMsg(message: _271.MsgTransferDreamProtoMsg): _271.MsgTransferDream;
                 toProto(message: _271.MsgTransferDream): Uint8Array;
                 toProtoMsg(message: _271.MsgTransferDream): _271.MsgTransferDreamProtoMsg;
@@ -11710,12 +12237,14 @@ export declare namespace sparkdream {
             };
             MsgCreateInterim: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _271.MsgCreateInterim, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _271.MsgCreateInterim;
                 fromPartial(object: import("../helpers").DeepPartial<_271.MsgCreateInterim>): _271.MsgCreateInterim;
                 fromAmino(object: _271.MsgCreateInterimAmino): _271.MsgCreateInterim;
                 toAmino(message: _271.MsgCreateInterim): _271.MsgCreateInterimAmino;
                 fromAminoMsg(object: _271.MsgCreateInterimAminoMsg): _271.MsgCreateInterim;
+                toAminoMsg(message: _271.MsgCreateInterim): _271.MsgCreateInterimAminoMsg;
                 fromProtoMsg(message: _271.MsgCreateInterimProtoMsg): _271.MsgCreateInterim;
                 toProto(message: _271.MsgCreateInterim): Uint8Array;
                 toProtoMsg(message: _271.MsgCreateInterim): _271.MsgCreateInterimProtoMsg;
@@ -11734,12 +12263,14 @@ export declare namespace sparkdream {
             };
             MsgAssignInterim: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _271.MsgAssignInterim, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _271.MsgAssignInterim;
                 fromPartial(object: import("../helpers").DeepPartial<_271.MsgAssignInterim>): _271.MsgAssignInterim;
                 fromAmino(object: _271.MsgAssignInterimAmino): _271.MsgAssignInterim;
                 toAmino(message: _271.MsgAssignInterim): _271.MsgAssignInterimAmino;
                 fromAminoMsg(object: _271.MsgAssignInterimAminoMsg): _271.MsgAssignInterim;
+                toAminoMsg(message: _271.MsgAssignInterim): _271.MsgAssignInterimAminoMsg;
                 fromProtoMsg(message: _271.MsgAssignInterimProtoMsg): _271.MsgAssignInterim;
                 toProto(message: _271.MsgAssignInterim): Uint8Array;
                 toProtoMsg(message: _271.MsgAssignInterim): _271.MsgAssignInterimProtoMsg;
@@ -11758,12 +12289,14 @@ export declare namespace sparkdream {
             };
             MsgSubmitInterimWork: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _271.MsgSubmitInterimWork, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _271.MsgSubmitInterimWork;
                 fromPartial(object: import("../helpers").DeepPartial<_271.MsgSubmitInterimWork>): _271.MsgSubmitInterimWork;
                 fromAmino(object: _271.MsgSubmitInterimWorkAmino): _271.MsgSubmitInterimWork;
                 toAmino(message: _271.MsgSubmitInterimWork): _271.MsgSubmitInterimWorkAmino;
                 fromAminoMsg(object: _271.MsgSubmitInterimWorkAminoMsg): _271.MsgSubmitInterimWork;
+                toAminoMsg(message: _271.MsgSubmitInterimWork): _271.MsgSubmitInterimWorkAminoMsg;
                 fromProtoMsg(message: _271.MsgSubmitInterimWorkProtoMsg): _271.MsgSubmitInterimWork;
                 toProto(message: _271.MsgSubmitInterimWork): Uint8Array;
                 toProtoMsg(message: _271.MsgSubmitInterimWork): _271.MsgSubmitInterimWorkProtoMsg;
@@ -11782,12 +12315,14 @@ export declare namespace sparkdream {
             };
             MsgApproveInterim: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _271.MsgApproveInterim, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _271.MsgApproveInterim;
                 fromPartial(object: import("../helpers").DeepPartial<_271.MsgApproveInterim>): _271.MsgApproveInterim;
                 fromAmino(object: _271.MsgApproveInterimAmino): _271.MsgApproveInterim;
                 toAmino(message: _271.MsgApproveInterim): _271.MsgApproveInterimAmino;
                 fromAminoMsg(object: _271.MsgApproveInterimAminoMsg): _271.MsgApproveInterim;
+                toAminoMsg(message: _271.MsgApproveInterim): _271.MsgApproveInterimAminoMsg;
                 fromProtoMsg(message: _271.MsgApproveInterimProtoMsg): _271.MsgApproveInterim;
                 toProto(message: _271.MsgApproveInterim): Uint8Array;
                 toProtoMsg(message: _271.MsgApproveInterim): _271.MsgApproveInterimProtoMsg;
@@ -11806,12 +12341,14 @@ export declare namespace sparkdream {
             };
             MsgAbandonInterim: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _271.MsgAbandonInterim, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _271.MsgAbandonInterim;
                 fromPartial(object: import("../helpers").DeepPartial<_271.MsgAbandonInterim>): _271.MsgAbandonInterim;
                 fromAmino(object: _271.MsgAbandonInterimAmino): _271.MsgAbandonInterim;
                 toAmino(message: _271.MsgAbandonInterim): _271.MsgAbandonInterimAmino;
                 fromAminoMsg(object: _271.MsgAbandonInterimAminoMsg): _271.MsgAbandonInterim;
+                toAminoMsg(message: _271.MsgAbandonInterim): _271.MsgAbandonInterimAminoMsg;
                 fromProtoMsg(message: _271.MsgAbandonInterimProtoMsg): _271.MsgAbandonInterim;
                 toProto(message: _271.MsgAbandonInterim): Uint8Array;
                 toProtoMsg(message: _271.MsgAbandonInterim): _271.MsgAbandonInterimProtoMsg;
@@ -11830,12 +12367,14 @@ export declare namespace sparkdream {
             };
             MsgCompleteInterim: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _271.MsgCompleteInterim, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _271.MsgCompleteInterim;
                 fromPartial(object: import("../helpers").DeepPartial<_271.MsgCompleteInterim>): _271.MsgCompleteInterim;
                 fromAmino(object: _271.MsgCompleteInterimAmino): _271.MsgCompleteInterim;
                 toAmino(message: _271.MsgCompleteInterim): _271.MsgCompleteInterimAmino;
                 fromAminoMsg(object: _271.MsgCompleteInterimAminoMsg): _271.MsgCompleteInterim;
+                toAminoMsg(message: _271.MsgCompleteInterim): _271.MsgCompleteInterimAminoMsg;
                 fromProtoMsg(message: _271.MsgCompleteInterimProtoMsg): _271.MsgCompleteInterim;
                 toProto(message: _271.MsgCompleteInterim): Uint8Array;
                 toProtoMsg(message: _271.MsgCompleteInterim): _271.MsgCompleteInterimProtoMsg;
@@ -11854,12 +12393,14 @@ export declare namespace sparkdream {
             };
             MsgProposeProject: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _271.MsgProposeProject, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _271.MsgProposeProject;
                 fromPartial(object: import("../helpers").DeepPartial<_271.MsgProposeProject>): _271.MsgProposeProject;
                 fromAmino(object: _271.MsgProposeProjectAmino): _271.MsgProposeProject;
                 toAmino(message: _271.MsgProposeProject): _271.MsgProposeProjectAmino;
                 fromAminoMsg(object: _271.MsgProposeProjectAminoMsg): _271.MsgProposeProject;
+                toAminoMsg(message: _271.MsgProposeProject): _271.MsgProposeProjectAminoMsg;
                 fromProtoMsg(message: _271.MsgProposeProjectProtoMsg): _271.MsgProposeProject;
                 toProto(message: _271.MsgProposeProject): Uint8Array;
                 toProtoMsg(message: _271.MsgProposeProject): _271.MsgProposeProjectProtoMsg;
@@ -11878,12 +12419,14 @@ export declare namespace sparkdream {
             };
             MsgApproveProjectBudget: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _271.MsgApproveProjectBudget, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _271.MsgApproveProjectBudget;
                 fromPartial(object: import("../helpers").DeepPartial<_271.MsgApproveProjectBudget>): _271.MsgApproveProjectBudget;
                 fromAmino(object: _271.MsgApproveProjectBudgetAmino): _271.MsgApproveProjectBudget;
                 toAmino(message: _271.MsgApproveProjectBudget): _271.MsgApproveProjectBudgetAmino;
                 fromAminoMsg(object: _271.MsgApproveProjectBudgetAminoMsg): _271.MsgApproveProjectBudget;
+                toAminoMsg(message: _271.MsgApproveProjectBudget): _271.MsgApproveProjectBudgetAminoMsg;
                 fromProtoMsg(message: _271.MsgApproveProjectBudgetProtoMsg): _271.MsgApproveProjectBudget;
                 toProto(message: _271.MsgApproveProjectBudget): Uint8Array;
                 toProtoMsg(message: _271.MsgApproveProjectBudget): _271.MsgApproveProjectBudgetProtoMsg;
@@ -11902,12 +12445,14 @@ export declare namespace sparkdream {
             };
             MsgCancelProject: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _271.MsgCancelProject, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _271.MsgCancelProject;
                 fromPartial(object: import("../helpers").DeepPartial<_271.MsgCancelProject>): _271.MsgCancelProject;
                 fromAmino(object: _271.MsgCancelProjectAmino): _271.MsgCancelProject;
                 toAmino(message: _271.MsgCancelProject): _271.MsgCancelProjectAmino;
                 fromAminoMsg(object: _271.MsgCancelProjectAminoMsg): _271.MsgCancelProject;
+                toAminoMsg(message: _271.MsgCancelProject): _271.MsgCancelProjectAminoMsg;
                 fromProtoMsg(message: _271.MsgCancelProjectProtoMsg): _271.MsgCancelProject;
                 toProto(message: _271.MsgCancelProject): Uint8Array;
                 toProtoMsg(message: _271.MsgCancelProject): _271.MsgCancelProjectProtoMsg;
@@ -11926,12 +12471,14 @@ export declare namespace sparkdream {
             };
             MsgCreateInitiative: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _271.MsgCreateInitiative, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _271.MsgCreateInitiative;
                 fromPartial(object: import("../helpers").DeepPartial<_271.MsgCreateInitiative>): _271.MsgCreateInitiative;
                 fromAmino(object: _271.MsgCreateInitiativeAmino): _271.MsgCreateInitiative;
                 toAmino(message: _271.MsgCreateInitiative): _271.MsgCreateInitiativeAmino;
                 fromAminoMsg(object: _271.MsgCreateInitiativeAminoMsg): _271.MsgCreateInitiative;
+                toAminoMsg(message: _271.MsgCreateInitiative): _271.MsgCreateInitiativeAminoMsg;
                 fromProtoMsg(message: _271.MsgCreateInitiativeProtoMsg): _271.MsgCreateInitiative;
                 toProto(message: _271.MsgCreateInitiative): Uint8Array;
                 toProtoMsg(message: _271.MsgCreateInitiative): _271.MsgCreateInitiativeProtoMsg;
@@ -11950,12 +12497,14 @@ export declare namespace sparkdream {
             };
             MsgAssignInitiative: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _271.MsgAssignInitiative, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _271.MsgAssignInitiative;
                 fromPartial(object: import("../helpers").DeepPartial<_271.MsgAssignInitiative>): _271.MsgAssignInitiative;
                 fromAmino(object: _271.MsgAssignInitiativeAmino): _271.MsgAssignInitiative;
                 toAmino(message: _271.MsgAssignInitiative): _271.MsgAssignInitiativeAmino;
                 fromAminoMsg(object: _271.MsgAssignInitiativeAminoMsg): _271.MsgAssignInitiative;
+                toAminoMsg(message: _271.MsgAssignInitiative): _271.MsgAssignInitiativeAminoMsg;
                 fromProtoMsg(message: _271.MsgAssignInitiativeProtoMsg): _271.MsgAssignInitiative;
                 toProto(message: _271.MsgAssignInitiative): Uint8Array;
                 toProtoMsg(message: _271.MsgAssignInitiative): _271.MsgAssignInitiativeProtoMsg;
@@ -11974,12 +12523,14 @@ export declare namespace sparkdream {
             };
             MsgSubmitInitiativeWork: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _271.MsgSubmitInitiativeWork, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _271.MsgSubmitInitiativeWork;
                 fromPartial(object: import("../helpers").DeepPartial<_271.MsgSubmitInitiativeWork>): _271.MsgSubmitInitiativeWork;
                 fromAmino(object: _271.MsgSubmitInitiativeWorkAmino): _271.MsgSubmitInitiativeWork;
                 toAmino(message: _271.MsgSubmitInitiativeWork): _271.MsgSubmitInitiativeWorkAmino;
                 fromAminoMsg(object: _271.MsgSubmitInitiativeWorkAminoMsg): _271.MsgSubmitInitiativeWork;
+                toAminoMsg(message: _271.MsgSubmitInitiativeWork): _271.MsgSubmitInitiativeWorkAminoMsg;
                 fromProtoMsg(message: _271.MsgSubmitInitiativeWorkProtoMsg): _271.MsgSubmitInitiativeWork;
                 toProto(message: _271.MsgSubmitInitiativeWork): Uint8Array;
                 toProtoMsg(message: _271.MsgSubmitInitiativeWork): _271.MsgSubmitInitiativeWorkProtoMsg;
@@ -11998,12 +12549,14 @@ export declare namespace sparkdream {
             };
             MsgApproveInitiative: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _271.MsgApproveInitiative, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _271.MsgApproveInitiative;
                 fromPartial(object: import("../helpers").DeepPartial<_271.MsgApproveInitiative>): _271.MsgApproveInitiative;
                 fromAmino(object: _271.MsgApproveInitiativeAmino): _271.MsgApproveInitiative;
                 toAmino(message: _271.MsgApproveInitiative): _271.MsgApproveInitiativeAmino;
                 fromAminoMsg(object: _271.MsgApproveInitiativeAminoMsg): _271.MsgApproveInitiative;
+                toAminoMsg(message: _271.MsgApproveInitiative): _271.MsgApproveInitiativeAminoMsg;
                 fromProtoMsg(message: _271.MsgApproveInitiativeProtoMsg): _271.MsgApproveInitiative;
                 toProto(message: _271.MsgApproveInitiative): Uint8Array;
                 toProtoMsg(message: _271.MsgApproveInitiative): _271.MsgApproveInitiativeProtoMsg;
@@ -12022,12 +12575,14 @@ export declare namespace sparkdream {
             };
             MsgAbandonInitiative: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _271.MsgAbandonInitiative, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _271.MsgAbandonInitiative;
                 fromPartial(object: import("../helpers").DeepPartial<_271.MsgAbandonInitiative>): _271.MsgAbandonInitiative;
                 fromAmino(object: _271.MsgAbandonInitiativeAmino): _271.MsgAbandonInitiative;
                 toAmino(message: _271.MsgAbandonInitiative): _271.MsgAbandonInitiativeAmino;
                 fromAminoMsg(object: _271.MsgAbandonInitiativeAminoMsg): _271.MsgAbandonInitiative;
+                toAminoMsg(message: _271.MsgAbandonInitiative): _271.MsgAbandonInitiativeAminoMsg;
                 fromProtoMsg(message: _271.MsgAbandonInitiativeProtoMsg): _271.MsgAbandonInitiative;
                 toProto(message: _271.MsgAbandonInitiative): Uint8Array;
                 toProtoMsg(message: _271.MsgAbandonInitiative): _271.MsgAbandonInitiativeProtoMsg;
@@ -12046,12 +12601,14 @@ export declare namespace sparkdream {
             };
             MsgCompleteInitiative: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _271.MsgCompleteInitiative, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _271.MsgCompleteInitiative;
                 fromPartial(object: import("../helpers").DeepPartial<_271.MsgCompleteInitiative>): _271.MsgCompleteInitiative;
                 fromAmino(object: _271.MsgCompleteInitiativeAmino): _271.MsgCompleteInitiative;
                 toAmino(message: _271.MsgCompleteInitiative): _271.MsgCompleteInitiativeAmino;
                 fromAminoMsg(object: _271.MsgCompleteInitiativeAminoMsg): _271.MsgCompleteInitiative;
+                toAminoMsg(message: _271.MsgCompleteInitiative): _271.MsgCompleteInitiativeAminoMsg;
                 fromProtoMsg(message: _271.MsgCompleteInitiativeProtoMsg): _271.MsgCompleteInitiative;
                 toProto(message: _271.MsgCompleteInitiative): Uint8Array;
                 toProtoMsg(message: _271.MsgCompleteInitiative): _271.MsgCompleteInitiativeProtoMsg;
@@ -12070,12 +12627,14 @@ export declare namespace sparkdream {
             };
             MsgStake: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _271.MsgStake, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _271.MsgStake;
                 fromPartial(object: import("../helpers").DeepPartial<_271.MsgStake>): _271.MsgStake;
                 fromAmino(object: _271.MsgStakeAmino): _271.MsgStake;
                 toAmino(message: _271.MsgStake): _271.MsgStakeAmino;
                 fromAminoMsg(object: _271.MsgStakeAminoMsg): _271.MsgStake;
+                toAminoMsg(message: _271.MsgStake): _271.MsgStakeAminoMsg;
                 fromProtoMsg(message: _271.MsgStakeProtoMsg): _271.MsgStake;
                 toProto(message: _271.MsgStake): Uint8Array;
                 toProtoMsg(message: _271.MsgStake): _271.MsgStakeProtoMsg;
@@ -12094,12 +12653,14 @@ export declare namespace sparkdream {
             };
             MsgUnstake: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _271.MsgUnstake, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _271.MsgUnstake;
                 fromPartial(object: import("../helpers").DeepPartial<_271.MsgUnstake>): _271.MsgUnstake;
                 fromAmino(object: _271.MsgUnstakeAmino): _271.MsgUnstake;
                 toAmino(message: _271.MsgUnstake): _271.MsgUnstakeAmino;
                 fromAminoMsg(object: _271.MsgUnstakeAminoMsg): _271.MsgUnstake;
+                toAminoMsg(message: _271.MsgUnstake): _271.MsgUnstakeAminoMsg;
                 fromProtoMsg(message: _271.MsgUnstakeProtoMsg): _271.MsgUnstake;
                 toProto(message: _271.MsgUnstake): Uint8Array;
                 toProtoMsg(message: _271.MsgUnstake): _271.MsgUnstakeProtoMsg;
@@ -12118,12 +12679,14 @@ export declare namespace sparkdream {
             };
             MsgClaimStakingRewards: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _271.MsgClaimStakingRewards, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _271.MsgClaimStakingRewards;
                 fromPartial(object: import("../helpers").DeepPartial<_271.MsgClaimStakingRewards>): _271.MsgClaimStakingRewards;
                 fromAmino(object: _271.MsgClaimStakingRewardsAmino): _271.MsgClaimStakingRewards;
                 toAmino(message: _271.MsgClaimStakingRewards): _271.MsgClaimStakingRewardsAmino;
                 fromAminoMsg(object: _271.MsgClaimStakingRewardsAminoMsg): _271.MsgClaimStakingRewards;
+                toAminoMsg(message: _271.MsgClaimStakingRewards): _271.MsgClaimStakingRewardsAminoMsg;
                 fromProtoMsg(message: _271.MsgClaimStakingRewardsProtoMsg): _271.MsgClaimStakingRewards;
                 toProto(message: _271.MsgClaimStakingRewards): Uint8Array;
                 toProtoMsg(message: _271.MsgClaimStakingRewards): _271.MsgClaimStakingRewardsProtoMsg;
@@ -12142,12 +12705,14 @@ export declare namespace sparkdream {
             };
             MsgCompoundStakingRewards: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _271.MsgCompoundStakingRewards, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _271.MsgCompoundStakingRewards;
                 fromPartial(object: import("../helpers").DeepPartial<_271.MsgCompoundStakingRewards>): _271.MsgCompoundStakingRewards;
                 fromAmino(object: _271.MsgCompoundStakingRewardsAmino): _271.MsgCompoundStakingRewards;
                 toAmino(message: _271.MsgCompoundStakingRewards): _271.MsgCompoundStakingRewardsAmino;
                 fromAminoMsg(object: _271.MsgCompoundStakingRewardsAminoMsg): _271.MsgCompoundStakingRewards;
+                toAminoMsg(message: _271.MsgCompoundStakingRewards): _271.MsgCompoundStakingRewardsAminoMsg;
                 fromProtoMsg(message: _271.MsgCompoundStakingRewardsProtoMsg): _271.MsgCompoundStakingRewards;
                 toProto(message: _271.MsgCompoundStakingRewards): Uint8Array;
                 toProtoMsg(message: _271.MsgCompoundStakingRewards): _271.MsgCompoundStakingRewardsProtoMsg;
@@ -12166,12 +12731,14 @@ export declare namespace sparkdream {
             };
             MsgCreateChallenge: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _271.MsgCreateChallenge, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _271.MsgCreateChallenge;
                 fromPartial(object: import("../helpers").DeepPartial<_271.MsgCreateChallenge>): _271.MsgCreateChallenge;
                 fromAmino(object: _271.MsgCreateChallengeAmino): _271.MsgCreateChallenge;
                 toAmino(message: _271.MsgCreateChallenge): _271.MsgCreateChallengeAmino;
                 fromAminoMsg(object: _271.MsgCreateChallengeAminoMsg): _271.MsgCreateChallenge;
+                toAminoMsg(message: _271.MsgCreateChallenge): _271.MsgCreateChallengeAminoMsg;
                 fromProtoMsg(message: _271.MsgCreateChallengeProtoMsg): _271.MsgCreateChallenge;
                 toProto(message: _271.MsgCreateChallenge): Uint8Array;
                 toProtoMsg(message: _271.MsgCreateChallenge): _271.MsgCreateChallengeProtoMsg;
@@ -12190,12 +12757,14 @@ export declare namespace sparkdream {
             };
             MsgRespondToChallenge: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _271.MsgRespondToChallenge, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _271.MsgRespondToChallenge;
                 fromPartial(object: import("../helpers").DeepPartial<_271.MsgRespondToChallenge>): _271.MsgRespondToChallenge;
                 fromAmino(object: _271.MsgRespondToChallengeAmino): _271.MsgRespondToChallenge;
                 toAmino(message: _271.MsgRespondToChallenge): _271.MsgRespondToChallengeAmino;
                 fromAminoMsg(object: _271.MsgRespondToChallengeAminoMsg): _271.MsgRespondToChallenge;
+                toAminoMsg(message: _271.MsgRespondToChallenge): _271.MsgRespondToChallengeAminoMsg;
                 fromProtoMsg(message: _271.MsgRespondToChallengeProtoMsg): _271.MsgRespondToChallenge;
                 toProto(message: _271.MsgRespondToChallenge): Uint8Array;
                 toProtoMsg(message: _271.MsgRespondToChallenge): _271.MsgRespondToChallengeProtoMsg;
@@ -12214,12 +12783,14 @@ export declare namespace sparkdream {
             };
             MsgSubmitJurorVote: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _271.MsgSubmitJurorVote, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _271.MsgSubmitJurorVote;
                 fromPartial(object: import("../helpers").DeepPartial<_271.MsgSubmitJurorVote>): _271.MsgSubmitJurorVote;
                 fromAmino(object: _271.MsgSubmitJurorVoteAmino): _271.MsgSubmitJurorVote;
                 toAmino(message: _271.MsgSubmitJurorVote): _271.MsgSubmitJurorVoteAmino;
                 fromAminoMsg(object: _271.MsgSubmitJurorVoteAminoMsg): _271.MsgSubmitJurorVote;
+                toAminoMsg(message: _271.MsgSubmitJurorVote): _271.MsgSubmitJurorVoteAminoMsg;
                 fromProtoMsg(message: _271.MsgSubmitJurorVoteProtoMsg): _271.MsgSubmitJurorVote;
                 toProto(message: _271.MsgSubmitJurorVote): Uint8Array;
                 toProtoMsg(message: _271.MsgSubmitJurorVote): _271.MsgSubmitJurorVoteProtoMsg;
@@ -12238,12 +12809,14 @@ export declare namespace sparkdream {
             };
             MsgSubmitExpertTestimony: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _271.MsgSubmitExpertTestimony, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _271.MsgSubmitExpertTestimony;
                 fromPartial(object: import("../helpers").DeepPartial<_271.MsgSubmitExpertTestimony>): _271.MsgSubmitExpertTestimony;
                 fromAmino(object: _271.MsgSubmitExpertTestimonyAmino): _271.MsgSubmitExpertTestimony;
                 toAmino(message: _271.MsgSubmitExpertTestimony): _271.MsgSubmitExpertTestimonyAmino;
                 fromAminoMsg(object: _271.MsgSubmitExpertTestimonyAminoMsg): _271.MsgSubmitExpertTestimony;
+                toAminoMsg(message: _271.MsgSubmitExpertTestimony): _271.MsgSubmitExpertTestimonyAminoMsg;
                 fromProtoMsg(message: _271.MsgSubmitExpertTestimonyProtoMsg): _271.MsgSubmitExpertTestimony;
                 toProto(message: _271.MsgSubmitExpertTestimony): Uint8Array;
                 toProtoMsg(message: _271.MsgSubmitExpertTestimony): _271.MsgSubmitExpertTestimonyProtoMsg;
@@ -12262,12 +12835,14 @@ export declare namespace sparkdream {
             };
             MsgChallengeContent: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _271.MsgChallengeContent, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _271.MsgChallengeContent;
                 fromPartial(object: import("../helpers").DeepPartial<_271.MsgChallengeContent>): _271.MsgChallengeContent;
                 fromAmino(object: _271.MsgChallengeContentAmino): _271.MsgChallengeContent;
                 toAmino(message: _271.MsgChallengeContent): _271.MsgChallengeContentAmino;
                 fromAminoMsg(object: _271.MsgChallengeContentAminoMsg): _271.MsgChallengeContent;
+                toAminoMsg(message: _271.MsgChallengeContent): _271.MsgChallengeContentAminoMsg;
                 fromProtoMsg(message: _271.MsgChallengeContentProtoMsg): _271.MsgChallengeContent;
                 toProto(message: _271.MsgChallengeContent): Uint8Array;
                 toProtoMsg(message: _271.MsgChallengeContent): _271.MsgChallengeContentProtoMsg;
@@ -12286,12 +12861,14 @@ export declare namespace sparkdream {
             };
             MsgRespondToContentChallenge: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _271.MsgRespondToContentChallenge, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _271.MsgRespondToContentChallenge;
                 fromPartial(object: import("../helpers").DeepPartial<_271.MsgRespondToContentChallenge>): _271.MsgRespondToContentChallenge;
                 fromAmino(object: _271.MsgRespondToContentChallengeAmino): _271.MsgRespondToContentChallenge;
                 toAmino(message: _271.MsgRespondToContentChallenge): _271.MsgRespondToContentChallengeAmino;
                 fromAminoMsg(object: _271.MsgRespondToContentChallengeAminoMsg): _271.MsgRespondToContentChallenge;
+                toAminoMsg(message: _271.MsgRespondToContentChallenge): _271.MsgRespondToContentChallengeAminoMsg;
                 fromProtoMsg(message: _271.MsgRespondToContentChallengeProtoMsg): _271.MsgRespondToContentChallenge;
                 toProto(message: _271.MsgRespondToContentChallenge): Uint8Array;
                 toProtoMsg(message: _271.MsgRespondToContentChallenge): _271.MsgRespondToContentChallengeProtoMsg;
@@ -12310,12 +12887,14 @@ export declare namespace sparkdream {
             };
             MsgRegisterZkPublicKey: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _271.MsgRegisterZkPublicKey, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _271.MsgRegisterZkPublicKey;
                 fromPartial(object: import("../helpers").DeepPartial<_271.MsgRegisterZkPublicKey>): _271.MsgRegisterZkPublicKey;
                 fromAmino(object: _271.MsgRegisterZkPublicKeyAmino): _271.MsgRegisterZkPublicKey;
                 toAmino(message: _271.MsgRegisterZkPublicKey): _271.MsgRegisterZkPublicKeyAmino;
                 fromAminoMsg(object: _271.MsgRegisterZkPublicKeyAminoMsg): _271.MsgRegisterZkPublicKey;
+                toAminoMsg(message: _271.MsgRegisterZkPublicKey): _271.MsgRegisterZkPublicKeyAminoMsg;
                 fromProtoMsg(message: _271.MsgRegisterZkPublicKeyProtoMsg): _271.MsgRegisterZkPublicKey;
                 toProto(message: _271.MsgRegisterZkPublicKey): Uint8Array;
                 toProtoMsg(message: _271.MsgRegisterZkPublicKey): _271.MsgRegisterZkPublicKeyProtoMsg;
@@ -12334,12 +12913,14 @@ export declare namespace sparkdream {
             };
             MsgCreateTag: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _271.MsgCreateTag, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _271.MsgCreateTag;
                 fromPartial(object: import("../helpers").DeepPartial<_271.MsgCreateTag>): _271.MsgCreateTag;
                 fromAmino(object: _271.MsgCreateTagAmino): _271.MsgCreateTag;
                 toAmino(message: _271.MsgCreateTag): _271.MsgCreateTagAmino;
                 fromAminoMsg(object: _271.MsgCreateTagAminoMsg): _271.MsgCreateTag;
+                toAminoMsg(message: _271.MsgCreateTag): _271.MsgCreateTagAminoMsg;
                 fromProtoMsg(message: _271.MsgCreateTagProtoMsg): _271.MsgCreateTag;
                 toProto(message: _271.MsgCreateTag): Uint8Array;
                 toProtoMsg(message: _271.MsgCreateTag): _271.MsgCreateTagProtoMsg;
@@ -12358,12 +12939,14 @@ export declare namespace sparkdream {
             };
             MsgReportTag: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _271.MsgReportTag, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _271.MsgReportTag;
                 fromPartial(object: import("../helpers").DeepPartial<_271.MsgReportTag>): _271.MsgReportTag;
                 fromAmino(object: _271.MsgReportTagAmino): _271.MsgReportTag;
                 toAmino(message: _271.MsgReportTag): _271.MsgReportTagAmino;
                 fromAminoMsg(object: _271.MsgReportTagAminoMsg): _271.MsgReportTag;
+                toAminoMsg(message: _271.MsgReportTag): _271.MsgReportTagAminoMsg;
                 fromProtoMsg(message: _271.MsgReportTagProtoMsg): _271.MsgReportTag;
                 toProto(message: _271.MsgReportTag): Uint8Array;
                 toProtoMsg(message: _271.MsgReportTag): _271.MsgReportTagProtoMsg;
@@ -12382,12 +12965,14 @@ export declare namespace sparkdream {
             };
             MsgResolveTagReport: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _271.MsgResolveTagReport, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _271.MsgResolveTagReport;
                 fromPartial(object: import("../helpers").DeepPartial<_271.MsgResolveTagReport>): _271.MsgResolveTagReport;
                 fromAmino(object: _271.MsgResolveTagReportAmino): _271.MsgResolveTagReport;
                 toAmino(message: _271.MsgResolveTagReport): _271.MsgResolveTagReportAmino;
                 fromAminoMsg(object: _271.MsgResolveTagReportAminoMsg): _271.MsgResolveTagReport;
+                toAminoMsg(message: _271.MsgResolveTagReport): _271.MsgResolveTagReportAminoMsg;
                 fromProtoMsg(message: _271.MsgResolveTagReportProtoMsg): _271.MsgResolveTagReport;
                 toProto(message: _271.MsgResolveTagReport): Uint8Array;
                 toProtoMsg(message: _271.MsgResolveTagReport): _271.MsgResolveTagReportProtoMsg;
@@ -12406,12 +12991,14 @@ export declare namespace sparkdream {
             };
             MsgCreateTagBudget: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _271.MsgCreateTagBudget, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _271.MsgCreateTagBudget;
                 fromPartial(object: import("../helpers").DeepPartial<_271.MsgCreateTagBudget>): _271.MsgCreateTagBudget;
                 fromAmino(object: _271.MsgCreateTagBudgetAmino): _271.MsgCreateTagBudget;
                 toAmino(message: _271.MsgCreateTagBudget): _271.MsgCreateTagBudgetAmino;
                 fromAminoMsg(object: _271.MsgCreateTagBudgetAminoMsg): _271.MsgCreateTagBudget;
+                toAminoMsg(message: _271.MsgCreateTagBudget): _271.MsgCreateTagBudgetAminoMsg;
                 fromProtoMsg(message: _271.MsgCreateTagBudgetProtoMsg): _271.MsgCreateTagBudget;
                 toProto(message: _271.MsgCreateTagBudget): Uint8Array;
                 toProtoMsg(message: _271.MsgCreateTagBudget): _271.MsgCreateTagBudgetProtoMsg;
@@ -12430,12 +13017,14 @@ export declare namespace sparkdream {
             };
             MsgAwardFromTagBudget: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _271.MsgAwardFromTagBudget, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _271.MsgAwardFromTagBudget;
                 fromPartial(object: import("../helpers").DeepPartial<_271.MsgAwardFromTagBudget>): _271.MsgAwardFromTagBudget;
                 fromAmino(object: _271.MsgAwardFromTagBudgetAmino): _271.MsgAwardFromTagBudget;
                 toAmino(message: _271.MsgAwardFromTagBudget): _271.MsgAwardFromTagBudgetAmino;
                 fromAminoMsg(object: _271.MsgAwardFromTagBudgetAminoMsg): _271.MsgAwardFromTagBudget;
+                toAminoMsg(message: _271.MsgAwardFromTagBudget): _271.MsgAwardFromTagBudgetAminoMsg;
                 fromProtoMsg(message: _271.MsgAwardFromTagBudgetProtoMsg): _271.MsgAwardFromTagBudget;
                 toProto(message: _271.MsgAwardFromTagBudget): Uint8Array;
                 toProtoMsg(message: _271.MsgAwardFromTagBudget): _271.MsgAwardFromTagBudgetProtoMsg;
@@ -12454,12 +13043,14 @@ export declare namespace sparkdream {
             };
             MsgTopUpTagBudget: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _271.MsgTopUpTagBudget, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _271.MsgTopUpTagBudget;
                 fromPartial(object: import("../helpers").DeepPartial<_271.MsgTopUpTagBudget>): _271.MsgTopUpTagBudget;
                 fromAmino(object: _271.MsgTopUpTagBudgetAmino): _271.MsgTopUpTagBudget;
                 toAmino(message: _271.MsgTopUpTagBudget): _271.MsgTopUpTagBudgetAmino;
                 fromAminoMsg(object: _271.MsgTopUpTagBudgetAminoMsg): _271.MsgTopUpTagBudget;
+                toAminoMsg(message: _271.MsgTopUpTagBudget): _271.MsgTopUpTagBudgetAminoMsg;
                 fromProtoMsg(message: _271.MsgTopUpTagBudgetProtoMsg): _271.MsgTopUpTagBudget;
                 toProto(message: _271.MsgTopUpTagBudget): Uint8Array;
                 toProtoMsg(message: _271.MsgTopUpTagBudget): _271.MsgTopUpTagBudgetProtoMsg;
@@ -12478,12 +13069,14 @@ export declare namespace sparkdream {
             };
             MsgToggleTagBudget: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _271.MsgToggleTagBudget, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _271.MsgToggleTagBudget;
                 fromPartial(object: import("../helpers").DeepPartial<_271.MsgToggleTagBudget>): _271.MsgToggleTagBudget;
                 fromAmino(object: _271.MsgToggleTagBudgetAmino): _271.MsgToggleTagBudget;
                 toAmino(message: _271.MsgToggleTagBudget): _271.MsgToggleTagBudgetAmino;
                 fromAminoMsg(object: _271.MsgToggleTagBudgetAminoMsg): _271.MsgToggleTagBudget;
+                toAminoMsg(message: _271.MsgToggleTagBudget): _271.MsgToggleTagBudgetAminoMsg;
                 fromProtoMsg(message: _271.MsgToggleTagBudgetProtoMsg): _271.MsgToggleTagBudget;
                 toProto(message: _271.MsgToggleTagBudget): Uint8Array;
                 toProtoMsg(message: _271.MsgToggleTagBudget): _271.MsgToggleTagBudgetProtoMsg;
@@ -12502,12 +13095,14 @@ export declare namespace sparkdream {
             };
             MsgWithdrawTagBudget: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _271.MsgWithdrawTagBudget, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _271.MsgWithdrawTagBudget;
                 fromPartial(object: import("../helpers").DeepPartial<_271.MsgWithdrawTagBudget>): _271.MsgWithdrawTagBudget;
                 fromAmino(object: _271.MsgWithdrawTagBudgetAmino): _271.MsgWithdrawTagBudget;
                 toAmino(message: _271.MsgWithdrawTagBudget): _271.MsgWithdrawTagBudgetAmino;
                 fromAminoMsg(object: _271.MsgWithdrawTagBudgetAminoMsg): _271.MsgWithdrawTagBudget;
+                toAminoMsg(message: _271.MsgWithdrawTagBudget): _271.MsgWithdrawTagBudgetAminoMsg;
                 fromProtoMsg(message: _271.MsgWithdrawTagBudgetProtoMsg): _271.MsgWithdrawTagBudget;
                 toProto(message: _271.MsgWithdrawTagBudget): Uint8Array;
                 toProtoMsg(message: _271.MsgWithdrawTagBudget): _271.MsgWithdrawTagBudgetProtoMsg;
@@ -12526,12 +13121,14 @@ export declare namespace sparkdream {
             };
             MsgBondRole: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _271.MsgBondRole, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _271.MsgBondRole;
                 fromPartial(object: import("../helpers").DeepPartial<_271.MsgBondRole>): _271.MsgBondRole;
                 fromAmino(object: _271.MsgBondRoleAmino): _271.MsgBondRole;
                 toAmino(message: _271.MsgBondRole): _271.MsgBondRoleAmino;
                 fromAminoMsg(object: _271.MsgBondRoleAminoMsg): _271.MsgBondRole;
+                toAminoMsg(message: _271.MsgBondRole): _271.MsgBondRoleAminoMsg;
                 fromProtoMsg(message: _271.MsgBondRoleProtoMsg): _271.MsgBondRole;
                 toProto(message: _271.MsgBondRole): Uint8Array;
                 toProtoMsg(message: _271.MsgBondRole): _271.MsgBondRoleProtoMsg;
@@ -12550,12 +13147,14 @@ export declare namespace sparkdream {
             };
             MsgUnbondRole: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _271.MsgUnbondRole, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _271.MsgUnbondRole;
                 fromPartial(object: import("../helpers").DeepPartial<_271.MsgUnbondRole>): _271.MsgUnbondRole;
                 fromAmino(object: _271.MsgUnbondRoleAmino): _271.MsgUnbondRole;
                 toAmino(message: _271.MsgUnbondRole): _271.MsgUnbondRoleAmino;
                 fromAminoMsg(object: _271.MsgUnbondRoleAminoMsg): _271.MsgUnbondRole;
+                toAminoMsg(message: _271.MsgUnbondRole): _271.MsgUnbondRoleAminoMsg;
                 fromProtoMsg(message: _271.MsgUnbondRoleProtoMsg): _271.MsgUnbondRole;
                 toProto(message: _271.MsgUnbondRole): Uint8Array;
                 toProtoMsg(message: _271.MsgUnbondRole): _271.MsgUnbondRoleProtoMsg;
@@ -12574,12 +13173,14 @@ export declare namespace sparkdream {
             };
             MsgReportMember: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _271.MsgReportMember, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _271.MsgReportMember;
                 fromPartial(object: import("../helpers").DeepPartial<_271.MsgReportMember>): _271.MsgReportMember;
                 fromAmino(object: _271.MsgReportMemberAmino): _271.MsgReportMember;
                 toAmino(message: _271.MsgReportMember): _271.MsgReportMemberAmino;
                 fromAminoMsg(object: _271.MsgReportMemberAminoMsg): _271.MsgReportMember;
+                toAminoMsg(message: _271.MsgReportMember): _271.MsgReportMemberAminoMsg;
                 fromProtoMsg(message: _271.MsgReportMemberProtoMsg): _271.MsgReportMember;
                 toProto(message: _271.MsgReportMember): Uint8Array;
                 toProtoMsg(message: _271.MsgReportMember): _271.MsgReportMemberProtoMsg;
@@ -12598,12 +13199,14 @@ export declare namespace sparkdream {
             };
             MsgCosignMemberReport: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _271.MsgCosignMemberReport, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _271.MsgCosignMemberReport;
                 fromPartial(object: import("../helpers").DeepPartial<_271.MsgCosignMemberReport>): _271.MsgCosignMemberReport;
                 fromAmino(object: _271.MsgCosignMemberReportAmino): _271.MsgCosignMemberReport;
                 toAmino(message: _271.MsgCosignMemberReport): _271.MsgCosignMemberReportAmino;
                 fromAminoMsg(object: _271.MsgCosignMemberReportAminoMsg): _271.MsgCosignMemberReport;
+                toAminoMsg(message: _271.MsgCosignMemberReport): _271.MsgCosignMemberReportAminoMsg;
                 fromProtoMsg(message: _271.MsgCosignMemberReportProtoMsg): _271.MsgCosignMemberReport;
                 toProto(message: _271.MsgCosignMemberReport): Uint8Array;
                 toProtoMsg(message: _271.MsgCosignMemberReport): _271.MsgCosignMemberReportProtoMsg;
@@ -12622,12 +13225,14 @@ export declare namespace sparkdream {
             };
             MsgResolveMemberReport: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _271.MsgResolveMemberReport, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _271.MsgResolveMemberReport;
                 fromPartial(object: import("../helpers").DeepPartial<_271.MsgResolveMemberReport>): _271.MsgResolveMemberReport;
                 fromAmino(object: _271.MsgResolveMemberReportAmino): _271.MsgResolveMemberReport;
                 toAmino(message: _271.MsgResolveMemberReport): _271.MsgResolveMemberReportAmino;
                 fromAminoMsg(object: _271.MsgResolveMemberReportAminoMsg): _271.MsgResolveMemberReport;
+                toAminoMsg(message: _271.MsgResolveMemberReport): _271.MsgResolveMemberReportAminoMsg;
                 fromProtoMsg(message: _271.MsgResolveMemberReportProtoMsg): _271.MsgResolveMemberReport;
                 toProto(message: _271.MsgResolveMemberReport): Uint8Array;
                 toProtoMsg(message: _271.MsgResolveMemberReport): _271.MsgResolveMemberReportProtoMsg;
@@ -12646,12 +13251,14 @@ export declare namespace sparkdream {
             };
             MsgDefendMemberReport: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _271.MsgDefendMemberReport, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _271.MsgDefendMemberReport;
                 fromPartial(object: import("../helpers").DeepPartial<_271.MsgDefendMemberReport>): _271.MsgDefendMemberReport;
                 fromAmino(object: _271.MsgDefendMemberReportAmino): _271.MsgDefendMemberReport;
                 toAmino(message: _271.MsgDefendMemberReport): _271.MsgDefendMemberReportAmino;
                 fromAminoMsg(object: _271.MsgDefendMemberReportAminoMsg): _271.MsgDefendMemberReport;
+                toAminoMsg(message: _271.MsgDefendMemberReport): _271.MsgDefendMemberReportAminoMsg;
                 fromProtoMsg(message: _271.MsgDefendMemberReportProtoMsg): _271.MsgDefendMemberReport;
                 toProto(message: _271.MsgDefendMemberReport): Uint8Array;
                 toProtoMsg(message: _271.MsgDefendMemberReport): _271.MsgDefendMemberReportProtoMsg;
@@ -12670,12 +13277,14 @@ export declare namespace sparkdream {
             };
             MsgAppealGovAction: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _271.MsgAppealGovAction, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _271.MsgAppealGovAction;
                 fromPartial(object: import("../helpers").DeepPartial<_271.MsgAppealGovAction>): _271.MsgAppealGovAction;
                 fromAmino(object: _271.MsgAppealGovActionAmino): _271.MsgAppealGovAction;
                 toAmino(message: _271.MsgAppealGovAction): _271.MsgAppealGovActionAmino;
                 fromAminoMsg(object: _271.MsgAppealGovActionAminoMsg): _271.MsgAppealGovAction;
+                toAminoMsg(message: _271.MsgAppealGovAction): _271.MsgAppealGovActionAminoMsg;
                 fromProtoMsg(message: _271.MsgAppealGovActionProtoMsg): _271.MsgAppealGovAction;
                 toProto(message: _271.MsgAppealGovAction): Uint8Array;
                 toProtoMsg(message: _271.MsgAppealGovAction): _271.MsgAppealGovActionProtoMsg;
@@ -12694,12 +13303,14 @@ export declare namespace sparkdream {
             };
             MsgResolveGovActionAppeal: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _271.MsgResolveGovActionAppeal, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _271.MsgResolveGovActionAppeal;
                 fromPartial(object: import("../helpers").DeepPartial<_271.MsgResolveGovActionAppeal>): _271.MsgResolveGovActionAppeal;
                 fromAmino(object: _271.MsgResolveGovActionAppealAmino): _271.MsgResolveGovActionAppeal;
                 toAmino(message: _271.MsgResolveGovActionAppeal): _271.MsgResolveGovActionAppealAmino;
                 fromAminoMsg(object: _271.MsgResolveGovActionAppealAminoMsg): _271.MsgResolveGovActionAppeal;
+                toAminoMsg(message: _271.MsgResolveGovActionAppeal): _271.MsgResolveGovActionAppealAminoMsg;
                 fromProtoMsg(message: _271.MsgResolveGovActionAppealProtoMsg): _271.MsgResolveGovActionAppeal;
                 toProto(message: _271.MsgResolveGovActionAppeal): Uint8Array;
                 toProtoMsg(message: _271.MsgResolveGovActionAppeal): _271.MsgResolveGovActionAppealProtoMsg;
@@ -14688,6 +15299,30 @@ export declare namespace sparkdream {
                 toProto(message: _264.QueryMemberStandingResponse): Uint8Array;
                 toProtoMsg(message: _264.QueryMemberStandingResponse): _264.QueryMemberStandingResponseProtoMsg;
             };
+            QueryRequiredInvitationStakeRequest: {
+                typeUrl: string;
+                encode(message: _264.QueryRequiredInvitationStakeRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _264.QueryRequiredInvitationStakeRequest;
+                fromPartial(object: import("../helpers").DeepPartial<_264.QueryRequiredInvitationStakeRequest>): _264.QueryRequiredInvitationStakeRequest;
+                fromAmino(object: _264.QueryRequiredInvitationStakeRequestAmino): _264.QueryRequiredInvitationStakeRequest;
+                toAmino(message: _264.QueryRequiredInvitationStakeRequest): _264.QueryRequiredInvitationStakeRequestAmino;
+                fromAminoMsg(object: _264.QueryRequiredInvitationStakeRequestAminoMsg): _264.QueryRequiredInvitationStakeRequest;
+                fromProtoMsg(message: _264.QueryRequiredInvitationStakeRequestProtoMsg): _264.QueryRequiredInvitationStakeRequest;
+                toProto(message: _264.QueryRequiredInvitationStakeRequest): Uint8Array;
+                toProtoMsg(message: _264.QueryRequiredInvitationStakeRequest): _264.QueryRequiredInvitationStakeRequestProtoMsg;
+            };
+            QueryRequiredInvitationStakeResponse: {
+                typeUrl: string;
+                encode(message: _264.QueryRequiredInvitationStakeResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _264.QueryRequiredInvitationStakeResponse;
+                fromPartial(object: import("../helpers").DeepPartial<_264.QueryRequiredInvitationStakeResponse>): _264.QueryRequiredInvitationStakeResponse;
+                fromAmino(object: _264.QueryRequiredInvitationStakeResponseAmino): _264.QueryRequiredInvitationStakeResponse;
+                toAmino(message: _264.QueryRequiredInvitationStakeResponse): _264.QueryRequiredInvitationStakeResponseAmino;
+                fromAminoMsg(object: _264.QueryRequiredInvitationStakeResponseAminoMsg): _264.QueryRequiredInvitationStakeResponse;
+                fromProtoMsg(message: _264.QueryRequiredInvitationStakeResponseProtoMsg): _264.QueryRequiredInvitationStakeResponse;
+                toProto(message: _264.QueryRequiredInvitationStakeResponse): Uint8Array;
+                toProtoMsg(message: _264.QueryRequiredInvitationStakeResponse): _264.QueryRequiredInvitationStakeResponseProtoMsg;
+            };
             projectCategoryFromJSON(object: any): _263.ProjectCategory;
             projectCategoryToJSON(object: _263.ProjectCategory): string;
             projectStatusFromJSON(object: any): _263.ProjectStatus;
@@ -15461,12 +16096,14 @@ export declare namespace sparkdream {
             };
             MsgPropose: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _276.MsgPropose, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _276.MsgPropose;
                 fromPartial(object: import("../helpers").DeepPartial<_276.MsgPropose>): _276.MsgPropose;
                 fromAmino(object: _276.MsgProposeAmino): _276.MsgPropose;
                 toAmino(message: _276.MsgPropose): _276.MsgProposeAmino;
                 fromAminoMsg(object: _276.MsgProposeAminoMsg): _276.MsgPropose;
+                toAminoMsg(message: _276.MsgPropose): _276.MsgProposeAminoMsg;
                 fromProtoMsg(message: _276.MsgProposeProtoMsg): _276.MsgPropose;
                 toProto(message: _276.MsgPropose): Uint8Array;
                 toProtoMsg(message: _276.MsgPropose): _276.MsgProposeProtoMsg;
@@ -15485,12 +16122,14 @@ export declare namespace sparkdream {
             };
             MsgApprove: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _276.MsgApprove, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _276.MsgApprove;
                 fromPartial(object: import("../helpers").DeepPartial<_276.MsgApprove>): _276.MsgApprove;
                 fromAmino(object: _276.MsgApproveAmino): _276.MsgApprove;
                 toAmino(message: _276.MsgApprove): _276.MsgApproveAmino;
                 fromAminoMsg(object: _276.MsgApproveAminoMsg): _276.MsgApprove;
+                toAminoMsg(message: _276.MsgApprove): _276.MsgApproveAminoMsg;
                 fromProtoMsg(message: _276.MsgApproveProtoMsg): _276.MsgApprove;
                 toProto(message: _276.MsgApprove): Uint8Array;
                 toProtoMsg(message: _276.MsgApprove): _276.MsgApproveProtoMsg;
@@ -15509,12 +16148,14 @@ export declare namespace sparkdream {
             };
             MsgReject: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _276.MsgReject, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _276.MsgReject;
                 fromPartial(object: import("../helpers").DeepPartial<_276.MsgReject>): _276.MsgReject;
                 fromAmino(object: _276.MsgRejectAmino): _276.MsgReject;
                 toAmino(message: _276.MsgReject): _276.MsgRejectAmino;
                 fromAminoMsg(object: _276.MsgRejectAminoMsg): _276.MsgReject;
+                toAminoMsg(message: _276.MsgReject): _276.MsgRejectAminoMsg;
                 fromProtoMsg(message: _276.MsgRejectProtoMsg): _276.MsgReject;
                 toProto(message: _276.MsgReject): Uint8Array;
                 toProtoMsg(message: _276.MsgReject): _276.MsgRejectProtoMsg;
@@ -15533,12 +16174,14 @@ export declare namespace sparkdream {
             };
             MsgStake: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _276.MsgStake, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _276.MsgStake;
                 fromPartial(object: import("../helpers").DeepPartial<_276.MsgStake>): _276.MsgStake;
                 fromAmino(object: _276.MsgStakeAmino): _276.MsgStake;
                 toAmino(message: _276.MsgStake): _276.MsgStakeAmino;
                 fromAminoMsg(object: _276.MsgStakeAminoMsg): _276.MsgStake;
+                toAminoMsg(message: _276.MsgStake): _276.MsgStakeAminoMsg;
                 fromProtoMsg(message: _276.MsgStakeProtoMsg): _276.MsgStake;
                 toProto(message: _276.MsgStake): Uint8Array;
                 toProtoMsg(message: _276.MsgStake): _276.MsgStakeProtoMsg;
@@ -15557,12 +16200,14 @@ export declare namespace sparkdream {
             };
             MsgWithdraw: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _276.MsgWithdraw, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _276.MsgWithdraw;
                 fromPartial(object: import("../helpers").DeepPartial<_276.MsgWithdraw>): _276.MsgWithdraw;
                 fromAmino(object: _276.MsgWithdrawAmino): _276.MsgWithdraw;
                 toAmino(message: _276.MsgWithdraw): _276.MsgWithdrawAmino;
                 fromAminoMsg(object: _276.MsgWithdrawAminoMsg): _276.MsgWithdraw;
+                toAminoMsg(message: _276.MsgWithdraw): _276.MsgWithdrawAminoMsg;
                 fromProtoMsg(message: _276.MsgWithdrawProtoMsg): _276.MsgWithdraw;
                 toProto(message: _276.MsgWithdraw): Uint8Array;
                 toProtoMsg(message: _276.MsgWithdraw): _276.MsgWithdrawProtoMsg;
@@ -15581,12 +16226,14 @@ export declare namespace sparkdream {
             };
             MsgReveal: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _276.MsgReveal, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _276.MsgReveal;
                 fromPartial(object: import("../helpers").DeepPartial<_276.MsgReveal>): _276.MsgReveal;
                 fromAmino(object: _276.MsgRevealAmino): _276.MsgReveal;
                 toAmino(message: _276.MsgReveal): _276.MsgRevealAmino;
                 fromAminoMsg(object: _276.MsgRevealAminoMsg): _276.MsgReveal;
+                toAminoMsg(message: _276.MsgReveal): _276.MsgRevealAminoMsg;
                 fromProtoMsg(message: _276.MsgRevealProtoMsg): _276.MsgReveal;
                 toProto(message: _276.MsgReveal): Uint8Array;
                 toProtoMsg(message: _276.MsgReveal): _276.MsgRevealProtoMsg;
@@ -15605,12 +16252,14 @@ export declare namespace sparkdream {
             };
             MsgVerify: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _276.MsgVerify, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _276.MsgVerify;
                 fromPartial(object: import("../helpers").DeepPartial<_276.MsgVerify>): _276.MsgVerify;
                 fromAmino(object: _276.MsgVerifyAmino): _276.MsgVerify;
                 toAmino(message: _276.MsgVerify): _276.MsgVerifyAmino;
                 fromAminoMsg(object: _276.MsgVerifyAminoMsg): _276.MsgVerify;
+                toAminoMsg(message: _276.MsgVerify): _276.MsgVerifyAminoMsg;
                 fromProtoMsg(message: _276.MsgVerifyProtoMsg): _276.MsgVerify;
                 toProto(message: _276.MsgVerify): Uint8Array;
                 toProtoMsg(message: _276.MsgVerify): _276.MsgVerifyProtoMsg;
@@ -15629,12 +16278,14 @@ export declare namespace sparkdream {
             };
             MsgCancel: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _276.MsgCancel, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _276.MsgCancel;
                 fromPartial(object: import("../helpers").DeepPartial<_276.MsgCancel>): _276.MsgCancel;
                 fromAmino(object: _276.MsgCancelAmino): _276.MsgCancel;
                 toAmino(message: _276.MsgCancel): _276.MsgCancelAmino;
                 fromAminoMsg(object: _276.MsgCancelAminoMsg): _276.MsgCancel;
+                toAminoMsg(message: _276.MsgCancel): _276.MsgCancelAminoMsg;
                 fromProtoMsg(message: _276.MsgCancelProtoMsg): _276.MsgCancel;
                 toProto(message: _276.MsgCancel): Uint8Array;
                 toProtoMsg(message: _276.MsgCancel): _276.MsgCancelProtoMsg;
@@ -15653,12 +16304,14 @@ export declare namespace sparkdream {
             };
             MsgResolveDispute: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _276.MsgResolveDispute, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _276.MsgResolveDispute;
                 fromPartial(object: import("../helpers").DeepPartial<_276.MsgResolveDispute>): _276.MsgResolveDispute;
                 fromAmino(object: _276.MsgResolveDisputeAmino): _276.MsgResolveDispute;
                 toAmino(message: _276.MsgResolveDispute): _276.MsgResolveDisputeAmino;
                 fromAminoMsg(object: _276.MsgResolveDisputeAminoMsg): _276.MsgResolveDispute;
+                toAminoMsg(message: _276.MsgResolveDispute): _276.MsgResolveDisputeAminoMsg;
                 fromProtoMsg(message: _276.MsgResolveDisputeProtoMsg): _276.MsgResolveDispute;
                 toProto(message: _276.MsgResolveDispute): Uint8Array;
                 toProtoMsg(message: _276.MsgResolveDispute): _276.MsgResolveDisputeProtoMsg;
@@ -16868,12 +17521,14 @@ export declare namespace sparkdream {
             };
             MsgSetDisplayName: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _305.MsgSetDisplayName, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _305.MsgSetDisplayName;
                 fromPartial(object: import("../helpers").DeepPartial<_305.MsgSetDisplayName>): _305.MsgSetDisplayName;
                 fromAmino(object: _305.MsgSetDisplayNameAmino): _305.MsgSetDisplayName;
                 toAmino(message: _305.MsgSetDisplayName): _305.MsgSetDisplayNameAmino;
                 fromAminoMsg(object: _305.MsgSetDisplayNameAminoMsg): _305.MsgSetDisplayName;
+                toAminoMsg(message: _305.MsgSetDisplayName): _305.MsgSetDisplayNameAminoMsg;
                 fromProtoMsg(message: _305.MsgSetDisplayNameProtoMsg): _305.MsgSetDisplayName;
                 toProto(message: _305.MsgSetDisplayName): Uint8Array;
                 toProtoMsg(message: _305.MsgSetDisplayName): _305.MsgSetDisplayNameProtoMsg;
@@ -16892,12 +17547,14 @@ export declare namespace sparkdream {
             };
             MsgSetUsername: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _305.MsgSetUsername, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _305.MsgSetUsername;
                 fromPartial(object: import("../helpers").DeepPartial<_305.MsgSetUsername>): _305.MsgSetUsername;
                 fromAmino(object: _305.MsgSetUsernameAmino): _305.MsgSetUsername;
                 toAmino(message: _305.MsgSetUsername): _305.MsgSetUsernameAmino;
                 fromAminoMsg(object: _305.MsgSetUsernameAminoMsg): _305.MsgSetUsername;
+                toAminoMsg(message: _305.MsgSetUsername): _305.MsgSetUsernameAminoMsg;
                 fromProtoMsg(message: _305.MsgSetUsernameProtoMsg): _305.MsgSetUsername;
                 toProto(message: _305.MsgSetUsername): Uint8Array;
                 toProtoMsg(message: _305.MsgSetUsername): _305.MsgSetUsernameProtoMsg;
@@ -16916,12 +17573,14 @@ export declare namespace sparkdream {
             };
             MsgSetDisplayTitle: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _305.MsgSetDisplayTitle, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _305.MsgSetDisplayTitle;
                 fromPartial(object: import("../helpers").DeepPartial<_305.MsgSetDisplayTitle>): _305.MsgSetDisplayTitle;
                 fromAmino(object: _305.MsgSetDisplayTitleAmino): _305.MsgSetDisplayTitle;
                 toAmino(message: _305.MsgSetDisplayTitle): _305.MsgSetDisplayTitleAmino;
                 fromAminoMsg(object: _305.MsgSetDisplayTitleAminoMsg): _305.MsgSetDisplayTitle;
+                toAminoMsg(message: _305.MsgSetDisplayTitle): _305.MsgSetDisplayTitleAminoMsg;
                 fromProtoMsg(message: _305.MsgSetDisplayTitleProtoMsg): _305.MsgSetDisplayTitle;
                 toProto(message: _305.MsgSetDisplayTitle): Uint8Array;
                 toProtoMsg(message: _305.MsgSetDisplayTitle): _305.MsgSetDisplayTitleProtoMsg;
@@ -16940,12 +17599,14 @@ export declare namespace sparkdream {
             };
             MsgCreateGuild: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _305.MsgCreateGuild, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _305.MsgCreateGuild;
                 fromPartial(object: import("../helpers").DeepPartial<_305.MsgCreateGuild>): _305.MsgCreateGuild;
                 fromAmino(object: _305.MsgCreateGuildAmino): _305.MsgCreateGuild;
                 toAmino(message: _305.MsgCreateGuild): _305.MsgCreateGuildAmino;
                 fromAminoMsg(object: _305.MsgCreateGuildAminoMsg): _305.MsgCreateGuild;
+                toAminoMsg(message: _305.MsgCreateGuild): _305.MsgCreateGuildAminoMsg;
                 fromProtoMsg(message: _305.MsgCreateGuildProtoMsg): _305.MsgCreateGuild;
                 toProto(message: _305.MsgCreateGuild): Uint8Array;
                 toProtoMsg(message: _305.MsgCreateGuild): _305.MsgCreateGuildProtoMsg;
@@ -16964,12 +17625,14 @@ export declare namespace sparkdream {
             };
             MsgJoinGuild: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _305.MsgJoinGuild, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _305.MsgJoinGuild;
                 fromPartial(object: import("../helpers").DeepPartial<_305.MsgJoinGuild>): _305.MsgJoinGuild;
                 fromAmino(object: _305.MsgJoinGuildAmino): _305.MsgJoinGuild;
                 toAmino(message: _305.MsgJoinGuild): _305.MsgJoinGuildAmino;
                 fromAminoMsg(object: _305.MsgJoinGuildAminoMsg): _305.MsgJoinGuild;
+                toAminoMsg(message: _305.MsgJoinGuild): _305.MsgJoinGuildAminoMsg;
                 fromProtoMsg(message: _305.MsgJoinGuildProtoMsg): _305.MsgJoinGuild;
                 toProto(message: _305.MsgJoinGuild): Uint8Array;
                 toProtoMsg(message: _305.MsgJoinGuild): _305.MsgJoinGuildProtoMsg;
@@ -16988,12 +17651,14 @@ export declare namespace sparkdream {
             };
             MsgLeaveGuild: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _305.MsgLeaveGuild, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _305.MsgLeaveGuild;
                 fromPartial(object: import("../helpers").DeepPartial<_305.MsgLeaveGuild>): _305.MsgLeaveGuild;
                 fromAmino(object: _305.MsgLeaveGuildAmino): _305.MsgLeaveGuild;
                 toAmino(message: _305.MsgLeaveGuild): _305.MsgLeaveGuildAmino;
                 fromAminoMsg(object: _305.MsgLeaveGuildAminoMsg): _305.MsgLeaveGuild;
+                toAminoMsg(message: _305.MsgLeaveGuild): _305.MsgLeaveGuildAminoMsg;
                 fromProtoMsg(message: _305.MsgLeaveGuildProtoMsg): _305.MsgLeaveGuild;
                 toProto(message: _305.MsgLeaveGuild): Uint8Array;
                 toProtoMsg(message: _305.MsgLeaveGuild): _305.MsgLeaveGuildProtoMsg;
@@ -17012,12 +17677,14 @@ export declare namespace sparkdream {
             };
             MsgTransferGuildFounder: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _305.MsgTransferGuildFounder, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _305.MsgTransferGuildFounder;
                 fromPartial(object: import("../helpers").DeepPartial<_305.MsgTransferGuildFounder>): _305.MsgTransferGuildFounder;
                 fromAmino(object: _305.MsgTransferGuildFounderAmino): _305.MsgTransferGuildFounder;
                 toAmino(message: _305.MsgTransferGuildFounder): _305.MsgTransferGuildFounderAmino;
                 fromAminoMsg(object: _305.MsgTransferGuildFounderAminoMsg): _305.MsgTransferGuildFounder;
+                toAminoMsg(message: _305.MsgTransferGuildFounder): _305.MsgTransferGuildFounderAminoMsg;
                 fromProtoMsg(message: _305.MsgTransferGuildFounderProtoMsg): _305.MsgTransferGuildFounder;
                 toProto(message: _305.MsgTransferGuildFounder): Uint8Array;
                 toProtoMsg(message: _305.MsgTransferGuildFounder): _305.MsgTransferGuildFounderProtoMsg;
@@ -17036,12 +17703,14 @@ export declare namespace sparkdream {
             };
             MsgDissolveGuild: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _305.MsgDissolveGuild, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _305.MsgDissolveGuild;
                 fromPartial(object: import("../helpers").DeepPartial<_305.MsgDissolveGuild>): _305.MsgDissolveGuild;
                 fromAmino(object: _305.MsgDissolveGuildAmino): _305.MsgDissolveGuild;
                 toAmino(message: _305.MsgDissolveGuild): _305.MsgDissolveGuildAmino;
                 fromAminoMsg(object: _305.MsgDissolveGuildAminoMsg): _305.MsgDissolveGuild;
+                toAminoMsg(message: _305.MsgDissolveGuild): _305.MsgDissolveGuildAminoMsg;
                 fromProtoMsg(message: _305.MsgDissolveGuildProtoMsg): _305.MsgDissolveGuild;
                 toProto(message: _305.MsgDissolveGuild): Uint8Array;
                 toProtoMsg(message: _305.MsgDissolveGuild): _305.MsgDissolveGuildProtoMsg;
@@ -17060,12 +17729,14 @@ export declare namespace sparkdream {
             };
             MsgPromoteToOfficer: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _305.MsgPromoteToOfficer, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _305.MsgPromoteToOfficer;
                 fromPartial(object: import("../helpers").DeepPartial<_305.MsgPromoteToOfficer>): _305.MsgPromoteToOfficer;
                 fromAmino(object: _305.MsgPromoteToOfficerAmino): _305.MsgPromoteToOfficer;
                 toAmino(message: _305.MsgPromoteToOfficer): _305.MsgPromoteToOfficerAmino;
                 fromAminoMsg(object: _305.MsgPromoteToOfficerAminoMsg): _305.MsgPromoteToOfficer;
+                toAminoMsg(message: _305.MsgPromoteToOfficer): _305.MsgPromoteToOfficerAminoMsg;
                 fromProtoMsg(message: _305.MsgPromoteToOfficerProtoMsg): _305.MsgPromoteToOfficer;
                 toProto(message: _305.MsgPromoteToOfficer): Uint8Array;
                 toProtoMsg(message: _305.MsgPromoteToOfficer): _305.MsgPromoteToOfficerProtoMsg;
@@ -17084,12 +17755,14 @@ export declare namespace sparkdream {
             };
             MsgDemoteOfficer: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _305.MsgDemoteOfficer, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _305.MsgDemoteOfficer;
                 fromPartial(object: import("../helpers").DeepPartial<_305.MsgDemoteOfficer>): _305.MsgDemoteOfficer;
                 fromAmino(object: _305.MsgDemoteOfficerAmino): _305.MsgDemoteOfficer;
                 toAmino(message: _305.MsgDemoteOfficer): _305.MsgDemoteOfficerAmino;
                 fromAminoMsg(object: _305.MsgDemoteOfficerAminoMsg): _305.MsgDemoteOfficer;
+                toAminoMsg(message: _305.MsgDemoteOfficer): _305.MsgDemoteOfficerAminoMsg;
                 fromProtoMsg(message: _305.MsgDemoteOfficerProtoMsg): _305.MsgDemoteOfficer;
                 toProto(message: _305.MsgDemoteOfficer): Uint8Array;
                 toProtoMsg(message: _305.MsgDemoteOfficer): _305.MsgDemoteOfficerProtoMsg;
@@ -17108,12 +17781,14 @@ export declare namespace sparkdream {
             };
             MsgInviteToGuild: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _305.MsgInviteToGuild, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _305.MsgInviteToGuild;
                 fromPartial(object: import("../helpers").DeepPartial<_305.MsgInviteToGuild>): _305.MsgInviteToGuild;
                 fromAmino(object: _305.MsgInviteToGuildAmino): _305.MsgInviteToGuild;
                 toAmino(message: _305.MsgInviteToGuild): _305.MsgInviteToGuildAmino;
                 fromAminoMsg(object: _305.MsgInviteToGuildAminoMsg): _305.MsgInviteToGuild;
+                toAminoMsg(message: _305.MsgInviteToGuild): _305.MsgInviteToGuildAminoMsg;
                 fromProtoMsg(message: _305.MsgInviteToGuildProtoMsg): _305.MsgInviteToGuild;
                 toProto(message: _305.MsgInviteToGuild): Uint8Array;
                 toProtoMsg(message: _305.MsgInviteToGuild): _305.MsgInviteToGuildProtoMsg;
@@ -17132,12 +17807,14 @@ export declare namespace sparkdream {
             };
             MsgAcceptGuildInvite: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _305.MsgAcceptGuildInvite, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _305.MsgAcceptGuildInvite;
                 fromPartial(object: import("../helpers").DeepPartial<_305.MsgAcceptGuildInvite>): _305.MsgAcceptGuildInvite;
                 fromAmino(object: _305.MsgAcceptGuildInviteAmino): _305.MsgAcceptGuildInvite;
                 toAmino(message: _305.MsgAcceptGuildInvite): _305.MsgAcceptGuildInviteAmino;
                 fromAminoMsg(object: _305.MsgAcceptGuildInviteAminoMsg): _305.MsgAcceptGuildInvite;
+                toAminoMsg(message: _305.MsgAcceptGuildInvite): _305.MsgAcceptGuildInviteAminoMsg;
                 fromProtoMsg(message: _305.MsgAcceptGuildInviteProtoMsg): _305.MsgAcceptGuildInvite;
                 toProto(message: _305.MsgAcceptGuildInvite): Uint8Array;
                 toProtoMsg(message: _305.MsgAcceptGuildInvite): _305.MsgAcceptGuildInviteProtoMsg;
@@ -17156,12 +17833,14 @@ export declare namespace sparkdream {
             };
             MsgRevokeGuildInvite: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _305.MsgRevokeGuildInvite, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _305.MsgRevokeGuildInvite;
                 fromPartial(object: import("../helpers").DeepPartial<_305.MsgRevokeGuildInvite>): _305.MsgRevokeGuildInvite;
                 fromAmino(object: _305.MsgRevokeGuildInviteAmino): _305.MsgRevokeGuildInvite;
                 toAmino(message: _305.MsgRevokeGuildInvite): _305.MsgRevokeGuildInviteAmino;
                 fromAminoMsg(object: _305.MsgRevokeGuildInviteAminoMsg): _305.MsgRevokeGuildInvite;
+                toAminoMsg(message: _305.MsgRevokeGuildInvite): _305.MsgRevokeGuildInviteAminoMsg;
                 fromProtoMsg(message: _305.MsgRevokeGuildInviteProtoMsg): _305.MsgRevokeGuildInvite;
                 toProto(message: _305.MsgRevokeGuildInvite): Uint8Array;
                 toProtoMsg(message: _305.MsgRevokeGuildInvite): _305.MsgRevokeGuildInviteProtoMsg;
@@ -17180,12 +17859,14 @@ export declare namespace sparkdream {
             };
             MsgSetGuildInviteOnly: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _305.MsgSetGuildInviteOnly, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _305.MsgSetGuildInviteOnly;
                 fromPartial(object: import("../helpers").DeepPartial<_305.MsgSetGuildInviteOnly>): _305.MsgSetGuildInviteOnly;
                 fromAmino(object: _305.MsgSetGuildInviteOnlyAmino): _305.MsgSetGuildInviteOnly;
                 toAmino(message: _305.MsgSetGuildInviteOnly): _305.MsgSetGuildInviteOnlyAmino;
                 fromAminoMsg(object: _305.MsgSetGuildInviteOnlyAminoMsg): _305.MsgSetGuildInviteOnly;
+                toAminoMsg(message: _305.MsgSetGuildInviteOnly): _305.MsgSetGuildInviteOnlyAminoMsg;
                 fromProtoMsg(message: _305.MsgSetGuildInviteOnlyProtoMsg): _305.MsgSetGuildInviteOnly;
                 toProto(message: _305.MsgSetGuildInviteOnly): Uint8Array;
                 toProtoMsg(message: _305.MsgSetGuildInviteOnly): _305.MsgSetGuildInviteOnlyProtoMsg;
@@ -17204,12 +17885,14 @@ export declare namespace sparkdream {
             };
             MsgUpdateGuildDescription: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _305.MsgUpdateGuildDescription, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _305.MsgUpdateGuildDescription;
                 fromPartial(object: import("../helpers").DeepPartial<_305.MsgUpdateGuildDescription>): _305.MsgUpdateGuildDescription;
                 fromAmino(object: _305.MsgUpdateGuildDescriptionAmino): _305.MsgUpdateGuildDescription;
                 toAmino(message: _305.MsgUpdateGuildDescription): _305.MsgUpdateGuildDescriptionAmino;
                 fromAminoMsg(object: _305.MsgUpdateGuildDescriptionAminoMsg): _305.MsgUpdateGuildDescription;
+                toAminoMsg(message: _305.MsgUpdateGuildDescription): _305.MsgUpdateGuildDescriptionAminoMsg;
                 fromProtoMsg(message: _305.MsgUpdateGuildDescriptionProtoMsg): _305.MsgUpdateGuildDescription;
                 toProto(message: _305.MsgUpdateGuildDescription): Uint8Array;
                 toProtoMsg(message: _305.MsgUpdateGuildDescription): _305.MsgUpdateGuildDescriptionProtoMsg;
@@ -17228,12 +17911,14 @@ export declare namespace sparkdream {
             };
             MsgKickFromGuild: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _305.MsgKickFromGuild, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _305.MsgKickFromGuild;
                 fromPartial(object: import("../helpers").DeepPartial<_305.MsgKickFromGuild>): _305.MsgKickFromGuild;
                 fromAmino(object: _305.MsgKickFromGuildAmino): _305.MsgKickFromGuild;
                 toAmino(message: _305.MsgKickFromGuild): _305.MsgKickFromGuildAmino;
                 fromAminoMsg(object: _305.MsgKickFromGuildAminoMsg): _305.MsgKickFromGuild;
+                toAminoMsg(message: _305.MsgKickFromGuild): _305.MsgKickFromGuildAminoMsg;
                 fromProtoMsg(message: _305.MsgKickFromGuildProtoMsg): _305.MsgKickFromGuild;
                 toProto(message: _305.MsgKickFromGuild): Uint8Array;
                 toProtoMsg(message: _305.MsgKickFromGuild): _305.MsgKickFromGuildProtoMsg;
@@ -17252,12 +17937,14 @@ export declare namespace sparkdream {
             };
             MsgClaimGuildFounder: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _305.MsgClaimGuildFounder, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _305.MsgClaimGuildFounder;
                 fromPartial(object: import("../helpers").DeepPartial<_305.MsgClaimGuildFounder>): _305.MsgClaimGuildFounder;
                 fromAmino(object: _305.MsgClaimGuildFounderAmino): _305.MsgClaimGuildFounder;
                 toAmino(message: _305.MsgClaimGuildFounder): _305.MsgClaimGuildFounderAmino;
                 fromAminoMsg(object: _305.MsgClaimGuildFounderAminoMsg): _305.MsgClaimGuildFounder;
+                toAminoMsg(message: _305.MsgClaimGuildFounder): _305.MsgClaimGuildFounderAminoMsg;
                 fromProtoMsg(message: _305.MsgClaimGuildFounderProtoMsg): _305.MsgClaimGuildFounder;
                 toProto(message: _305.MsgClaimGuildFounder): Uint8Array;
                 toProtoMsg(message: _305.MsgClaimGuildFounder): _305.MsgClaimGuildFounderProtoMsg;
@@ -17276,12 +17963,14 @@ export declare namespace sparkdream {
             };
             MsgStartQuest: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _305.MsgStartQuest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _305.MsgStartQuest;
                 fromPartial(object: import("../helpers").DeepPartial<_305.MsgStartQuest>): _305.MsgStartQuest;
                 fromAmino(object: _305.MsgStartQuestAmino): _305.MsgStartQuest;
                 toAmino(message: _305.MsgStartQuest): _305.MsgStartQuestAmino;
                 fromAminoMsg(object: _305.MsgStartQuestAminoMsg): _305.MsgStartQuest;
+                toAminoMsg(message: _305.MsgStartQuest): _305.MsgStartQuestAminoMsg;
                 fromProtoMsg(message: _305.MsgStartQuestProtoMsg): _305.MsgStartQuest;
                 toProto(message: _305.MsgStartQuest): Uint8Array;
                 toProtoMsg(message: _305.MsgStartQuest): _305.MsgStartQuestProtoMsg;
@@ -17300,12 +17989,14 @@ export declare namespace sparkdream {
             };
             MsgClaimQuestReward: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _305.MsgClaimQuestReward, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _305.MsgClaimQuestReward;
                 fromPartial(object: import("../helpers").DeepPartial<_305.MsgClaimQuestReward>): _305.MsgClaimQuestReward;
                 fromAmino(object: _305.MsgClaimQuestRewardAmino): _305.MsgClaimQuestReward;
                 toAmino(message: _305.MsgClaimQuestReward): _305.MsgClaimQuestRewardAmino;
                 fromAminoMsg(object: _305.MsgClaimQuestRewardAminoMsg): _305.MsgClaimQuestReward;
+                toAminoMsg(message: _305.MsgClaimQuestReward): _305.MsgClaimQuestRewardAminoMsg;
                 fromProtoMsg(message: _305.MsgClaimQuestRewardProtoMsg): _305.MsgClaimQuestReward;
                 toProto(message: _305.MsgClaimQuestReward): Uint8Array;
                 toProtoMsg(message: _305.MsgClaimQuestReward): _305.MsgClaimQuestRewardProtoMsg;
@@ -17324,12 +18015,14 @@ export declare namespace sparkdream {
             };
             MsgAbandonQuest: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _305.MsgAbandonQuest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _305.MsgAbandonQuest;
                 fromPartial(object: import("../helpers").DeepPartial<_305.MsgAbandonQuest>): _305.MsgAbandonQuest;
                 fromAmino(object: _305.MsgAbandonQuestAmino): _305.MsgAbandonQuest;
                 toAmino(message: _305.MsgAbandonQuest): _305.MsgAbandonQuestAmino;
                 fromAminoMsg(object: _305.MsgAbandonQuestAminoMsg): _305.MsgAbandonQuest;
+                toAminoMsg(message: _305.MsgAbandonQuest): _305.MsgAbandonQuestAminoMsg;
                 fromProtoMsg(message: _305.MsgAbandonQuestProtoMsg): _305.MsgAbandonQuest;
                 toProto(message: _305.MsgAbandonQuest): Uint8Array;
                 toProtoMsg(message: _305.MsgAbandonQuest): _305.MsgAbandonQuestProtoMsg;
@@ -17530,12 +18223,14 @@ export declare namespace sparkdream {
             };
             MsgReportDisplayName: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _305.MsgReportDisplayName, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _305.MsgReportDisplayName;
                 fromPartial(object: import("../helpers").DeepPartial<_305.MsgReportDisplayName>): _305.MsgReportDisplayName;
                 fromAmino(object: _305.MsgReportDisplayNameAmino): _305.MsgReportDisplayName;
                 toAmino(message: _305.MsgReportDisplayName): _305.MsgReportDisplayNameAmino;
                 fromAminoMsg(object: _305.MsgReportDisplayNameAminoMsg): _305.MsgReportDisplayName;
+                toAminoMsg(message: _305.MsgReportDisplayName): _305.MsgReportDisplayNameAminoMsg;
                 fromProtoMsg(message: _305.MsgReportDisplayNameProtoMsg): _305.MsgReportDisplayName;
                 toProto(message: _305.MsgReportDisplayName): Uint8Array;
                 toProtoMsg(message: _305.MsgReportDisplayName): _305.MsgReportDisplayNameProtoMsg;
@@ -17554,12 +18249,14 @@ export declare namespace sparkdream {
             };
             MsgAppealDisplayNameModeration: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _305.MsgAppealDisplayNameModeration, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _305.MsgAppealDisplayNameModeration;
                 fromPartial(object: import("../helpers").DeepPartial<_305.MsgAppealDisplayNameModeration>): _305.MsgAppealDisplayNameModeration;
                 fromAmino(object: _305.MsgAppealDisplayNameModerationAmino): _305.MsgAppealDisplayNameModeration;
                 toAmino(message: _305.MsgAppealDisplayNameModeration): _305.MsgAppealDisplayNameModerationAmino;
                 fromAminoMsg(object: _305.MsgAppealDisplayNameModerationAminoMsg): _305.MsgAppealDisplayNameModeration;
+                toAminoMsg(message: _305.MsgAppealDisplayNameModeration): _305.MsgAppealDisplayNameModerationAminoMsg;
                 fromProtoMsg(message: _305.MsgAppealDisplayNameModerationProtoMsg): _305.MsgAppealDisplayNameModeration;
                 toProto(message: _305.MsgAppealDisplayNameModeration): Uint8Array;
                 toProtoMsg(message: _305.MsgAppealDisplayNameModeration): _305.MsgAppealDisplayNameModerationProtoMsg;
@@ -17812,12 +18509,14 @@ export declare namespace sparkdream {
             };
             MsgNominate: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _305.MsgNominate, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _305.MsgNominate;
                 fromPartial(object: import("../helpers").DeepPartial<_305.MsgNominate>): _305.MsgNominate;
                 fromAmino(object: _305.MsgNominateAmino): _305.MsgNominate;
                 toAmino(message: _305.MsgNominate): _305.MsgNominateAmino;
                 fromAminoMsg(object: _305.MsgNominateAminoMsg): _305.MsgNominate;
+                toAminoMsg(message: _305.MsgNominate): _305.MsgNominateAminoMsg;
                 fromProtoMsg(message: _305.MsgNominateProtoMsg): _305.MsgNominate;
                 toProto(message: _305.MsgNominate): Uint8Array;
                 toProtoMsg(message: _305.MsgNominate): _305.MsgNominateProtoMsg;
@@ -17836,12 +18535,14 @@ export declare namespace sparkdream {
             };
             MsgStakeNomination: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _305.MsgStakeNomination, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _305.MsgStakeNomination;
                 fromPartial(object: import("../helpers").DeepPartial<_305.MsgStakeNomination>): _305.MsgStakeNomination;
                 fromAmino(object: _305.MsgStakeNominationAmino): _305.MsgStakeNomination;
                 toAmino(message: _305.MsgStakeNomination): _305.MsgStakeNominationAmino;
                 fromAminoMsg(object: _305.MsgStakeNominationAminoMsg): _305.MsgStakeNomination;
+                toAminoMsg(message: _305.MsgStakeNomination): _305.MsgStakeNominationAminoMsg;
                 fromProtoMsg(message: _305.MsgStakeNominationProtoMsg): _305.MsgStakeNomination;
                 toProto(message: _305.MsgStakeNomination): Uint8Array;
                 toProtoMsg(message: _305.MsgStakeNomination): _305.MsgStakeNominationProtoMsg;
@@ -17860,12 +18561,14 @@ export declare namespace sparkdream {
             };
             MsgUnstakeNomination: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _305.MsgUnstakeNomination, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _305.MsgUnstakeNomination;
                 fromPartial(object: import("../helpers").DeepPartial<_305.MsgUnstakeNomination>): _305.MsgUnstakeNomination;
                 fromAmino(object: _305.MsgUnstakeNominationAmino): _305.MsgUnstakeNomination;
                 toAmino(message: _305.MsgUnstakeNomination): _305.MsgUnstakeNominationAmino;
                 fromAminoMsg(object: _305.MsgUnstakeNominationAminoMsg): _305.MsgUnstakeNomination;
+                toAminoMsg(message: _305.MsgUnstakeNomination): _305.MsgUnstakeNominationAminoMsg;
                 fromProtoMsg(message: _305.MsgUnstakeNominationProtoMsg): _305.MsgUnstakeNomination;
                 toProto(message: _305.MsgUnstakeNomination): Uint8Array;
                 toProtoMsg(message: _305.MsgUnstakeNomination): _305.MsgUnstakeNominationProtoMsg;
@@ -20082,12 +20785,14 @@ export declare namespace sparkdream {
             };
             MsgCreateSession: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _312.MsgCreateSession, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _312.MsgCreateSession;
                 fromPartial(object: import("../helpers").DeepPartial<_312.MsgCreateSession>): _312.MsgCreateSession;
                 fromAmino(object: _312.MsgCreateSessionAmino): _312.MsgCreateSession;
                 toAmino(message: _312.MsgCreateSession): _312.MsgCreateSessionAmino;
                 fromAminoMsg(object: _312.MsgCreateSessionAminoMsg): _312.MsgCreateSession;
+                toAminoMsg(message: _312.MsgCreateSession): _312.MsgCreateSessionAminoMsg;
                 fromProtoMsg(message: _312.MsgCreateSessionProtoMsg): _312.MsgCreateSession;
                 toProto(message: _312.MsgCreateSession): Uint8Array;
                 toProtoMsg(message: _312.MsgCreateSession): _312.MsgCreateSessionProtoMsg;
@@ -20106,12 +20811,14 @@ export declare namespace sparkdream {
             };
             MsgRevokeSession: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _312.MsgRevokeSession, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _312.MsgRevokeSession;
                 fromPartial(object: import("../helpers").DeepPartial<_312.MsgRevokeSession>): _312.MsgRevokeSession;
                 fromAmino(object: _312.MsgRevokeSessionAmino): _312.MsgRevokeSession;
                 toAmino(message: _312.MsgRevokeSession): _312.MsgRevokeSessionAmino;
                 fromAminoMsg(object: _312.MsgRevokeSessionAminoMsg): _312.MsgRevokeSession;
+                toAminoMsg(message: _312.MsgRevokeSession): _312.MsgRevokeSessionAminoMsg;
                 fromProtoMsg(message: _312.MsgRevokeSessionProtoMsg): _312.MsgRevokeSession;
                 toProto(message: _312.MsgRevokeSession): Uint8Array;
                 toProtoMsg(message: _312.MsgRevokeSession): _312.MsgRevokeSessionProtoMsg;
@@ -20130,12 +20837,14 @@ export declare namespace sparkdream {
             };
             MsgExecSession: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _312.MsgExecSession, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _312.MsgExecSession;
                 fromPartial(object: import("../helpers").DeepPartial<_312.MsgExecSession>): _312.MsgExecSession;
                 fromAmino(object: _312.MsgExecSessionAmino): _312.MsgExecSession;
                 toAmino(message: _312.MsgExecSession): _312.MsgExecSessionAmino;
                 fromAminoMsg(object: _312.MsgExecSessionAminoMsg): _312.MsgExecSession;
+                toAminoMsg(message: _312.MsgExecSession): _312.MsgExecSessionAminoMsg;
                 fromProtoMsg(message: _312.MsgExecSessionProtoMsg): _312.MsgExecSession;
                 toProto(message: _312.MsgExecSession): Uint8Array;
                 toProtoMsg(message: _312.MsgExecSession): _312.MsgExecSessionProtoMsg;
@@ -20752,12 +21461,14 @@ export declare namespace sparkdream {
             };
             MsgShieldedExec: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _317.MsgShieldedExec, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _317.MsgShieldedExec;
                 fromPartial(object: import("../helpers").DeepPartial<_317.MsgShieldedExec>): _317.MsgShieldedExec;
                 fromAmino(object: _317.MsgShieldedExecAmino): _317.MsgShieldedExec;
                 toAmino(message: _317.MsgShieldedExec): _317.MsgShieldedExecAmino;
                 fromAminoMsg(object: _317.MsgShieldedExecAminoMsg): _317.MsgShieldedExec;
+                toAminoMsg(message: _317.MsgShieldedExec): _317.MsgShieldedExecAminoMsg;
                 fromProtoMsg(message: _317.MsgShieldedExecProtoMsg): _317.MsgShieldedExec;
                 toProto(message: _317.MsgShieldedExec): Uint8Array;
                 toProtoMsg(message: _317.MsgShieldedExec): _317.MsgShieldedExecProtoMsg;
@@ -20776,12 +21487,14 @@ export declare namespace sparkdream {
             };
             MsgTriggerDkg: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _317.MsgTriggerDkg, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _317.MsgTriggerDkg;
                 fromPartial(object: import("../helpers").DeepPartial<_317.MsgTriggerDkg>): _317.MsgTriggerDkg;
                 fromAmino(object: _317.MsgTriggerDkgAmino): _317.MsgTriggerDkg;
                 toAmino(message: _317.MsgTriggerDkg): _317.MsgTriggerDkgAmino;
                 fromAminoMsg(object: _317.MsgTriggerDkgAminoMsg): _317.MsgTriggerDkg;
+                toAminoMsg(message: _317.MsgTriggerDkg): _317.MsgTriggerDkgAminoMsg;
                 fromProtoMsg(message: _317.MsgTriggerDkgProtoMsg): _317.MsgTriggerDkg;
                 toProto(message: _317.MsgTriggerDkg): Uint8Array;
                 toProtoMsg(message: _317.MsgTriggerDkg): _317.MsgTriggerDkgProtoMsg;
@@ -20800,12 +21513,14 @@ export declare namespace sparkdream {
             };
             MsgRegisterShieldedOp: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _317.MsgRegisterShieldedOp, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _317.MsgRegisterShieldedOp;
                 fromPartial(object: import("../helpers").DeepPartial<_317.MsgRegisterShieldedOp>): _317.MsgRegisterShieldedOp;
                 fromAmino(object: _317.MsgRegisterShieldedOpAmino): _317.MsgRegisterShieldedOp;
                 toAmino(message: _317.MsgRegisterShieldedOp): _317.MsgRegisterShieldedOpAmino;
                 fromAminoMsg(object: _317.MsgRegisterShieldedOpAminoMsg): _317.MsgRegisterShieldedOp;
+                toAminoMsg(message: _317.MsgRegisterShieldedOp): _317.MsgRegisterShieldedOpAminoMsg;
                 fromProtoMsg(message: _317.MsgRegisterShieldedOpProtoMsg): _317.MsgRegisterShieldedOp;
                 toProto(message: _317.MsgRegisterShieldedOp): Uint8Array;
                 toProtoMsg(message: _317.MsgRegisterShieldedOp): _317.MsgRegisterShieldedOpProtoMsg;
@@ -20824,12 +21539,14 @@ export declare namespace sparkdream {
             };
             MsgDeregisterShieldedOp: {
                 typeUrl: string;
+                aminoType: string;
                 encode(message: _317.MsgDeregisterShieldedOp, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                 decode(input: import("..").BinaryReader | Uint8Array, length?: number): _317.MsgDeregisterShieldedOp;
                 fromPartial(object: import("../helpers").DeepPartial<_317.MsgDeregisterShieldedOp>): _317.MsgDeregisterShieldedOp;
                 fromAmino(object: _317.MsgDeregisterShieldedOpAmino): _317.MsgDeregisterShieldedOp;
                 toAmino(message: _317.MsgDeregisterShieldedOp): _317.MsgDeregisterShieldedOpAmino;
                 fromAminoMsg(object: _317.MsgDeregisterShieldedOpAminoMsg): _317.MsgDeregisterShieldedOp;
+                toAminoMsg(message: _317.MsgDeregisterShieldedOp): _317.MsgDeregisterShieldedOpAminoMsg;
                 fromProtoMsg(message: _317.MsgDeregisterShieldedOpProtoMsg): _317.MsgDeregisterShieldedOp;
                 toProto(message: _317.MsgDeregisterShieldedOp): Uint8Array;
                 toProtoMsg(message: _317.MsgDeregisterShieldedOp): _317.MsgDeregisterShieldedOpProtoMsg;
@@ -21959,6 +22676,8 @@ export declare namespace sparkdream {
                         params(request?: _198.QueryParamsRequest): Promise<_198.QueryParamsResponse>;
                         getPolicyPermissions(request: _198.QueryGetPolicyPermissionsRequest): Promise<_198.QueryGetPolicyPermissionsResponse>;
                         listPolicyPermissions(request?: _198.QueryAllPolicyPermissionsRequest): Promise<_198.QueryAllPolicyPermissionsResponse>;
+                        getDecisionPolicy(request: _198.QueryGetDecisionPolicyRequest): Promise<_198.QueryGetDecisionPolicyResponse>;
+                        listDecisionPolicies(request?: _198.QueryAllDecisionPoliciesRequest): Promise<_198.QueryAllDecisionPoliciesResponse>;
                         getGroup(request: _198.QueryGetGroupRequest): Promise<_198.QueryGetGroupResponse>;
                         listGroups(request?: _198.QueryAllGroupRequest): Promise<_198.QueryAllGroupResponse>;
                         getCouncilMembers(request: _198.QueryGetCouncilMembersRequest): Promise<_198.QueryGetCouncilMembersResponse>;
@@ -22061,6 +22780,8 @@ export declare namespace sparkdream {
                         names(request: _244.QueryNamesRequest): Promise<_244.QueryNamesResponse>;
                         getDispute(request: _244.QueryGetDisputeRequest): Promise<_244.QueryGetDisputeResponse>;
                         listDispute(request?: _244.QueryAllDisputeRequest): Promise<_244.QueryAllDisputeResponse>;
+                        getOwnerInfo(request: _244.QueryGetOwnerInfoRequest): Promise<_244.QueryGetOwnerInfoResponse>;
+                        targets(request: _244.QueryTargetsRequest): Promise<_244.QueryTargetsResponse>;
                     };
                 };
                 rep: {
@@ -22142,6 +22863,7 @@ export declare namespace sparkdream {
                         memberReports(request?: _264.QueryMemberReportsRequest): Promise<_264.QueryMemberReportsResponse>;
                         memberWarnings(request: _264.QueryMemberWarningsRequest): Promise<_264.QueryMemberWarningsResponse>;
                         memberStanding(request: _264.QueryMemberStandingRequest): Promise<_264.QueryMemberStandingResponse>;
+                        requiredInvitationStake(request: _264.QueryRequiredInvitationStakeRequest): Promise<_264.QueryRequiredInvitationStakeResponse>;
                     };
                 };
                 reveal: {