@0xkaleab/sdk-js 0.2.7

package/dist/types/codegen/lumera/bundle.d.ts

@@ -0,0 +1,1972 @@
+import * as _11 from "./supernode/v1/tx";
+import * as _12 from "./supernode/v1/supernode_state";
+import * as _13 from "./supernode/v1/supernode_account_history";
+import * as _14 from "./supernode/v1/super_node";
+import * as _15 from "./supernode/v1/query";
+import * as _16 from "./supernode/v1/params";
+import * as _17 from "./supernode/v1/metrics_aggregate";
+import * as _18 from "./supernode/v1/metrics";
+import * as _19 from "./supernode/v1/ip_address_history";
+import * as _20 from "./supernode/v1/genesis";
+import * as _21 from "./supernode/v1/evidence";
+import * as _22 from "./supernode/module/v1/module";
+import * as _23 from "./lumeraid/tx";
+import * as _24 from "./lumeraid/query";
+import * as _25 from "./lumeraid/params";
+import * as _26 from "./lumeraid/handshake_info";
+import * as _27 from "./lumeraid/genesis";
+import * as _28 from "./claim/tx";
+import * as _29 from "./claim/query";
+import * as _30 from "./claim/params";
+import * as _31 from "./claim/genesis";
+import * as _32 from "./claim/claim_record";
+import * as _33 from "./action/v1/tx";
+import * as _34 from "./action/v1/query";
+import * as _35 from "./action/v1/params";
+import * as _36 from "./action/v1/metadata";
+import * as _37 from "./action/v1/genesis";
+import * as _38 from "./action/v1/action_type";
+import * as _39 from "./action/v1/action_state";
+import * as _40 from "./action/v1/action";
+import * as _41 from "./action/module/v1/module";
+import * as _229 from "./supernode/v1/query.rpc.Query";
+import * as _230 from "./lumeraid/query.rpc.Query";
+import * as _231 from "./claim/query.rpc.Query";
+import * as _232 from "./action/v1/query.rpc.Query";
+import * as _237 from "./supernode/v1/tx.rpc.msg";
+import * as _238 from "./lumeraid/tx.rpc.msg";
+import * as _239 from "./claim/tx.rpc.msg";
+import * as _240 from "./action/v1/tx.rpc.msg";
+export declare namespace lumera {
+    namespace supernode {
+        const v1: {
+            MsgClientImpl: typeof _237.MsgClientImpl;
+            createClientImpl: (rpc: import("..").TxRpc) => _237.MsgClientImpl;
+            updateParams: (client: import("@interchainjs/cosmos").ISigningClient, signerAddress: string, message: _11.MsgUpdateParams | _11.MsgUpdateParams[], fee: import("..").StdFee | "auto", memo: string) => Promise<import("@interchainjs/types").DeliverTxResponse>;
+            registerSupernode: (client: import("@interchainjs/cosmos").ISigningClient, signerAddress: string, message: _11.MsgRegisterSupernode | _11.MsgRegisterSupernode[], fee: import("..").StdFee | "auto", memo: string) => Promise<import("@interchainjs/types").DeliverTxResponse>;
+            deregisterSupernode: (client: import("@interchainjs/cosmos").ISigningClient, signerAddress: string, message: _11.MsgDeregisterSupernode | _11.MsgDeregisterSupernode[], fee: import("..").StdFee | "auto", memo: string) => Promise<import("@interchainjs/types").DeliverTxResponse>;
+            startSupernode: (client: import("@interchainjs/cosmos").ISigningClient, signerAddress: string, message: _11.MsgStartSupernode | _11.MsgStartSupernode[], fee: import("..").StdFee | "auto", memo: string) => Promise<import("@interchainjs/types").DeliverTxResponse>;
+            stopSupernode: (client: import("@interchainjs/cosmos").ISigningClient, signerAddress: string, message: _11.MsgStopSupernode | _11.MsgStopSupernode[], fee: import("..").StdFee | "auto", memo: string) => Promise<import("@interchainjs/types").DeliverTxResponse>;
+            updateSupernode: (client: import("@interchainjs/cosmos").ISigningClient, signerAddress: string, message: _11.MsgUpdateSupernode | _11.MsgUpdateSupernode[], fee: import("..").StdFee | "auto", memo: string) => Promise<import("@interchainjs/types").DeliverTxResponse>;
+            reportSupernodeMetrics: (client: import("@interchainjs/cosmos").ISigningClient, signerAddress: string, message: _11.MsgReportSupernodeMetrics | _11.MsgReportSupernodeMetrics[], fee: import("..").StdFee | "auto", memo: string) => Promise<import("@interchainjs/types").DeliverTxResponse>;
+            QueryClientImpl: typeof _229.QueryClientImpl;
+            createRpcQueryExtension: (base: import("@cosmjs/stargate").QueryClient) => {
+                params(request?: _15.QueryParamsRequest): Promise<_15.QueryParamsResponse>;
+                getSuperNode(request: _15.QueryGetSuperNodeRequest): Promise<_15.QueryGetSuperNodeResponse>;
+                getSuperNodeBySuperNodeAddress(request: _15.QueryGetSuperNodeBySuperNodeAddressRequest): Promise<_15.QueryGetSuperNodeBySuperNodeAddressResponse>;
+                listSuperNodes(request?: _15.QueryListSuperNodesRequest): Promise<_15.QueryListSuperNodesResponse>;
+                getTopSuperNodesForBlock(request: _15.QueryGetTopSuperNodesForBlockRequest): Promise<_15.QueryGetTopSuperNodesForBlockResponse>;
+                getMetrics(request: _15.QueryGetMetricsRequest): Promise<_15.QueryGetMetricsResponse>;
+            };
+            getParams: (client: import("..").EndpointOrRpc, request: _15.QueryParamsRequest) => Promise<_15.QueryParamsResponse>;
+            getGetSuperNode: (client: import("..").EndpointOrRpc, request: _15.QueryGetSuperNodeRequest) => Promise<_15.QueryGetSuperNodeResponse>;
+            getGetSuperNodeBySuperNodeAddress: (client: import("..").EndpointOrRpc, request: _15.QueryGetSuperNodeBySuperNodeAddressRequest) => Promise<_15.QueryGetSuperNodeBySuperNodeAddressResponse>;
+            getListSuperNodes: (client: import("..").EndpointOrRpc, request: _15.QueryListSuperNodesRequest) => Promise<_15.QueryListSuperNodesResponse>;
+            getGetTopSuperNodesForBlock: (client: import("..").EndpointOrRpc, request: _15.QueryGetTopSuperNodesForBlockRequest) => Promise<_15.QueryGetTopSuperNodesForBlockResponse>;
+            getGetMetrics: (client: import("..").EndpointOrRpc, request: _15.QueryGetMetricsRequest) => Promise<_15.QueryGetMetricsResponse>;
+            registry: ReadonlyArray<[string, import("..").TelescopeGeneratedType<any, any, any>]>;
+            AminoConverter: {
+                "/lumera.supernode.v1.MsgUpdateParams": {
+                    aminoType: string;
+                    toAmino: (message: _11.MsgUpdateParams) => _11.MsgUpdateParamsAmino;
+                    fromAmino: (object: _11.MsgUpdateParamsAmino) => _11.MsgUpdateParams;
+                };
+                "/lumera.supernode.v1.MsgRegisterSupernode": {
+                    aminoType: string;
+                    toAmino: (message: _11.MsgRegisterSupernode) => _11.MsgRegisterSupernodeAmino;
+                    fromAmino: (object: _11.MsgRegisterSupernodeAmino) => _11.MsgRegisterSupernode;
+                };
+                "/lumera.supernode.v1.MsgDeregisterSupernode": {
+                    aminoType: string;
+                    toAmino: (message: _11.MsgDeregisterSupernode) => _11.MsgDeregisterSupernodeAmino;
+                    fromAmino: (object: _11.MsgDeregisterSupernodeAmino) => _11.MsgDeregisterSupernode;
+                };
+                "/lumera.supernode.v1.MsgStartSupernode": {
+                    aminoType: string;
+                    toAmino: (message: _11.MsgStartSupernode) => _11.MsgStartSupernodeAmino;
+                    fromAmino: (object: _11.MsgStartSupernodeAmino) => _11.MsgStartSupernode;
+                };
+                "/lumera.supernode.v1.MsgStopSupernode": {
+                    aminoType: string;
+                    toAmino: (message: _11.MsgStopSupernode) => _11.MsgStopSupernodeAmino;
+                    fromAmino: (object: _11.MsgStopSupernodeAmino) => _11.MsgStopSupernode;
+                };
+                "/lumera.supernode.v1.MsgUpdateSupernode": {
+                    aminoType: string;
+                    toAmino: (message: _11.MsgUpdateSupernode) => _11.MsgUpdateSupernodeAmino;
+                    fromAmino: (object: _11.MsgUpdateSupernodeAmino) => _11.MsgUpdateSupernode;
+                };
+                "/lumera.supernode.v1.MsgReportSupernodeMetrics": {
+                    aminoType: string;
+                    toAmino: (message: _11.MsgReportSupernodeMetrics) => _11.MsgReportSupernodeMetricsAmino;
+                    fromAmino: (object: _11.MsgReportSupernodeMetricsAmino) => _11.MsgReportSupernodeMetrics;
+                };
+            };
+            Evidence: {
+                typeUrl: string;
+                is(o: any): o is _21.Evidence;
+                isAmino(o: any): o is _21.EvidenceAmino;
+                encode(message: _21.Evidence, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _21.Evidence;
+                fromPartial(object: import("../helpers").DeepPartial<_21.Evidence>): _21.Evidence;
+                fromAmino(object: _21.EvidenceAmino): _21.Evidence;
+                toAmino(message: _21.Evidence): _21.EvidenceAmino;
+                fromAminoMsg(object: _21.EvidenceAminoMsg): _21.Evidence;
+                fromProtoMsg(message: _21.EvidenceProtoMsg): _21.Evidence;
+                toProto(message: _21.Evidence): Uint8Array;
+                toProtoMsg(message: _21.Evidence): _21.EvidenceProtoMsg;
+                registerTypeUrl(): void;
+            };
+            GenesisState: {
+                typeUrl: string;
+                is(o: any): o is _20.GenesisState;
+                isAmino(o: any): o is _20.GenesisStateAmino;
+                encode(message: _20.GenesisState, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _20.GenesisState;
+                fromPartial(object: import("../helpers").DeepPartial<_20.GenesisState>): _20.GenesisState;
+                fromAmino(object: _20.GenesisStateAmino): _20.GenesisState;
+                toAmino(message: _20.GenesisState): _20.GenesisStateAmino;
+                fromAminoMsg(object: _20.GenesisStateAminoMsg): _20.GenesisState;
+                fromProtoMsg(message: _20.GenesisStateProtoMsg): _20.GenesisState;
+                toProto(message: _20.GenesisState): Uint8Array;
+                toProtoMsg(message: _20.GenesisState): _20.GenesisStateProtoMsg;
+                registerTypeUrl(): void;
+            };
+            IPAddressHistory: {
+                typeUrl: string;
+                is(o: any): o is _19.IPAddressHistory;
+                isAmino(o: any): o is _19.IPAddressHistoryAmino;
+                encode(message: _19.IPAddressHistory, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _19.IPAddressHistory;
+                fromPartial(object: import("../helpers").DeepPartial<_19.IPAddressHistory>): _19.IPAddressHistory;
+                fromAmino(object: _19.IPAddressHistoryAmino): _19.IPAddressHistory;
+                toAmino(message: _19.IPAddressHistory): _19.IPAddressHistoryAmino;
+                fromAminoMsg(object: _19.IPAddressHistoryAminoMsg): _19.IPAddressHistory;
+                fromProtoMsg(message: _19.IPAddressHistoryProtoMsg): _19.IPAddressHistory;
+                toProto(message: _19.IPAddressHistory): Uint8Array;
+                toProtoMsg(message: _19.IPAddressHistory): _19.IPAddressHistoryProtoMsg;
+                registerTypeUrl(): void;
+            };
+            portStateFromJSON(object: any): _18.PortState;
+            portStateToJSON(object: _18.PortState): string;
+            PortState: typeof _18.PortState;
+            PortStateAmino: typeof _18.PortState;
+            PortStatus: {
+                typeUrl: string;
+                is(o: any): o is _18.PortStatus;
+                isAmino(o: any): o is _18.PortStatusAmino;
+                encode(message: _18.PortStatus, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _18.PortStatus;
+                fromPartial(object: import("../helpers").DeepPartial<_18.PortStatus>): _18.PortStatus;
+                fromAmino(object: _18.PortStatusAmino): _18.PortStatus;
+                toAmino(message: _18.PortStatus): _18.PortStatusAmino;
+                fromAminoMsg(object: _18.PortStatusAminoMsg): _18.PortStatus;
+                fromProtoMsg(message: _18.PortStatusProtoMsg): _18.PortStatus;
+                toProto(message: _18.PortStatus): Uint8Array;
+                toProtoMsg(message: _18.PortStatus): _18.PortStatusProtoMsg;
+                registerTypeUrl(): void;
+            };
+            SupernodeMetrics: {
+                typeUrl: string;
+                is(o: any): o is _18.SupernodeMetrics;
+                isAmino(o: any): o is _18.SupernodeMetricsAmino;
+                encode(message: _18.SupernodeMetrics, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _18.SupernodeMetrics;
+                fromPartial(object: import("../helpers").DeepPartial<_18.SupernodeMetrics>): _18.SupernodeMetrics;
+                fromAmino(object: _18.SupernodeMetricsAmino): _18.SupernodeMetrics;
+                toAmino(message: _18.SupernodeMetrics): _18.SupernodeMetricsAmino;
+                fromAminoMsg(object: _18.SupernodeMetricsAminoMsg): _18.SupernodeMetrics;
+                fromProtoMsg(message: _18.SupernodeMetricsProtoMsg): _18.SupernodeMetrics;
+                toProto(message: _18.SupernodeMetrics): Uint8Array;
+                toProtoMsg(message: _18.SupernodeMetrics): _18.SupernodeMetricsProtoMsg;
+                registerTypeUrl(): void;
+            };
+            SupernodeMetricsState: {
+                typeUrl: string;
+                is(o: any): o is _18.SupernodeMetricsState;
+                isAmino(o: any): o is _18.SupernodeMetricsStateAmino;
+                encode(message: _18.SupernodeMetricsState, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _18.SupernodeMetricsState;
+                fromPartial(object: import("../helpers").DeepPartial<_18.SupernodeMetricsState>): _18.SupernodeMetricsState;
+                fromAmino(object: _18.SupernodeMetricsStateAmino): _18.SupernodeMetricsState;
+                toAmino(message: _18.SupernodeMetricsState): _18.SupernodeMetricsStateAmino;
+                fromAminoMsg(object: _18.SupernodeMetricsStateAminoMsg): _18.SupernodeMetricsState;
+                fromProtoMsg(message: _18.SupernodeMetricsStateProtoMsg): _18.SupernodeMetricsState;
+                toProto(message: _18.SupernodeMetricsState): Uint8Array;
+                toProtoMsg(message: _18.SupernodeMetricsState): _18.SupernodeMetricsStateProtoMsg;
+                registerTypeUrl(): void;
+            };
+            MetricsAggregate_MetricsEntry: {
+                encode(message: _17.MetricsAggregate_MetricsEntry, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _17.MetricsAggregate_MetricsEntry;
+                fromPartial(object: import("../helpers").DeepPartial<_17.MetricsAggregate_MetricsEntry>): _17.MetricsAggregate_MetricsEntry;
+                fromAmino(object: _17.MetricsAggregate_MetricsEntryAmino): _17.MetricsAggregate_MetricsEntry;
+                toAmino(message: _17.MetricsAggregate_MetricsEntry): _17.MetricsAggregate_MetricsEntryAmino;
+                fromAminoMsg(object: _17.MetricsAggregate_MetricsEntryAminoMsg): _17.MetricsAggregate_MetricsEntry;
+                fromProtoMsg(message: _17.MetricsAggregate_MetricsEntryProtoMsg): _17.MetricsAggregate_MetricsEntry;
+                toProto(message: _17.MetricsAggregate_MetricsEntry): Uint8Array;
+                registerTypeUrl(): void;
+            };
+            MetricsAggregate: {
+                typeUrl: string;
+                is(o: any): o is _17.MetricsAggregate;
+                isAmino(o: any): o is _17.MetricsAggregateAmino;
+                encode(message: _17.MetricsAggregate, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _17.MetricsAggregate;
+                fromPartial(object: import("../helpers").DeepPartial<_17.MetricsAggregate>): _17.MetricsAggregate;
+                fromAmino(object: _17.MetricsAggregateAmino): _17.MetricsAggregate;
+                toAmino(message: _17.MetricsAggregate): _17.MetricsAggregateAmino;
+                fromAminoMsg(object: _17.MetricsAggregateAminoMsg): _17.MetricsAggregate;
+                fromProtoMsg(message: _17.MetricsAggregateProtoMsg): _17.MetricsAggregate;
+                toProto(message: _17.MetricsAggregate): Uint8Array;
+                toProtoMsg(message: _17.MetricsAggregate): _17.MetricsAggregateProtoMsg;
+                registerTypeUrl(): void;
+            };
+            Params: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _16.Params;
+                isAmino(o: any): o is _16.ParamsAmino;
+                encode(message: _16.Params, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _16.Params;
+                fromPartial(object: import("../helpers").DeepPartial<_16.Params>): _16.Params;
+                fromAmino(object: _16.ParamsAmino): _16.Params;
+                toAmino(message: _16.Params): _16.ParamsAmino;
+                fromAminoMsg(object: _16.ParamsAminoMsg): _16.Params;
+                toAminoMsg(message: _16.Params): _16.ParamsAminoMsg;
+                fromProtoMsg(message: _16.ParamsProtoMsg): _16.Params;
+                toProto(message: _16.Params): Uint8Array;
+                toProtoMsg(message: _16.Params): _16.ParamsProtoMsg;
+                registerTypeUrl(): void;
+            };
+            QueryParamsRequest: {
+                typeUrl: string;
+                is(o: any): o is _15.QueryParamsRequest;
+                isAmino(o: any): o is _15.QueryParamsRequestAmino;
+                encode(_: _15.QueryParamsRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _15.QueryParamsRequest;
+                fromPartial(_: import("../helpers").DeepPartial<_15.QueryParamsRequest>): _15.QueryParamsRequest;
+                fromAmino(_: _15.QueryParamsRequestAmino): _15.QueryParamsRequest;
+                toAmino(_: _15.QueryParamsRequest): _15.QueryParamsRequestAmino;
+                fromAminoMsg(object: _15.QueryParamsRequestAminoMsg): _15.QueryParamsRequest;
+                fromProtoMsg(message: _15.QueryParamsRequestProtoMsg): _15.QueryParamsRequest;
+                toProto(message: _15.QueryParamsRequest): Uint8Array;
+                toProtoMsg(message: _15.QueryParamsRequest): _15.QueryParamsRequestProtoMsg;
+                registerTypeUrl(): void;
+            };
+            QueryParamsResponse: {
+                typeUrl: string;
+                is(o: any): o is _15.QueryParamsResponse;
+                isAmino(o: any): o is _15.QueryParamsResponseAmino;
+                encode(message: _15.QueryParamsResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _15.QueryParamsResponse;
+                fromPartial(object: import("../helpers").DeepPartial<_15.QueryParamsResponse>): _15.QueryParamsResponse;
+                fromAmino(object: _15.QueryParamsResponseAmino): _15.QueryParamsResponse;
+                toAmino(message: _15.QueryParamsResponse): _15.QueryParamsResponseAmino;
+                fromAminoMsg(object: _15.QueryParamsResponseAminoMsg): _15.QueryParamsResponse;
+                fromProtoMsg(message: _15.QueryParamsResponseProtoMsg): _15.QueryParamsResponse;
+                toProto(message: _15.QueryParamsResponse): Uint8Array;
+                toProtoMsg(message: _15.QueryParamsResponse): _15.QueryParamsResponseProtoMsg;
+                registerTypeUrl(): void;
+            };
+            QueryGetSuperNodeRequest: {
+                typeUrl: string;
+                is(o: any): o is _15.QueryGetSuperNodeRequest;
+                isAmino(o: any): o is _15.QueryGetSuperNodeRequestAmino;
+                encode(message: _15.QueryGetSuperNodeRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _15.QueryGetSuperNodeRequest;
+                fromPartial(object: import("../helpers").DeepPartial<_15.QueryGetSuperNodeRequest>): _15.QueryGetSuperNodeRequest;
+                fromAmino(object: _15.QueryGetSuperNodeRequestAmino): _15.QueryGetSuperNodeRequest;
+                toAmino(message: _15.QueryGetSuperNodeRequest): _15.QueryGetSuperNodeRequestAmino;
+                fromAminoMsg(object: _15.QueryGetSuperNodeRequestAminoMsg): _15.QueryGetSuperNodeRequest;
+                fromProtoMsg(message: _15.QueryGetSuperNodeRequestProtoMsg): _15.QueryGetSuperNodeRequest;
+                toProto(message: _15.QueryGetSuperNodeRequest): Uint8Array;
+                toProtoMsg(message: _15.QueryGetSuperNodeRequest): _15.QueryGetSuperNodeRequestProtoMsg;
+                registerTypeUrl(): void;
+            };
+            QueryGetSuperNodeResponse: {
+                typeUrl: string;
+                is(o: any): o is _15.QueryGetSuperNodeResponse;
+                isAmino(o: any): o is _15.QueryGetSuperNodeResponseAmino;
+                encode(message: _15.QueryGetSuperNodeResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _15.QueryGetSuperNodeResponse;
+                fromPartial(object: import("../helpers").DeepPartial<_15.QueryGetSuperNodeResponse>): _15.QueryGetSuperNodeResponse;
+                fromAmino(object: _15.QueryGetSuperNodeResponseAmino): _15.QueryGetSuperNodeResponse;
+                toAmino(message: _15.QueryGetSuperNodeResponse): _15.QueryGetSuperNodeResponseAmino;
+                fromAminoMsg(object: _15.QueryGetSuperNodeResponseAminoMsg): _15.QueryGetSuperNodeResponse;
+                fromProtoMsg(message: _15.QueryGetSuperNodeResponseProtoMsg): _15.QueryGetSuperNodeResponse;
+                toProto(message: _15.QueryGetSuperNodeResponse): Uint8Array;
+                toProtoMsg(message: _15.QueryGetSuperNodeResponse): _15.QueryGetSuperNodeResponseProtoMsg;
+                registerTypeUrl(): void;
+            };
+            QueryGetSuperNodeBySuperNodeAddressRequest: {
+                typeUrl: string;
+                is(o: any): o is _15.QueryGetSuperNodeBySuperNodeAddressRequest;
+                isAmino(o: any): o is _15.QueryGetSuperNodeBySuperNodeAddressRequestAmino;
+                encode(message: _15.QueryGetSuperNodeBySuperNodeAddressRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _15.QueryGetSuperNodeBySuperNodeAddressRequest;
+                fromPartial(object: import("../helpers").DeepPartial<_15.QueryGetSuperNodeBySuperNodeAddressRequest>): _15.QueryGetSuperNodeBySuperNodeAddressRequest;
+                fromAmino(object: _15.QueryGetSuperNodeBySuperNodeAddressRequestAmino): _15.QueryGetSuperNodeBySuperNodeAddressRequest;
+                toAmino(message: _15.QueryGetSuperNodeBySuperNodeAddressRequest): _15.QueryGetSuperNodeBySuperNodeAddressRequestAmino;
+                fromAminoMsg(object: _15.QueryGetSuperNodeBySuperNodeAddressRequestAminoMsg): _15.QueryGetSuperNodeBySuperNodeAddressRequest;
+                fromProtoMsg(message: _15.QueryGetSuperNodeBySuperNodeAddressRequestProtoMsg): _15.QueryGetSuperNodeBySuperNodeAddressRequest;
+                toProto(message: _15.QueryGetSuperNodeBySuperNodeAddressRequest): Uint8Array;
+                toProtoMsg(message: _15.QueryGetSuperNodeBySuperNodeAddressRequest): _15.QueryGetSuperNodeBySuperNodeAddressRequestProtoMsg;
+                registerTypeUrl(): void;
+            };
+            QueryGetSuperNodeBySuperNodeAddressResponse: {
+                typeUrl: string;
+                is(o: any): o is _15.QueryGetSuperNodeBySuperNodeAddressResponse;
+                isAmino(o: any): o is _15.QueryGetSuperNodeBySuperNodeAddressResponseAmino;
+                encode(message: _15.QueryGetSuperNodeBySuperNodeAddressResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _15.QueryGetSuperNodeBySuperNodeAddressResponse;
+                fromPartial(object: import("../helpers").DeepPartial<_15.QueryGetSuperNodeBySuperNodeAddressResponse>): _15.QueryGetSuperNodeBySuperNodeAddressResponse;
+                fromAmino(object: _15.QueryGetSuperNodeBySuperNodeAddressResponseAmino): _15.QueryGetSuperNodeBySuperNodeAddressResponse;
+                toAmino(message: _15.QueryGetSuperNodeBySuperNodeAddressResponse): _15.QueryGetSuperNodeBySuperNodeAddressResponseAmino;
+                fromAminoMsg(object: _15.QueryGetSuperNodeBySuperNodeAddressResponseAminoMsg): _15.QueryGetSuperNodeBySuperNodeAddressResponse;
+                fromProtoMsg(message: _15.QueryGetSuperNodeBySuperNodeAddressResponseProtoMsg): _15.QueryGetSuperNodeBySuperNodeAddressResponse;
+                toProto(message: _15.QueryGetSuperNodeBySuperNodeAddressResponse): Uint8Array;
+                toProtoMsg(message: _15.QueryGetSuperNodeBySuperNodeAddressResponse): _15.QueryGetSuperNodeBySuperNodeAddressResponseProtoMsg;
+                registerTypeUrl(): void;
+            };
+            QueryListSuperNodesRequest: {
+                typeUrl: string;
+                is(o: any): o is _15.QueryListSuperNodesRequest;
+                isAmino(o: any): o is _15.QueryListSuperNodesRequestAmino;
+                encode(message: _15.QueryListSuperNodesRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _15.QueryListSuperNodesRequest;
+                fromPartial(object: import("../helpers").DeepPartial<_15.QueryListSuperNodesRequest>): _15.QueryListSuperNodesRequest;
+                fromAmino(object: _15.QueryListSuperNodesRequestAmino): _15.QueryListSuperNodesRequest;
+                toAmino(message: _15.QueryListSuperNodesRequest): _15.QueryListSuperNodesRequestAmino;
+                fromAminoMsg(object: _15.QueryListSuperNodesRequestAminoMsg): _15.QueryListSuperNodesRequest;
+                fromProtoMsg(message: _15.QueryListSuperNodesRequestProtoMsg): _15.QueryListSuperNodesRequest;
+                toProto(message: _15.QueryListSuperNodesRequest): Uint8Array;
+                toProtoMsg(message: _15.QueryListSuperNodesRequest): _15.QueryListSuperNodesRequestProtoMsg;
+                registerTypeUrl(): void;
+            };
+            QueryListSuperNodesResponse: {
+                typeUrl: string;
+                is(o: any): o is _15.QueryListSuperNodesResponse;
+                isAmino(o: any): o is _15.QueryListSuperNodesResponseAmino;
+                encode(message: _15.QueryListSuperNodesResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _15.QueryListSuperNodesResponse;
+                fromPartial(object: import("../helpers").DeepPartial<_15.QueryListSuperNodesResponse>): _15.QueryListSuperNodesResponse;
+                fromAmino(object: _15.QueryListSuperNodesResponseAmino): _15.QueryListSuperNodesResponse;
+                toAmino(message: _15.QueryListSuperNodesResponse): _15.QueryListSuperNodesResponseAmino;
+                fromAminoMsg(object: _15.QueryListSuperNodesResponseAminoMsg): _15.QueryListSuperNodesResponse;
+                fromProtoMsg(message: _15.QueryListSuperNodesResponseProtoMsg): _15.QueryListSuperNodesResponse;
+                toProto(message: _15.QueryListSuperNodesResponse): Uint8Array;
+                toProtoMsg(message: _15.QueryListSuperNodesResponse): _15.QueryListSuperNodesResponseProtoMsg;
+                registerTypeUrl(): void;
+            };
+            QueryGetTopSuperNodesForBlockRequest: {
+                typeUrl: string;
+                is(o: any): o is _15.QueryGetTopSuperNodesForBlockRequest;
+                isAmino(o: any): o is _15.QueryGetTopSuperNodesForBlockRequestAmino;
+                encode(message: _15.QueryGetTopSuperNodesForBlockRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _15.QueryGetTopSuperNodesForBlockRequest;
+                fromPartial(object: import("../helpers").DeepPartial<_15.QueryGetTopSuperNodesForBlockRequest>): _15.QueryGetTopSuperNodesForBlockRequest;
+                fromAmino(object: _15.QueryGetTopSuperNodesForBlockRequestAmino): _15.QueryGetTopSuperNodesForBlockRequest;
+                toAmino(message: _15.QueryGetTopSuperNodesForBlockRequest): _15.QueryGetTopSuperNodesForBlockRequestAmino;
+                fromAminoMsg(object: _15.QueryGetTopSuperNodesForBlockRequestAminoMsg): _15.QueryGetTopSuperNodesForBlockRequest;
+                fromProtoMsg(message: _15.QueryGetTopSuperNodesForBlockRequestProtoMsg): _15.QueryGetTopSuperNodesForBlockRequest;
+                toProto(message: _15.QueryGetTopSuperNodesForBlockRequest): Uint8Array;
+                toProtoMsg(message: _15.QueryGetTopSuperNodesForBlockRequest): _15.QueryGetTopSuperNodesForBlockRequestProtoMsg;
+                registerTypeUrl(): void;
+            };
+            QueryGetTopSuperNodesForBlockResponse: {
+                typeUrl: string;
+                is(o: any): o is _15.QueryGetTopSuperNodesForBlockResponse;
+                isAmino(o: any): o is _15.QueryGetTopSuperNodesForBlockResponseAmino;
+                encode(message: _15.QueryGetTopSuperNodesForBlockResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _15.QueryGetTopSuperNodesForBlockResponse;
+                fromPartial(object: import("../helpers").DeepPartial<_15.QueryGetTopSuperNodesForBlockResponse>): _15.QueryGetTopSuperNodesForBlockResponse;
+                fromAmino(object: _15.QueryGetTopSuperNodesForBlockResponseAmino): _15.QueryGetTopSuperNodesForBlockResponse;
+                toAmino(message: _15.QueryGetTopSuperNodesForBlockResponse): _15.QueryGetTopSuperNodesForBlockResponseAmino;
+                fromAminoMsg(object: _15.QueryGetTopSuperNodesForBlockResponseAminoMsg): _15.QueryGetTopSuperNodesForBlockResponse;
+                fromProtoMsg(message: _15.QueryGetTopSuperNodesForBlockResponseProtoMsg): _15.QueryGetTopSuperNodesForBlockResponse;
+                toProto(message: _15.QueryGetTopSuperNodesForBlockResponse): Uint8Array;
+                toProtoMsg(message: _15.QueryGetTopSuperNodesForBlockResponse): _15.QueryGetTopSuperNodesForBlockResponseProtoMsg;
+                registerTypeUrl(): void;
+            };
+            QueryGetMetricsRequest: {
+                typeUrl: string;
+                is(o: any): o is _15.QueryGetMetricsRequest;
+                isAmino(o: any): o is _15.QueryGetMetricsRequestAmino;
+                encode(message: _15.QueryGetMetricsRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _15.QueryGetMetricsRequest;
+                fromPartial(object: import("../helpers").DeepPartial<_15.QueryGetMetricsRequest>): _15.QueryGetMetricsRequest;
+                fromAmino(object: _15.QueryGetMetricsRequestAmino): _15.QueryGetMetricsRequest;
+                toAmino(message: _15.QueryGetMetricsRequest): _15.QueryGetMetricsRequestAmino;
+                fromAminoMsg(object: _15.QueryGetMetricsRequestAminoMsg): _15.QueryGetMetricsRequest;
+                fromProtoMsg(message: _15.QueryGetMetricsRequestProtoMsg): _15.QueryGetMetricsRequest;
+                toProto(message: _15.QueryGetMetricsRequest): Uint8Array;
+                toProtoMsg(message: _15.QueryGetMetricsRequest): _15.QueryGetMetricsRequestProtoMsg;
+                registerTypeUrl(): void;
+            };
+            QueryGetMetricsResponse: {
+                typeUrl: string;
+                is(o: any): o is _15.QueryGetMetricsResponse;
+                isAmino(o: any): o is _15.QueryGetMetricsResponseAmino;
+                encode(message: _15.QueryGetMetricsResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _15.QueryGetMetricsResponse;
+                fromPartial(object: import("../helpers").DeepPartial<_15.QueryGetMetricsResponse>): _15.QueryGetMetricsResponse;
+                fromAmino(object: _15.QueryGetMetricsResponseAmino): _15.QueryGetMetricsResponse;
+                toAmino(message: _15.QueryGetMetricsResponse): _15.QueryGetMetricsResponseAmino;
+                fromAminoMsg(object: _15.QueryGetMetricsResponseAminoMsg): _15.QueryGetMetricsResponse;
+                fromProtoMsg(message: _15.QueryGetMetricsResponseProtoMsg): _15.QueryGetMetricsResponse;
+                toProto(message: _15.QueryGetMetricsResponse): Uint8Array;
+                toProtoMsg(message: _15.QueryGetMetricsResponse): _15.QueryGetMetricsResponseProtoMsg;
+                registerTypeUrl(): void;
+            };
+            SuperNode: {
+                typeUrl: string;
+                is(o: any): o is _14.SuperNode;
+                isAmino(o: any): o is _14.SuperNodeAmino;
+                encode(message: _14.SuperNode, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _14.SuperNode;
+                fromPartial(object: import("../helpers").DeepPartial<_14.SuperNode>): _14.SuperNode;
+                fromAmino(object: _14.SuperNodeAmino): _14.SuperNode;
+                toAmino(message: _14.SuperNode): _14.SuperNodeAmino;
+                fromAminoMsg(object: _14.SuperNodeAminoMsg): _14.SuperNode;
+                fromProtoMsg(message: _14.SuperNodeProtoMsg): _14.SuperNode;
+                toProto(message: _14.SuperNode): Uint8Array;
+                toProtoMsg(message: _14.SuperNode): _14.SuperNodeProtoMsg;
+                registerTypeUrl(): void;
+            };
+            SupernodeAccountHistory: {
+                typeUrl: string;
+                is(o: any): o is _13.SupernodeAccountHistory;
+                isAmino(o: any): o is _13.SupernodeAccountHistoryAmino;
+                encode(message: _13.SupernodeAccountHistory, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _13.SupernodeAccountHistory;
+                fromPartial(object: import("../helpers").DeepPartial<_13.SupernodeAccountHistory>): _13.SupernodeAccountHistory;
+                fromAmino(object: _13.SupernodeAccountHistoryAmino): _13.SupernodeAccountHistory;
+                toAmino(message: _13.SupernodeAccountHistory): _13.SupernodeAccountHistoryAmino;
+                fromAminoMsg(object: _13.SupernodeAccountHistoryAminoMsg): _13.SupernodeAccountHistory;
+                fromProtoMsg(message: _13.SupernodeAccountHistoryProtoMsg): _13.SupernodeAccountHistory;
+                toProto(message: _13.SupernodeAccountHistory): Uint8Array;
+                toProtoMsg(message: _13.SupernodeAccountHistory): _13.SupernodeAccountHistoryProtoMsg;
+                registerTypeUrl(): void;
+            };
+            superNodeStateFromJSON(object: any): _12.SuperNodeState;
+            superNodeStateToJSON(object: _12.SuperNodeState): string;
+            SuperNodeState: typeof _12.SuperNodeState;
+            SuperNodeStateAmino: typeof _12.SuperNodeState;
+            SuperNodeStateRecord: {
+                typeUrl: string;
+                is(o: any): o is _12.SuperNodeStateRecord;
+                isAmino(o: any): o is _12.SuperNodeStateRecordAmino;
+                encode(message: _12.SuperNodeStateRecord, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _12.SuperNodeStateRecord;
+                fromPartial(object: import("../helpers").DeepPartial<_12.SuperNodeStateRecord>): _12.SuperNodeStateRecord;
+                fromAmino(object: _12.SuperNodeStateRecordAmino): _12.SuperNodeStateRecord;
+                toAmino(message: _12.SuperNodeStateRecord): _12.SuperNodeStateRecordAmino;
+                fromAminoMsg(object: _12.SuperNodeStateRecordAminoMsg): _12.SuperNodeStateRecord;
+                fromProtoMsg(message: _12.SuperNodeStateRecordProtoMsg): _12.SuperNodeStateRecord;
+                toProto(message: _12.SuperNodeStateRecord): Uint8Array;
+                toProtoMsg(message: _12.SuperNodeStateRecord): _12.SuperNodeStateRecordProtoMsg;
+                registerTypeUrl(): void;
+            };
+            MsgUpdateParams: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _11.MsgUpdateParams;
+                isAmino(o: any): o is _11.MsgUpdateParamsAmino;
+                encode(message: _11.MsgUpdateParams, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _11.MsgUpdateParams;
+                fromPartial(object: import("../helpers").DeepPartial<_11.MsgUpdateParams>): _11.MsgUpdateParams;
+                fromAmino(object: _11.MsgUpdateParamsAmino): _11.MsgUpdateParams;
+                toAmino(message: _11.MsgUpdateParams): _11.MsgUpdateParamsAmino;
+                fromAminoMsg(object: _11.MsgUpdateParamsAminoMsg): _11.MsgUpdateParams;
+                toAminoMsg(message: _11.MsgUpdateParams): _11.MsgUpdateParamsAminoMsg;
+                fromProtoMsg(message: _11.MsgUpdateParamsProtoMsg): _11.MsgUpdateParams;
+                toProto(message: _11.MsgUpdateParams): Uint8Array;
+                toProtoMsg(message: _11.MsgUpdateParams): _11.MsgUpdateParamsProtoMsg;
+                registerTypeUrl(): void;
+            };
+            MsgUpdateParamsResponse: {
+                typeUrl: string;
+                is(o: any): o is _11.MsgUpdateParamsResponse;
+                isAmino(o: any): o is _11.MsgUpdateParamsResponseAmino;
+                encode(_: _11.MsgUpdateParamsResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _11.MsgUpdateParamsResponse;
+                fromPartial(_: import("../helpers").DeepPartial<_11.MsgUpdateParamsResponse>): _11.MsgUpdateParamsResponse;
+                fromAmino(_: _11.MsgUpdateParamsResponseAmino): _11.MsgUpdateParamsResponse;
+                toAmino(_: _11.MsgUpdateParamsResponse): _11.MsgUpdateParamsResponseAmino;
+                fromAminoMsg(object: _11.MsgUpdateParamsResponseAminoMsg): _11.MsgUpdateParamsResponse;
+                fromProtoMsg(message: _11.MsgUpdateParamsResponseProtoMsg): _11.MsgUpdateParamsResponse;
+                toProto(message: _11.MsgUpdateParamsResponse): Uint8Array;
+                toProtoMsg(message: _11.MsgUpdateParamsResponse): _11.MsgUpdateParamsResponseProtoMsg;
+                registerTypeUrl(): void;
+            };
+            MsgRegisterSupernode: {
+                typeUrl: string;
+                is(o: any): o is _11.MsgRegisterSupernode;
+                isAmino(o: any): o is _11.MsgRegisterSupernodeAmino;
+                encode(message: _11.MsgRegisterSupernode, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _11.MsgRegisterSupernode;
+                fromPartial(object: import("../helpers").DeepPartial<_11.MsgRegisterSupernode>): _11.MsgRegisterSupernode;
+                fromAmino(object: _11.MsgRegisterSupernodeAmino): _11.MsgRegisterSupernode;
+                toAmino(message: _11.MsgRegisterSupernode): _11.MsgRegisterSupernodeAmino;
+                fromAminoMsg(object: _11.MsgRegisterSupernodeAminoMsg): _11.MsgRegisterSupernode;
+                fromProtoMsg(message: _11.MsgRegisterSupernodeProtoMsg): _11.MsgRegisterSupernode;
+                toProto(message: _11.MsgRegisterSupernode): Uint8Array;
+                toProtoMsg(message: _11.MsgRegisterSupernode): _11.MsgRegisterSupernodeProtoMsg;
+                registerTypeUrl(): void;
+            };
+            MsgRegisterSupernodeResponse: {
+                typeUrl: string;
+                is(o: any): o is _11.MsgRegisterSupernodeResponse;
+                isAmino(o: any): o is _11.MsgRegisterSupernodeResponseAmino;
+                encode(_: _11.MsgRegisterSupernodeResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _11.MsgRegisterSupernodeResponse;
+                fromPartial(_: import("../helpers").DeepPartial<_11.MsgRegisterSupernodeResponse>): _11.MsgRegisterSupernodeResponse;
+                fromAmino(_: _11.MsgRegisterSupernodeResponseAmino): _11.MsgRegisterSupernodeResponse;
+                toAmino(_: _11.MsgRegisterSupernodeResponse): _11.MsgRegisterSupernodeResponseAmino;
+                fromAminoMsg(object: _11.MsgRegisterSupernodeResponseAminoMsg): _11.MsgRegisterSupernodeResponse;
+                fromProtoMsg(message: _11.MsgRegisterSupernodeResponseProtoMsg): _11.MsgRegisterSupernodeResponse;
+                toProto(message: _11.MsgRegisterSupernodeResponse): Uint8Array;
+                toProtoMsg(message: _11.MsgRegisterSupernodeResponse): _11.MsgRegisterSupernodeResponseProtoMsg;
+                registerTypeUrl(): void;
+            };
+            MsgDeregisterSupernode: {
+                typeUrl: string;
+                is(o: any): o is _11.MsgDeregisterSupernode;
+                isAmino(o: any): o is _11.MsgDeregisterSupernodeAmino;
+                encode(message: _11.MsgDeregisterSupernode, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _11.MsgDeregisterSupernode;
+                fromPartial(object: import("../helpers").DeepPartial<_11.MsgDeregisterSupernode>): _11.MsgDeregisterSupernode;
+                fromAmino(object: _11.MsgDeregisterSupernodeAmino): _11.MsgDeregisterSupernode;
+                toAmino(message: _11.MsgDeregisterSupernode): _11.MsgDeregisterSupernodeAmino;
+                fromAminoMsg(object: _11.MsgDeregisterSupernodeAminoMsg): _11.MsgDeregisterSupernode;
+                fromProtoMsg(message: _11.MsgDeregisterSupernodeProtoMsg): _11.MsgDeregisterSupernode;
+                toProto(message: _11.MsgDeregisterSupernode): Uint8Array;
+                toProtoMsg(message: _11.MsgDeregisterSupernode): _11.MsgDeregisterSupernodeProtoMsg;
+                registerTypeUrl(): void;
+            };
+            MsgDeregisterSupernodeResponse: {
+                typeUrl: string;
+                is(o: any): o is _11.MsgDeregisterSupernodeResponse;
+                isAmino(o: any): o is _11.MsgDeregisterSupernodeResponseAmino;
+                encode(_: _11.MsgDeregisterSupernodeResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _11.MsgDeregisterSupernodeResponse;
+                fromPartial(_: import("../helpers").DeepPartial<_11.MsgDeregisterSupernodeResponse>): _11.MsgDeregisterSupernodeResponse;
+                fromAmino(_: _11.MsgDeregisterSupernodeResponseAmino): _11.MsgDeregisterSupernodeResponse;
+                toAmino(_: _11.MsgDeregisterSupernodeResponse): _11.MsgDeregisterSupernodeResponseAmino;
+                fromAminoMsg(object: _11.MsgDeregisterSupernodeResponseAminoMsg): _11.MsgDeregisterSupernodeResponse;
+                fromProtoMsg(message: _11.MsgDeregisterSupernodeResponseProtoMsg): _11.MsgDeregisterSupernodeResponse;
+                toProto(message: _11.MsgDeregisterSupernodeResponse): Uint8Array;
+                toProtoMsg(message: _11.MsgDeregisterSupernodeResponse): _11.MsgDeregisterSupernodeResponseProtoMsg;
+                registerTypeUrl(): void;
+            };
+            MsgStartSupernode: {
+                typeUrl: string;
+                is(o: any): o is _11.MsgStartSupernode;
+                isAmino(o: any): o is _11.MsgStartSupernodeAmino;
+                encode(message: _11.MsgStartSupernode, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _11.MsgStartSupernode;
+                fromPartial(object: import("../helpers").DeepPartial<_11.MsgStartSupernode>): _11.MsgStartSupernode;
+                fromAmino(object: _11.MsgStartSupernodeAmino): _11.MsgStartSupernode;
+                toAmino(message: _11.MsgStartSupernode): _11.MsgStartSupernodeAmino;
+                fromAminoMsg(object: _11.MsgStartSupernodeAminoMsg): _11.MsgStartSupernode;
+                fromProtoMsg(message: _11.MsgStartSupernodeProtoMsg): _11.MsgStartSupernode;
+                toProto(message: _11.MsgStartSupernode): Uint8Array;
+                toProtoMsg(message: _11.MsgStartSupernode): _11.MsgStartSupernodeProtoMsg;
+                registerTypeUrl(): void;
+            };
+            MsgStartSupernodeResponse: {
+                typeUrl: string;
+                is(o: any): o is _11.MsgStartSupernodeResponse;
+                isAmino(o: any): o is _11.MsgStartSupernodeResponseAmino;
+                encode(_: _11.MsgStartSupernodeResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _11.MsgStartSupernodeResponse;
+                fromPartial(_: import("../helpers").DeepPartial<_11.MsgStartSupernodeResponse>): _11.MsgStartSupernodeResponse;
+                fromAmino(_: _11.MsgStartSupernodeResponseAmino): _11.MsgStartSupernodeResponse;
+                toAmino(_: _11.MsgStartSupernodeResponse): _11.MsgStartSupernodeResponseAmino;
+                fromAminoMsg(object: _11.MsgStartSupernodeResponseAminoMsg): _11.MsgStartSupernodeResponse;
+                fromProtoMsg(message: _11.MsgStartSupernodeResponseProtoMsg): _11.MsgStartSupernodeResponse;
+                toProto(message: _11.MsgStartSupernodeResponse): Uint8Array;
+                toProtoMsg(message: _11.MsgStartSupernodeResponse): _11.MsgStartSupernodeResponseProtoMsg;
+                registerTypeUrl(): void;
+            };
+            MsgStopSupernode: {
+                typeUrl: string;
+                is(o: any): o is _11.MsgStopSupernode;
+                isAmino(o: any): o is _11.MsgStopSupernodeAmino;
+                encode(message: _11.MsgStopSupernode, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _11.MsgStopSupernode;
+                fromPartial(object: import("../helpers").DeepPartial<_11.MsgStopSupernode>): _11.MsgStopSupernode;
+                fromAmino(object: _11.MsgStopSupernodeAmino): _11.MsgStopSupernode;
+                toAmino(message: _11.MsgStopSupernode): _11.MsgStopSupernodeAmino;
+                fromAminoMsg(object: _11.MsgStopSupernodeAminoMsg): _11.MsgStopSupernode;
+                fromProtoMsg(message: _11.MsgStopSupernodeProtoMsg): _11.MsgStopSupernode;
+                toProto(message: _11.MsgStopSupernode): Uint8Array;
+                toProtoMsg(message: _11.MsgStopSupernode): _11.MsgStopSupernodeProtoMsg;
+                registerTypeUrl(): void;
+            };
+            MsgStopSupernodeResponse: {
+                typeUrl: string;
+                is(o: any): o is _11.MsgStopSupernodeResponse;
+                isAmino(o: any): o is _11.MsgStopSupernodeResponseAmino;
+                encode(_: _11.MsgStopSupernodeResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _11.MsgStopSupernodeResponse;
+                fromPartial(_: import("../helpers").DeepPartial<_11.MsgStopSupernodeResponse>): _11.MsgStopSupernodeResponse;
+                fromAmino(_: _11.MsgStopSupernodeResponseAmino): _11.MsgStopSupernodeResponse;
+                toAmino(_: _11.MsgStopSupernodeResponse): _11.MsgStopSupernodeResponseAmino;
+                fromAminoMsg(object: _11.MsgStopSupernodeResponseAminoMsg): _11.MsgStopSupernodeResponse;
+                fromProtoMsg(message: _11.MsgStopSupernodeResponseProtoMsg): _11.MsgStopSupernodeResponse;
+                toProto(message: _11.MsgStopSupernodeResponse): Uint8Array;
+                toProtoMsg(message: _11.MsgStopSupernodeResponse): _11.MsgStopSupernodeResponseProtoMsg;
+                registerTypeUrl(): void;
+            };
+            MsgUpdateSupernode: {
+                typeUrl: string;
+                is(o: any): o is _11.MsgUpdateSupernode;
+                isAmino(o: any): o is _11.MsgUpdateSupernodeAmino;
+                encode(message: _11.MsgUpdateSupernode, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _11.MsgUpdateSupernode;
+                fromPartial(object: import("../helpers").DeepPartial<_11.MsgUpdateSupernode>): _11.MsgUpdateSupernode;
+                fromAmino(object: _11.MsgUpdateSupernodeAmino): _11.MsgUpdateSupernode;
+                toAmino(message: _11.MsgUpdateSupernode): _11.MsgUpdateSupernodeAmino;
+                fromAminoMsg(object: _11.MsgUpdateSupernodeAminoMsg): _11.MsgUpdateSupernode;
+                fromProtoMsg(message: _11.MsgUpdateSupernodeProtoMsg): _11.MsgUpdateSupernode;
+                toProto(message: _11.MsgUpdateSupernode): Uint8Array;
+                toProtoMsg(message: _11.MsgUpdateSupernode): _11.MsgUpdateSupernodeProtoMsg;
+                registerTypeUrl(): void;
+            };
+            MsgUpdateSupernodeResponse: {
+                typeUrl: string;
+                is(o: any): o is _11.MsgUpdateSupernodeResponse;
+                isAmino(o: any): o is _11.MsgUpdateSupernodeResponseAmino;
+                encode(_: _11.MsgUpdateSupernodeResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _11.MsgUpdateSupernodeResponse;
+                fromPartial(_: import("../helpers").DeepPartial<_11.MsgUpdateSupernodeResponse>): _11.MsgUpdateSupernodeResponse;
+                fromAmino(_: _11.MsgUpdateSupernodeResponseAmino): _11.MsgUpdateSupernodeResponse;
+                toAmino(_: _11.MsgUpdateSupernodeResponse): _11.MsgUpdateSupernodeResponseAmino;
+                fromAminoMsg(object: _11.MsgUpdateSupernodeResponseAminoMsg): _11.MsgUpdateSupernodeResponse;
+                fromProtoMsg(message: _11.MsgUpdateSupernodeResponseProtoMsg): _11.MsgUpdateSupernodeResponse;
+                toProto(message: _11.MsgUpdateSupernodeResponse): Uint8Array;
+                toProtoMsg(message: _11.MsgUpdateSupernodeResponse): _11.MsgUpdateSupernodeResponseProtoMsg;
+                registerTypeUrl(): void;
+            };
+            MsgReportSupernodeMetrics: {
+                typeUrl: string;
+                is(o: any): o is _11.MsgReportSupernodeMetrics;
+                isAmino(o: any): o is _11.MsgReportSupernodeMetricsAmino;
+                encode(message: _11.MsgReportSupernodeMetrics, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _11.MsgReportSupernodeMetrics;
+                fromPartial(object: import("../helpers").DeepPartial<_11.MsgReportSupernodeMetrics>): _11.MsgReportSupernodeMetrics;
+                fromAmino(object: _11.MsgReportSupernodeMetricsAmino): _11.MsgReportSupernodeMetrics;
+                toAmino(message: _11.MsgReportSupernodeMetrics): _11.MsgReportSupernodeMetricsAmino;
+                fromAminoMsg(object: _11.MsgReportSupernodeMetricsAminoMsg): _11.MsgReportSupernodeMetrics;
+                fromProtoMsg(message: _11.MsgReportSupernodeMetricsProtoMsg): _11.MsgReportSupernodeMetrics;
+                toProto(message: _11.MsgReportSupernodeMetrics): Uint8Array;
+                toProtoMsg(message: _11.MsgReportSupernodeMetrics): _11.MsgReportSupernodeMetricsProtoMsg;
+                registerTypeUrl(): void;
+            };
+            MsgReportSupernodeMetricsResponse: {
+                typeUrl: string;
+                is(o: any): o is _11.MsgReportSupernodeMetricsResponse;
+                isAmino(o: any): o is _11.MsgReportSupernodeMetricsResponseAmino;
+                encode(message: _11.MsgReportSupernodeMetricsResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _11.MsgReportSupernodeMetricsResponse;
+                fromPartial(object: import("../helpers").DeepPartial<_11.MsgReportSupernodeMetricsResponse>): _11.MsgReportSupernodeMetricsResponse;
+                fromAmino(object: _11.MsgReportSupernodeMetricsResponseAmino): _11.MsgReportSupernodeMetricsResponse;
+                toAmino(message: _11.MsgReportSupernodeMetricsResponse): _11.MsgReportSupernodeMetricsResponseAmino;
+                fromAminoMsg(object: _11.MsgReportSupernodeMetricsResponseAminoMsg): _11.MsgReportSupernodeMetricsResponse;
+                fromProtoMsg(message: _11.MsgReportSupernodeMetricsResponseProtoMsg): _11.MsgReportSupernodeMetricsResponse;
+                toProto(message: _11.MsgReportSupernodeMetricsResponse): Uint8Array;
+                toProtoMsg(message: _11.MsgReportSupernodeMetricsResponse): _11.MsgReportSupernodeMetricsResponseProtoMsg;
+                registerTypeUrl(): void;
+            };
+        };
+        namespace module {
+            const v1: {
+                Module: {
+                    typeUrl: string;
+                    is(o: any): o is _22.Module;
+                    isAmino(o: any): o is _22.ModuleAmino;
+                    encode(message: _22.Module, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _22.Module;
+                    fromPartial(object: import("../helpers").DeepPartial<_22.Module>): _22.Module;
+                    fromAmino(object: _22.ModuleAmino): _22.Module;
+                    toAmino(message: _22.Module): _22.ModuleAmino;
+                    fromAminoMsg(object: _22.ModuleAminoMsg): _22.Module;
+                    fromProtoMsg(message: _22.ModuleProtoMsg): _22.Module;
+                    toProto(message: _22.Module): Uint8Array;
+                    toProtoMsg(message: _22.Module): _22.ModuleProtoMsg;
+                    registerTypeUrl(): void;
+                };
+            };
+        }
+    }
+    const lumeraid: {
+        MsgClientImpl: typeof _238.MsgClientImpl;
+        createClientImpl: (rpc: import("..").TxRpc) => _238.MsgClientImpl;
+        updateParams: (client: import("@interchainjs/cosmos").ISigningClient, signerAddress: string, message: _23.MsgUpdateParams | _23.MsgUpdateParams[], fee: import("..").StdFee | "auto", memo: string) => Promise<import("@interchainjs/types").DeliverTxResponse>;
+        QueryClientImpl: typeof _230.QueryClientImpl;
+        createRpcQueryExtension: (base: import("@cosmjs/stargate").QueryClient) => {
+            params(request?: _24.QueryParamsRequest): Promise<_24.QueryParamsResponse>;
+        };
+        getParams: (client: import("..").EndpointOrRpc, request: _24.QueryParamsRequest) => Promise<_24.QueryParamsResponse>;
+        registry: ReadonlyArray<[string, import("..").TelescopeGeneratedType<any, any, any>]>;
+        AminoConverter: {
+            "/lumera.lumeraid.MsgUpdateParams": {
+                aminoType: string;
+                toAmino: (message: _23.MsgUpdateParams) => _23.MsgUpdateParamsAmino;
+                fromAmino: (object: _23.MsgUpdateParamsAmino) => _23.MsgUpdateParams;
+            };
+        };
+        GenesisState: {
+            typeUrl: string;
+            is(o: any): o is _27.GenesisState;
+            isAmino(o: any): o is _27.GenesisStateAmino;
+            encode(message: _27.GenesisState, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _27.GenesisState;
+            fromPartial(object: import("../helpers").DeepPartial<_27.GenesisState>): _27.GenesisState;
+            fromAmino(object: _27.GenesisStateAmino): _27.GenesisState;
+            toAmino(message: _27.GenesisState): _27.GenesisStateAmino;
+            fromAminoMsg(object: _27.GenesisStateAminoMsg): _27.GenesisState;
+            fromProtoMsg(message: _27.GenesisStateProtoMsg): _27.GenesisState;
+            toProto(message: _27.GenesisState): Uint8Array;
+            toProtoMsg(message: _27.GenesisState): _27.GenesisStateProtoMsg;
+            registerTypeUrl(): void;
+        };
+        HandshakeInfo: {
+            typeUrl: string;
+            is(o: any): o is _26.HandshakeInfo;
+            isAmino(o: any): o is _26.HandshakeInfoAmino;
+            encode(message: _26.HandshakeInfo, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _26.HandshakeInfo;
+            fromPartial(object: import("../helpers").DeepPartial<_26.HandshakeInfo>): _26.HandshakeInfo;
+            fromAmino(object: _26.HandshakeInfoAmino): _26.HandshakeInfo;
+            toAmino(message: _26.HandshakeInfo): _26.HandshakeInfoAmino;
+            fromAminoMsg(object: _26.HandshakeInfoAminoMsg): _26.HandshakeInfo;
+            fromProtoMsg(message: _26.HandshakeInfoProtoMsg): _26.HandshakeInfo;
+            toProto(message: _26.HandshakeInfo): Uint8Array;
+            toProtoMsg(message: _26.HandshakeInfo): _26.HandshakeInfoProtoMsg;
+            registerTypeUrl(): void;
+        };
+        Params: {
+            typeUrl: string;
+            aminoType: string;
+            is(o: any): o is _25.Params;
+            isAmino(o: any): o is _25.ParamsAmino;
+            encode(_: _25.Params, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _25.Params;
+            fromPartial(_: import("../helpers").DeepPartial<_25.Params>): _25.Params;
+            fromAmino(_: _25.ParamsAmino): _25.Params;
+            toAmino(_: _25.Params): _25.ParamsAmino;
+            fromAminoMsg(object: _25.ParamsAminoMsg): _25.Params;
+            toAminoMsg(message: _25.Params): _25.ParamsAminoMsg;
+            fromProtoMsg(message: _25.ParamsProtoMsg): _25.Params;
+            toProto(message: _25.Params): Uint8Array;
+            toProtoMsg(message: _25.Params): _25.ParamsProtoMsg;
+            registerTypeUrl(): void;
+        };
+        QueryParamsRequest: {
+            typeUrl: string;
+            is(o: any): o is _24.QueryParamsRequest;
+            isAmino(o: any): o is _24.QueryParamsRequestAmino;
+            encode(_: _24.QueryParamsRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _24.QueryParamsRequest;
+            fromPartial(_: import("../helpers").DeepPartial<_24.QueryParamsRequest>): _24.QueryParamsRequest;
+            fromAmino(_: _24.QueryParamsRequestAmino): _24.QueryParamsRequest;
+            toAmino(_: _24.QueryParamsRequest): _24.QueryParamsRequestAmino;
+            fromAminoMsg(object: _24.QueryParamsRequestAminoMsg): _24.QueryParamsRequest;
+            fromProtoMsg(message: _24.QueryParamsRequestProtoMsg): _24.QueryParamsRequest;
+            toProto(message: _24.QueryParamsRequest): Uint8Array;
+            toProtoMsg(message: _24.QueryParamsRequest): _24.QueryParamsRequestProtoMsg;
+            registerTypeUrl(): void;
+        };
+        QueryParamsResponse: {
+            typeUrl: string;
+            is(o: any): o is _24.QueryParamsResponse;
+            isAmino(o: any): o is _24.QueryParamsResponseAmino;
+            encode(message: _24.QueryParamsResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _24.QueryParamsResponse;
+            fromPartial(object: import("../helpers").DeepPartial<_24.QueryParamsResponse>): _24.QueryParamsResponse;
+            fromAmino(object: _24.QueryParamsResponseAmino): _24.QueryParamsResponse;
+            toAmino(message: _24.QueryParamsResponse): _24.QueryParamsResponseAmino;
+            fromAminoMsg(object: _24.QueryParamsResponseAminoMsg): _24.QueryParamsResponse;
+            fromProtoMsg(message: _24.QueryParamsResponseProtoMsg): _24.QueryParamsResponse;
+            toProto(message: _24.QueryParamsResponse): Uint8Array;
+            toProtoMsg(message: _24.QueryParamsResponse): _24.QueryParamsResponseProtoMsg;
+            registerTypeUrl(): void;
+        };
+        MsgUpdateParams: {
+            typeUrl: string;
+            aminoType: string;
+            is(o: any): o is _23.MsgUpdateParams;
+            isAmino(o: any): o is _23.MsgUpdateParamsAmino;
+            encode(message: _23.MsgUpdateParams, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _23.MsgUpdateParams;
+            fromPartial(object: import("../helpers").DeepPartial<_23.MsgUpdateParams>): _23.MsgUpdateParams;
+            fromAmino(object: _23.MsgUpdateParamsAmino): _23.MsgUpdateParams;
+            toAmino(message: _23.MsgUpdateParams): _23.MsgUpdateParamsAmino;
+            fromAminoMsg(object: _23.MsgUpdateParamsAminoMsg): _23.MsgUpdateParams;
+            toAminoMsg(message: _23.MsgUpdateParams): _23.MsgUpdateParamsAminoMsg;
+            fromProtoMsg(message: _23.MsgUpdateParamsProtoMsg): _23.MsgUpdateParams;
+            toProto(message: _23.MsgUpdateParams): Uint8Array;
+            toProtoMsg(message: _23.MsgUpdateParams): _23.MsgUpdateParamsProtoMsg;
+            registerTypeUrl(): void;
+        };
+        MsgUpdateParamsResponse: {
+            typeUrl: string;
+            is(o: any): o is _23.MsgUpdateParamsResponse;
+            isAmino(o: any): o is _23.MsgUpdateParamsResponseAmino;
+            encode(_: _23.MsgUpdateParamsResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _23.MsgUpdateParamsResponse;
+            fromPartial(_: import("../helpers").DeepPartial<_23.MsgUpdateParamsResponse>): _23.MsgUpdateParamsResponse;
+            fromAmino(_: _23.MsgUpdateParamsResponseAmino): _23.MsgUpdateParamsResponse;
+            toAmino(_: _23.MsgUpdateParamsResponse): _23.MsgUpdateParamsResponseAmino;
+            fromAminoMsg(object: _23.MsgUpdateParamsResponseAminoMsg): _23.MsgUpdateParamsResponse;
+            fromProtoMsg(message: _23.MsgUpdateParamsResponseProtoMsg): _23.MsgUpdateParamsResponse;
+            toProto(message: _23.MsgUpdateParamsResponse): Uint8Array;
+            toProtoMsg(message: _23.MsgUpdateParamsResponse): _23.MsgUpdateParamsResponseProtoMsg;
+            registerTypeUrl(): void;
+        };
+    };
+    const claim: {
+        MsgClientImpl: typeof _239.MsgClientImpl;
+        createClientImpl: (rpc: import("..").TxRpc) => _239.MsgClientImpl;
+        updateParams: (client: import("@interchainjs/cosmos").ISigningClient, signerAddress: string, message: _28.MsgUpdateParams | _28.MsgUpdateParams[], fee: import("..").StdFee | "auto", memo: string) => Promise<import("@interchainjs/types").DeliverTxResponse>;
+        claim: (client: import("@interchainjs/cosmos").ISigningClient, signerAddress: string, message: _28.MsgClaim | _28.MsgClaim[], fee: import("..").StdFee | "auto", memo: string) => Promise<import("@interchainjs/types").DeliverTxResponse>;
+        delayedClaim: (client: import("@interchainjs/cosmos").ISigningClient, signerAddress: string, message: _28.MsgDelayedClaim | _28.MsgDelayedClaim[], fee: import("..").StdFee | "auto", memo: string) => Promise<import("@interchainjs/types").DeliverTxResponse>;
+        QueryClientImpl: typeof _231.QueryClientImpl;
+        createRpcQueryExtension: (base: import("@cosmjs/stargate").QueryClient) => {
+            params(request?: _29.QueryParamsRequest): Promise<_29.QueryParamsResponse>;
+            claimRecord(request: _29.QueryClaimRecordRequest): Promise<_29.QueryClaimRecordResponse>;
+            listClaimed(request: _29.QueryListClaimedRequest): Promise<_29.QueryListClaimedResponse>;
+        };
+        getParams: (client: import("..").EndpointOrRpc, request: _29.QueryParamsRequest) => Promise<_29.QueryParamsResponse>;
+        getClaimRecord: (client: import("..").EndpointOrRpc, request: _29.QueryClaimRecordRequest) => Promise<_29.QueryClaimRecordResponse>;
+        getListClaimed: (client: import("..").EndpointOrRpc, request: _29.QueryListClaimedRequest) => Promise<_29.QueryListClaimedResponse>;
+        registry: ReadonlyArray<[string, import("..").TelescopeGeneratedType<any, any, any>]>;
+        AminoConverter: {
+            "/lumera.claim.MsgUpdateParams": {
+                aminoType: string;
+                toAmino: (message: _28.MsgUpdateParams) => _28.MsgUpdateParamsAmino;
+                fromAmino: (object: _28.MsgUpdateParamsAmino) => _28.MsgUpdateParams;
+            };
+            "/lumera.claim.MsgClaim": {
+                aminoType: string;
+                toAmino: (message: _28.MsgClaim) => _28.MsgClaimAmino;
+                fromAmino: (object: _28.MsgClaimAmino) => _28.MsgClaim;
+            };
+            "/lumera.claim.MsgDelayedClaim": {
+                aminoType: string;
+                toAmino: (message: _28.MsgDelayedClaim) => _28.MsgDelayedClaimAmino;
+                fromAmino: (object: _28.MsgDelayedClaimAmino) => _28.MsgDelayedClaim;
+            };
+        };
+        ClaimRecord: {
+            typeUrl: string;
+            is(o: any): o is _32.ClaimRecord;
+            isAmino(o: any): o is _32.ClaimRecordAmino;
+            encode(message: _32.ClaimRecord, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _32.ClaimRecord;
+            fromPartial(object: import("../helpers").DeepPartial<_32.ClaimRecord>): _32.ClaimRecord;
+            fromAmino(object: _32.ClaimRecordAmino): _32.ClaimRecord;
+            toAmino(message: _32.ClaimRecord): _32.ClaimRecordAmino;
+            fromAminoMsg(object: _32.ClaimRecordAminoMsg): _32.ClaimRecord;
+            fromProtoMsg(message: _32.ClaimRecordProtoMsg): _32.ClaimRecord;
+            toProto(message: _32.ClaimRecord): Uint8Array;
+            toProtoMsg(message: _32.ClaimRecord): _32.ClaimRecordProtoMsg;
+            registerTypeUrl(): void;
+        };
+        GenesisState: {
+            typeUrl: string;
+            is(o: any): o is _31.GenesisState;
+            isAmino(o: any): o is _31.GenesisStateAmino;
+            encode(message: _31.GenesisState, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _31.GenesisState;
+            fromPartial(object: import("../helpers").DeepPartial<_31.GenesisState>): _31.GenesisState;
+            fromAmino(object: _31.GenesisStateAmino): _31.GenesisState;
+            toAmino(message: _31.GenesisState): _31.GenesisStateAmino;
+            fromAminoMsg(object: _31.GenesisStateAminoMsg): _31.GenesisState;
+            fromProtoMsg(message: _31.GenesisStateProtoMsg): _31.GenesisState;
+            toProto(message: _31.GenesisState): Uint8Array;
+            toProtoMsg(message: _31.GenesisState): _31.GenesisStateProtoMsg;
+            registerTypeUrl(): void;
+        };
+        Params: {
+            typeUrl: string;
+            is(o: any): o is _30.Params;
+            isAmino(o: any): o is _30.ParamsAmino;
+            encode(message: _30.Params, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _30.Params;
+            fromPartial(object: import("../helpers").DeepPartial<_30.Params>): _30.Params;
+            fromAmino(object: _30.ParamsAmino): _30.Params;
+            toAmino(message: _30.Params): _30.ParamsAmino;
+            fromAminoMsg(object: _30.ParamsAminoMsg): _30.Params;
+            fromProtoMsg(message: _30.ParamsProtoMsg): _30.Params;
+            toProto(message: _30.Params): Uint8Array;
+            toProtoMsg(message: _30.Params): _30.ParamsProtoMsg;
+            registerTypeUrl(): void;
+        };
+        QueryParamsRequest: {
+            typeUrl: string;
+            is(o: any): o is _29.QueryParamsRequest;
+            isAmino(o: any): o is _29.QueryParamsRequestAmino;
+            encode(_: _29.QueryParamsRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _29.QueryParamsRequest;
+            fromPartial(_: import("../helpers").DeepPartial<_29.QueryParamsRequest>): _29.QueryParamsRequest;
+            fromAmino(_: _29.QueryParamsRequestAmino): _29.QueryParamsRequest;
+            toAmino(_: _29.QueryParamsRequest): _29.QueryParamsRequestAmino;
+            fromAminoMsg(object: _29.QueryParamsRequestAminoMsg): _29.QueryParamsRequest;
+            fromProtoMsg(message: _29.QueryParamsRequestProtoMsg): _29.QueryParamsRequest;
+            toProto(message: _29.QueryParamsRequest): Uint8Array;
+            toProtoMsg(message: _29.QueryParamsRequest): _29.QueryParamsRequestProtoMsg;
+            registerTypeUrl(): void;
+        };
+        QueryParamsResponse: {
+            typeUrl: string;
+            is(o: any): o is _29.QueryParamsResponse;
+            isAmino(o: any): o is _29.QueryParamsResponseAmino;
+            encode(message: _29.QueryParamsResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _29.QueryParamsResponse;
+            fromPartial(object: import("../helpers").DeepPartial<_29.QueryParamsResponse>): _29.QueryParamsResponse;
+            fromAmino(object: _29.QueryParamsResponseAmino): _29.QueryParamsResponse;
+            toAmino(message: _29.QueryParamsResponse): _29.QueryParamsResponseAmino;
+            fromAminoMsg(object: _29.QueryParamsResponseAminoMsg): _29.QueryParamsResponse;
+            fromProtoMsg(message: _29.QueryParamsResponseProtoMsg): _29.QueryParamsResponse;
+            toProto(message: _29.QueryParamsResponse): Uint8Array;
+            toProtoMsg(message: _29.QueryParamsResponse): _29.QueryParamsResponseProtoMsg;
+            registerTypeUrl(): void;
+        };
+        QueryClaimRecordRequest: {
+            typeUrl: string;
+            is(o: any): o is _29.QueryClaimRecordRequest;
+            isAmino(o: any): o is _29.QueryClaimRecordRequestAmino;
+            encode(message: _29.QueryClaimRecordRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _29.QueryClaimRecordRequest;
+            fromPartial(object: import("../helpers").DeepPartial<_29.QueryClaimRecordRequest>): _29.QueryClaimRecordRequest;
+            fromAmino(object: _29.QueryClaimRecordRequestAmino): _29.QueryClaimRecordRequest;
+            toAmino(message: _29.QueryClaimRecordRequest): _29.QueryClaimRecordRequestAmino;
+            fromAminoMsg(object: _29.QueryClaimRecordRequestAminoMsg): _29.QueryClaimRecordRequest;
+            fromProtoMsg(message: _29.QueryClaimRecordRequestProtoMsg): _29.QueryClaimRecordRequest;
+            toProto(message: _29.QueryClaimRecordRequest): Uint8Array;
+            toProtoMsg(message: _29.QueryClaimRecordRequest): _29.QueryClaimRecordRequestProtoMsg;
+            registerTypeUrl(): void;
+        };
+        QueryClaimRecordResponse: {
+            typeUrl: string;
+            is(o: any): o is _29.QueryClaimRecordResponse;
+            isAmino(o: any): o is _29.QueryClaimRecordResponseAmino;
+            encode(message: _29.QueryClaimRecordResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _29.QueryClaimRecordResponse;
+            fromPartial(object: import("../helpers").DeepPartial<_29.QueryClaimRecordResponse>): _29.QueryClaimRecordResponse;
+            fromAmino(object: _29.QueryClaimRecordResponseAmino): _29.QueryClaimRecordResponse;
+            toAmino(message: _29.QueryClaimRecordResponse): _29.QueryClaimRecordResponseAmino;
+            fromAminoMsg(object: _29.QueryClaimRecordResponseAminoMsg): _29.QueryClaimRecordResponse;
+            fromProtoMsg(message: _29.QueryClaimRecordResponseProtoMsg): _29.QueryClaimRecordResponse;
+            toProto(message: _29.QueryClaimRecordResponse): Uint8Array;
+            toProtoMsg(message: _29.QueryClaimRecordResponse): _29.QueryClaimRecordResponseProtoMsg;
+            registerTypeUrl(): void;
+        };
+        QueryListClaimedRequest: {
+            typeUrl: string;
+            is(o: any): o is _29.QueryListClaimedRequest;
+            isAmino(o: any): o is _29.QueryListClaimedRequestAmino;
+            encode(message: _29.QueryListClaimedRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _29.QueryListClaimedRequest;
+            fromPartial(object: import("../helpers").DeepPartial<_29.QueryListClaimedRequest>): _29.QueryListClaimedRequest;
+            fromAmino(object: _29.QueryListClaimedRequestAmino): _29.QueryListClaimedRequest;
+            toAmino(message: _29.QueryListClaimedRequest): _29.QueryListClaimedRequestAmino;
+            fromAminoMsg(object: _29.QueryListClaimedRequestAminoMsg): _29.QueryListClaimedRequest;
+            fromProtoMsg(message: _29.QueryListClaimedRequestProtoMsg): _29.QueryListClaimedRequest;
+            toProto(message: _29.QueryListClaimedRequest): Uint8Array;
+            toProtoMsg(message: _29.QueryListClaimedRequest): _29.QueryListClaimedRequestProtoMsg;
+            registerTypeUrl(): void;
+        };
+        QueryListClaimedResponse: {
+            typeUrl: string;
+            is(o: any): o is _29.QueryListClaimedResponse;
+            isAmino(o: any): o is _29.QueryListClaimedResponseAmino;
+            encode(message: _29.QueryListClaimedResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _29.QueryListClaimedResponse;
+            fromPartial(object: import("../helpers").DeepPartial<_29.QueryListClaimedResponse>): _29.QueryListClaimedResponse;
+            fromAmino(object: _29.QueryListClaimedResponseAmino): _29.QueryListClaimedResponse;
+            toAmino(message: _29.QueryListClaimedResponse): _29.QueryListClaimedResponseAmino;
+            fromAminoMsg(object: _29.QueryListClaimedResponseAminoMsg): _29.QueryListClaimedResponse;
+            fromProtoMsg(message: _29.QueryListClaimedResponseProtoMsg): _29.QueryListClaimedResponse;
+            toProto(message: _29.QueryListClaimedResponse): Uint8Array;
+            toProtoMsg(message: _29.QueryListClaimedResponse): _29.QueryListClaimedResponseProtoMsg;
+            registerTypeUrl(): void;
+        };
+        MsgUpdateParams: {
+            typeUrl: string;
+            is(o: any): o is _28.MsgUpdateParams;
+            isAmino(o: any): o is _28.MsgUpdateParamsAmino;
+            encode(message: _28.MsgUpdateParams, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _28.MsgUpdateParams;
+            fromPartial(object: import("../helpers").DeepPartial<_28.MsgUpdateParams>): _28.MsgUpdateParams;
+            fromAmino(object: _28.MsgUpdateParamsAmino): _28.MsgUpdateParams;
+            toAmino(message: _28.MsgUpdateParams): _28.MsgUpdateParamsAmino;
+            fromAminoMsg(object: _28.MsgUpdateParamsAminoMsg): _28.MsgUpdateParams;
+            fromProtoMsg(message: _28.MsgUpdateParamsProtoMsg): _28.MsgUpdateParams;
+            toProto(message: _28.MsgUpdateParams): Uint8Array;
+            toProtoMsg(message: _28.MsgUpdateParams): _28.MsgUpdateParamsProtoMsg;
+            registerTypeUrl(): void;
+        };
+        MsgUpdateParamsResponse: {
+            typeUrl: string;
+            is(o: any): o is _28.MsgUpdateParamsResponse;
+            isAmino(o: any): o is _28.MsgUpdateParamsResponseAmino;
+            encode(_: _28.MsgUpdateParamsResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _28.MsgUpdateParamsResponse;
+            fromPartial(_: import("../helpers").DeepPartial<_28.MsgUpdateParamsResponse>): _28.MsgUpdateParamsResponse;
+            fromAmino(_: _28.MsgUpdateParamsResponseAmino): _28.MsgUpdateParamsResponse;
+            toAmino(_: _28.MsgUpdateParamsResponse): _28.MsgUpdateParamsResponseAmino;
+            fromAminoMsg(object: _28.MsgUpdateParamsResponseAminoMsg): _28.MsgUpdateParamsResponse;
+            fromProtoMsg(message: _28.MsgUpdateParamsResponseProtoMsg): _28.MsgUpdateParamsResponse;
+            toProto(message: _28.MsgUpdateParamsResponse): Uint8Array;
+            toProtoMsg(message: _28.MsgUpdateParamsResponse): _28.MsgUpdateParamsResponseProtoMsg;
+            registerTypeUrl(): void;
+        };
+        MsgClaim: {
+            typeUrl: string;
+            is(o: any): o is _28.MsgClaim;
+            isAmino(o: any): o is _28.MsgClaimAmino;
+            encode(message: _28.MsgClaim, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _28.MsgClaim;
+            fromPartial(object: import("../helpers").DeepPartial<_28.MsgClaim>): _28.MsgClaim;
+            fromAmino(object: _28.MsgClaimAmino): _28.MsgClaim;
+            toAmino(message: _28.MsgClaim): _28.MsgClaimAmino;
+            fromAminoMsg(object: _28.MsgClaimAminoMsg): _28.MsgClaim;
+            fromProtoMsg(message: _28.MsgClaimProtoMsg): _28.MsgClaim;
+            toProto(message: _28.MsgClaim): Uint8Array;
+            toProtoMsg(message: _28.MsgClaim): _28.MsgClaimProtoMsg;
+            registerTypeUrl(): void;
+        };
+        MsgClaimResponse: {
+            typeUrl: string;
+            is(o: any): o is _28.MsgClaimResponse;
+            isAmino(o: any): o is _28.MsgClaimResponseAmino;
+            encode(_: _28.MsgClaimResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _28.MsgClaimResponse;
+            fromPartial(_: import("../helpers").DeepPartial<_28.MsgClaimResponse>): _28.MsgClaimResponse;
+            fromAmino(_: _28.MsgClaimResponseAmino): _28.MsgClaimResponse;
+            toAmino(_: _28.MsgClaimResponse): _28.MsgClaimResponseAmino;
+            fromAminoMsg(object: _28.MsgClaimResponseAminoMsg): _28.MsgClaimResponse;
+            fromProtoMsg(message: _28.MsgClaimResponseProtoMsg): _28.MsgClaimResponse;
+            toProto(message: _28.MsgClaimResponse): Uint8Array;
+            toProtoMsg(message: _28.MsgClaimResponse): _28.MsgClaimResponseProtoMsg;
+            registerTypeUrl(): void;
+        };
+        MsgDelayedClaim: {
+            typeUrl: string;
+            is(o: any): o is _28.MsgDelayedClaim;
+            isAmino(o: any): o is _28.MsgDelayedClaimAmino;
+            encode(message: _28.MsgDelayedClaim, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _28.MsgDelayedClaim;
+            fromPartial(object: import("../helpers").DeepPartial<_28.MsgDelayedClaim>): _28.MsgDelayedClaim;
+            fromAmino(object: _28.MsgDelayedClaimAmino): _28.MsgDelayedClaim;
+            toAmino(message: _28.MsgDelayedClaim): _28.MsgDelayedClaimAmino;
+            fromAminoMsg(object: _28.MsgDelayedClaimAminoMsg): _28.MsgDelayedClaim;
+            fromProtoMsg(message: _28.MsgDelayedClaimProtoMsg): _28.MsgDelayedClaim;
+            toProto(message: _28.MsgDelayedClaim): Uint8Array;
+            toProtoMsg(message: _28.MsgDelayedClaim): _28.MsgDelayedClaimProtoMsg;
+            registerTypeUrl(): void;
+        };
+        MsgDelayedClaimResponse: {
+            typeUrl: string;
+            is(o: any): o is _28.MsgDelayedClaimResponse;
+            isAmino(o: any): o is _28.MsgDelayedClaimResponseAmino;
+            encode(_: _28.MsgDelayedClaimResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+            decode(input: import("..").BinaryReader | Uint8Array, length?: number): _28.MsgDelayedClaimResponse;
+            fromPartial(_: import("../helpers").DeepPartial<_28.MsgDelayedClaimResponse>): _28.MsgDelayedClaimResponse;
+            fromAmino(_: _28.MsgDelayedClaimResponseAmino): _28.MsgDelayedClaimResponse;
+            toAmino(_: _28.MsgDelayedClaimResponse): _28.MsgDelayedClaimResponseAmino;
+            fromAminoMsg(object: _28.MsgDelayedClaimResponseAminoMsg): _28.MsgDelayedClaimResponse;
+            fromProtoMsg(message: _28.MsgDelayedClaimResponseProtoMsg): _28.MsgDelayedClaimResponse;
+            toProto(message: _28.MsgDelayedClaimResponse): Uint8Array;
+            toProtoMsg(message: _28.MsgDelayedClaimResponse): _28.MsgDelayedClaimResponseProtoMsg;
+            registerTypeUrl(): void;
+        };
+    };
+    namespace action {
+        const v1: {
+            MsgClientImpl: typeof _240.MsgClientImpl;
+            createClientImpl: (rpc: import("..").TxRpc) => _240.MsgClientImpl;
+            updateParams: (client: import("@interchainjs/cosmos").ISigningClient, signerAddress: string, message: _33.MsgUpdateParams | _33.MsgUpdateParams[], fee: import("..").StdFee | "auto", memo: string) => Promise<import("@interchainjs/types").DeliverTxResponse>;
+            requestAction: (client: import("@interchainjs/cosmos").ISigningClient, signerAddress: string, message: _33.MsgRequestAction | _33.MsgRequestAction[], fee: import("..").StdFee | "auto", memo: string) => Promise<import("@interchainjs/types").DeliverTxResponse>;
+            finalizeAction: (client: import("@interchainjs/cosmos").ISigningClient, signerAddress: string, message: _33.MsgFinalizeAction | _33.MsgFinalizeAction[], fee: import("..").StdFee | "auto", memo: string) => Promise<import("@interchainjs/types").DeliverTxResponse>;
+            approveAction: (client: import("@interchainjs/cosmos").ISigningClient, signerAddress: string, message: _33.MsgApproveAction | _33.MsgApproveAction[], fee: import("..").StdFee | "auto", memo: string) => Promise<import("@interchainjs/types").DeliverTxResponse>;
+            QueryClientImpl: typeof _232.QueryClientImpl;
+            createRpcQueryExtension: (base: import("@cosmjs/stargate").QueryClient) => {
+                params(request?: _34.QueryParamsRequest): Promise<_34.QueryParamsResponse>;
+                getAction(request: _34.QueryGetActionRequest): Promise<_34.QueryGetActionResponse>;
+                getActionFee(request: _34.QueryGetActionFeeRequest): Promise<_34.QueryGetActionFeeResponse>;
+                listActions(request: _34.QueryListActionsRequest): Promise<_34.QueryListActionsResponse>;
+                listActionsByCreator(request: _34.QueryListActionsByCreatorRequest): Promise<_34.QueryListActionsByCreatorResponse>;
+                listActionsBySuperNode(request: _34.QueryListActionsBySuperNodeRequest): Promise<_34.QueryListActionsBySuperNodeResponse>;
+                listActionsByBlockHeight(request: _34.QueryListActionsByBlockHeightRequest): Promise<_34.QueryListActionsByBlockHeightResponse>;
+                listExpiredActions(request?: _34.QueryListExpiredActionsRequest): Promise<_34.QueryListExpiredActionsResponse>;
+                queryActionByMetadata(request: _34.QueryActionByMetadataRequest): Promise<_34.QueryActionByMetadataResponse>;
+            };
+            getParams: (client: import("..").EndpointOrRpc, request: _34.QueryParamsRequest) => Promise<_34.QueryParamsResponse>;
+            getGetAction: (client: import("..").EndpointOrRpc, request: _34.QueryGetActionRequest) => Promise<_34.QueryGetActionResponse>;
+            getGetActionFee: (client: import("..").EndpointOrRpc, request: _34.QueryGetActionFeeRequest) => Promise<_34.QueryGetActionFeeResponse>;
+            getListActions: (client: import("..").EndpointOrRpc, request: _34.QueryListActionsRequest) => Promise<_34.QueryListActionsResponse>;
+            getListActionsByCreator: (client: import("..").EndpointOrRpc, request: _34.QueryListActionsByCreatorRequest) => Promise<_34.QueryListActionsByCreatorResponse>;
+            getListActionsBySuperNode: (client: import("..").EndpointOrRpc, request: _34.QueryListActionsBySuperNodeRequest) => Promise<_34.QueryListActionsBySuperNodeResponse>;
+            getListActionsByBlockHeight: (client: import("..").EndpointOrRpc, request: _34.QueryListActionsByBlockHeightRequest) => Promise<_34.QueryListActionsByBlockHeightResponse>;
+            getListExpiredActions: (client: import("..").EndpointOrRpc, request: _34.QueryListExpiredActionsRequest) => Promise<_34.QueryListExpiredActionsResponse>;
+            getQueryActionByMetadata: (client: import("..").EndpointOrRpc, request: _34.QueryActionByMetadataRequest) => Promise<_34.QueryActionByMetadataResponse>;
+            registry: ReadonlyArray<[string, import("..").TelescopeGeneratedType<any, any, any>]>;
+            AminoConverter: {
+                "/lumera.action.v1.MsgUpdateParams": {
+                    aminoType: string;
+                    toAmino: (message: _33.MsgUpdateParams) => _33.MsgUpdateParamsAmino;
+                    fromAmino: (object: _33.MsgUpdateParamsAmino) => _33.MsgUpdateParams;
+                };
+                "/lumera.action.v1.MsgRequestAction": {
+                    aminoType: string;
+                    toAmino: (message: _33.MsgRequestAction) => _33.MsgRequestActionAmino;
+                    fromAmino: (object: _33.MsgRequestActionAmino) => _33.MsgRequestAction;
+                };
+                "/lumera.action.v1.MsgFinalizeAction": {
+                    aminoType: string;
+                    toAmino: (message: _33.MsgFinalizeAction) => _33.MsgFinalizeActionAmino;
+                    fromAmino: (object: _33.MsgFinalizeActionAmino) => _33.MsgFinalizeAction;
+                };
+                "/lumera.action.v1.MsgApproveAction": {
+                    aminoType: string;
+                    toAmino: (message: _33.MsgApproveAction) => _33.MsgApproveActionAmino;
+                    fromAmino: (object: _33.MsgApproveActionAmino) => _33.MsgApproveAction;
+                };
+            };
+            Action: {
+                typeUrl: string;
+                is(o: any): o is _40.Action;
+                isAmino(o: any): o is _40.ActionAmino;
+                encode(message: _40.Action, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _40.Action;
+                fromPartial(object: import("../helpers").DeepPartial<_40.Action>): _40.Action;
+                fromAmino(object: _40.ActionAmino): _40.Action;
+                toAmino(message: _40.Action): _40.ActionAmino;
+                fromAminoMsg(object: _40.ActionAminoMsg): _40.Action;
+                fromProtoMsg(message: _40.ActionProtoMsg): _40.Action;
+                toProto(message: _40.Action): Uint8Array;
+                toProtoMsg(message: _40.Action): _40.ActionProtoMsg;
+                registerTypeUrl(): void;
+            };
+            actionStateFromJSON(object: any): _39.ActionState;
+            actionStateToJSON(object: _39.ActionState): string;
+            ActionState: typeof _39.ActionState;
+            ActionStateAmino: typeof _39.ActionState;
+            actionTypeFromJSON(object: any): _38.ActionType;
+            actionTypeToJSON(object: _38.ActionType): string;
+            ActionType: typeof _38.ActionType;
+            ActionTypeAmino: typeof _38.ActionType;
+            GenesisState: {
+                typeUrl: string;
+                is(o: any): o is _37.GenesisState;
+                isAmino(o: any): o is _37.GenesisStateAmino;
+                encode(message: _37.GenesisState, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _37.GenesisState;
+                fromPartial(object: import("../helpers").DeepPartial<_37.GenesisState>): _37.GenesisState;
+                fromAmino(object: _37.GenesisStateAmino): _37.GenesisState;
+                toAmino(message: _37.GenesisState): _37.GenesisStateAmino;
+                fromAminoMsg(object: _37.GenesisStateAminoMsg): _37.GenesisState;
+                fromProtoMsg(message: _37.GenesisStateProtoMsg): _37.GenesisState;
+                toProto(message: _37.GenesisState): Uint8Array;
+                toProtoMsg(message: _37.GenesisState): _37.GenesisStateProtoMsg;
+                registerTypeUrl(): void;
+            };
+            SenseMetadata: {
+                typeUrl: string;
+                is(o: any): o is _36.SenseMetadata;
+                isAmino(o: any): o is _36.SenseMetadataAmino;
+                encode(message: _36.SenseMetadata, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _36.SenseMetadata;
+                fromPartial(object: import("../helpers").DeepPartial<_36.SenseMetadata>): _36.SenseMetadata;
+                fromAmino(object: _36.SenseMetadataAmino): _36.SenseMetadata;
+                toAmino(message: _36.SenseMetadata): _36.SenseMetadataAmino;
+                fromAminoMsg(object: _36.SenseMetadataAminoMsg): _36.SenseMetadata;
+                fromProtoMsg(message: _36.SenseMetadataProtoMsg): _36.SenseMetadata;
+                toProto(message: _36.SenseMetadata): Uint8Array;
+                toProtoMsg(message: _36.SenseMetadata): _36.SenseMetadataProtoMsg;
+                registerTypeUrl(): void;
+            };
+            CascadeMetadata: {
+                typeUrl: string;
+                is(o: any): o is _36.CascadeMetadata;
+                isAmino(o: any): o is _36.CascadeMetadataAmino;
+                encode(message: _36.CascadeMetadata, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _36.CascadeMetadata;
+                fromPartial(object: import("../helpers").DeepPartial<_36.CascadeMetadata>): _36.CascadeMetadata;
+                fromAmino(object: _36.CascadeMetadataAmino): _36.CascadeMetadata;
+                toAmino(message: _36.CascadeMetadata): _36.CascadeMetadataAmino;
+                fromAminoMsg(object: _36.CascadeMetadataAminoMsg): _36.CascadeMetadata;
+                fromProtoMsg(message: _36.CascadeMetadataProtoMsg): _36.CascadeMetadata;
+                toProto(message: _36.CascadeMetadata): Uint8Array;
+                toProtoMsg(message: _36.CascadeMetadata): _36.CascadeMetadataProtoMsg;
+                registerTypeUrl(): void;
+            };
+            Params: {
+                typeUrl: string;
+                is(o: any): o is _35.Params;
+                isAmino(o: any): o is _35.ParamsAmino;
+                encode(message: _35.Params, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _35.Params;
+                fromPartial(object: import("../helpers").DeepPartial<_35.Params>): _35.Params;
+                fromAmino(object: _35.ParamsAmino): _35.Params;
+                toAmino(message: _35.Params): _35.ParamsAmino;
+                fromAminoMsg(object: _35.ParamsAminoMsg): _35.Params;
+                fromProtoMsg(message: _35.ParamsProtoMsg): _35.Params;
+                toProto(message: _35.Params): Uint8Array;
+                toProtoMsg(message: _35.Params): _35.ParamsProtoMsg;
+                registerTypeUrl(): void;
+            };
+            QueryParamsRequest: {
+                typeUrl: string;
+                is(o: any): o is _34.QueryParamsRequest;
+                isAmino(o: any): o is _34.QueryParamsRequestAmino;
+                encode(_: _34.QueryParamsRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _34.QueryParamsRequest;
+                fromPartial(_: import("../helpers").DeepPartial<_34.QueryParamsRequest>): _34.QueryParamsRequest;
+                fromAmino(_: _34.QueryParamsRequestAmino): _34.QueryParamsRequest;
+                toAmino(_: _34.QueryParamsRequest): _34.QueryParamsRequestAmino;
+                fromAminoMsg(object: _34.QueryParamsRequestAminoMsg): _34.QueryParamsRequest;
+                fromProtoMsg(message: _34.QueryParamsRequestProtoMsg): _34.QueryParamsRequest;
+                toProto(message: _34.QueryParamsRequest): Uint8Array;
+                toProtoMsg(message: _34.QueryParamsRequest): _34.QueryParamsRequestProtoMsg;
+                registerTypeUrl(): void;
+            };
+            QueryParamsResponse: {
+                typeUrl: string;
+                is(o: any): o is _34.QueryParamsResponse;
+                isAmino(o: any): o is _34.QueryParamsResponseAmino;
+                encode(message: _34.QueryParamsResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _34.QueryParamsResponse;
+                fromPartial(object: import("../helpers").DeepPartial<_34.QueryParamsResponse>): _34.QueryParamsResponse;
+                fromAmino(object: _34.QueryParamsResponseAmino): _34.QueryParamsResponse;
+                toAmino(message: _34.QueryParamsResponse): _34.QueryParamsResponseAmino;
+                fromAminoMsg(object: _34.QueryParamsResponseAminoMsg): _34.QueryParamsResponse;
+                fromProtoMsg(message: _34.QueryParamsResponseProtoMsg): _34.QueryParamsResponse;
+                toProto(message: _34.QueryParamsResponse): Uint8Array;
+                toProtoMsg(message: _34.QueryParamsResponse): _34.QueryParamsResponseProtoMsg;
+                registerTypeUrl(): void;
+            };
+            QueryGetActionRequest: {
+                typeUrl: string;
+                is(o: any): o is _34.QueryGetActionRequest;
+                isAmino(o: any): o is _34.QueryGetActionRequestAmino;
+                encode(message: _34.QueryGetActionRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _34.QueryGetActionRequest;
+                fromPartial(object: import("../helpers").DeepPartial<_34.QueryGetActionRequest>): _34.QueryGetActionRequest;
+                fromAmino(object: _34.QueryGetActionRequestAmino): _34.QueryGetActionRequest;
+                toAmino(message: _34.QueryGetActionRequest): _34.QueryGetActionRequestAmino;
+                fromAminoMsg(object: _34.QueryGetActionRequestAminoMsg): _34.QueryGetActionRequest;
+                fromProtoMsg(message: _34.QueryGetActionRequestProtoMsg): _34.QueryGetActionRequest;
+                toProto(message: _34.QueryGetActionRequest): Uint8Array;
+                toProtoMsg(message: _34.QueryGetActionRequest): _34.QueryGetActionRequestProtoMsg;
+                registerTypeUrl(): void;
+            };
+            QueryGetActionResponse: {
+                typeUrl: string;
+                is(o: any): o is _34.QueryGetActionResponse;
+                isAmino(o: any): o is _34.QueryGetActionResponseAmino;
+                encode(message: _34.QueryGetActionResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _34.QueryGetActionResponse;
+                fromPartial(object: import("../helpers").DeepPartial<_34.QueryGetActionResponse>): _34.QueryGetActionResponse;
+                fromAmino(object: _34.QueryGetActionResponseAmino): _34.QueryGetActionResponse;
+                toAmino(message: _34.QueryGetActionResponse): _34.QueryGetActionResponseAmino;
+                fromAminoMsg(object: _34.QueryGetActionResponseAminoMsg): _34.QueryGetActionResponse;
+                fromProtoMsg(message: _34.QueryGetActionResponseProtoMsg): _34.QueryGetActionResponse;
+                toProto(message: _34.QueryGetActionResponse): Uint8Array;
+                toProtoMsg(message: _34.QueryGetActionResponse): _34.QueryGetActionResponseProtoMsg;
+                registerTypeUrl(): void;
+            };
+            QueryGetActionFeeRequest: {
+                typeUrl: string;
+                is(o: any): o is _34.QueryGetActionFeeRequest;
+                isAmino(o: any): o is _34.QueryGetActionFeeRequestAmino;
+                encode(message: _34.QueryGetActionFeeRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _34.QueryGetActionFeeRequest;
+                fromPartial(object: import("../helpers").DeepPartial<_34.QueryGetActionFeeRequest>): _34.QueryGetActionFeeRequest;
+                fromAmino(object: _34.QueryGetActionFeeRequestAmino): _34.QueryGetActionFeeRequest;
+                toAmino(message: _34.QueryGetActionFeeRequest): _34.QueryGetActionFeeRequestAmino;
+                fromAminoMsg(object: _34.QueryGetActionFeeRequestAminoMsg): _34.QueryGetActionFeeRequest;
+                fromProtoMsg(message: _34.QueryGetActionFeeRequestProtoMsg): _34.QueryGetActionFeeRequest;
+                toProto(message: _34.QueryGetActionFeeRequest): Uint8Array;
+                toProtoMsg(message: _34.QueryGetActionFeeRequest): _34.QueryGetActionFeeRequestProtoMsg;
+                registerTypeUrl(): void;
+            };
+            QueryGetActionFeeResponse: {
+                typeUrl: string;
+                is(o: any): o is _34.QueryGetActionFeeResponse;
+                isAmino(o: any): o is _34.QueryGetActionFeeResponseAmino;
+                encode(message: _34.QueryGetActionFeeResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _34.QueryGetActionFeeResponse;
+                fromPartial(object: import("../helpers").DeepPartial<_34.QueryGetActionFeeResponse>): _34.QueryGetActionFeeResponse;
+                fromAmino(object: _34.QueryGetActionFeeResponseAmino): _34.QueryGetActionFeeResponse;
+                toAmino(message: _34.QueryGetActionFeeResponse): _34.QueryGetActionFeeResponseAmino;
+                fromAminoMsg(object: _34.QueryGetActionFeeResponseAminoMsg): _34.QueryGetActionFeeResponse;
+                fromProtoMsg(message: _34.QueryGetActionFeeResponseProtoMsg): _34.QueryGetActionFeeResponse;
+                toProto(message: _34.QueryGetActionFeeResponse): Uint8Array;
+                toProtoMsg(message: _34.QueryGetActionFeeResponse): _34.QueryGetActionFeeResponseProtoMsg;
+                registerTypeUrl(): void;
+            };
+            QueryListActionsRequest: {
+                typeUrl: string;
+                is(o: any): o is _34.QueryListActionsRequest;
+                isAmino(o: any): o is _34.QueryListActionsRequestAmino;
+                encode(message: _34.QueryListActionsRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _34.QueryListActionsRequest;
+                fromPartial(object: import("../helpers").DeepPartial<_34.QueryListActionsRequest>): _34.QueryListActionsRequest;
+                fromAmino(object: _34.QueryListActionsRequestAmino): _34.QueryListActionsRequest;
+                toAmino(message: _34.QueryListActionsRequest): _34.QueryListActionsRequestAmino;
+                fromAminoMsg(object: _34.QueryListActionsRequestAminoMsg): _34.QueryListActionsRequest;
+                fromProtoMsg(message: _34.QueryListActionsRequestProtoMsg): _34.QueryListActionsRequest;
+                toProto(message: _34.QueryListActionsRequest): Uint8Array;
+                toProtoMsg(message: _34.QueryListActionsRequest): _34.QueryListActionsRequestProtoMsg;
+                registerTypeUrl(): void;
+            };
+            QueryListActionsResponse: {
+                typeUrl: string;
+                is(o: any): o is _34.QueryListActionsResponse;
+                isAmino(o: any): o is _34.QueryListActionsResponseAmino;
+                encode(message: _34.QueryListActionsResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _34.QueryListActionsResponse;
+                fromPartial(object: import("../helpers").DeepPartial<_34.QueryListActionsResponse>): _34.QueryListActionsResponse;
+                fromAmino(object: _34.QueryListActionsResponseAmino): _34.QueryListActionsResponse;
+                toAmino(message: _34.QueryListActionsResponse): _34.QueryListActionsResponseAmino;
+                fromAminoMsg(object: _34.QueryListActionsResponseAminoMsg): _34.QueryListActionsResponse;
+                fromProtoMsg(message: _34.QueryListActionsResponseProtoMsg): _34.QueryListActionsResponse;
+                toProto(message: _34.QueryListActionsResponse): Uint8Array;
+                toProtoMsg(message: _34.QueryListActionsResponse): _34.QueryListActionsResponseProtoMsg;
+                registerTypeUrl(): void;
+            };
+            QueryListActionsByCreatorRequest: {
+                typeUrl: string;
+                is(o: any): o is _34.QueryListActionsByCreatorRequest;
+                isAmino(o: any): o is _34.QueryListActionsByCreatorRequestAmino;
+                encode(message: _34.QueryListActionsByCreatorRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _34.QueryListActionsByCreatorRequest;
+                fromPartial(object: import("../helpers").DeepPartial<_34.QueryListActionsByCreatorRequest>): _34.QueryListActionsByCreatorRequest;
+                fromAmino(object: _34.QueryListActionsByCreatorRequestAmino): _34.QueryListActionsByCreatorRequest;
+                toAmino(message: _34.QueryListActionsByCreatorRequest): _34.QueryListActionsByCreatorRequestAmino;
+                fromAminoMsg(object: _34.QueryListActionsByCreatorRequestAminoMsg): _34.QueryListActionsByCreatorRequest;
+                fromProtoMsg(message: _34.QueryListActionsByCreatorRequestProtoMsg): _34.QueryListActionsByCreatorRequest;
+                toProto(message: _34.QueryListActionsByCreatorRequest): Uint8Array;
+                toProtoMsg(message: _34.QueryListActionsByCreatorRequest): _34.QueryListActionsByCreatorRequestProtoMsg;
+                registerTypeUrl(): void;
+            };
+            QueryListActionsByCreatorResponse: {
+                typeUrl: string;
+                is(o: any): o is _34.QueryListActionsByCreatorResponse;
+                isAmino(o: any): o is _34.QueryListActionsByCreatorResponseAmino;
+                encode(message: _34.QueryListActionsByCreatorResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _34.QueryListActionsByCreatorResponse;
+                fromPartial(object: import("../helpers").DeepPartial<_34.QueryListActionsByCreatorResponse>): _34.QueryListActionsByCreatorResponse;
+                fromAmino(object: _34.QueryListActionsByCreatorResponseAmino): _34.QueryListActionsByCreatorResponse;
+                toAmino(message: _34.QueryListActionsByCreatorResponse): _34.QueryListActionsByCreatorResponseAmino;
+                fromAminoMsg(object: _34.QueryListActionsByCreatorResponseAminoMsg): _34.QueryListActionsByCreatorResponse;
+                fromProtoMsg(message: _34.QueryListActionsByCreatorResponseProtoMsg): _34.QueryListActionsByCreatorResponse;
+                toProto(message: _34.QueryListActionsByCreatorResponse): Uint8Array;
+                toProtoMsg(message: _34.QueryListActionsByCreatorResponse): _34.QueryListActionsByCreatorResponseProtoMsg;
+                registerTypeUrl(): void;
+            };
+            QueryListActionsBySuperNodeRequest: {
+                typeUrl: string;
+                is(o: any): o is _34.QueryListActionsBySuperNodeRequest;
+                isAmino(o: any): o is _34.QueryListActionsBySuperNodeRequestAmino;
+                encode(message: _34.QueryListActionsBySuperNodeRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _34.QueryListActionsBySuperNodeRequest;
+                fromPartial(object: import("../helpers").DeepPartial<_34.QueryListActionsBySuperNodeRequest>): _34.QueryListActionsBySuperNodeRequest;
+                fromAmino(object: _34.QueryListActionsBySuperNodeRequestAmino): _34.QueryListActionsBySuperNodeRequest;
+                toAmino(message: _34.QueryListActionsBySuperNodeRequest): _34.QueryListActionsBySuperNodeRequestAmino;
+                fromAminoMsg(object: _34.QueryListActionsBySuperNodeRequestAminoMsg): _34.QueryListActionsBySuperNodeRequest;
+                fromProtoMsg(message: _34.QueryListActionsBySuperNodeRequestProtoMsg): _34.QueryListActionsBySuperNodeRequest;
+                toProto(message: _34.QueryListActionsBySuperNodeRequest): Uint8Array;
+                toProtoMsg(message: _34.QueryListActionsBySuperNodeRequest): _34.QueryListActionsBySuperNodeRequestProtoMsg;
+                registerTypeUrl(): void;
+            };
+            QueryListActionsBySuperNodeResponse: {
+                typeUrl: string;
+                is(o: any): o is _34.QueryListActionsBySuperNodeResponse;
+                isAmino(o: any): o is _34.QueryListActionsBySuperNodeResponseAmino;
+                encode(message: _34.QueryListActionsBySuperNodeResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _34.QueryListActionsBySuperNodeResponse;
+                fromPartial(object: import("../helpers").DeepPartial<_34.QueryListActionsBySuperNodeResponse>): _34.QueryListActionsBySuperNodeResponse;
+                fromAmino(object: _34.QueryListActionsBySuperNodeResponseAmino): _34.QueryListActionsBySuperNodeResponse;
+                toAmino(message: _34.QueryListActionsBySuperNodeResponse): _34.QueryListActionsBySuperNodeResponseAmino;
+                fromAminoMsg(object: _34.QueryListActionsBySuperNodeResponseAminoMsg): _34.QueryListActionsBySuperNodeResponse;
+                fromProtoMsg(message: _34.QueryListActionsBySuperNodeResponseProtoMsg): _34.QueryListActionsBySuperNodeResponse;
+                toProto(message: _34.QueryListActionsBySuperNodeResponse): Uint8Array;
+                toProtoMsg(message: _34.QueryListActionsBySuperNodeResponse): _34.QueryListActionsBySuperNodeResponseProtoMsg;
+                registerTypeUrl(): void;
+            };
+            QueryListActionsByBlockHeightRequest: {
+                typeUrl: string;
+                is(o: any): o is _34.QueryListActionsByBlockHeightRequest;
+                isAmino(o: any): o is _34.QueryListActionsByBlockHeightRequestAmino;
+                encode(message: _34.QueryListActionsByBlockHeightRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _34.QueryListActionsByBlockHeightRequest;
+                fromPartial(object: import("../helpers").DeepPartial<_34.QueryListActionsByBlockHeightRequest>): _34.QueryListActionsByBlockHeightRequest;
+                fromAmino(object: _34.QueryListActionsByBlockHeightRequestAmino): _34.QueryListActionsByBlockHeightRequest;
+                toAmino(message: _34.QueryListActionsByBlockHeightRequest): _34.QueryListActionsByBlockHeightRequestAmino;
+                fromAminoMsg(object: _34.QueryListActionsByBlockHeightRequestAminoMsg): _34.QueryListActionsByBlockHeightRequest;
+                fromProtoMsg(message: _34.QueryListActionsByBlockHeightRequestProtoMsg): _34.QueryListActionsByBlockHeightRequest;
+                toProto(message: _34.QueryListActionsByBlockHeightRequest): Uint8Array;
+                toProtoMsg(message: _34.QueryListActionsByBlockHeightRequest): _34.QueryListActionsByBlockHeightRequestProtoMsg;
+                registerTypeUrl(): void;
+            };
+            QueryListActionsByBlockHeightResponse: {
+                typeUrl: string;
+                is(o: any): o is _34.QueryListActionsByBlockHeightResponse;
+                isAmino(o: any): o is _34.QueryListActionsByBlockHeightResponseAmino;
+                encode(message: _34.QueryListActionsByBlockHeightResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _34.QueryListActionsByBlockHeightResponse;
+                fromPartial(object: import("../helpers").DeepPartial<_34.QueryListActionsByBlockHeightResponse>): _34.QueryListActionsByBlockHeightResponse;
+                fromAmino(object: _34.QueryListActionsByBlockHeightResponseAmino): _34.QueryListActionsByBlockHeightResponse;
+                toAmino(message: _34.QueryListActionsByBlockHeightResponse): _34.QueryListActionsByBlockHeightResponseAmino;
+                fromAminoMsg(object: _34.QueryListActionsByBlockHeightResponseAminoMsg): _34.QueryListActionsByBlockHeightResponse;
+                fromProtoMsg(message: _34.QueryListActionsByBlockHeightResponseProtoMsg): _34.QueryListActionsByBlockHeightResponse;
+                toProto(message: _34.QueryListActionsByBlockHeightResponse): Uint8Array;
+                toProtoMsg(message: _34.QueryListActionsByBlockHeightResponse): _34.QueryListActionsByBlockHeightResponseProtoMsg;
+                registerTypeUrl(): void;
+            };
+            QueryListExpiredActionsRequest: {
+                typeUrl: string;
+                is(o: any): o is _34.QueryListExpiredActionsRequest;
+                isAmino(o: any): o is _34.QueryListExpiredActionsRequestAmino;
+                encode(message: _34.QueryListExpiredActionsRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _34.QueryListExpiredActionsRequest;
+                fromPartial(object: import("../helpers").DeepPartial<_34.QueryListExpiredActionsRequest>): _34.QueryListExpiredActionsRequest;
+                fromAmino(object: _34.QueryListExpiredActionsRequestAmino): _34.QueryListExpiredActionsRequest;
+                toAmino(message: _34.QueryListExpiredActionsRequest): _34.QueryListExpiredActionsRequestAmino;
+                fromAminoMsg(object: _34.QueryListExpiredActionsRequestAminoMsg): _34.QueryListExpiredActionsRequest;
+                fromProtoMsg(message: _34.QueryListExpiredActionsRequestProtoMsg): _34.QueryListExpiredActionsRequest;
+                toProto(message: _34.QueryListExpiredActionsRequest): Uint8Array;
+                toProtoMsg(message: _34.QueryListExpiredActionsRequest): _34.QueryListExpiredActionsRequestProtoMsg;
+                registerTypeUrl(): void;
+            };
+            QueryListExpiredActionsResponse: {
+                typeUrl: string;
+                is(o: any): o is _34.QueryListExpiredActionsResponse;
+                isAmino(o: any): o is _34.QueryListExpiredActionsResponseAmino;
+                encode(message: _34.QueryListExpiredActionsResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _34.QueryListExpiredActionsResponse;
+                fromPartial(object: import("../helpers").DeepPartial<_34.QueryListExpiredActionsResponse>): _34.QueryListExpiredActionsResponse;
+                fromAmino(object: _34.QueryListExpiredActionsResponseAmino): _34.QueryListExpiredActionsResponse;
+                toAmino(message: _34.QueryListExpiredActionsResponse): _34.QueryListExpiredActionsResponseAmino;
+                fromAminoMsg(object: _34.QueryListExpiredActionsResponseAminoMsg): _34.QueryListExpiredActionsResponse;
+                fromProtoMsg(message: _34.QueryListExpiredActionsResponseProtoMsg): _34.QueryListExpiredActionsResponse;
+                toProto(message: _34.QueryListExpiredActionsResponse): Uint8Array;
+                toProtoMsg(message: _34.QueryListExpiredActionsResponse): _34.QueryListExpiredActionsResponseProtoMsg;
+                registerTypeUrl(): void;
+            };
+            QueryActionByMetadataRequest: {
+                typeUrl: string;
+                is(o: any): o is _34.QueryActionByMetadataRequest;
+                isAmino(o: any): o is _34.QueryActionByMetadataRequestAmino;
+                encode(message: _34.QueryActionByMetadataRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _34.QueryActionByMetadataRequest;
+                fromPartial(object: import("../helpers").DeepPartial<_34.QueryActionByMetadataRequest>): _34.QueryActionByMetadataRequest;
+                fromAmino(object: _34.QueryActionByMetadataRequestAmino): _34.QueryActionByMetadataRequest;
+                toAmino(message: _34.QueryActionByMetadataRequest): _34.QueryActionByMetadataRequestAmino;
+                fromAminoMsg(object: _34.QueryActionByMetadataRequestAminoMsg): _34.QueryActionByMetadataRequest;
+                fromProtoMsg(message: _34.QueryActionByMetadataRequestProtoMsg): _34.QueryActionByMetadataRequest;
+                toProto(message: _34.QueryActionByMetadataRequest): Uint8Array;
+                toProtoMsg(message: _34.QueryActionByMetadataRequest): _34.QueryActionByMetadataRequestProtoMsg;
+                registerTypeUrl(): void;
+            };
+            QueryActionByMetadataResponse: {
+                typeUrl: string;
+                is(o: any): o is _34.QueryActionByMetadataResponse;
+                isAmino(o: any): o is _34.QueryActionByMetadataResponseAmino;
+                encode(message: _34.QueryActionByMetadataResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _34.QueryActionByMetadataResponse;
+                fromPartial(object: import("../helpers").DeepPartial<_34.QueryActionByMetadataResponse>): _34.QueryActionByMetadataResponse;
+                fromAmino(object: _34.QueryActionByMetadataResponseAmino): _34.QueryActionByMetadataResponse;
+                toAmino(message: _34.QueryActionByMetadataResponse): _34.QueryActionByMetadataResponseAmino;
+                fromAminoMsg(object: _34.QueryActionByMetadataResponseAminoMsg): _34.QueryActionByMetadataResponse;
+                fromProtoMsg(message: _34.QueryActionByMetadataResponseProtoMsg): _34.QueryActionByMetadataResponse;
+                toProto(message: _34.QueryActionByMetadataResponse): Uint8Array;
+                toProtoMsg(message: _34.QueryActionByMetadataResponse): _34.QueryActionByMetadataResponseProtoMsg;
+                registerTypeUrl(): void;
+            };
+            MsgUpdateParams: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _33.MsgUpdateParams;
+                isAmino(o: any): o is _33.MsgUpdateParamsAmino;
+                encode(message: _33.MsgUpdateParams, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _33.MsgUpdateParams;
+                fromPartial(object: import("../helpers").DeepPartial<_33.MsgUpdateParams>): _33.MsgUpdateParams;
+                fromAmino(object: _33.MsgUpdateParamsAmino): _33.MsgUpdateParams;
+                toAmino(message: _33.MsgUpdateParams): _33.MsgUpdateParamsAmino;
+                fromAminoMsg(object: _33.MsgUpdateParamsAminoMsg): _33.MsgUpdateParams;
+                toAminoMsg(message: _33.MsgUpdateParams): _33.MsgUpdateParamsAminoMsg;
+                fromProtoMsg(message: _33.MsgUpdateParamsProtoMsg): _33.MsgUpdateParams;
+                toProto(message: _33.MsgUpdateParams): Uint8Array;
+                toProtoMsg(message: _33.MsgUpdateParams): _33.MsgUpdateParamsProtoMsg;
+                registerTypeUrl(): void;
+            };
+            MsgUpdateParamsResponse: {
+                typeUrl: string;
+                is(o: any): o is _33.MsgUpdateParamsResponse;
+                isAmino(o: any): o is _33.MsgUpdateParamsResponseAmino;
+                encode(_: _33.MsgUpdateParamsResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _33.MsgUpdateParamsResponse;
+                fromPartial(_: import("../helpers").DeepPartial<_33.MsgUpdateParamsResponse>): _33.MsgUpdateParamsResponse;
+                fromAmino(_: _33.MsgUpdateParamsResponseAmino): _33.MsgUpdateParamsResponse;
+                toAmino(_: _33.MsgUpdateParamsResponse): _33.MsgUpdateParamsResponseAmino;
+                fromAminoMsg(object: _33.MsgUpdateParamsResponseAminoMsg): _33.MsgUpdateParamsResponse;
+                fromProtoMsg(message: _33.MsgUpdateParamsResponseProtoMsg): _33.MsgUpdateParamsResponse;
+                toProto(message: _33.MsgUpdateParamsResponse): Uint8Array;
+                toProtoMsg(message: _33.MsgUpdateParamsResponse): _33.MsgUpdateParamsResponseProtoMsg;
+                registerTypeUrl(): void;
+            };
+            MsgRequestAction: {
+                typeUrl: string;
+                is(o: any): o is _33.MsgRequestAction;
+                isAmino(o: any): o is _33.MsgRequestActionAmino;
+                encode(message: _33.MsgRequestAction, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _33.MsgRequestAction;
+                fromPartial(object: import("../helpers").DeepPartial<_33.MsgRequestAction>): _33.MsgRequestAction;
+                fromAmino(object: _33.MsgRequestActionAmino): _33.MsgRequestAction;
+                toAmino(message: _33.MsgRequestAction): _33.MsgRequestActionAmino;
+                fromAminoMsg(object: _33.MsgRequestActionAminoMsg): _33.MsgRequestAction;
+                fromProtoMsg(message: _33.MsgRequestActionProtoMsg): _33.MsgRequestAction;
+                toProto(message: _33.MsgRequestAction): Uint8Array;
+                toProtoMsg(message: _33.MsgRequestAction): _33.MsgRequestActionProtoMsg;
+                registerTypeUrl(): void;
+            };
+            MsgRequestActionResponse: {
+                typeUrl: string;
+                is(o: any): o is _33.MsgRequestActionResponse;
+                isAmino(o: any): o is _33.MsgRequestActionResponseAmino;
+                encode(message: _33.MsgRequestActionResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _33.MsgRequestActionResponse;
+                fromPartial(object: import("../helpers").DeepPartial<_33.MsgRequestActionResponse>): _33.MsgRequestActionResponse;
+                fromAmino(object: _33.MsgRequestActionResponseAmino): _33.MsgRequestActionResponse;
+                toAmino(message: _33.MsgRequestActionResponse): _33.MsgRequestActionResponseAmino;
+                fromAminoMsg(object: _33.MsgRequestActionResponseAminoMsg): _33.MsgRequestActionResponse;
+                fromProtoMsg(message: _33.MsgRequestActionResponseProtoMsg): _33.MsgRequestActionResponse;
+                toProto(message: _33.MsgRequestActionResponse): Uint8Array;
+                toProtoMsg(message: _33.MsgRequestActionResponse): _33.MsgRequestActionResponseProtoMsg;
+                registerTypeUrl(): void;
+            };
+            MsgFinalizeAction: {
+                typeUrl: string;
+                is(o: any): o is _33.MsgFinalizeAction;
+                isAmino(o: any): o is _33.MsgFinalizeActionAmino;
+                encode(message: _33.MsgFinalizeAction, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _33.MsgFinalizeAction;
+                fromPartial(object: import("../helpers").DeepPartial<_33.MsgFinalizeAction>): _33.MsgFinalizeAction;
+                fromAmino(object: _33.MsgFinalizeActionAmino): _33.MsgFinalizeAction;
+                toAmino(message: _33.MsgFinalizeAction): _33.MsgFinalizeActionAmino;
+                fromAminoMsg(object: _33.MsgFinalizeActionAminoMsg): _33.MsgFinalizeAction;
+                fromProtoMsg(message: _33.MsgFinalizeActionProtoMsg): _33.MsgFinalizeAction;
+                toProto(message: _33.MsgFinalizeAction): Uint8Array;
+                toProtoMsg(message: _33.MsgFinalizeAction): _33.MsgFinalizeActionProtoMsg;
+                registerTypeUrl(): void;
+            };
+            MsgFinalizeActionResponse: {
+                typeUrl: string;
+                is(o: any): o is _33.MsgFinalizeActionResponse;
+                isAmino(o: any): o is _33.MsgFinalizeActionResponseAmino;
+                encode(_: _33.MsgFinalizeActionResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _33.MsgFinalizeActionResponse;
+                fromPartial(_: import("../helpers").DeepPartial<_33.MsgFinalizeActionResponse>): _33.MsgFinalizeActionResponse;
+                fromAmino(_: _33.MsgFinalizeActionResponseAmino): _33.MsgFinalizeActionResponse;
+                toAmino(_: _33.MsgFinalizeActionResponse): _33.MsgFinalizeActionResponseAmino;
+                fromAminoMsg(object: _33.MsgFinalizeActionResponseAminoMsg): _33.MsgFinalizeActionResponse;
+                fromProtoMsg(message: _33.MsgFinalizeActionResponseProtoMsg): _33.MsgFinalizeActionResponse;
+                toProto(message: _33.MsgFinalizeActionResponse): Uint8Array;
+                toProtoMsg(message: _33.MsgFinalizeActionResponse): _33.MsgFinalizeActionResponseProtoMsg;
+                registerTypeUrl(): void;
+            };
+            MsgApproveAction: {
+                typeUrl: string;
+                is(o: any): o is _33.MsgApproveAction;
+                isAmino(o: any): o is _33.MsgApproveActionAmino;
+                encode(message: _33.MsgApproveAction, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _33.MsgApproveAction;
+                fromPartial(object: import("../helpers").DeepPartial<_33.MsgApproveAction>): _33.MsgApproveAction;
+                fromAmino(object: _33.MsgApproveActionAmino): _33.MsgApproveAction;
+                toAmino(message: _33.MsgApproveAction): _33.MsgApproveActionAmino;
+                fromAminoMsg(object: _33.MsgApproveActionAminoMsg): _33.MsgApproveAction;
+                fromProtoMsg(message: _33.MsgApproveActionProtoMsg): _33.MsgApproveAction;
+                toProto(message: _33.MsgApproveAction): Uint8Array;
+                toProtoMsg(message: _33.MsgApproveAction): _33.MsgApproveActionProtoMsg;
+                registerTypeUrl(): void;
+            };
+            MsgApproveActionResponse: {
+                typeUrl: string;
+                is(o: any): o is _33.MsgApproveActionResponse;
+                isAmino(o: any): o is _33.MsgApproveActionResponseAmino;
+                encode(message: _33.MsgApproveActionResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _33.MsgApproveActionResponse;
+                fromPartial(object: import("../helpers").DeepPartial<_33.MsgApproveActionResponse>): _33.MsgApproveActionResponse;
+                fromAmino(object: _33.MsgApproveActionResponseAmino): _33.MsgApproveActionResponse;
+                toAmino(message: _33.MsgApproveActionResponse): _33.MsgApproveActionResponseAmino;
+                fromAminoMsg(object: _33.MsgApproveActionResponseAminoMsg): _33.MsgApproveActionResponse;
+                fromProtoMsg(message: _33.MsgApproveActionResponseProtoMsg): _33.MsgApproveActionResponse;
+                toProto(message: _33.MsgApproveActionResponse): Uint8Array;
+                toProtoMsg(message: _33.MsgApproveActionResponse): _33.MsgApproveActionResponseProtoMsg;
+                registerTypeUrl(): void;
+            };
+        };
+        namespace module {
+            const v1: {
+                Module: {
+                    typeUrl: string;
+                    is(o: any): o is _41.Module;
+                    isAmino(o: any): o is _41.ModuleAmino;
+                    encode(message: _41.Module, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                    decode(input: import("..").BinaryReader | Uint8Array, length?: number): _41.Module;
+                    fromPartial(object: import("../helpers").DeepPartial<_41.Module>): _41.Module;
+                    fromAmino(object: _41.ModuleAmino): _41.Module;
+                    toAmino(message: _41.Module): _41.ModuleAmino;
+                    fromAminoMsg(object: _41.ModuleAminoMsg): _41.Module;
+                    fromProtoMsg(message: _41.ModuleProtoMsg): _41.Module;
+                    toProto(message: _41.Module): Uint8Array;
+                    toProtoMsg(message: _41.Module): _41.ModuleProtoMsg;
+                    registerTypeUrl(): void;
+                };
+            };
+        }
+    }
+    const ClientFactory: {
+        createRPCMsgClient: ({ rpc }: {
+            rpc: import("../helpers").Rpc;
+        }) => Promise<{
+            lumera: {
+                supernode: {
+                    v1: _237.MsgClientImpl;
+                };
+                lumeraid: _238.MsgClientImpl;
+                claim: _239.MsgClientImpl;
+                action: {
+                    v1: _240.MsgClientImpl;
+                };
+            };
+            cosmos: {
+                vesting: {
+                    v1beta1: import("../cosmos/vesting/v1beta1/tx.rpc.msg").MsgClientImpl;
+                };
+                upgrade: {
+                    v1beta1: import("../cosmos/upgrade/v1beta1/tx.rpc.msg").MsgClientImpl;
+                };
+                staking: {
+                    v1beta1: import("../cosmos/staking/v1beta1/tx.rpc.msg").MsgClientImpl;
+                };
+                slashing: {
+                    v1beta1: import("../cosmos/slashing/v1beta1/tx.rpc.msg").MsgClientImpl;
+                };
+                nft: {
+                    v1beta1: import("../cosmos/nft/v1beta1/tx.rpc.msg").MsgClientImpl;
+                };
+                mint: {
+                    v1beta1: import("../cosmos/mint/v1beta1/tx.rpc.msg").MsgClientImpl;
+                };
+                group: {
+                    v1: import("../cosmos/group/v1/tx.rpc.msg").MsgClientImpl;
+                };
+                gov: {
+                    v1beta1: import("../cosmos/gov/v1beta1/tx.rpc.msg").MsgClientImpl;
+                    v1: import("../cosmos/gov/v1/tx.rpc.msg").MsgClientImpl;
+                };
+                feegrant: {
+                    v1beta1: import("../cosmos/feegrant/v1beta1/tx.rpc.msg").MsgClientImpl;
+                };
+                evidence: {
+                    v1beta1: import("../cosmos/evidence/v1beta1/tx.rpc.msg").MsgClientImpl;
+                };
+                distribution: {
+                    v1beta1: import("../cosmos/distribution/v1beta1/tx.rpc.msg").MsgClientImpl;
+                };
+                crisis: {
+                    v1beta1: import("../cosmos/crisis/v1beta1/tx.rpc.msg").MsgClientImpl;
+                };
+                consensus: {
+                    v1: import("../cosmos/consensus/v1/tx.rpc.msg").MsgClientImpl;
+                };
+                circuit: {
+                    v1: import("../cosmos/circuit/v1/tx.rpc.msg").MsgClientImpl;
+                };
+                bank: {
+                    v1beta1: import("../cosmos/bank/v1beta1/tx.rpc.msg").MsgClientImpl;
+                };
+                authz: {
+                    v1beta1: import("../cosmos/authz/v1beta1/tx.rpc.msg").MsgClientImpl;
+                };
+                auth: {
+                    v1beta1: import("../cosmos/auth/v1beta1/tx.rpc.msg").MsgClientImpl;
+                };
+            };
+        }>;
+        createRPCQueryClient: ({ rpcEndpoint }: {
+            rpcEndpoint: string | import("@cosmjs/tendermint-rpc").HttpEndpoint;
+        }) => Promise<{
+            lumera: {
+                supernode: {
+                    v1: {
+                        params(request?: _15.QueryParamsRequest): Promise<_15.QueryParamsResponse>;
+                        getSuperNode(request: _15.QueryGetSuperNodeRequest): Promise<_15.QueryGetSuperNodeResponse>;
+                        getSuperNodeBySuperNodeAddress(request: _15.QueryGetSuperNodeBySuperNodeAddressRequest): Promise<_15.QueryGetSuperNodeBySuperNodeAddressResponse>;
+                        listSuperNodes(request?: _15.QueryListSuperNodesRequest): Promise<_15.QueryListSuperNodesResponse>;
+                        getTopSuperNodesForBlock(request: _15.QueryGetTopSuperNodesForBlockRequest): Promise<_15.QueryGetTopSuperNodesForBlockResponse>;
+                        getMetrics(request: _15.QueryGetMetricsRequest): Promise<_15.QueryGetMetricsResponse>;
+                    };
+                };
+                lumeraid: {
+                    params(request?: _24.QueryParamsRequest): Promise<_24.QueryParamsResponse>;
+                };
+                claim: {
+                    params(request?: _29.QueryParamsRequest): Promise<_29.QueryParamsResponse>;
+                    claimRecord(request: _29.QueryClaimRecordRequest): Promise<_29.QueryClaimRecordResponse>;
+                    listClaimed(request: _29.QueryListClaimedRequest): Promise<_29.QueryListClaimedResponse>;
+                };
+                action: {
+                    v1: {
+                        params(request?: _34.QueryParamsRequest): Promise<_34.QueryParamsResponse>;
+                        getAction(request: _34.QueryGetActionRequest): Promise<_34.QueryGetActionResponse>;
+                        getActionFee(request: _34.QueryGetActionFeeRequest): Promise<_34.QueryGetActionFeeResponse>;
+                        listActions(request: _34.QueryListActionsRequest): Promise<_34.QueryListActionsResponse>;
+                        listActionsByCreator(request: _34.QueryListActionsByCreatorRequest): Promise<_34.QueryListActionsByCreatorResponse>;
+                        listActionsBySuperNode(request: _34.QueryListActionsBySuperNodeRequest): Promise<_34.QueryListActionsBySuperNodeResponse>;
+                        listActionsByBlockHeight(request: _34.QueryListActionsByBlockHeightRequest): Promise<_34.QueryListActionsByBlockHeightResponse>;
+                        listExpiredActions(request?: _34.QueryListExpiredActionsRequest): Promise<_34.QueryListExpiredActionsResponse>;
+                        queryActionByMetadata(request: _34.QueryActionByMetadataRequest): Promise<_34.QueryActionByMetadataResponse>;
+                    };
+                };
+            };
+            cosmos: {
+                upgrade: {
+                    v1beta1: {
+                        currentPlan(request?: import("../cosmos/upgrade/v1beta1/query").QueryCurrentPlanRequest): Promise<import("../cosmos/upgrade/v1beta1/query").QueryCurrentPlanResponse>;
+                        appliedPlan(request: import("../cosmos/upgrade/v1beta1/query").QueryAppliedPlanRequest): Promise<import("../cosmos/upgrade/v1beta1/query").QueryAppliedPlanResponse>;
+                        upgradedConsensusState(request: import("../cosmos/upgrade/v1beta1/query").QueryUpgradedConsensusStateRequest): Promise<import("../cosmos/upgrade/v1beta1/query").QueryUpgradedConsensusStateResponse>;
+                        moduleVersions(request: import("../cosmos/upgrade/v1beta1/query").QueryModuleVersionsRequest): Promise<import("../cosmos/upgrade/v1beta1/query").QueryModuleVersionsResponse>;
+                        authority(request?: import("../cosmos/upgrade/v1beta1/query").QueryAuthorityRequest): Promise<import("../cosmos/upgrade/v1beta1/query").QueryAuthorityResponse>;
+                    };
+                };
+                tx: {
+                    v1beta1: {
+                        simulate(request: import("../cosmos/tx/v1beta1/service").SimulateRequest): Promise<import("../cosmos/tx/v1beta1/service").SimulateResponse>;
+                        getTx(request: import("../cosmos/tx/v1beta1/service").GetTxRequest): Promise<import("../cosmos/tx/v1beta1/service").GetTxResponse>;
+                        broadcastTx(request: import("../cosmos/tx/v1beta1/service").BroadcastTxRequest): Promise<import("../cosmos/tx/v1beta1/service").BroadcastTxResponse>;
+                        getTxsEvent(request: import("../cosmos/tx/v1beta1/service").GetTxsEventRequest): Promise<import("../cosmos/tx/v1beta1/service").GetTxsEventResponse>;
+                        getBlockWithTxs(request: import("../cosmos/tx/v1beta1/service").GetBlockWithTxsRequest): Promise<import("../cosmos/tx/v1beta1/service").GetBlockWithTxsResponse>;
+                        txDecode(request: import("../cosmos/tx/v1beta1/service").TxDecodeRequest): Promise<import("../cosmos/tx/v1beta1/service").TxDecodeResponse>;
+                        txEncode(request: import("../cosmos/tx/v1beta1/service").TxEncodeRequest): Promise<import("../cosmos/tx/v1beta1/service").TxEncodeResponse>;
+                        txEncodeAmino(request: import("../cosmos/tx/v1beta1/service").TxEncodeAminoRequest): Promise<import("../cosmos/tx/v1beta1/service").TxEncodeAminoResponse>;
+                        txDecodeAmino(request: import("../cosmos/tx/v1beta1/service").TxDecodeAminoRequest): Promise<import("../cosmos/tx/v1beta1/service").TxDecodeAminoResponse>;
+                    };
+                };
+                staking: {
+                    v1beta1: {
+                        validators(request: import("../cosmos/staking/v1beta1/query").QueryValidatorsRequest): Promise<import("../cosmos/staking/v1beta1/query").QueryValidatorsResponse>;
+                        validator(request: import("../cosmos/staking/v1beta1/query").QueryValidatorRequest): Promise<import("../cosmos/staking/v1beta1/query").QueryValidatorResponse>;
+                        validatorDelegations(request: import("../cosmos/staking/v1beta1/query").QueryValidatorDelegationsRequest): Promise<import("../cosmos/staking/v1beta1/query").QueryValidatorDelegationsResponse>;
+                        validatorUnbondingDelegations(request: import("../cosmos/staking/v1beta1/query").QueryValidatorUnbondingDelegationsRequest): Promise<import("../cosmos/staking/v1beta1/query").QueryValidatorUnbondingDelegationsResponse>;
+                        delegation(request: import("../cosmos/staking/v1beta1/query").QueryDelegationRequest): Promise<import("../cosmos/staking/v1beta1/query").QueryDelegationResponse>;
+                        unbondingDelegation(request: import("../cosmos/staking/v1beta1/query").QueryUnbondingDelegationRequest): Promise<import("../cosmos/staking/v1beta1/query").QueryUnbondingDelegationResponse>;
+                        delegatorDelegations(request: import("../cosmos/staking/v1beta1/query").QueryDelegatorDelegationsRequest): Promise<import("../cosmos/staking/v1beta1/query").QueryDelegatorDelegationsResponse>;
+                        delegatorUnbondingDelegations(request: import("../cosmos/staking/v1beta1/query").QueryDelegatorUnbondingDelegationsRequest): Promise<import("../cosmos/staking/v1beta1/query").QueryDelegatorUnbondingDelegationsResponse>;
+                        redelegations(request: import("../cosmos/staking/v1beta1/query").QueryRedelegationsRequest): Promise<import("../cosmos/staking/v1beta1/query").QueryRedelegationsResponse>;
+                        delegatorValidators(request: import("../cosmos/staking/v1beta1/query").QueryDelegatorValidatorsRequest): Promise<import("../cosmos/staking/v1beta1/query").QueryDelegatorValidatorsResponse>;
+                        delegatorValidator(request: import("../cosmos/staking/v1beta1/query").QueryDelegatorValidatorRequest): Promise<import("../cosmos/staking/v1beta1/query").QueryDelegatorValidatorResponse>;
+                        historicalInfo(request: import("../cosmos/staking/v1beta1/query").QueryHistoricalInfoRequest): Promise<import("../cosmos/staking/v1beta1/query").QueryHistoricalInfoResponse>;
+                        pool(request?: import("../cosmos/staking/v1beta1/query").QueryPoolRequest): Promise<import("../cosmos/staking/v1beta1/query").QueryPoolResponse>;
+                        params(request?: import("../cosmos/staking/v1beta1/query").QueryParamsRequest): Promise<import("../cosmos/staking/v1beta1/query").QueryParamsResponse>;
+                    };
+                };
+                slashing: {
+                    v1beta1: {
+                        params(request?: import("../cosmos/slashing/v1beta1/query").QueryParamsRequest): Promise<import("../cosmos/slashing/v1beta1/query").QueryParamsResponse>;
+                        signingInfo(request: import("../cosmos/slashing/v1beta1/query").QuerySigningInfoRequest): Promise<import("../cosmos/slashing/v1beta1/query").QuerySigningInfoResponse>;
+                        signingInfos(request?: import("../cosmos/slashing/v1beta1/query").QuerySigningInfosRequest): Promise<import("../cosmos/slashing/v1beta1/query").QuerySigningInfosResponse>;
+                    };
+                };
+                params: {
+                    v1beta1: {
+                        params(request: import("../cosmos/params/v1beta1/query").QueryParamsRequest): Promise<import("../cosmos/params/v1beta1/query").QueryParamsResponse>;
+                        subspaces(request?: import("../cosmos/params/v1beta1/query").QuerySubspacesRequest): Promise<import("../cosmos/params/v1beta1/query").QuerySubspacesResponse>;
+                    };
+                };
+                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>;
+                        };
+                    };
+                };
+                nft: {
+                    v1beta1: {
+                        balance(request: import("../cosmos/nft/v1beta1/query").QueryBalanceRequest): Promise<import("../cosmos/nft/v1beta1/query").QueryBalanceResponse>;
+                        owner(request: import("../cosmos/nft/v1beta1/query").QueryOwnerRequest): Promise<import("../cosmos/nft/v1beta1/query").QueryOwnerResponse>;
+                        supply(request: import("../cosmos/nft/v1beta1/query").QuerySupplyRequest): Promise<import("../cosmos/nft/v1beta1/query").QuerySupplyResponse>;
+                        nFTs(request: import("../cosmos/nft/v1beta1/query").QueryNFTsRequest): Promise<import("../cosmos/nft/v1beta1/query").QueryNFTsResponse>;
+                        nFT(request: import("../cosmos/nft/v1beta1/query").QueryNFTRequest): Promise<import("../cosmos/nft/v1beta1/query").QueryNFTResponse>;
+                        class(request: import("../cosmos/nft/v1beta1/query").QueryClassRequest): Promise<import("../cosmos/nft/v1beta1/query").QueryClassResponse>;
+                        classes(request?: import("../cosmos/nft/v1beta1/query").QueryClassesRequest): Promise<import("../cosmos/nft/v1beta1/query").QueryClassesResponse>;
+                    };
+                };
+                mint: {
+                    v1beta1: {
+                        params(request?: import("../cosmos/mint/v1beta1/query").QueryParamsRequest): Promise<import("../cosmos/mint/v1beta1/query").QueryParamsResponse>;
+                        inflation(request?: import("../cosmos/mint/v1beta1/query").QueryInflationRequest): Promise<import("../cosmos/mint/v1beta1/query").QueryInflationResponse>;
+                        annualProvisions(request?: import("../cosmos/mint/v1beta1/query").QueryAnnualProvisionsRequest): Promise<import("../cosmos/mint/v1beta1/query").QueryAnnualProvisionsResponse>;
+                    };
+                };
+                group: {
+                    v1: {
+                        groupInfo(request: import("../cosmos/group/v1/query").QueryGroupInfoRequest): Promise<import("../cosmos/group/v1/query").QueryGroupInfoResponse>;
+                        groupPolicyInfo(request: import("../cosmos/group/v1/query").QueryGroupPolicyInfoRequest): Promise<import("../cosmos/group/v1/query").QueryGroupPolicyInfoResponse>;
+                        groupMembers(request: import("../cosmos/group/v1/query").QueryGroupMembersRequest): Promise<import("../cosmos/group/v1/query").QueryGroupMembersResponse>;
+                        groupsByAdmin(request: import("../cosmos/group/v1/query").QueryGroupsByAdminRequest): Promise<import("../cosmos/group/v1/query").QueryGroupsByAdminResponse>;
+                        groupPoliciesByGroup(request: import("../cosmos/group/v1/query").QueryGroupPoliciesByGroupRequest): Promise<import("../cosmos/group/v1/query").QueryGroupPoliciesByGroupResponse>;
+                        groupPoliciesByAdmin(request: import("../cosmos/group/v1/query").QueryGroupPoliciesByAdminRequest): Promise<import("../cosmos/group/v1/query").QueryGroupPoliciesByAdminResponse>;
+                        proposal(request: import("../cosmos/group/v1/query").QueryProposalRequest): Promise<import("../cosmos/group/v1/query").QueryProposalResponse>;
+                        proposalsByGroupPolicy(request: import("../cosmos/group/v1/query").QueryProposalsByGroupPolicyRequest): Promise<import("../cosmos/group/v1/query").QueryProposalsByGroupPolicyResponse>;
+                        voteByProposalVoter(request: import("../cosmos/group/v1/query").QueryVoteByProposalVoterRequest): Promise<import("../cosmos/group/v1/query").QueryVoteByProposalVoterResponse>;
+                        votesByProposal(request: import("../cosmos/group/v1/query").QueryVotesByProposalRequest): Promise<import("../cosmos/group/v1/query").QueryVotesByProposalResponse>;
+                        votesByVoter(request: import("../cosmos/group/v1/query").QueryVotesByVoterRequest): Promise<import("../cosmos/group/v1/query").QueryVotesByVoterResponse>;
+                        groupsByMember(request: import("../cosmos/group/v1/query").QueryGroupsByMemberRequest): Promise<import("../cosmos/group/v1/query").QueryGroupsByMemberResponse>;
+                        tallyResult(request: import("../cosmos/group/v1/query").QueryTallyResultRequest): Promise<import("../cosmos/group/v1/query").QueryTallyResultResponse>;
+                        groups(request?: import("../cosmos/group/v1/query").QueryGroupsRequest): Promise<import("../cosmos/group/v1/query").QueryGroupsResponse>;
+                    };
+                };
+                gov: {
+                    v1beta1: {
+                        proposal(request: import("../cosmos/gov/v1beta1/query").QueryProposalRequest): Promise<import("../cosmos/gov/v1beta1/query").QueryProposalResponse>;
+                        proposals(request: import("../cosmos/gov/v1beta1/query").QueryProposalsRequest): Promise<import("../cosmos/gov/v1beta1/query").QueryProposalsResponse>;
+                        vote(request: import("../cosmos/gov/v1beta1/query").QueryVoteRequest): Promise<import("../cosmos/gov/v1beta1/query").QueryVoteResponse>;
+                        votes(request: import("../cosmos/gov/v1beta1/query").QueryVotesRequest): Promise<import("../cosmos/gov/v1beta1/query").QueryVotesResponse>;
+                        params(request: import("../cosmos/gov/v1beta1/query").QueryParamsRequest): Promise<import("../cosmos/gov/v1beta1/query").QueryParamsResponse>;
+                        deposit(request: import("../cosmos/gov/v1beta1/query").QueryDepositRequest): Promise<import("../cosmos/gov/v1beta1/query").QueryDepositResponse>;
+                        deposits(request: import("../cosmos/gov/v1beta1/query").QueryDepositsRequest): Promise<import("../cosmos/gov/v1beta1/query").QueryDepositsResponse>;
+                        tallyResult(request: import("../cosmos/gov/v1beta1/query").QueryTallyResultRequest): Promise<import("../cosmos/gov/v1beta1/query").QueryTallyResultResponse>;
+                    };
+                    v1: {
+                        constitution(request?: import("../cosmos/gov/v1/query").QueryConstitutionRequest): Promise<import("../cosmos/gov/v1/query").QueryConstitutionResponse>;
+                        proposal(request: import("../cosmos/gov/v1/query").QueryProposalRequest): Promise<import("../cosmos/gov/v1/query").QueryProposalResponse>;
+                        proposals(request: import("../cosmos/gov/v1/query").QueryProposalsRequest): Promise<import("../cosmos/gov/v1/query").QueryProposalsResponse>;
+                        vote(request: import("../cosmos/gov/v1/query").QueryVoteRequest): Promise<import("../cosmos/gov/v1/query").QueryVoteResponse>;
+                        votes(request: import("../cosmos/gov/v1/query").QueryVotesRequest): Promise<import("../cosmos/gov/v1/query").QueryVotesResponse>;
+                        params(request: import("../cosmos/gov/v1/query").QueryParamsRequest): Promise<import("../cosmos/gov/v1/query").QueryParamsResponse>;
+                        deposit(request: import("../cosmos/gov/v1/query").QueryDepositRequest): Promise<import("../cosmos/gov/v1/query").QueryDepositResponse>;
+                        deposits(request: import("../cosmos/gov/v1/query").QueryDepositsRequest): Promise<import("../cosmos/gov/v1/query").QueryDepositsResponse>;
+                        tallyResult(request: import("../cosmos/gov/v1/query").QueryTallyResultRequest): Promise<import("../cosmos/gov/v1/query").QueryTallyResultResponse>;
+                    };
+                };
+                feegrant: {
+                    v1beta1: {
+                        allowance(request: import("../cosmos/feegrant/v1beta1/query").QueryAllowanceRequest): Promise<import("../cosmos/feegrant/v1beta1/query").QueryAllowanceResponse>;
+                        allowances(request: import("../cosmos/feegrant/v1beta1/query").QueryAllowancesRequest): Promise<import("../cosmos/feegrant/v1beta1/query").QueryAllowancesResponse>;
+                        allowancesByGranter(request: import("../cosmos/feegrant/v1beta1/query").QueryAllowancesByGranterRequest): Promise<import("../cosmos/feegrant/v1beta1/query").QueryAllowancesByGranterResponse>;
+                    };
+                };
+                evidence: {
+                    v1beta1: {
+                        evidence(request: import("../cosmos/evidence/v1beta1/query").QueryEvidenceRequest): Promise<import("../cosmos/evidence/v1beta1/query").QueryEvidenceResponse>;
+                        allEvidence(request?: import("../cosmos/evidence/v1beta1/query").QueryAllEvidenceRequest): Promise<import("../cosmos/evidence/v1beta1/query").QueryAllEvidenceResponse>;
+                    };
+                };
+                distribution: {
+                    v1beta1: {
+                        params(request?: import("../cosmos/distribution/v1beta1/query").QueryParamsRequest): Promise<import("../cosmos/distribution/v1beta1/query").QueryParamsResponse>;
+                        validatorDistributionInfo(request: import("../cosmos/distribution/v1beta1/query").QueryValidatorDistributionInfoRequest): Promise<import("../cosmos/distribution/v1beta1/query").QueryValidatorDistributionInfoResponse>;
+                        validatorOutstandingRewards(request: import("../cosmos/distribution/v1beta1/query").QueryValidatorOutstandingRewardsRequest): Promise<import("../cosmos/distribution/v1beta1/query").QueryValidatorOutstandingRewardsResponse>;
+                        validatorCommission(request: import("../cosmos/distribution/v1beta1/query").QueryValidatorCommissionRequest): Promise<import("../cosmos/distribution/v1beta1/query").QueryValidatorCommissionResponse>;
+                        validatorSlashes(request: import("../cosmos/distribution/v1beta1/query").QueryValidatorSlashesRequest): Promise<import("../cosmos/distribution/v1beta1/query").QueryValidatorSlashesResponse>;
+                        delegationRewards(request: import("../cosmos/distribution/v1beta1/query").QueryDelegationRewardsRequest): Promise<import("../cosmos/distribution/v1beta1/query").QueryDelegationRewardsResponse>;
+                        delegationTotalRewards(request: import("../cosmos/distribution/v1beta1/query").QueryDelegationTotalRewardsRequest): Promise<import("../cosmos/distribution/v1beta1/query").QueryDelegationTotalRewardsResponse>;
+                        delegatorValidators(request: import("../cosmos/distribution/v1beta1/query").QueryDelegatorValidatorsRequest): Promise<import("../cosmos/distribution/v1beta1/query").QueryDelegatorValidatorsResponse>;
+                        delegatorWithdrawAddress(request: import("../cosmos/distribution/v1beta1/query").QueryDelegatorWithdrawAddressRequest): Promise<import("../cosmos/distribution/v1beta1/query").QueryDelegatorWithdrawAddressResponse>;
+                        communityPool(request?: import("../cosmos/distribution/v1beta1/query").QueryCommunityPoolRequest): Promise<import("../cosmos/distribution/v1beta1/query").QueryCommunityPoolResponse>;
+                    };
+                };
+                consensus: {
+                    v1: {
+                        params(request?: import("../cosmos/consensus/v1/query").QueryParamsRequest): Promise<import("../cosmos/consensus/v1/query").QueryParamsResponse>;
+                    };
+                };
+                circuit: {
+                    v1: {
+                        account(request: import("../cosmos/circuit/v1/query").QueryAccountRequest): Promise<import("../cosmos/circuit/v1/query").AccountResponse>;
+                        accounts(request?: import("../cosmos/circuit/v1/query").QueryAccountsRequest): Promise<import("../cosmos/circuit/v1/query").AccountsResponse>;
+                        disabledList(request?: import("../cosmos/circuit/v1/query").QueryDisabledListRequest): Promise<import("../cosmos/circuit/v1/query").DisabledListResponse>;
+                    };
+                };
+                base: {
+                    tendermint: {
+                        v1beta1: {
+                            getNodeInfo(request?: import("../cosmos/base/tendermint/v1beta1/query").GetNodeInfoRequest): Promise<import("../cosmos/base/tendermint/v1beta1/query").GetNodeInfoResponse>;
+                            getSyncing(request?: import("../cosmos/base/tendermint/v1beta1/query").GetSyncingRequest): Promise<import("../cosmos/base/tendermint/v1beta1/query").GetSyncingResponse>;
+                            getLatestBlock(request?: import("../cosmos/base/tendermint/v1beta1/query").GetLatestBlockRequest): Promise<import("../cosmos/base/tendermint/v1beta1/query").GetLatestBlockResponse>;
+                            getBlockByHeight(request: import("../cosmos/base/tendermint/v1beta1/query").GetBlockByHeightRequest): Promise<import("../cosmos/base/tendermint/v1beta1/query").GetBlockByHeightResponse>;
+                            getLatestValidatorSet(request?: import("../cosmos/base/tendermint/v1beta1/query").GetLatestValidatorSetRequest): Promise<import("../cosmos/base/tendermint/v1beta1/query").GetLatestValidatorSetResponse>;
+                            getValidatorSetByHeight(request: import("../cosmos/base/tendermint/v1beta1/query").GetValidatorSetByHeightRequest): Promise<import("../cosmos/base/tendermint/v1beta1/query").GetValidatorSetByHeightResponse>;
+                            aBCIQuery(request: import("../cosmos/base/tendermint/v1beta1/query").ABCIQueryRequest): Promise<import("../cosmos/base/tendermint/v1beta1/query").ABCIQueryResponse>;
+                        };
+                    };
+                    node: {
+                        v1beta1: {
+                            config(request?: import("../cosmos/base/node/v1beta1/query").ConfigRequest): Promise<import("../cosmos/base/node/v1beta1/query").ConfigResponse>;
+                            status(request?: import("../cosmos/base/node/v1beta1/query").StatusRequest): Promise<import("../cosmos/base/node/v1beta1/query").StatusResponse>;
+                        };
+                    };
+                };
+                bank: {
+                    v1beta1: {
+                        balance(request: import("../cosmos/bank/v1beta1/query").QueryBalanceRequest): Promise<import("../cosmos/bank/v1beta1/query").QueryBalanceResponse>;
+                        allBalances(request: import("../cosmos/bank/v1beta1/query").QueryAllBalancesRequest): Promise<import("../cosmos/bank/v1beta1/query").QueryAllBalancesResponse>;
+                        spendableBalances(request: import("../cosmos/bank/v1beta1/query").QuerySpendableBalancesRequest): Promise<import("../cosmos/bank/v1beta1/query").QuerySpendableBalancesResponse>;
+                        spendableBalanceByDenom(request: import("../cosmos/bank/v1beta1/query").QuerySpendableBalanceByDenomRequest): Promise<import("../cosmos/bank/v1beta1/query").QuerySpendableBalanceByDenomResponse>;
+                        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>;
+                        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>;
+                        sendEnabled(request: import("../cosmos/bank/v1beta1/query").QuerySendEnabledRequest): Promise<import("../cosmos/bank/v1beta1/query").QuerySendEnabledResponse>;
+                    };
+                };
+                autocli: {
+                    v1: {
+                        appOptions(request?: import("../cosmos/autocli/v1/query").AppOptionsRequest): Promise<import("../cosmos/autocli/v1/query").AppOptionsResponse>;
+                    };
+                };
+                authz: {
+                    v1beta1: {
+                        grants(request: import("../cosmos/authz/v1beta1/query").QueryGrantsRequest): Promise<import("../cosmos/authz/v1beta1/query").QueryGrantsResponse>;
+                        granterGrants(request: import("../cosmos/authz/v1beta1/query").QueryGranterGrantsRequest): Promise<import("../cosmos/authz/v1beta1/query").QueryGranterGrantsResponse>;
+                        granteeGrants(request: import("../cosmos/authz/v1beta1/query").QueryGranteeGrantsRequest): Promise<import("../cosmos/authz/v1beta1/query").QueryGranteeGrantsResponse>;
+                    };
+                };
+                auth: {
+                    v1beta1: {
+                        accounts(request?: import("../cosmos/auth/v1beta1/query").QueryAccountsRequest): Promise<import("../cosmos/auth/v1beta1/query").QueryAccountsResponse>;
+                        account(request: import("../cosmos/auth/v1beta1/query").QueryAccountRequest): Promise<import("../cosmos/auth/v1beta1/query").QueryAccountResponse>;
+                        accountAddressByID(request: import("../cosmos/auth/v1beta1/query").QueryAccountAddressByIDRequest): Promise<import("../cosmos/auth/v1beta1/query").QueryAccountAddressByIDResponse>;
+                        params(request?: import("../cosmos/auth/v1beta1/query").QueryParamsRequest): Promise<import("../cosmos/auth/v1beta1/query").QueryParamsResponse>;
+                        moduleAccounts(request?: import("../cosmos/auth/v1beta1/query").QueryModuleAccountsRequest): Promise<import("../cosmos/auth/v1beta1/query").QueryModuleAccountsResponse>;
+                        moduleAccountByName(request: import("../cosmos/auth/v1beta1/query").QueryModuleAccountByNameRequest): Promise<import("../cosmos/auth/v1beta1/query").QueryModuleAccountByNameResponse>;
+                        bech32Prefix(request?: import("../cosmos/auth/v1beta1/query").Bech32PrefixRequest): Promise<import("../cosmos/auth/v1beta1/query").Bech32PrefixResponse>;
+                        addressBytesToString(request: import("../cosmos/auth/v1beta1/query").AddressBytesToStringRequest): Promise<import("../cosmos/auth/v1beta1/query").AddressBytesToStringResponse>;
+                        addressStringToBytes(request: import("../cosmos/auth/v1beta1/query").AddressStringToBytesRequest): Promise<import("../cosmos/auth/v1beta1/query").AddressStringToBytesResponse>;
+                        accountInfo(request: import("../cosmos/auth/v1beta1/query").QueryAccountInfoRequest): Promise<import("../cosmos/auth/v1beta1/query").QueryAccountInfoResponse>;
+                    };
+                };
+                app: {
+                    v1alpha1: {
+                        config(request?: import("../cosmos/app/v1alpha1/query").QueryConfigRequest): Promise<import("../cosmos/app/v1alpha1/query").QueryConfigResponse>;
+                    };
+                };
+            };
+        }>;
+    };
+}