@sparkdreamnft/sparkdreamjs 0.0.6 → 0.0.7

package/sparkdream/bundle.d.ts

@@ -1,335 +1,335 @@
-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";
+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 {
     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;
+                    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;
                 };
             };
         }
         const v1: {
-            MsgClientImpl: typeof _336.MsgClientImpl;
-            createClientImpl: (rpc: import("..").TxRpc) => _336.MsgClientImpl;
-            QueryClientImpl: typeof _334.QueryClientImpl;
+            MsgClientImpl: typeof _342.MsgClientImpl;
+            createClientImpl: (rpc: import("..").TxRpc) => _342.MsgClientImpl;
+            QueryClientImpl: typeof _340.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>;
+                params(request?: _179.QueryParamsRequest): Promise<_179.QueryParamsResponse>;
+                showPost(request: _179.QueryShowPostRequest): Promise<_179.QueryShowPostResponse>;
+                listPost(request?: _179.QueryListPostRequest): Promise<_179.QueryListPostResponse>;
             };
-            LCDQueryClient: typeof _332.LCDQueryClient;
+            LCDQueryClient: typeof _338.LCDQueryClient;
             registry: ReadonlyArray<[string, import("..").TelescopeGeneratedType<any, any, any>]>;
             load: (protoRegistry: Registry) => void;
             MessageComposer: {
                 encoded: {
-                    updateParams(value: _178.MsgUpdateParams): {
+                    updateParams(value: _180.MsgUpdateParams): {
                         typeUrl: string;
                         value: Uint8Array<ArrayBufferLike>;
                     };
-                    createPost(value: _178.MsgCreatePost): {
+                    createPost(value: _180.MsgCreatePost): {
                         typeUrl: string;
                         value: Uint8Array<ArrayBufferLike>;
                     };
-                    updatePost(value: _178.MsgUpdatePost): {
+                    updatePost(value: _180.MsgUpdatePost): {
                         typeUrl: string;
                         value: Uint8Array<ArrayBufferLike>;
                     };
-                    deletePost(value: _178.MsgDeletePost): {
+                    deletePost(value: _180.MsgDeletePost): {
                         typeUrl: string;
                         value: Uint8Array<ArrayBufferLike>;
                     };
                 };
                 withTypeUrl: {
-                    updateParams(value: _178.MsgUpdateParams): {
+                    updateParams(value: _180.MsgUpdateParams): {
                         typeUrl: string;
-                        value: _178.MsgUpdateParams;
+                        value: _180.MsgUpdateParams;
                     };
-                    createPost(value: _178.MsgCreatePost): {
+                    createPost(value: _180.MsgCreatePost): {
                         typeUrl: string;
-                        value: _178.MsgCreatePost;
+                        value: _180.MsgCreatePost;
                     };
-                    updatePost(value: _178.MsgUpdatePost): {
+                    updatePost(value: _180.MsgUpdatePost): {
                         typeUrl: string;
-                        value: _178.MsgUpdatePost;
+                        value: _180.MsgUpdatePost;
                     };
-                    deletePost(value: _178.MsgDeletePost): {
+                    deletePost(value: _180.MsgDeletePost): {
                         typeUrl: string;
-                        value: _178.MsgDeletePost;
+                        value: _180.MsgDeletePost;
                     };
                 };
                 fromPartial: {
-                    updateParams(value: _178.MsgUpdateParams): {
+                    updateParams(value: _180.MsgUpdateParams): {
                         typeUrl: string;
-                        value: _178.MsgUpdateParams;
+                        value: _180.MsgUpdateParams;
                     };
-                    createPost(value: _178.MsgCreatePost): {
+                    createPost(value: _180.MsgCreatePost): {
                         typeUrl: string;
-                        value: _178.MsgCreatePost;
+                        value: _180.MsgCreatePost;
                     };
-                    updatePost(value: _178.MsgUpdatePost): {
+                    updatePost(value: _180.MsgUpdatePost): {
                         typeUrl: string;
-                        value: _178.MsgUpdatePost;
+                        value: _180.MsgUpdatePost;
                     };
-                    deletePost(value: _178.MsgDeletePost): {
+                    deletePost(value: _180.MsgDeletePost): {
                         typeUrl: string;
-                        value: _178.MsgDeletePost;
+                        value: _180.MsgDeletePost;
                     };
                 };
             };
             AminoConverter: {
                 "/sparkdream.blog.v1.MsgUpdateParams": {
                     aminoType: string;
-                    toAmino: (message: _178.MsgUpdateParams) => _178.MsgUpdateParamsAmino;
-                    fromAmino: (object: _178.MsgUpdateParamsAmino) => _178.MsgUpdateParams;
+                    toAmino: (message: _180.MsgUpdateParams) => _180.MsgUpdateParamsAmino;
+                    fromAmino: (object: _180.MsgUpdateParamsAmino) => _180.MsgUpdateParams;
                 };
                 "/sparkdream.blog.v1.MsgCreatePost": {
                     aminoType: string;
-                    toAmino: (message: _178.MsgCreatePost) => _178.MsgCreatePostAmino;
-                    fromAmino: (object: _178.MsgCreatePostAmino) => _178.MsgCreatePost;
+                    toAmino: (message: _180.MsgCreatePost) => _180.MsgCreatePostAmino;
+                    fromAmino: (object: _180.MsgCreatePostAmino) => _180.MsgCreatePost;
                 };
                 "/sparkdream.blog.v1.MsgUpdatePost": {
                     aminoType: string;
-                    toAmino: (message: _178.MsgUpdatePost) => _178.MsgUpdatePostAmino;
-                    fromAmino: (object: _178.MsgUpdatePostAmino) => _178.MsgUpdatePost;
+                    toAmino: (message: _180.MsgUpdatePost) => _180.MsgUpdatePostAmino;
+                    fromAmino: (object: _180.MsgUpdatePostAmino) => _180.MsgUpdatePost;
                 };
                 "/sparkdream.blog.v1.MsgDeletePost": {
                     aminoType: string;
-                    toAmino: (message: _178.MsgDeletePost) => _178.MsgDeletePostAmino;
-                    fromAmino: (object: _178.MsgDeletePostAmino) => _178.MsgDeletePost;
+                    toAmino: (message: _180.MsgDeletePost) => _180.MsgDeletePostAmino;
+                    fromAmino: (object: _180.MsgDeletePostAmino) => _180.MsgDeletePost;
                 };
             };
             MsgUpdateParams: {
                 typeUrl: string;
                 aminoType: string;
-                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;
+                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;
             };
             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;
+                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;
             };
             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;
+                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: _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;
+                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: _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;
+                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(_: _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;
+                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: _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;
+                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(_: _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;
+                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;
             };
             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;
+                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: _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;
+                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: _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;
+                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: _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;
+                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: _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;
+                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: _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;
+                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: _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;
+                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;
-                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;
+                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: _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;
+                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;
             };
         };
     }
@@ -338,130 +338,130 @@ export declare namespace sparkdream {
             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;
+                    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;
                 };
             };
         }
         const v1: {
-            MsgClientImpl: typeof _337.MsgClientImpl;
-            createClientImpl: (rpc: import("..").TxRpc) => _337.MsgClientImpl;
-            QueryClientImpl: typeof _335.QueryClientImpl;
+            MsgClientImpl: typeof _343.MsgClientImpl;
+            createClientImpl: (rpc: import("..").TxRpc) => _343.MsgClientImpl;
+            QueryClientImpl: typeof _341.QueryClientImpl;
             createRpcQueryExtension: (base: QueryClient) => {
-                params(request?: _182.QueryParamsRequest): Promise<_182.QueryParamsResponse>;
+                params(request?: _184.QueryParamsRequest): Promise<_184.QueryParamsResponse>;
             };
-            LCDQueryClient: typeof _333.LCDQueryClient;
+            LCDQueryClient: typeof _339.LCDQueryClient;
             registry: ReadonlyArray<[string, import("..").TelescopeGeneratedType<any, any, any>]>;
             load: (protoRegistry: Registry) => void;
             MessageComposer: {
                 encoded: {
-                    updateParams(value: _183.MsgUpdateParams): {
+                    updateParams(value: _185.MsgUpdateParams): {
                         typeUrl: string;
                         value: Uint8Array<ArrayBufferLike>;
                     };
                 };
                 withTypeUrl: {
-                    updateParams(value: _183.MsgUpdateParams): {
+                    updateParams(value: _185.MsgUpdateParams): {
                         typeUrl: string;
-                        value: _183.MsgUpdateParams;
+                        value: _185.MsgUpdateParams;
                     };
                 };
                 fromPartial: {
-                    updateParams(value: _183.MsgUpdateParams): {
+                    updateParams(value: _185.MsgUpdateParams): {
                         typeUrl: string;
-                        value: _183.MsgUpdateParams;
+                        value: _185.MsgUpdateParams;
                     };
                 };
             };
             AminoConverter: {
                 "/sparkdream.sparkdream.v1.MsgUpdateParams": {
                     aminoType: string;
-                    toAmino: (message: _183.MsgUpdateParams) => _183.MsgUpdateParamsAmino;
-                    fromAmino: (object: _183.MsgUpdateParamsAmino) => _183.MsgUpdateParams;
+                    toAmino: (message: _185.MsgUpdateParams) => _185.MsgUpdateParamsAmino;
+                    fromAmino: (object: _185.MsgUpdateParamsAmino) => _185.MsgUpdateParams;
                 };
             };
             MsgUpdateParams: {
                 typeUrl: string;
                 aminoType: string;
-                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;
+                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(_: _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;
+                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(_: _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;
+                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: _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;
+                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(_: _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;
+                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: _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;
+                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;
             };
         };
     }
@@ -522,10 +522,10 @@ export declare namespace sparkdream {
             };
             sparkdream: {
                 blog: {
-                    v1: _336.MsgClientImpl;
+                    v1: _342.MsgClientImpl;
                 };
                 sparkdream: {
-                    v1: _337.MsgClientImpl;
+                    v1: _343.MsgClientImpl;
                 };
             };
         }>;
@@ -563,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>;
@@ -671,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>;
@@ -737,14 +729,14 @@ export declare namespace sparkdream {
             sparkdream: {
                 blog: {
                     v1: {
-                        params(request?: _177.QueryParamsRequest): Promise<_177.QueryParamsResponse>;
-                        showPost(request: _177.QueryShowPostRequest): Promise<_177.QueryShowPostResponse>;
-                        listPost(request?: _177.QueryListPostRequest): Promise<_177.QueryListPostResponse>;
+                        params(request?: _179.QueryParamsRequest): Promise<_179.QueryParamsResponse>;
+                        showPost(request: _179.QueryShowPostRequest): Promise<_179.QueryShowPostResponse>;
+                        listPost(request?: _179.QueryListPostRequest): Promise<_179.QueryListPostResponse>;
                     };
                 };
                 sparkdream: {
                     v1: {
-                        params(request?: _182.QueryParamsRequest): Promise<_182.QueryParamsResponse>;
+                        params(request?: _184.QueryParamsRequest): Promise<_184.QueryParamsResponse>;
                     };
                 };
             };
@@ -810,10 +802,10 @@ export declare namespace sparkdream {
             };
             sparkdream: {
                 blog: {
-                    v1: _332.LCDQueryClient;
+                    v1: _338.LCDQueryClient;
                 };
                 sparkdream: {
-                    v1: _333.LCDQueryClient;
+                    v1: _339.LCDQueryClient;
                 };
             };
         }>;