@sparkdreamnft/sparkdreamjs 0.0.4 → 0.0.6

package/sparkdream/bundle.d.ts

@@ -1,354 +1,470 @@
-import * as _173 from "./blog/genesis";
-import * as _174 from "./blog/params";
-import * as _175 from "./blog/post";
-import * as _176 from "./blog/query";
-import * as _177 from "./blog/tx";
-import * as _178 from "./sparkdream/genesis";
-import * as _179 from "./sparkdream/params";
-import * as _180 from "./sparkdream/query";
-import * as _181 from "./sparkdream/tx";
-import * as _330 from "./blog/query.lcd";
-import * as _331 from "./sparkdream/query.lcd";
-import * as _332 from "./blog/query.rpc.Query";
-import * as _333 from "./sparkdream/query.rpc.Query";
-import * as _334 from "./blog/tx.rpc.msg";
-import * as _335 from "./sparkdream/tx.rpc.msg";
+import * as _173 from "./blog/module/v1/module";
+import * as _174 from "./blog/v1/genesis";
+import * as _175 from "./blog/v1/params";
+import * as _176 from "./blog/v1/post";
+import * as _177 from "./blog/v1/query";
+import * as _178 from "./blog/v1/tx";
+import * as _179 from "./sparkdream/module/v1/module";
+import * as _180 from "./sparkdream/v1/genesis";
+import * as _181 from "./sparkdream/v1/params";
+import * as _182 from "./sparkdream/v1/query";
+import * as _183 from "./sparkdream/v1/tx";
+import * as _332 from "./blog/v1/query.lcd";
+import * as _333 from "./sparkdream/v1/query.lcd";
+import * as _334 from "./blog/v1/query.rpc.Query";
+import * as _335 from "./sparkdream/v1/query.rpc.Query";
+import * as _336 from "./blog/v1/tx.rpc.msg";
+import * as _337 from "./sparkdream/v1/tx.rpc.msg";
 export declare namespace sparkdream {
-    const blog: {
-        MsgClientImpl: typeof _334.MsgClientImpl;
-        createClientImpl: (rpc: import("..").TxRpc) => _334.MsgClientImpl;
-        QueryClientImpl: typeof _332.QueryClientImpl;
-        createRpcQueryExtension: (base: QueryClient) => {
-            params(request?: _176.QueryParamsRequest): Promise<_176.QueryParamsResponse>;
-            showPost(request: _176.QueryShowPostRequest): Promise<_176.QueryShowPostResponse>;
-            listPost(request?: _176.QueryListPostRequest): Promise<_176.QueryListPostResponse>;
-        };
-        LCDQueryClient: typeof _330.LCDQueryClient;
-        registry: ReadonlyArray<[string, import("..").TelescopeGeneratedType<any, any, any>]>;
-        AminoConverter: {
-            "/sparkdream.blog.MsgUpdateParams": {
-                aminoType: string;
-                toAmino: (message: _177.MsgUpdateParams) => _177.MsgUpdateParamsAmino;
-                fromAmino: (object: _177.MsgUpdateParamsAmino) => _177.MsgUpdateParams;
+    namespace blog {
+        namespace module {
+            const v1: {
+                Module: {
+                    typeUrl: string;
+                    encode(message: _173.Module, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _173.Module;
+                    fromPartial(object: import("../helpers").DeepPartial<_173.Module>): _173.Module;
+                    fromAmino(object: _173.ModuleAmino): _173.Module;
+                    toAmino(message: _173.Module): _173.ModuleAmino;
+                    fromAminoMsg(object: _173.ModuleAminoMsg): _173.Module;
+                    fromProtoMsg(message: _173.ModuleProtoMsg): _173.Module;
+                    toProto(message: _173.Module): Uint8Array;
+                    toProtoMsg(message: _173.Module): _173.ModuleProtoMsg;
+                };
             };
-            "/sparkdream.blog.MsgCreatePost": {
-                aminoType: string;
-                toAmino: (message: _177.MsgCreatePost) => _177.MsgCreatePostAmino;
-                fromAmino: (object: _177.MsgCreatePostAmino) => _177.MsgCreatePost;
+        }
+        const v1: {
+            MsgClientImpl: typeof _336.MsgClientImpl;
+            createClientImpl: (rpc: import("..").TxRpc) => _336.MsgClientImpl;
+            QueryClientImpl: typeof _334.QueryClientImpl;
+            createRpcQueryExtension: (base: QueryClient) => {
+                params(request?: _177.QueryParamsRequest): Promise<_177.QueryParamsResponse>;
+                showPost(request: _177.QueryShowPostRequest): Promise<_177.QueryShowPostResponse>;
+                listPost(request?: _177.QueryListPostRequest): Promise<_177.QueryListPostResponse>;
+            };
+            LCDQueryClient: typeof _332.LCDQueryClient;
+            registry: ReadonlyArray<[string, import("..").TelescopeGeneratedType<any, any, any>]>;
+            load: (protoRegistry: Registry) => void;
+            MessageComposer: {
+                encoded: {
+                    updateParams(value: _178.MsgUpdateParams): {
+                        typeUrl: string;
+                        value: Uint8Array<ArrayBufferLike>;
+                    };
+                    createPost(value: _178.MsgCreatePost): {
+                        typeUrl: string;
+                        value: Uint8Array<ArrayBufferLike>;
+                    };
+                    updatePost(value: _178.MsgUpdatePost): {
+                        typeUrl: string;
+                        value: Uint8Array<ArrayBufferLike>;
+                    };
+                    deletePost(value: _178.MsgDeletePost): {
+                        typeUrl: string;
+                        value: Uint8Array<ArrayBufferLike>;
+                    };
+                };
+                withTypeUrl: {
+                    updateParams(value: _178.MsgUpdateParams): {
+                        typeUrl: string;
+                        value: _178.MsgUpdateParams;
+                    };
+                    createPost(value: _178.MsgCreatePost): {
+                        typeUrl: string;
+                        value: _178.MsgCreatePost;
+                    };
+                    updatePost(value: _178.MsgUpdatePost): {
+                        typeUrl: string;
+                        value: _178.MsgUpdatePost;
+                    };
+                    deletePost(value: _178.MsgDeletePost): {
+                        typeUrl: string;
+                        value: _178.MsgDeletePost;
+                    };
+                };
+                fromPartial: {
+                    updateParams(value: _178.MsgUpdateParams): {
+                        typeUrl: string;
+                        value: _178.MsgUpdateParams;
+                    };
+                    createPost(value: _178.MsgCreatePost): {
+                        typeUrl: string;
+                        value: _178.MsgCreatePost;
+                    };
+                    updatePost(value: _178.MsgUpdatePost): {
+                        typeUrl: string;
+                        value: _178.MsgUpdatePost;
+                    };
+                    deletePost(value: _178.MsgDeletePost): {
+                        typeUrl: string;
+                        value: _178.MsgDeletePost;
+                    };
+                };
+            };
+            AminoConverter: {
+                "/sparkdream.blog.v1.MsgUpdateParams": {
+                    aminoType: string;
+                    toAmino: (message: _178.MsgUpdateParams) => _178.MsgUpdateParamsAmino;
+                    fromAmino: (object: _178.MsgUpdateParamsAmino) => _178.MsgUpdateParams;
+                };
+                "/sparkdream.blog.v1.MsgCreatePost": {
+                    aminoType: string;
+                    toAmino: (message: _178.MsgCreatePost) => _178.MsgCreatePostAmino;
+                    fromAmino: (object: _178.MsgCreatePostAmino) => _178.MsgCreatePost;
+                };
+                "/sparkdream.blog.v1.MsgUpdatePost": {
+                    aminoType: string;
+                    toAmino: (message: _178.MsgUpdatePost) => _178.MsgUpdatePostAmino;
+                    fromAmino: (object: _178.MsgUpdatePostAmino) => _178.MsgUpdatePost;
+                };
+                "/sparkdream.blog.v1.MsgDeletePost": {
+                    aminoType: string;
+                    toAmino: (message: _178.MsgDeletePost) => _178.MsgDeletePostAmino;
+                    fromAmino: (object: _178.MsgDeletePostAmino) => _178.MsgDeletePost;
+                };
             };
-            "/sparkdream.blog.MsgUpdatePost": {
+            MsgUpdateParams: {
+                typeUrl: string;
                 aminoType: string;
-                toAmino: (message: _177.MsgUpdatePost) => _177.MsgUpdatePostAmino;
-                fromAmino: (object: _177.MsgUpdatePostAmino) => _177.MsgUpdatePost;
+                encode(message: _178.MsgUpdateParams, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _178.MsgUpdateParams;
+                fromPartial(object: import("../helpers").DeepPartial<_178.MsgUpdateParams>): _178.MsgUpdateParams;
+                fromAmino(object: _178.MsgUpdateParamsAmino): _178.MsgUpdateParams;
+                toAmino(message: _178.MsgUpdateParams): _178.MsgUpdateParamsAmino;
+                fromAminoMsg(object: _178.MsgUpdateParamsAminoMsg): _178.MsgUpdateParams;
+                toAminoMsg(message: _178.MsgUpdateParams): _178.MsgUpdateParamsAminoMsg;
+                fromProtoMsg(message: _178.MsgUpdateParamsProtoMsg): _178.MsgUpdateParams;
+                toProto(message: _178.MsgUpdateParams): Uint8Array;
+                toProtoMsg(message: _178.MsgUpdateParams): _178.MsgUpdateParamsProtoMsg;
+            };
+            MsgUpdateParamsResponse: {
+                typeUrl: string;
+                encode(_: _178.MsgUpdateParamsResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _178.MsgUpdateParamsResponse;
+                fromPartial(_: import("../helpers").DeepPartial<_178.MsgUpdateParamsResponse>): _178.MsgUpdateParamsResponse;
+                fromAmino(_: _178.MsgUpdateParamsResponseAmino): _178.MsgUpdateParamsResponse;
+                toAmino(_: _178.MsgUpdateParamsResponse): _178.MsgUpdateParamsResponseAmino;
+                fromAminoMsg(object: _178.MsgUpdateParamsResponseAminoMsg): _178.MsgUpdateParamsResponse;
+                fromProtoMsg(message: _178.MsgUpdateParamsResponseProtoMsg): _178.MsgUpdateParamsResponse;
+                toProto(message: _178.MsgUpdateParamsResponse): Uint8Array;
+                toProtoMsg(message: _178.MsgUpdateParamsResponse): _178.MsgUpdateParamsResponseProtoMsg;
+            };
+            MsgCreatePost: {
+                typeUrl: string;
+                encode(message: _178.MsgCreatePost, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _178.MsgCreatePost;
+                fromPartial(object: import("../helpers").DeepPartial<_178.MsgCreatePost>): _178.MsgCreatePost;
+                fromAmino(object: _178.MsgCreatePostAmino): _178.MsgCreatePost;
+                toAmino(message: _178.MsgCreatePost): _178.MsgCreatePostAmino;
+                fromAminoMsg(object: _178.MsgCreatePostAminoMsg): _178.MsgCreatePost;
+                fromProtoMsg(message: _178.MsgCreatePostProtoMsg): _178.MsgCreatePost;
+                toProto(message: _178.MsgCreatePost): Uint8Array;
+                toProtoMsg(message: _178.MsgCreatePost): _178.MsgCreatePostProtoMsg;
             };
-            "/sparkdream.blog.MsgDeletePost": {
+            MsgCreatePostResponse: {
+                typeUrl: string;
+                encode(message: _178.MsgCreatePostResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _178.MsgCreatePostResponse;
+                fromPartial(object: import("../helpers").DeepPartial<_178.MsgCreatePostResponse>): _178.MsgCreatePostResponse;
+                fromAmino(object: _178.MsgCreatePostResponseAmino): _178.MsgCreatePostResponse;
+                toAmino(message: _178.MsgCreatePostResponse): _178.MsgCreatePostResponseAmino;
+                fromAminoMsg(object: _178.MsgCreatePostResponseAminoMsg): _178.MsgCreatePostResponse;
+                fromProtoMsg(message: _178.MsgCreatePostResponseProtoMsg): _178.MsgCreatePostResponse;
+                toProto(message: _178.MsgCreatePostResponse): Uint8Array;
+                toProtoMsg(message: _178.MsgCreatePostResponse): _178.MsgCreatePostResponseProtoMsg;
+            };
+            MsgUpdatePost: {
+                typeUrl: string;
+                encode(message: _178.MsgUpdatePost, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _178.MsgUpdatePost;
+                fromPartial(object: import("../helpers").DeepPartial<_178.MsgUpdatePost>): _178.MsgUpdatePost;
+                fromAmino(object: _178.MsgUpdatePostAmino): _178.MsgUpdatePost;
+                toAmino(message: _178.MsgUpdatePost): _178.MsgUpdatePostAmino;
+                fromAminoMsg(object: _178.MsgUpdatePostAminoMsg): _178.MsgUpdatePost;
+                fromProtoMsg(message: _178.MsgUpdatePostProtoMsg): _178.MsgUpdatePost;
+                toProto(message: _178.MsgUpdatePost): Uint8Array;
+                toProtoMsg(message: _178.MsgUpdatePost): _178.MsgUpdatePostProtoMsg;
+            };
+            MsgUpdatePostResponse: {
+                typeUrl: string;
+                encode(_: _178.MsgUpdatePostResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _178.MsgUpdatePostResponse;
+                fromPartial(_: import("../helpers").DeepPartial<_178.MsgUpdatePostResponse>): _178.MsgUpdatePostResponse;
+                fromAmino(_: _178.MsgUpdatePostResponseAmino): _178.MsgUpdatePostResponse;
+                toAmino(_: _178.MsgUpdatePostResponse): _178.MsgUpdatePostResponseAmino;
+                fromAminoMsg(object: _178.MsgUpdatePostResponseAminoMsg): _178.MsgUpdatePostResponse;
+                fromProtoMsg(message: _178.MsgUpdatePostResponseProtoMsg): _178.MsgUpdatePostResponse;
+                toProto(message: _178.MsgUpdatePostResponse): Uint8Array;
+                toProtoMsg(message: _178.MsgUpdatePostResponse): _178.MsgUpdatePostResponseProtoMsg;
+            };
+            MsgDeletePost: {
+                typeUrl: string;
+                encode(message: _178.MsgDeletePost, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _178.MsgDeletePost;
+                fromPartial(object: import("../helpers").DeepPartial<_178.MsgDeletePost>): _178.MsgDeletePost;
+                fromAmino(object: _178.MsgDeletePostAmino): _178.MsgDeletePost;
+                toAmino(message: _178.MsgDeletePost): _178.MsgDeletePostAmino;
+                fromAminoMsg(object: _178.MsgDeletePostAminoMsg): _178.MsgDeletePost;
+                fromProtoMsg(message: _178.MsgDeletePostProtoMsg): _178.MsgDeletePost;
+                toProto(message: _178.MsgDeletePost): Uint8Array;
+                toProtoMsg(message: _178.MsgDeletePost): _178.MsgDeletePostProtoMsg;
+            };
+            MsgDeletePostResponse: {
+                typeUrl: string;
+                encode(_: _178.MsgDeletePostResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _178.MsgDeletePostResponse;
+                fromPartial(_: import("../helpers").DeepPartial<_178.MsgDeletePostResponse>): _178.MsgDeletePostResponse;
+                fromAmino(_: _178.MsgDeletePostResponseAmino): _178.MsgDeletePostResponse;
+                toAmino(_: _178.MsgDeletePostResponse): _178.MsgDeletePostResponseAmino;
+                fromAminoMsg(object: _178.MsgDeletePostResponseAminoMsg): _178.MsgDeletePostResponse;
+                fromProtoMsg(message: _178.MsgDeletePostResponseProtoMsg): _178.MsgDeletePostResponse;
+                toProto(message: _178.MsgDeletePostResponse): Uint8Array;
+                toProtoMsg(message: _178.MsgDeletePostResponse): _178.MsgDeletePostResponseProtoMsg;
+            };
+            QueryParamsRequest: {
+                typeUrl: string;
+                encode(_: _177.QueryParamsRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _177.QueryParamsRequest;
+                fromPartial(_: import("../helpers").DeepPartial<_177.QueryParamsRequest>): _177.QueryParamsRequest;
+                fromAmino(_: _177.QueryParamsRequestAmino): _177.QueryParamsRequest;
+                toAmino(_: _177.QueryParamsRequest): _177.QueryParamsRequestAmino;
+                fromAminoMsg(object: _177.QueryParamsRequestAminoMsg): _177.QueryParamsRequest;
+                fromProtoMsg(message: _177.QueryParamsRequestProtoMsg): _177.QueryParamsRequest;
+                toProto(message: _177.QueryParamsRequest): Uint8Array;
+                toProtoMsg(message: _177.QueryParamsRequest): _177.QueryParamsRequestProtoMsg;
+            };
+            QueryParamsResponse: {
+                typeUrl: string;
+                encode(message: _177.QueryParamsResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _177.QueryParamsResponse;
+                fromPartial(object: import("../helpers").DeepPartial<_177.QueryParamsResponse>): _177.QueryParamsResponse;
+                fromAmino(object: _177.QueryParamsResponseAmino): _177.QueryParamsResponse;
+                toAmino(message: _177.QueryParamsResponse): _177.QueryParamsResponseAmino;
+                fromAminoMsg(object: _177.QueryParamsResponseAminoMsg): _177.QueryParamsResponse;
+                fromProtoMsg(message: _177.QueryParamsResponseProtoMsg): _177.QueryParamsResponse;
+                toProto(message: _177.QueryParamsResponse): Uint8Array;
+                toProtoMsg(message: _177.QueryParamsResponse): _177.QueryParamsResponseProtoMsg;
+            };
+            QueryShowPostRequest: {
+                typeUrl: string;
+                encode(message: _177.QueryShowPostRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _177.QueryShowPostRequest;
+                fromPartial(object: import("../helpers").DeepPartial<_177.QueryShowPostRequest>): _177.QueryShowPostRequest;
+                fromAmino(object: _177.QueryShowPostRequestAmino): _177.QueryShowPostRequest;
+                toAmino(message: _177.QueryShowPostRequest): _177.QueryShowPostRequestAmino;
+                fromAminoMsg(object: _177.QueryShowPostRequestAminoMsg): _177.QueryShowPostRequest;
+                fromProtoMsg(message: _177.QueryShowPostRequestProtoMsg): _177.QueryShowPostRequest;
+                toProto(message: _177.QueryShowPostRequest): Uint8Array;
+                toProtoMsg(message: _177.QueryShowPostRequest): _177.QueryShowPostRequestProtoMsg;
+            };
+            QueryShowPostResponse: {
+                typeUrl: string;
+                encode(message: _177.QueryShowPostResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _177.QueryShowPostResponse;
+                fromPartial(object: import("../helpers").DeepPartial<_177.QueryShowPostResponse>): _177.QueryShowPostResponse;
+                fromAmino(object: _177.QueryShowPostResponseAmino): _177.QueryShowPostResponse;
+                toAmino(message: _177.QueryShowPostResponse): _177.QueryShowPostResponseAmino;
+                fromAminoMsg(object: _177.QueryShowPostResponseAminoMsg): _177.QueryShowPostResponse;
+                fromProtoMsg(message: _177.QueryShowPostResponseProtoMsg): _177.QueryShowPostResponse;
+                toProto(message: _177.QueryShowPostResponse): Uint8Array;
+                toProtoMsg(message: _177.QueryShowPostResponse): _177.QueryShowPostResponseProtoMsg;
+            };
+            QueryListPostRequest: {
+                typeUrl: string;
+                encode(message: _177.QueryListPostRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _177.QueryListPostRequest;
+                fromPartial(object: import("../helpers").DeepPartial<_177.QueryListPostRequest>): _177.QueryListPostRequest;
+                fromAmino(object: _177.QueryListPostRequestAmino): _177.QueryListPostRequest;
+                toAmino(message: _177.QueryListPostRequest): _177.QueryListPostRequestAmino;
+                fromAminoMsg(object: _177.QueryListPostRequestAminoMsg): _177.QueryListPostRequest;
+                fromProtoMsg(message: _177.QueryListPostRequestProtoMsg): _177.QueryListPostRequest;
+                toProto(message: _177.QueryListPostRequest): Uint8Array;
+                toProtoMsg(message: _177.QueryListPostRequest): _177.QueryListPostRequestProtoMsg;
+            };
+            QueryListPostResponse: {
+                typeUrl: string;
+                encode(message: _177.QueryListPostResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _177.QueryListPostResponse;
+                fromPartial(object: import("../helpers").DeepPartial<_177.QueryListPostResponse>): _177.QueryListPostResponse;
+                fromAmino(object: _177.QueryListPostResponseAmino): _177.QueryListPostResponse;
+                toAmino(message: _177.QueryListPostResponse): _177.QueryListPostResponseAmino;
+                fromAminoMsg(object: _177.QueryListPostResponseAminoMsg): _177.QueryListPostResponse;
+                fromProtoMsg(message: _177.QueryListPostResponseProtoMsg): _177.QueryListPostResponse;
+                toProto(message: _177.QueryListPostResponse): Uint8Array;
+                toProtoMsg(message: _177.QueryListPostResponse): _177.QueryListPostResponseProtoMsg;
+            };
+            Post: {
+                typeUrl: string;
+                encode(message: _176.Post, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _176.Post;
+                fromPartial(object: import("../helpers").DeepPartial<_176.Post>): _176.Post;
+                fromAmino(object: _176.PostAmino): _176.Post;
+                toAmino(message: _176.Post): _176.PostAmino;
+                fromAminoMsg(object: _176.PostAminoMsg): _176.Post;
+                fromProtoMsg(message: _176.PostProtoMsg): _176.Post;
+                toProto(message: _176.Post): Uint8Array;
+                toProtoMsg(message: _176.Post): _176.PostProtoMsg;
+            };
+            Params: {
+                typeUrl: string;
                 aminoType: string;
-                toAmino: (message: _177.MsgDeletePost) => _177.MsgDeletePostAmino;
-                fromAmino: (object: _177.MsgDeletePostAmino) => _177.MsgDeletePost;
+                encode(_: _175.Params, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _175.Params;
+                fromPartial(_: import("../helpers").DeepPartial<_175.Params>): _175.Params;
+                fromAmino(_: _175.ParamsAmino): _175.Params;
+                toAmino(_: _175.Params): _175.ParamsAmino;
+                fromAminoMsg(object: _175.ParamsAminoMsg): _175.Params;
+                toAminoMsg(message: _175.Params): _175.ParamsAminoMsg;
+                fromProtoMsg(message: _175.ParamsProtoMsg): _175.Params;
+                toProto(message: _175.Params): Uint8Array;
+                toProtoMsg(message: _175.Params): _175.ParamsProtoMsg;
+            };
+            GenesisState: {
+                typeUrl: string;
+                encode(message: _174.GenesisState, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _174.GenesisState;
+                fromPartial(object: import("../helpers").DeepPartial<_174.GenesisState>): _174.GenesisState;
+                fromAmino(object: _174.GenesisStateAmino): _174.GenesisState;
+                toAmino(message: _174.GenesisState): _174.GenesisStateAmino;
+                fromAminoMsg(object: _174.GenesisStateAminoMsg): _174.GenesisState;
+                fromProtoMsg(message: _174.GenesisStateProtoMsg): _174.GenesisState;
+                toProto(message: _174.GenesisState): Uint8Array;
+                toProtoMsg(message: _174.GenesisState): _174.GenesisStateProtoMsg;
             };
         };
-        MsgUpdateParams: {
-            typeUrl: string;
-            aminoType: string;
-            encode(message: _177.MsgUpdateParams, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _177.MsgUpdateParams;
-            fromPartial(object: import("../helpers").DeepPartial<_177.MsgUpdateParams>): _177.MsgUpdateParams;
-            fromAmino(object: _177.MsgUpdateParamsAmino): _177.MsgUpdateParams;
-            toAmino(message: _177.MsgUpdateParams): _177.MsgUpdateParamsAmino;
-            fromAminoMsg(object: _177.MsgUpdateParamsAminoMsg): _177.MsgUpdateParams;
-            toAminoMsg(message: _177.MsgUpdateParams): _177.MsgUpdateParamsAminoMsg;
-            fromProtoMsg(message: _177.MsgUpdateParamsProtoMsg): _177.MsgUpdateParams;
-            toProto(message: _177.MsgUpdateParams): Uint8Array;
-            toProtoMsg(message: _177.MsgUpdateParams): _177.MsgUpdateParamsProtoMsg;
-        };
-        MsgUpdateParamsResponse: {
-            typeUrl: string;
-            encode(_: _177.MsgUpdateParamsResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _177.MsgUpdateParamsResponse;
-            fromPartial(_: import("../helpers").DeepPartial<_177.MsgUpdateParamsResponse>): _177.MsgUpdateParamsResponse;
-            fromAmino(_: _177.MsgUpdateParamsResponseAmino): _177.MsgUpdateParamsResponse;
-            toAmino(_: _177.MsgUpdateParamsResponse): _177.MsgUpdateParamsResponseAmino;
-            fromAminoMsg(object: _177.MsgUpdateParamsResponseAminoMsg): _177.MsgUpdateParamsResponse;
-            fromProtoMsg(message: _177.MsgUpdateParamsResponseProtoMsg): _177.MsgUpdateParamsResponse;
-            toProto(message: _177.MsgUpdateParamsResponse): Uint8Array;
-            toProtoMsg(message: _177.MsgUpdateParamsResponse): _177.MsgUpdateParamsResponseProtoMsg;
-        };
-        MsgCreatePost: {
-            typeUrl: string;
-            encode(message: _177.MsgCreatePost, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _177.MsgCreatePost;
-            fromPartial(object: import("../helpers").DeepPartial<_177.MsgCreatePost>): _177.MsgCreatePost;
-            fromAmino(object: _177.MsgCreatePostAmino): _177.MsgCreatePost;
-            toAmino(message: _177.MsgCreatePost): _177.MsgCreatePostAmino;
-            fromAminoMsg(object: _177.MsgCreatePostAminoMsg): _177.MsgCreatePost;
-            fromProtoMsg(message: _177.MsgCreatePostProtoMsg): _177.MsgCreatePost;
-            toProto(message: _177.MsgCreatePost): Uint8Array;
-            toProtoMsg(message: _177.MsgCreatePost): _177.MsgCreatePostProtoMsg;
-        };
-        MsgCreatePostResponse: {
-            typeUrl: string;
-            encode(message: _177.MsgCreatePostResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _177.MsgCreatePostResponse;
-            fromPartial(object: import("../helpers").DeepPartial<_177.MsgCreatePostResponse>): _177.MsgCreatePostResponse;
-            fromAmino(object: _177.MsgCreatePostResponseAmino): _177.MsgCreatePostResponse;
-            toAmino(message: _177.MsgCreatePostResponse): _177.MsgCreatePostResponseAmino;
-            fromAminoMsg(object: _177.MsgCreatePostResponseAminoMsg): _177.MsgCreatePostResponse;
-            fromProtoMsg(message: _177.MsgCreatePostResponseProtoMsg): _177.MsgCreatePostResponse;
-            toProto(message: _177.MsgCreatePostResponse): Uint8Array;
-            toProtoMsg(message: _177.MsgCreatePostResponse): _177.MsgCreatePostResponseProtoMsg;
-        };
-        MsgUpdatePost: {
-            typeUrl: string;
-            encode(message: _177.MsgUpdatePost, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _177.MsgUpdatePost;
-            fromPartial(object: import("../helpers").DeepPartial<_177.MsgUpdatePost>): _177.MsgUpdatePost;
-            fromAmino(object: _177.MsgUpdatePostAmino): _177.MsgUpdatePost;
-            toAmino(message: _177.MsgUpdatePost): _177.MsgUpdatePostAmino;
-            fromAminoMsg(object: _177.MsgUpdatePostAminoMsg): _177.MsgUpdatePost;
-            fromProtoMsg(message: _177.MsgUpdatePostProtoMsg): _177.MsgUpdatePost;
-            toProto(message: _177.MsgUpdatePost): Uint8Array;
-            toProtoMsg(message: _177.MsgUpdatePost): _177.MsgUpdatePostProtoMsg;
-        };
-        MsgUpdatePostResponse: {
-            typeUrl: string;
-            encode(_: _177.MsgUpdatePostResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _177.MsgUpdatePostResponse;
-            fromPartial(_: import("../helpers").DeepPartial<_177.MsgUpdatePostResponse>): _177.MsgUpdatePostResponse;
-            fromAmino(_: _177.MsgUpdatePostResponseAmino): _177.MsgUpdatePostResponse;
-            toAmino(_: _177.MsgUpdatePostResponse): _177.MsgUpdatePostResponseAmino;
-            fromAminoMsg(object: _177.MsgUpdatePostResponseAminoMsg): _177.MsgUpdatePostResponse;
-            fromProtoMsg(message: _177.MsgUpdatePostResponseProtoMsg): _177.MsgUpdatePostResponse;
-            toProto(message: _177.MsgUpdatePostResponse): Uint8Array;
-            toProtoMsg(message: _177.MsgUpdatePostResponse): _177.MsgUpdatePostResponseProtoMsg;
-        };
-        MsgDeletePost: {
-            typeUrl: string;
-            encode(message: _177.MsgDeletePost, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _177.MsgDeletePost;
-            fromPartial(object: import("../helpers").DeepPartial<_177.MsgDeletePost>): _177.MsgDeletePost;
-            fromAmino(object: _177.MsgDeletePostAmino): _177.MsgDeletePost;
-            toAmino(message: _177.MsgDeletePost): _177.MsgDeletePostAmino;
-            fromAminoMsg(object: _177.MsgDeletePostAminoMsg): _177.MsgDeletePost;
-            fromProtoMsg(message: _177.MsgDeletePostProtoMsg): _177.MsgDeletePost;
-            toProto(message: _177.MsgDeletePost): Uint8Array;
-            toProtoMsg(message: _177.MsgDeletePost): _177.MsgDeletePostProtoMsg;
-        };
-        MsgDeletePostResponse: {
-            typeUrl: string;
-            encode(_: _177.MsgDeletePostResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _177.MsgDeletePostResponse;
-            fromPartial(_: import("../helpers").DeepPartial<_177.MsgDeletePostResponse>): _177.MsgDeletePostResponse;
-            fromAmino(_: _177.MsgDeletePostResponseAmino): _177.MsgDeletePostResponse;
-            toAmino(_: _177.MsgDeletePostResponse): _177.MsgDeletePostResponseAmino;
-            fromAminoMsg(object: _177.MsgDeletePostResponseAminoMsg): _177.MsgDeletePostResponse;
-            fromProtoMsg(message: _177.MsgDeletePostResponseProtoMsg): _177.MsgDeletePostResponse;
-            toProto(message: _177.MsgDeletePostResponse): Uint8Array;
-            toProtoMsg(message: _177.MsgDeletePostResponse): _177.MsgDeletePostResponseProtoMsg;
-        };
-        QueryParamsRequest: {
-            typeUrl: string;
-            encode(_: _176.QueryParamsRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _176.QueryParamsRequest;
-            fromPartial(_: import("../helpers").DeepPartial<_176.QueryParamsRequest>): _176.QueryParamsRequest;
-            fromAmino(_: _176.QueryParamsRequestAmino): _176.QueryParamsRequest;
-            toAmino(_: _176.QueryParamsRequest): _176.QueryParamsRequestAmino;
-            fromAminoMsg(object: _176.QueryParamsRequestAminoMsg): _176.QueryParamsRequest;
-            fromProtoMsg(message: _176.QueryParamsRequestProtoMsg): _176.QueryParamsRequest;
-            toProto(message: _176.QueryParamsRequest): Uint8Array;
-            toProtoMsg(message: _176.QueryParamsRequest): _176.QueryParamsRequestProtoMsg;
-        };
-        QueryParamsResponse: {
-            typeUrl: string;
-            encode(message: _176.QueryParamsResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _176.QueryParamsResponse;
-            fromPartial(object: import("../helpers").DeepPartial<_176.QueryParamsResponse>): _176.QueryParamsResponse;
-            fromAmino(object: _176.QueryParamsResponseAmino): _176.QueryParamsResponse;
-            toAmino(message: _176.QueryParamsResponse): _176.QueryParamsResponseAmino;
-            fromAminoMsg(object: _176.QueryParamsResponseAminoMsg): _176.QueryParamsResponse;
-            fromProtoMsg(message: _176.QueryParamsResponseProtoMsg): _176.QueryParamsResponse;
-            toProto(message: _176.QueryParamsResponse): Uint8Array;
-            toProtoMsg(message: _176.QueryParamsResponse): _176.QueryParamsResponseProtoMsg;
-        };
-        QueryShowPostRequest: {
-            typeUrl: string;
-            encode(message: _176.QueryShowPostRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _176.QueryShowPostRequest;
-            fromPartial(object: import("../helpers").DeepPartial<_176.QueryShowPostRequest>): _176.QueryShowPostRequest;
-            fromAmino(object: _176.QueryShowPostRequestAmino): _176.QueryShowPostRequest;
-            toAmino(message: _176.QueryShowPostRequest): _176.QueryShowPostRequestAmino;
-            fromAminoMsg(object: _176.QueryShowPostRequestAminoMsg): _176.QueryShowPostRequest;
-            fromProtoMsg(message: _176.QueryShowPostRequestProtoMsg): _176.QueryShowPostRequest;
-            toProto(message: _176.QueryShowPostRequest): Uint8Array;
-            toProtoMsg(message: _176.QueryShowPostRequest): _176.QueryShowPostRequestProtoMsg;
-        };
-        QueryShowPostResponse: {
-            typeUrl: string;
-            encode(message: _176.QueryShowPostResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _176.QueryShowPostResponse;
-            fromPartial(object: import("../helpers").DeepPartial<_176.QueryShowPostResponse>): _176.QueryShowPostResponse;
-            fromAmino(object: _176.QueryShowPostResponseAmino): _176.QueryShowPostResponse;
-            toAmino(message: _176.QueryShowPostResponse): _176.QueryShowPostResponseAmino;
-            fromAminoMsg(object: _176.QueryShowPostResponseAminoMsg): _176.QueryShowPostResponse;
-            fromProtoMsg(message: _176.QueryShowPostResponseProtoMsg): _176.QueryShowPostResponse;
-            toProto(message: _176.QueryShowPostResponse): Uint8Array;
-            toProtoMsg(message: _176.QueryShowPostResponse): _176.QueryShowPostResponseProtoMsg;
-        };
-        QueryListPostRequest: {
-            typeUrl: string;
-            encode(message: _176.QueryListPostRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _176.QueryListPostRequest;
-            fromPartial(object: import("../helpers").DeepPartial<_176.QueryListPostRequest>): _176.QueryListPostRequest;
-            fromAmino(object: _176.QueryListPostRequestAmino): _176.QueryListPostRequest;
-            toAmino(message: _176.QueryListPostRequest): _176.QueryListPostRequestAmino;
-            fromAminoMsg(object: _176.QueryListPostRequestAminoMsg): _176.QueryListPostRequest;
-            fromProtoMsg(message: _176.QueryListPostRequestProtoMsg): _176.QueryListPostRequest;
-            toProto(message: _176.QueryListPostRequest): Uint8Array;
-            toProtoMsg(message: _176.QueryListPostRequest): _176.QueryListPostRequestProtoMsg;
-        };
-        QueryListPostResponse: {
-            typeUrl: string;
-            encode(message: _176.QueryListPostResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _176.QueryListPostResponse;
-            fromPartial(object: import("../helpers").DeepPartial<_176.QueryListPostResponse>): _176.QueryListPostResponse;
-            fromAmino(object: _176.QueryListPostResponseAmino): _176.QueryListPostResponse;
-            toAmino(message: _176.QueryListPostResponse): _176.QueryListPostResponseAmino;
-            fromAminoMsg(object: _176.QueryListPostResponseAminoMsg): _176.QueryListPostResponse;
-            fromProtoMsg(message: _176.QueryListPostResponseProtoMsg): _176.QueryListPostResponse;
-            toProto(message: _176.QueryListPostResponse): Uint8Array;
-            toProtoMsg(message: _176.QueryListPostResponse): _176.QueryListPostResponseProtoMsg;
-        };
-        Post: {
-            typeUrl: string;
-            encode(message: _175.Post, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _175.Post;
-            fromPartial(object: import("../helpers").DeepPartial<_175.Post>): _175.Post;
-            fromAmino(object: _175.PostAmino): _175.Post;
-            toAmino(message: _175.Post): _175.PostAmino;
-            fromAminoMsg(object: _175.PostAminoMsg): _175.Post;
-            fromProtoMsg(message: _175.PostProtoMsg): _175.Post;
-            toProto(message: _175.Post): Uint8Array;
-            toProtoMsg(message: _175.Post): _175.PostProtoMsg;
-        };
-        Params: {
-            typeUrl: string;
-            aminoType: string;
-            encode(_: _174.Params, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _174.Params;
-            fromPartial(_: import("../helpers").DeepPartial<_174.Params>): _174.Params;
-            fromAmino(_: _174.ParamsAmino): _174.Params;
-            toAmino(_: _174.Params): _174.ParamsAmino;
-            fromAminoMsg(object: _174.ParamsAminoMsg): _174.Params;
-            toAminoMsg(message: _174.Params): _174.ParamsAminoMsg;
-            fromProtoMsg(message: _174.ParamsProtoMsg): _174.Params;
-            toProto(message: _174.Params): Uint8Array;
-            toProtoMsg(message: _174.Params): _174.ParamsProtoMsg;
-        };
-        GenesisState: {
-            typeUrl: string;
-            encode(message: _173.GenesisState, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _173.GenesisState;
-            fromPartial(object: import("../helpers").DeepPartial<_173.GenesisState>): _173.GenesisState;
-            fromAmino(object: _173.GenesisStateAmino): _173.GenesisState;
-            toAmino(message: _173.GenesisState): _173.GenesisStateAmino;
-            fromAminoMsg(object: _173.GenesisStateAminoMsg): _173.GenesisState;
-            fromProtoMsg(message: _173.GenesisStateProtoMsg): _173.GenesisState;
-            toProto(message: _173.GenesisState): Uint8Array;
-            toProtoMsg(message: _173.GenesisState): _173.GenesisStateProtoMsg;
-        };
-    };
-    const sparkdream: {
-        MsgClientImpl: typeof _335.MsgClientImpl;
-        createClientImpl: (rpc: import("..").TxRpc) => _335.MsgClientImpl;
-        QueryClientImpl: typeof _333.QueryClientImpl;
-        createRpcQueryExtension: (base: QueryClient) => {
-            params(request?: _180.QueryParamsRequest): Promise<_180.QueryParamsResponse>;
-        };
-        LCDQueryClient: typeof _331.LCDQueryClient;
-        registry: ReadonlyArray<[string, import("..").TelescopeGeneratedType<any, any, any>]>;
-        AminoConverter: {
-            "/sparkdream.sparkdream.MsgUpdateParams": {
+    }
+    namespace sparkdream {
+        namespace module {
+            const v1: {
+                Module: {
+                    typeUrl: string;
+                    encode(message: _179.Module, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _179.Module;
+                    fromPartial(object: import("../helpers").DeepPartial<_179.Module>): _179.Module;
+                    fromAmino(object: _179.ModuleAmino): _179.Module;
+                    toAmino(message: _179.Module): _179.ModuleAmino;
+                    fromAminoMsg(object: _179.ModuleAminoMsg): _179.Module;
+                    fromProtoMsg(message: _179.ModuleProtoMsg): _179.Module;
+                    toProto(message: _179.Module): Uint8Array;
+                    toProtoMsg(message: _179.Module): _179.ModuleProtoMsg;
+                };
+            };
+        }
+        const v1: {
+            MsgClientImpl: typeof _337.MsgClientImpl;
+            createClientImpl: (rpc: import("..").TxRpc) => _337.MsgClientImpl;
+            QueryClientImpl: typeof _335.QueryClientImpl;
+            createRpcQueryExtension: (base: QueryClient) => {
+                params(request?: _182.QueryParamsRequest): Promise<_182.QueryParamsResponse>;
+            };
+            LCDQueryClient: typeof _333.LCDQueryClient;
+            registry: ReadonlyArray<[string, import("..").TelescopeGeneratedType<any, any, any>]>;
+            load: (protoRegistry: Registry) => void;
+            MessageComposer: {
+                encoded: {
+                    updateParams(value: _183.MsgUpdateParams): {
+                        typeUrl: string;
+                        value: Uint8Array<ArrayBufferLike>;
+                    };
+                };
+                withTypeUrl: {
+                    updateParams(value: _183.MsgUpdateParams): {
+                        typeUrl: string;
+                        value: _183.MsgUpdateParams;
+                    };
+                };
+                fromPartial: {
+                    updateParams(value: _183.MsgUpdateParams): {
+                        typeUrl: string;
+                        value: _183.MsgUpdateParams;
+                    };
+                };
+            };
+            AminoConverter: {
+                "/sparkdream.sparkdream.v1.MsgUpdateParams": {
+                    aminoType: string;
+                    toAmino: (message: _183.MsgUpdateParams) => _183.MsgUpdateParamsAmino;
+                    fromAmino: (object: _183.MsgUpdateParamsAmino) => _183.MsgUpdateParams;
+                };
+            };
+            MsgUpdateParams: {
+                typeUrl: string;
                 aminoType: string;
-                toAmino: (message: _181.MsgUpdateParams) => _181.MsgUpdateParamsAmino;
-                fromAmino: (object: _181.MsgUpdateParamsAmino) => _181.MsgUpdateParams;
+                encode(message: _183.MsgUpdateParams, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _183.MsgUpdateParams;
+                fromPartial(object: import("../helpers").DeepPartial<_183.MsgUpdateParams>): _183.MsgUpdateParams;
+                fromAmino(object: _183.MsgUpdateParamsAmino): _183.MsgUpdateParams;
+                toAmino(message: _183.MsgUpdateParams): _183.MsgUpdateParamsAmino;
+                fromAminoMsg(object: _183.MsgUpdateParamsAminoMsg): _183.MsgUpdateParams;
+                toAminoMsg(message: _183.MsgUpdateParams): _183.MsgUpdateParamsAminoMsg;
+                fromProtoMsg(message: _183.MsgUpdateParamsProtoMsg): _183.MsgUpdateParams;
+                toProto(message: _183.MsgUpdateParams): Uint8Array;
+                toProtoMsg(message: _183.MsgUpdateParams): _183.MsgUpdateParamsProtoMsg;
+            };
+            MsgUpdateParamsResponse: {
+                typeUrl: string;
+                encode(_: _183.MsgUpdateParamsResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _183.MsgUpdateParamsResponse;
+                fromPartial(_: import("../helpers").DeepPartial<_183.MsgUpdateParamsResponse>): _183.MsgUpdateParamsResponse;
+                fromAmino(_: _183.MsgUpdateParamsResponseAmino): _183.MsgUpdateParamsResponse;
+                toAmino(_: _183.MsgUpdateParamsResponse): _183.MsgUpdateParamsResponseAmino;
+                fromAminoMsg(object: _183.MsgUpdateParamsResponseAminoMsg): _183.MsgUpdateParamsResponse;
+                fromProtoMsg(message: _183.MsgUpdateParamsResponseProtoMsg): _183.MsgUpdateParamsResponse;
+                toProto(message: _183.MsgUpdateParamsResponse): Uint8Array;
+                toProtoMsg(message: _183.MsgUpdateParamsResponse): _183.MsgUpdateParamsResponseProtoMsg;
+            };
+            QueryParamsRequest: {
+                typeUrl: string;
+                encode(_: _182.QueryParamsRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _182.QueryParamsRequest;
+                fromPartial(_: import("../helpers").DeepPartial<_182.QueryParamsRequest>): _182.QueryParamsRequest;
+                fromAmino(_: _182.QueryParamsRequestAmino): _182.QueryParamsRequest;
+                toAmino(_: _182.QueryParamsRequest): _182.QueryParamsRequestAmino;
+                fromAminoMsg(object: _182.QueryParamsRequestAminoMsg): _182.QueryParamsRequest;
+                fromProtoMsg(message: _182.QueryParamsRequestProtoMsg): _182.QueryParamsRequest;
+                toProto(message: _182.QueryParamsRequest): Uint8Array;
+                toProtoMsg(message: _182.QueryParamsRequest): _182.QueryParamsRequestProtoMsg;
+            };
+            QueryParamsResponse: {
+                typeUrl: string;
+                encode(message: _182.QueryParamsResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _182.QueryParamsResponse;
+                fromPartial(object: import("../helpers").DeepPartial<_182.QueryParamsResponse>): _182.QueryParamsResponse;
+                fromAmino(object: _182.QueryParamsResponseAmino): _182.QueryParamsResponse;
+                toAmino(message: _182.QueryParamsResponse): _182.QueryParamsResponseAmino;
+                fromAminoMsg(object: _182.QueryParamsResponseAminoMsg): _182.QueryParamsResponse;
+                fromProtoMsg(message: _182.QueryParamsResponseProtoMsg): _182.QueryParamsResponse;
+                toProto(message: _182.QueryParamsResponse): Uint8Array;
+                toProtoMsg(message: _182.QueryParamsResponse): _182.QueryParamsResponseProtoMsg;
+            };
+            Params: {
+                typeUrl: string;
+                aminoType: string;
+                encode(_: _181.Params, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _181.Params;
+                fromPartial(_: import("../helpers").DeepPartial<_181.Params>): _181.Params;
+                fromAmino(_: _181.ParamsAmino): _181.Params;
+                toAmino(_: _181.Params): _181.ParamsAmino;
+                fromAminoMsg(object: _181.ParamsAminoMsg): _181.Params;
+                toAminoMsg(message: _181.Params): _181.ParamsAminoMsg;
+                fromProtoMsg(message: _181.ParamsProtoMsg): _181.Params;
+                toProto(message: _181.Params): Uint8Array;
+                toProtoMsg(message: _181.Params): _181.ParamsProtoMsg;
+            };
+            GenesisState: {
+                typeUrl: string;
+                encode(message: _180.GenesisState, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _180.GenesisState;
+                fromPartial(object: import("../helpers").DeepPartial<_180.GenesisState>): _180.GenesisState;
+                fromAmino(object: _180.GenesisStateAmino): _180.GenesisState;
+                toAmino(message: _180.GenesisState): _180.GenesisStateAmino;
+                fromAminoMsg(object: _180.GenesisStateAminoMsg): _180.GenesisState;
+                fromProtoMsg(message: _180.GenesisStateProtoMsg): _180.GenesisState;
+                toProto(message: _180.GenesisState): Uint8Array;
+                toProtoMsg(message: _180.GenesisState): _180.GenesisStateProtoMsg;
             };
         };
-        MsgUpdateParams: {
-            typeUrl: string;
-            aminoType: string;
-            encode(message: _181.MsgUpdateParams, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _181.MsgUpdateParams;
-            fromPartial(object: import("../helpers").DeepPartial<_181.MsgUpdateParams>): _181.MsgUpdateParams;
-            fromAmino(object: _181.MsgUpdateParamsAmino): _181.MsgUpdateParams;
-            toAmino(message: _181.MsgUpdateParams): _181.MsgUpdateParamsAmino;
-            fromAminoMsg(object: _181.MsgUpdateParamsAminoMsg): _181.MsgUpdateParams;
-            toAminoMsg(message: _181.MsgUpdateParams): _181.MsgUpdateParamsAminoMsg;
-            fromProtoMsg(message: _181.MsgUpdateParamsProtoMsg): _181.MsgUpdateParams;
-            toProto(message: _181.MsgUpdateParams): Uint8Array;
-            toProtoMsg(message: _181.MsgUpdateParams): _181.MsgUpdateParamsProtoMsg;
-        };
-        MsgUpdateParamsResponse: {
-            typeUrl: string;
-            encode(_: _181.MsgUpdateParamsResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _181.MsgUpdateParamsResponse;
-            fromPartial(_: import("../helpers").DeepPartial<_181.MsgUpdateParamsResponse>): _181.MsgUpdateParamsResponse;
-            fromAmino(_: _181.MsgUpdateParamsResponseAmino): _181.MsgUpdateParamsResponse;
-            toAmino(_: _181.MsgUpdateParamsResponse): _181.MsgUpdateParamsResponseAmino;
-            fromAminoMsg(object: _181.MsgUpdateParamsResponseAminoMsg): _181.MsgUpdateParamsResponse;
-            fromProtoMsg(message: _181.MsgUpdateParamsResponseProtoMsg): _181.MsgUpdateParamsResponse;
-            toProto(message: _181.MsgUpdateParamsResponse): Uint8Array;
-            toProtoMsg(message: _181.MsgUpdateParamsResponse): _181.MsgUpdateParamsResponseProtoMsg;
-        };
-        QueryParamsRequest: {
-            typeUrl: string;
-            encode(_: _180.QueryParamsRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _180.QueryParamsRequest;
-            fromPartial(_: import("../helpers").DeepPartial<_180.QueryParamsRequest>): _180.QueryParamsRequest;
-            fromAmino(_: _180.QueryParamsRequestAmino): _180.QueryParamsRequest;
-            toAmino(_: _180.QueryParamsRequest): _180.QueryParamsRequestAmino;
-            fromAminoMsg(object: _180.QueryParamsRequestAminoMsg): _180.QueryParamsRequest;
-            fromProtoMsg(message: _180.QueryParamsRequestProtoMsg): _180.QueryParamsRequest;
-            toProto(message: _180.QueryParamsRequest): Uint8Array;
-            toProtoMsg(message: _180.QueryParamsRequest): _180.QueryParamsRequestProtoMsg;
-        };
-        QueryParamsResponse: {
-            typeUrl: string;
-            encode(message: _180.QueryParamsResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _180.QueryParamsResponse;
-            fromPartial(object: import("../helpers").DeepPartial<_180.QueryParamsResponse>): _180.QueryParamsResponse;
-            fromAmino(object: _180.QueryParamsResponseAmino): _180.QueryParamsResponse;
-            toAmino(message: _180.QueryParamsResponse): _180.QueryParamsResponseAmino;
-            fromAminoMsg(object: _180.QueryParamsResponseAminoMsg): _180.QueryParamsResponse;
-            fromProtoMsg(message: _180.QueryParamsResponseProtoMsg): _180.QueryParamsResponse;
-            toProto(message: _180.QueryParamsResponse): Uint8Array;
-            toProtoMsg(message: _180.QueryParamsResponse): _180.QueryParamsResponseProtoMsg;
-        };
-        Params: {
-            typeUrl: string;
-            aminoType: string;
-            encode(_: _179.Params, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _179.Params;
-            fromPartial(_: import("../helpers").DeepPartial<_179.Params>): _179.Params;
-            fromAmino(_: _179.ParamsAmino): _179.Params;
-            toAmino(_: _179.Params): _179.ParamsAmino;
-            fromAminoMsg(object: _179.ParamsAminoMsg): _179.Params;
-            toAminoMsg(message: _179.Params): _179.ParamsAminoMsg;
-            fromProtoMsg(message: _179.ParamsProtoMsg): _179.Params;
-            toProto(message: _179.Params): Uint8Array;
-            toProtoMsg(message: _179.Params): _179.ParamsProtoMsg;
-        };
-        GenesisState: {
-            typeUrl: string;
-            encode(message: _178.GenesisState, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
-            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _178.GenesisState;
-            fromPartial(object: import("../helpers").DeepPartial<_178.GenesisState>): _178.GenesisState;
-            fromAmino(object: _178.GenesisStateAmino): _178.GenesisState;
-            toAmino(message: _178.GenesisState): _178.GenesisStateAmino;
-            fromAminoMsg(object: _178.GenesisStateAminoMsg): _178.GenesisState;
-            fromProtoMsg(message: _178.GenesisStateProtoMsg): _178.GenesisState;
-            toProto(message: _178.GenesisState): Uint8Array;
-            toProtoMsg(message: _178.GenesisState): _178.GenesisStateProtoMsg;
-        };
-    };
+    }
     const ClientFactory: {
         createRPCMsgClient: ({ rpc }: {
             rpc: import("../helpers").Rpc;
@@ -405,8 +521,12 @@ export declare namespace sparkdream {
                 };
             };
             sparkdream: {
-                blog: _334.MsgClientImpl;
-                sparkdream: _335.MsgClientImpl;
+                blog: {
+                    v1: _336.MsgClientImpl;
+                };
+                sparkdream: {
+                    v1: _337.MsgClientImpl;
+                };
             };
         }>;
         createRPCQueryClient: ({ rpcEndpoint }: {
@@ -616,12 +736,16 @@ export declare namespace sparkdream {
             };
             sparkdream: {
                 blog: {
-                    params(request?: _176.QueryParamsRequest): Promise<_176.QueryParamsResponse>;
-                    showPost(request: _176.QueryShowPostRequest): Promise<_176.QueryShowPostResponse>;
-                    listPost(request?: _176.QueryListPostRequest): Promise<_176.QueryListPostResponse>;
+                    v1: {
+                        params(request?: _177.QueryParamsRequest): Promise<_177.QueryParamsResponse>;
+                        showPost(request: _177.QueryShowPostRequest): Promise<_177.QueryShowPostResponse>;
+                        listPost(request?: _177.QueryListPostRequest): Promise<_177.QueryListPostResponse>;
+                    };
                 };
                 sparkdream: {
-                    params(request?: _180.QueryParamsRequest): Promise<_180.QueryParamsResponse>;
+                    v1: {
+                        params(request?: _182.QueryParamsRequest): Promise<_182.QueryParamsResponse>;
+                    };
                 };
             };
         }>;
@@ -685,8 +809,12 @@ export declare namespace sparkdream {
                 };
             };
             sparkdream: {
-                blog: _330.LCDQueryClient;
-                sparkdream: _331.LCDQueryClient;
+                blog: {
+                    v1: _332.LCDQueryClient;
+                };
+                sparkdream: {
+                    v1: _333.LCDQueryClient;
+                };
             };
         }>;
     };