@sparkdreamnft/sparkdreamjs 0.0.5 → 0.0.7

package/sparkdream/bundle.d.ts

@@ -1,432 +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 _175 from "./blog/module/v1/module";
+import * as _176 from "./blog/v1/genesis";
+import * as _177 from "./blog/v1/params";
+import * as _178 from "./blog/v1/post";
+import * as _179 from "./blog/v1/query";
+import * as _180 from "./blog/v1/tx";
+import * as _181 from "./sparkdream/module/v1/module";
+import * as _182 from "./sparkdream/v1/genesis";
+import * as _183 from "./sparkdream/v1/params";
+import * as _184 from "./sparkdream/v1/query";
+import * as _185 from "./sparkdream/v1/tx";
+import * as _338 from "./blog/v1/query.lcd";
+import * as _339 from "./sparkdream/v1/query.lcd";
+import * as _340 from "./blog/v1/query.rpc.Query";
+import * as _341 from "./sparkdream/v1/query.rpc.Query";
+import * as _342 from "./blog/v1/tx.rpc.msg";
+import * as _343 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>]>;
-        load: (protoRegistry: Registry) => void;
-        MessageComposer: {
-            encoded: {
-                updateParams(value: _177.MsgUpdateParams): {
-                    typeUrl: string;
-                    value: Uint8Array<ArrayBufferLike>;
-                };
-                createPost(value: _177.MsgCreatePost): {
-                    typeUrl: string;
-                    value: Uint8Array<ArrayBufferLike>;
-                };
-                updatePost(value: _177.MsgUpdatePost): {
-                    typeUrl: string;
-                    value: Uint8Array<ArrayBufferLike>;
-                };
-                deletePost(value: _177.MsgDeletePost): {
+    namespace blog {
+        namespace module {
+            const v1: {
+                Module: {
                     typeUrl: string;
-                    value: Uint8Array<ArrayBufferLike>;
+                    encode(message: _175.Module, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _175.Module;
+                    fromPartial(object: import("../helpers").DeepPartial<_175.Module>): _175.Module;
+                    fromAmino(object: _175.ModuleAmino): _175.Module;
+                    toAmino(message: _175.Module): _175.ModuleAmino;
+                    fromAminoMsg(object: _175.ModuleAminoMsg): _175.Module;
+                    fromProtoMsg(message: _175.ModuleProtoMsg): _175.Module;
+                    toProto(message: _175.Module): Uint8Array;
+                    toProtoMsg(message: _175.Module): _175.ModuleProtoMsg;
                 };
             };
-            withTypeUrl: {
-                updateParams(value: _177.MsgUpdateParams): {
-                    typeUrl: string;
-                    value: _177.MsgUpdateParams;
-                };
-                createPost(value: _177.MsgCreatePost): {
-                    typeUrl: string;
-                    value: _177.MsgCreatePost;
-                };
-                updatePost(value: _177.MsgUpdatePost): {
-                    typeUrl: string;
-                    value: _177.MsgUpdatePost;
-                };
-                deletePost(value: _177.MsgDeletePost): {
-                    typeUrl: string;
-                    value: _177.MsgDeletePost;
-                };
+        }
+        const v1: {
+            MsgClientImpl: typeof _342.MsgClientImpl;
+            createClientImpl: (rpc: import("..").TxRpc) => _342.MsgClientImpl;
+            QueryClientImpl: typeof _340.QueryClientImpl;
+            createRpcQueryExtension: (base: QueryClient) => {
+                params(request?: _179.QueryParamsRequest): Promise<_179.QueryParamsResponse>;
+                showPost(request: _179.QueryShowPostRequest): Promise<_179.QueryShowPostResponse>;
+                listPost(request?: _179.QueryListPostRequest): Promise<_179.QueryListPostResponse>;
             };
-            fromPartial: {
-                updateParams(value: _177.MsgUpdateParams): {
-                    typeUrl: string;
-                    value: _177.MsgUpdateParams;
+            LCDQueryClient: typeof _338.LCDQueryClient;
+            registry: ReadonlyArray<[string, import("..").TelescopeGeneratedType<any, any, any>]>;
+            load: (protoRegistry: Registry) => void;
+            MessageComposer: {
+                encoded: {
+                    updateParams(value: _180.MsgUpdateParams): {
+                        typeUrl: string;
+                        value: Uint8Array<ArrayBufferLike>;
+                    };
+                    createPost(value: _180.MsgCreatePost): {
+                        typeUrl: string;
+                        value: Uint8Array<ArrayBufferLike>;
+                    };
+                    updatePost(value: _180.MsgUpdatePost): {
+                        typeUrl: string;
+                        value: Uint8Array<ArrayBufferLike>;
+                    };
+                    deletePost(value: _180.MsgDeletePost): {
+                        typeUrl: string;
+                        value: Uint8Array<ArrayBufferLike>;
+                    };
                 };
-                createPost(value: _177.MsgCreatePost): {
-                    typeUrl: string;
-                    value: _177.MsgCreatePost;
+                withTypeUrl: {
+                    updateParams(value: _180.MsgUpdateParams): {
+                        typeUrl: string;
+                        value: _180.MsgUpdateParams;
+                    };
+                    createPost(value: _180.MsgCreatePost): {
+                        typeUrl: string;
+                        value: _180.MsgCreatePost;
+                    };
+                    updatePost(value: _180.MsgUpdatePost): {
+                        typeUrl: string;
+                        value: _180.MsgUpdatePost;
+                    };
+                    deletePost(value: _180.MsgDeletePost): {
+                        typeUrl: string;
+                        value: _180.MsgDeletePost;
+                    };
                 };
-                updatePost(value: _177.MsgUpdatePost): {
-                    typeUrl: string;
-                    value: _177.MsgUpdatePost;
+                fromPartial: {
+                    updateParams(value: _180.MsgUpdateParams): {
+                        typeUrl: string;
+                        value: _180.MsgUpdateParams;
+                    };
+                    createPost(value: _180.MsgCreatePost): {
+                        typeUrl: string;
+                        value: _180.MsgCreatePost;
+                    };
+                    updatePost(value: _180.MsgUpdatePost): {
+                        typeUrl: string;
+                        value: _180.MsgUpdatePost;
+                    };
+                    deletePost(value: _180.MsgDeletePost): {
+                        typeUrl: string;
+                        value: _180.MsgDeletePost;
+                    };
                 };
-                deletePost(value: _177.MsgDeletePost): {
-                    typeUrl: string;
-                    value: _177.MsgDeletePost;
+            };
+            AminoConverter: {
+                "/sparkdream.blog.v1.MsgUpdateParams": {
+                    aminoType: string;
+                    toAmino: (message: _180.MsgUpdateParams) => _180.MsgUpdateParamsAmino;
+                    fromAmino: (object: _180.MsgUpdateParamsAmino) => _180.MsgUpdateParams;
+                };
+                "/sparkdream.blog.v1.MsgCreatePost": {
+                    aminoType: string;
+                    toAmino: (message: _180.MsgCreatePost) => _180.MsgCreatePostAmino;
+                    fromAmino: (object: _180.MsgCreatePostAmino) => _180.MsgCreatePost;
+                };
+                "/sparkdream.blog.v1.MsgUpdatePost": {
+                    aminoType: string;
+                    toAmino: (message: _180.MsgUpdatePost) => _180.MsgUpdatePostAmino;
+                    fromAmino: (object: _180.MsgUpdatePostAmino) => _180.MsgUpdatePost;
+                };
+                "/sparkdream.blog.v1.MsgDeletePost": {
+                    aminoType: string;
+                    toAmino: (message: _180.MsgDeletePost) => _180.MsgDeletePostAmino;
+                    fromAmino: (object: _180.MsgDeletePostAmino) => _180.MsgDeletePost;
                 };
             };
-        };
-        AminoConverter: {
-            "/sparkdream.blog.MsgUpdateParams": {
+            MsgUpdateParams: {
+                typeUrl: string;
                 aminoType: string;
-                toAmino: (message: _177.MsgUpdateParams) => _177.MsgUpdateParamsAmino;
-                fromAmino: (object: _177.MsgUpdateParamsAmino) => _177.MsgUpdateParams;
+                encode(message: _180.MsgUpdateParams, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _180.MsgUpdateParams;
+                fromPartial(object: import("../helpers").DeepPartial<_180.MsgUpdateParams>): _180.MsgUpdateParams;
+                fromAmino(object: _180.MsgUpdateParamsAmino): _180.MsgUpdateParams;
+                toAmino(message: _180.MsgUpdateParams): _180.MsgUpdateParamsAmino;
+                fromAminoMsg(object: _180.MsgUpdateParamsAminoMsg): _180.MsgUpdateParams;
+                toAminoMsg(message: _180.MsgUpdateParams): _180.MsgUpdateParamsAminoMsg;
+                fromProtoMsg(message: _180.MsgUpdateParamsProtoMsg): _180.MsgUpdateParams;
+                toProto(message: _180.MsgUpdateParams): Uint8Array;
+                toProtoMsg(message: _180.MsgUpdateParams): _180.MsgUpdateParamsProtoMsg;
             };
-            "/sparkdream.blog.MsgCreatePost": {
-                aminoType: string;
-                toAmino: (message: _177.MsgCreatePost) => _177.MsgCreatePostAmino;
-                fromAmino: (object: _177.MsgCreatePostAmino) => _177.MsgCreatePost;
+            MsgUpdateParamsResponse: {
+                typeUrl: string;
+                encode(_: _180.MsgUpdateParamsResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _180.MsgUpdateParamsResponse;
+                fromPartial(_: import("../helpers").DeepPartial<_180.MsgUpdateParamsResponse>): _180.MsgUpdateParamsResponse;
+                fromAmino(_: _180.MsgUpdateParamsResponseAmino): _180.MsgUpdateParamsResponse;
+                toAmino(_: _180.MsgUpdateParamsResponse): _180.MsgUpdateParamsResponseAmino;
+                fromAminoMsg(object: _180.MsgUpdateParamsResponseAminoMsg): _180.MsgUpdateParamsResponse;
+                fromProtoMsg(message: _180.MsgUpdateParamsResponseProtoMsg): _180.MsgUpdateParamsResponse;
+                toProto(message: _180.MsgUpdateParamsResponse): Uint8Array;
+                toProtoMsg(message: _180.MsgUpdateParamsResponse): _180.MsgUpdateParamsResponseProtoMsg;
             };
-            "/sparkdream.blog.MsgUpdatePost": {
-                aminoType: string;
-                toAmino: (message: _177.MsgUpdatePost) => _177.MsgUpdatePostAmino;
-                fromAmino: (object: _177.MsgUpdatePostAmino) => _177.MsgUpdatePost;
+            MsgCreatePost: {
+                typeUrl: 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;
+                fromProtoMsg(message: _180.MsgCreatePostProtoMsg): _180.MsgCreatePost;
+                toProto(message: _180.MsgCreatePost): Uint8Array;
+                toProtoMsg(message: _180.MsgCreatePost): _180.MsgCreatePostProtoMsg;
+            };
+            MsgCreatePostResponse: {
+                typeUrl: string;
+                encode(message: _180.MsgCreatePostResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _180.MsgCreatePostResponse;
+                fromPartial(object: import("../helpers").DeepPartial<_180.MsgCreatePostResponse>): _180.MsgCreatePostResponse;
+                fromAmino(object: _180.MsgCreatePostResponseAmino): _180.MsgCreatePostResponse;
+                toAmino(message: _180.MsgCreatePostResponse): _180.MsgCreatePostResponseAmino;
+                fromAminoMsg(object: _180.MsgCreatePostResponseAminoMsg): _180.MsgCreatePostResponse;
+                fromProtoMsg(message: _180.MsgCreatePostResponseProtoMsg): _180.MsgCreatePostResponse;
+                toProto(message: _180.MsgCreatePostResponse): Uint8Array;
+                toProtoMsg(message: _180.MsgCreatePostResponse): _180.MsgCreatePostResponseProtoMsg;
+            };
+            MsgUpdatePost: {
+                typeUrl: 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;
+                fromProtoMsg(message: _180.MsgUpdatePostProtoMsg): _180.MsgUpdatePost;
+                toProto(message: _180.MsgUpdatePost): Uint8Array;
+                toProtoMsg(message: _180.MsgUpdatePost): _180.MsgUpdatePostProtoMsg;
+            };
+            MsgUpdatePostResponse: {
+                typeUrl: string;
+                encode(_: _180.MsgUpdatePostResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _180.MsgUpdatePostResponse;
+                fromPartial(_: import("../helpers").DeepPartial<_180.MsgUpdatePostResponse>): _180.MsgUpdatePostResponse;
+                fromAmino(_: _180.MsgUpdatePostResponseAmino): _180.MsgUpdatePostResponse;
+                toAmino(_: _180.MsgUpdatePostResponse): _180.MsgUpdatePostResponseAmino;
+                fromAminoMsg(object: _180.MsgUpdatePostResponseAminoMsg): _180.MsgUpdatePostResponse;
+                fromProtoMsg(message: _180.MsgUpdatePostResponseProtoMsg): _180.MsgUpdatePostResponse;
+                toProto(message: _180.MsgUpdatePostResponse): Uint8Array;
+                toProtoMsg(message: _180.MsgUpdatePostResponse): _180.MsgUpdatePostResponseProtoMsg;
+            };
+            MsgDeletePost: {
+                typeUrl: 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;
+                fromProtoMsg(message: _180.MsgDeletePostProtoMsg): _180.MsgDeletePost;
+                toProto(message: _180.MsgDeletePost): Uint8Array;
+                toProtoMsg(message: _180.MsgDeletePost): _180.MsgDeletePostProtoMsg;
+            };
+            MsgDeletePostResponse: {
+                typeUrl: string;
+                encode(_: _180.MsgDeletePostResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _180.MsgDeletePostResponse;
+                fromPartial(_: import("../helpers").DeepPartial<_180.MsgDeletePostResponse>): _180.MsgDeletePostResponse;
+                fromAmino(_: _180.MsgDeletePostResponseAmino): _180.MsgDeletePostResponse;
+                toAmino(_: _180.MsgDeletePostResponse): _180.MsgDeletePostResponseAmino;
+                fromAminoMsg(object: _180.MsgDeletePostResponseAminoMsg): _180.MsgDeletePostResponse;
+                fromProtoMsg(message: _180.MsgDeletePostResponseProtoMsg): _180.MsgDeletePostResponse;
+                toProto(message: _180.MsgDeletePostResponse): Uint8Array;
+                toProtoMsg(message: _180.MsgDeletePostResponse): _180.MsgDeletePostResponseProtoMsg;
             };
-            "/sparkdream.blog.MsgDeletePost": {
+            QueryParamsRequest: {
+                typeUrl: string;
+                encode(_: _179.QueryParamsRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _179.QueryParamsRequest;
+                fromPartial(_: import("../helpers").DeepPartial<_179.QueryParamsRequest>): _179.QueryParamsRequest;
+                fromAmino(_: _179.QueryParamsRequestAmino): _179.QueryParamsRequest;
+                toAmino(_: _179.QueryParamsRequest): _179.QueryParamsRequestAmino;
+                fromAminoMsg(object: _179.QueryParamsRequestAminoMsg): _179.QueryParamsRequest;
+                fromProtoMsg(message: _179.QueryParamsRequestProtoMsg): _179.QueryParamsRequest;
+                toProto(message: _179.QueryParamsRequest): Uint8Array;
+                toProtoMsg(message: _179.QueryParamsRequest): _179.QueryParamsRequestProtoMsg;
+            };
+            QueryParamsResponse: {
+                typeUrl: string;
+                encode(message: _179.QueryParamsResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _179.QueryParamsResponse;
+                fromPartial(object: import("../helpers").DeepPartial<_179.QueryParamsResponse>): _179.QueryParamsResponse;
+                fromAmino(object: _179.QueryParamsResponseAmino): _179.QueryParamsResponse;
+                toAmino(message: _179.QueryParamsResponse): _179.QueryParamsResponseAmino;
+                fromAminoMsg(object: _179.QueryParamsResponseAminoMsg): _179.QueryParamsResponse;
+                fromProtoMsg(message: _179.QueryParamsResponseProtoMsg): _179.QueryParamsResponse;
+                toProto(message: _179.QueryParamsResponse): Uint8Array;
+                toProtoMsg(message: _179.QueryParamsResponse): _179.QueryParamsResponseProtoMsg;
+            };
+            QueryShowPostRequest: {
+                typeUrl: string;
+                encode(message: _179.QueryShowPostRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _179.QueryShowPostRequest;
+                fromPartial(object: import("../helpers").DeepPartial<_179.QueryShowPostRequest>): _179.QueryShowPostRequest;
+                fromAmino(object: _179.QueryShowPostRequestAmino): _179.QueryShowPostRequest;
+                toAmino(message: _179.QueryShowPostRequest): _179.QueryShowPostRequestAmino;
+                fromAminoMsg(object: _179.QueryShowPostRequestAminoMsg): _179.QueryShowPostRequest;
+                fromProtoMsg(message: _179.QueryShowPostRequestProtoMsg): _179.QueryShowPostRequest;
+                toProto(message: _179.QueryShowPostRequest): Uint8Array;
+                toProtoMsg(message: _179.QueryShowPostRequest): _179.QueryShowPostRequestProtoMsg;
+            };
+            QueryShowPostResponse: {
+                typeUrl: string;
+                encode(message: _179.QueryShowPostResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _179.QueryShowPostResponse;
+                fromPartial(object: import("../helpers").DeepPartial<_179.QueryShowPostResponse>): _179.QueryShowPostResponse;
+                fromAmino(object: _179.QueryShowPostResponseAmino): _179.QueryShowPostResponse;
+                toAmino(message: _179.QueryShowPostResponse): _179.QueryShowPostResponseAmino;
+                fromAminoMsg(object: _179.QueryShowPostResponseAminoMsg): _179.QueryShowPostResponse;
+                fromProtoMsg(message: _179.QueryShowPostResponseProtoMsg): _179.QueryShowPostResponse;
+                toProto(message: _179.QueryShowPostResponse): Uint8Array;
+                toProtoMsg(message: _179.QueryShowPostResponse): _179.QueryShowPostResponseProtoMsg;
+            };
+            QueryListPostRequest: {
+                typeUrl: string;
+                encode(message: _179.QueryListPostRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _179.QueryListPostRequest;
+                fromPartial(object: import("../helpers").DeepPartial<_179.QueryListPostRequest>): _179.QueryListPostRequest;
+                fromAmino(object: _179.QueryListPostRequestAmino): _179.QueryListPostRequest;
+                toAmino(message: _179.QueryListPostRequest): _179.QueryListPostRequestAmino;
+                fromAminoMsg(object: _179.QueryListPostRequestAminoMsg): _179.QueryListPostRequest;
+                fromProtoMsg(message: _179.QueryListPostRequestProtoMsg): _179.QueryListPostRequest;
+                toProto(message: _179.QueryListPostRequest): Uint8Array;
+                toProtoMsg(message: _179.QueryListPostRequest): _179.QueryListPostRequestProtoMsg;
+            };
+            QueryListPostResponse: {
+                typeUrl: string;
+                encode(message: _179.QueryListPostResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _179.QueryListPostResponse;
+                fromPartial(object: import("../helpers").DeepPartial<_179.QueryListPostResponse>): _179.QueryListPostResponse;
+                fromAmino(object: _179.QueryListPostResponseAmino): _179.QueryListPostResponse;
+                toAmino(message: _179.QueryListPostResponse): _179.QueryListPostResponseAmino;
+                fromAminoMsg(object: _179.QueryListPostResponseAminoMsg): _179.QueryListPostResponse;
+                fromProtoMsg(message: _179.QueryListPostResponseProtoMsg): _179.QueryListPostResponse;
+                toProto(message: _179.QueryListPostResponse): Uint8Array;
+                toProtoMsg(message: _179.QueryListPostResponse): _179.QueryListPostResponseProtoMsg;
+            };
+            Post: {
+                typeUrl: string;
+                encode(message: _178.Post, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _178.Post;
+                fromPartial(object: import("../helpers").DeepPartial<_178.Post>): _178.Post;
+                fromAmino(object: _178.PostAmino): _178.Post;
+                toAmino(message: _178.Post): _178.PostAmino;
+                fromAminoMsg(object: _178.PostAminoMsg): _178.Post;
+                fromProtoMsg(message: _178.PostProtoMsg): _178.Post;
+                toProto(message: _178.Post): Uint8Array;
+                toProtoMsg(message: _178.Post): _178.PostProtoMsg;
+            };
+            Params: {
+                typeUrl: string;
                 aminoType: string;
-                toAmino: (message: _177.MsgDeletePost) => _177.MsgDeletePostAmino;
-                fromAmino: (object: _177.MsgDeletePostAmino) => _177.MsgDeletePost;
+                encode(_: _177.Params, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _177.Params;
+                fromPartial(_: import("../helpers").DeepPartial<_177.Params>): _177.Params;
+                fromAmino(_: _177.ParamsAmino): _177.Params;
+                toAmino(_: _177.Params): _177.ParamsAmino;
+                fromAminoMsg(object: _177.ParamsAminoMsg): _177.Params;
+                toAminoMsg(message: _177.Params): _177.ParamsAminoMsg;
+                fromProtoMsg(message: _177.ParamsProtoMsg): _177.Params;
+                toProto(message: _177.Params): Uint8Array;
+                toProtoMsg(message: _177.Params): _177.ParamsProtoMsg;
+            };
+            GenesisState: {
+                typeUrl: string;
+                encode(message: _176.GenesisState, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _176.GenesisState;
+                fromPartial(object: import("../helpers").DeepPartial<_176.GenesisState>): _176.GenesisState;
+                fromAmino(object: _176.GenesisStateAmino): _176.GenesisState;
+                toAmino(message: _176.GenesisState): _176.GenesisStateAmino;
+                fromAminoMsg(object: _176.GenesisStateAminoMsg): _176.GenesisState;
+                fromProtoMsg(message: _176.GenesisStateProtoMsg): _176.GenesisState;
+                toProto(message: _176.GenesisState): Uint8Array;
+                toProtoMsg(message: _176.GenesisState): _176.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>]>;
-        load: (protoRegistry: Registry) => void;
-        MessageComposer: {
-            encoded: {
-                updateParams(value: _181.MsgUpdateParams): {
+    }
+    namespace sparkdream {
+        namespace module {
+            const v1: {
+                Module: {
                     typeUrl: string;
-                    value: Uint8Array<ArrayBufferLike>;
+                    encode(message: _181.Module, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _181.Module;
+                    fromPartial(object: import("../helpers").DeepPartial<_181.Module>): _181.Module;
+                    fromAmino(object: _181.ModuleAmino): _181.Module;
+                    toAmino(message: _181.Module): _181.ModuleAmino;
+                    fromAminoMsg(object: _181.ModuleAminoMsg): _181.Module;
+                    fromProtoMsg(message: _181.ModuleProtoMsg): _181.Module;
+                    toProto(message: _181.Module): Uint8Array;
+                    toProtoMsg(message: _181.Module): _181.ModuleProtoMsg;
                 };
             };
-            withTypeUrl: {
-                updateParams(value: _181.MsgUpdateParams): {
-                    typeUrl: string;
-                    value: _181.MsgUpdateParams;
+        }
+        const v1: {
+            MsgClientImpl: typeof _343.MsgClientImpl;
+            createClientImpl: (rpc: import("..").TxRpc) => _343.MsgClientImpl;
+            QueryClientImpl: typeof _341.QueryClientImpl;
+            createRpcQueryExtension: (base: QueryClient) => {
+                params(request?: _184.QueryParamsRequest): Promise<_184.QueryParamsResponse>;
+            };
+            LCDQueryClient: typeof _339.LCDQueryClient;
+            registry: ReadonlyArray<[string, import("..").TelescopeGeneratedType<any, any, any>]>;
+            load: (protoRegistry: Registry) => void;
+            MessageComposer: {
+                encoded: {
+                    updateParams(value: _185.MsgUpdateParams): {
+                        typeUrl: string;
+                        value: Uint8Array<ArrayBufferLike>;
+                    };
+                };
+                withTypeUrl: {
+                    updateParams(value: _185.MsgUpdateParams): {
+                        typeUrl: string;
+                        value: _185.MsgUpdateParams;
+                    };
+                };
+                fromPartial: {
+                    updateParams(value: _185.MsgUpdateParams): {
+                        typeUrl: string;
+                        value: _185.MsgUpdateParams;
+                    };
                 };
             };
-            fromPartial: {
-                updateParams(value: _181.MsgUpdateParams): {
-                    typeUrl: string;
-                    value: _181.MsgUpdateParams;
+            AminoConverter: {
+                "/sparkdream.sparkdream.v1.MsgUpdateParams": {
+                    aminoType: string;
+                    toAmino: (message: _185.MsgUpdateParams) => _185.MsgUpdateParamsAmino;
+                    fromAmino: (object: _185.MsgUpdateParamsAmino) => _185.MsgUpdateParams;
                 };
             };
-        };
-        AminoConverter: {
-            "/sparkdream.sparkdream.MsgUpdateParams": {
+            MsgUpdateParams: {
+                typeUrl: string;
                 aminoType: string;
-                toAmino: (message: _181.MsgUpdateParams) => _181.MsgUpdateParamsAmino;
-                fromAmino: (object: _181.MsgUpdateParamsAmino) => _181.MsgUpdateParams;
+                encode(message: _185.MsgUpdateParams, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _185.MsgUpdateParams;
+                fromPartial(object: import("../helpers").DeepPartial<_185.MsgUpdateParams>): _185.MsgUpdateParams;
+                fromAmino(object: _185.MsgUpdateParamsAmino): _185.MsgUpdateParams;
+                toAmino(message: _185.MsgUpdateParams): _185.MsgUpdateParamsAmino;
+                fromAminoMsg(object: _185.MsgUpdateParamsAminoMsg): _185.MsgUpdateParams;
+                toAminoMsg(message: _185.MsgUpdateParams): _185.MsgUpdateParamsAminoMsg;
+                fromProtoMsg(message: _185.MsgUpdateParamsProtoMsg): _185.MsgUpdateParams;
+                toProto(message: _185.MsgUpdateParams): Uint8Array;
+                toProtoMsg(message: _185.MsgUpdateParams): _185.MsgUpdateParamsProtoMsg;
+            };
+            MsgUpdateParamsResponse: {
+                typeUrl: string;
+                encode(_: _185.MsgUpdateParamsResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _185.MsgUpdateParamsResponse;
+                fromPartial(_: import("../helpers").DeepPartial<_185.MsgUpdateParamsResponse>): _185.MsgUpdateParamsResponse;
+                fromAmino(_: _185.MsgUpdateParamsResponseAmino): _185.MsgUpdateParamsResponse;
+                toAmino(_: _185.MsgUpdateParamsResponse): _185.MsgUpdateParamsResponseAmino;
+                fromAminoMsg(object: _185.MsgUpdateParamsResponseAminoMsg): _185.MsgUpdateParamsResponse;
+                fromProtoMsg(message: _185.MsgUpdateParamsResponseProtoMsg): _185.MsgUpdateParamsResponse;
+                toProto(message: _185.MsgUpdateParamsResponse): Uint8Array;
+                toProtoMsg(message: _185.MsgUpdateParamsResponse): _185.MsgUpdateParamsResponseProtoMsg;
+            };
+            QueryParamsRequest: {
+                typeUrl: string;
+                encode(_: _184.QueryParamsRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _184.QueryParamsRequest;
+                fromPartial(_: import("../helpers").DeepPartial<_184.QueryParamsRequest>): _184.QueryParamsRequest;
+                fromAmino(_: _184.QueryParamsRequestAmino): _184.QueryParamsRequest;
+                toAmino(_: _184.QueryParamsRequest): _184.QueryParamsRequestAmino;
+                fromAminoMsg(object: _184.QueryParamsRequestAminoMsg): _184.QueryParamsRequest;
+                fromProtoMsg(message: _184.QueryParamsRequestProtoMsg): _184.QueryParamsRequest;
+                toProto(message: _184.QueryParamsRequest): Uint8Array;
+                toProtoMsg(message: _184.QueryParamsRequest): _184.QueryParamsRequestProtoMsg;
+            };
+            QueryParamsResponse: {
+                typeUrl: string;
+                encode(message: _184.QueryParamsResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _184.QueryParamsResponse;
+                fromPartial(object: import("../helpers").DeepPartial<_184.QueryParamsResponse>): _184.QueryParamsResponse;
+                fromAmino(object: _184.QueryParamsResponseAmino): _184.QueryParamsResponse;
+                toAmino(message: _184.QueryParamsResponse): _184.QueryParamsResponseAmino;
+                fromAminoMsg(object: _184.QueryParamsResponseAminoMsg): _184.QueryParamsResponse;
+                fromProtoMsg(message: _184.QueryParamsResponseProtoMsg): _184.QueryParamsResponse;
+                toProto(message: _184.QueryParamsResponse): Uint8Array;
+                toProtoMsg(message: _184.QueryParamsResponse): _184.QueryParamsResponseProtoMsg;
+            };
+            Params: {
+                typeUrl: string;
+                aminoType: string;
+                encode(_: _183.Params, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _183.Params;
+                fromPartial(_: import("../helpers").DeepPartial<_183.Params>): _183.Params;
+                fromAmino(_: _183.ParamsAmino): _183.Params;
+                toAmino(_: _183.Params): _183.ParamsAmino;
+                fromAminoMsg(object: _183.ParamsAminoMsg): _183.Params;
+                toAminoMsg(message: _183.Params): _183.ParamsAminoMsg;
+                fromProtoMsg(message: _183.ParamsProtoMsg): _183.Params;
+                toProto(message: _183.Params): Uint8Array;
+                toProtoMsg(message: _183.Params): _183.ParamsProtoMsg;
+            };
+            GenesisState: {
+                typeUrl: string;
+                encode(message: _182.GenesisState, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _182.GenesisState;
+                fromPartial(object: import("../helpers").DeepPartial<_182.GenesisState>): _182.GenesisState;
+                fromAmino(object: _182.GenesisStateAmino): _182.GenesisState;
+                toAmino(message: _182.GenesisState): _182.GenesisStateAmino;
+                fromAminoMsg(object: _182.GenesisStateAminoMsg): _182.GenesisState;
+                fromProtoMsg(message: _182.GenesisStateProtoMsg): _182.GenesisState;
+                toProto(message: _182.GenesisState): Uint8Array;
+                toProtoMsg(message: _182.GenesisState): _182.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;
@@ -483,8 +521,12 @@ export declare namespace sparkdream {
                 };
             };
             sparkdream: {
-                blog: _334.MsgClientImpl;
-                sparkdream: _335.MsgClientImpl;
+                blog: {
+                    v1: _342.MsgClientImpl;
+                };
+                sparkdream: {
+                    v1: _343.MsgClientImpl;
+                };
             };
         }>;
         createRPCQueryClient: ({ rpcEndpoint }: {
@@ -521,9 +563,9 @@ export declare namespace sparkdream {
                         totalSupply(request?: import("../cosmos/bank/v1beta1/query").QueryTotalSupplyRequest): Promise<import("../cosmos/bank/v1beta1/query").QueryTotalSupplyResponse>;
                         supplyOf(request: import("../cosmos/bank/v1beta1/query").QuerySupplyOfRequest): Promise<import("../cosmos/bank/v1beta1/query").QuerySupplyOfResponse>;
                         params(request?: import("../cosmos/bank/v1beta1/query").QueryParamsRequest): Promise<import("../cosmos/bank/v1beta1/query").QueryParamsResponse>;
+                        denomsMetadata(request?: import("../cosmos/bank/v1beta1/query").QueryDenomsMetadataRequest): Promise<import("../cosmos/bank/v1beta1/query").QueryDenomsMetadataResponse>;
                         denomMetadata(request: import("../cosmos/bank/v1beta1/query").QueryDenomMetadataRequest): Promise<import("../cosmos/bank/v1beta1/query").QueryDenomMetadataResponse>;
                         denomMetadataByQueryString(request: import("../cosmos/bank/v1beta1/query").QueryDenomMetadataByQueryStringRequest): Promise<import("../cosmos/bank/v1beta1/query").QueryDenomMetadataByQueryStringResponse>;
-                        denomsMetadata(request?: import("../cosmos/bank/v1beta1/query").QueryDenomsMetadataRequest): Promise<import("../cosmos/bank/v1beta1/query").QueryDenomsMetadataResponse>;
                         denomOwners(request: import("../cosmos/bank/v1beta1/query").QueryDenomOwnersRequest): Promise<import("../cosmos/bank/v1beta1/query").QueryDenomOwnersResponse>;
                         denomOwnersByQuery(request: import("../cosmos/bank/v1beta1/query").QueryDenomOwnersByQueryRequest): Promise<import("../cosmos/bank/v1beta1/query").QueryDenomOwnersByQueryResponse>;
                         sendEnabled(request: import("../cosmos/bank/v1beta1/query").QuerySendEnabledRequest): Promise<import("../cosmos/bank/v1beta1/query").QuerySendEnabledResponse>;
@@ -629,14 +671,6 @@ export declare namespace sparkdream {
                         annualProvisions(request?: import("../cosmos/mint/v1beta1/query").QueryAnnualProvisionsRequest): Promise<import("../cosmos/mint/v1beta1/query").QueryAnnualProvisionsResponse>;
                     };
                 };
-                orm: {
-                    query: {
-                        v1alpha1: {
-                            get(request: import("../cosmos/orm/query/v1alpha1/query").GetRequest): Promise<import("../cosmos/orm/query/v1alpha1/query").GetResponse>;
-                            list(request: import("../cosmos/orm/query/v1alpha1/query").ListRequest): Promise<import("../cosmos/orm/query/v1alpha1/query").ListResponse>;
-                        };
-                    };
-                };
                 params: {
                     v1beta1: {
                         params(request: import("../cosmos/params/v1beta1/query").QueryParamsRequest): Promise<import("../cosmos/params/v1beta1/query").QueryParamsResponse>;
@@ -694,12 +728,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?: _179.QueryParamsRequest): Promise<_179.QueryParamsResponse>;
+                        showPost(request: _179.QueryShowPostRequest): Promise<_179.QueryShowPostResponse>;
+                        listPost(request?: _179.QueryListPostRequest): Promise<_179.QueryListPostResponse>;
+                    };
                 };
                 sparkdream: {
-                    params(request?: _180.QueryParamsRequest): Promise<_180.QueryParamsResponse>;
+                    v1: {
+                        params(request?: _184.QueryParamsRequest): Promise<_184.QueryParamsResponse>;
+                    };
                 };
             };
         }>;
@@ -763,8 +801,12 @@ export declare namespace sparkdream {
                 };
             };
             sparkdream: {
-                blog: _330.LCDQueryClient;
-                sparkdream: _331.LCDQueryClient;
+                blog: {
+                    v1: _338.LCDQueryClient;
+                };
+                sparkdream: {
+                    v1: _339.LCDQueryClient;
+                };
             };
         }>;
     };