@xpla/xpla-react 1.7.0-beta.0 → 1.7.0-beta.11

package/ibc/applications/interchain_accounts/host/v1/host.js

@@ -0,0 +1,186 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryRequest = exports.Params = void 0;
+const binary_1 = require("../../../../../binary");
+const helpers_1 = require("../../../../../helpers");
+function createBaseParams() {
+    return {
+        hostEnabled: false,
+        allowMessages: []
+    };
+}
+exports.Params = {
+    typeUrl: "/ibc.applications.interchain_accounts.host.v1.Params",
+    aminoType: "cosmos-sdk/Params",
+    is(o) {
+        return o && (o.$typeUrl === exports.Params.typeUrl || typeof o.hostEnabled === "boolean" && Array.isArray(o.allowMessages) && (!o.allowMessages.length || typeof o.allowMessages[0] === "string"));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === exports.Params.typeUrl || typeof o.host_enabled === "boolean" && Array.isArray(o.allow_messages) && (!o.allow_messages.length || typeof o.allow_messages[0] === "string"));
+    },
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.hostEnabled === true) {
+            writer.uint32(8).bool(message.hostEnabled);
+        }
+        for (const v of message.allowMessages) {
+            writer.uint32(18).string(v);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseParams();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.hostEnabled = reader.bool();
+                    break;
+                case 2:
+                    message.allowMessages.push(reader.string());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseParams();
+        message.hostEnabled = object.hostEnabled ?? false;
+        message.allowMessages = object.allowMessages?.map(e => e) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseParams();
+        if (object.host_enabled !== undefined && object.host_enabled !== null) {
+            message.hostEnabled = object.host_enabled;
+        }
+        message.allowMessages = object.allow_messages?.map(e => e) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.host_enabled = message.hostEnabled === false ? undefined : message.hostEnabled;
+        if (message.allowMessages) {
+            obj.allow_messages = message.allowMessages.map(e => e);
+        }
+        else {
+            obj.allow_messages = message.allowMessages;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.Params.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/Params",
+            value: exports.Params.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return exports.Params.decode(message.value);
+    },
+    toProto(message) {
+        return exports.Params.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/ibc.applications.interchain_accounts.host.v1.Params",
+            value: exports.Params.encode(message).finish()
+        };
+    },
+    registerTypeUrl() { }
+};
+function createBaseQueryRequest() {
+    return {
+        path: "",
+        data: new Uint8Array()
+    };
+}
+exports.QueryRequest = {
+    typeUrl: "/ibc.applications.interchain_accounts.host.v1.QueryRequest",
+    aminoType: "cosmos-sdk/QueryRequest",
+    is(o) {
+        return o && (o.$typeUrl === exports.QueryRequest.typeUrl || typeof o.path === "string" && (o.data instanceof Uint8Array || typeof o.data === "string"));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === exports.QueryRequest.typeUrl || typeof o.path === "string" && (o.data instanceof Uint8Array || typeof o.data === "string"));
+    },
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.path !== "") {
+            writer.uint32(10).string(message.path);
+        }
+        if (message.data.length !== 0) {
+            writer.uint32(18).bytes(message.data);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.path = reader.string();
+                    break;
+                case 2:
+                    message.data = reader.bytes();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryRequest();
+        message.path = object.path ?? "";
+        message.data = object.data ?? new Uint8Array();
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryRequest();
+        if (object.path !== undefined && object.path !== null) {
+            message.path = object.path;
+        }
+        if (object.data !== undefined && object.data !== null) {
+            message.data = (0, helpers_1.bytesFromBase64)(object.data);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.path = message.path === "" ? undefined : message.path;
+        obj.data = message.data ? (0, helpers_1.base64FromBytes)(message.data) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.QueryRequest.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/QueryRequest",
+            value: exports.QueryRequest.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return exports.QueryRequest.decode(message.value);
+    },
+    toProto(message) {
+        return exports.QueryRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/ibc.applications.interchain_accounts.host.v1.QueryRequest",
+            value: exports.QueryRequest.encode(message).finish()
+        };
+    },
+    registerTypeUrl() { }
+};

package/ibc/applications/interchain_accounts/host/v1/query.d.ts

@@ -0,0 +1,69 @@
+import { Params, ParamsAmino } from "./host";
+import { BinaryReader, BinaryWriter } from "../../../../../binary";
+import { DeepPartial } from "../../../../../helpers";
+/** QueryParamsRequest is the request type for the Query/Params RPC method. */
+export interface QueryParamsRequest {
+}
+export interface QueryParamsRequestProtoMsg {
+    typeUrl: "/ibc.applications.interchain_accounts.host.v1.QueryParamsRequest";
+    value: Uint8Array;
+}
+/** QueryParamsRequest is the request type for the Query/Params RPC method. */
+export interface QueryParamsRequestAmino {
+}
+export interface QueryParamsRequestAminoMsg {
+    type: "cosmos-sdk/QueryParamsRequest";
+    value: QueryParamsRequestAmino;
+}
+/** QueryParamsResponse is the response type for the Query/Params RPC method. */
+export interface QueryParamsResponse {
+    /** params defines the parameters of the module. */
+    params?: Params;
+}
+export interface QueryParamsResponseProtoMsg {
+    typeUrl: "/ibc.applications.interchain_accounts.host.v1.QueryParamsResponse";
+    value: Uint8Array;
+}
+/** QueryParamsResponse is the response type for the Query/Params RPC method. */
+export interface QueryParamsResponseAmino {
+    /** params defines the parameters of the module. */
+    params?: ParamsAmino;
+}
+export interface QueryParamsResponseAminoMsg {
+    type: "cosmos-sdk/QueryParamsResponse";
+    value: QueryParamsResponseAmino;
+}
+export declare const QueryParamsRequest: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is QueryParamsRequest;
+    isAmino(o: any): o is QueryParamsRequestAmino;
+    encode(_: QueryParamsRequest, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryParamsRequest;
+    fromPartial(_: DeepPartial<QueryParamsRequest>): QueryParamsRequest;
+    fromAmino(_: QueryParamsRequestAmino): QueryParamsRequest;
+    toAmino(_: QueryParamsRequest): QueryParamsRequestAmino;
+    fromAminoMsg(object: QueryParamsRequestAminoMsg): QueryParamsRequest;
+    toAminoMsg(message: QueryParamsRequest): QueryParamsRequestAminoMsg;
+    fromProtoMsg(message: QueryParamsRequestProtoMsg): QueryParamsRequest;
+    toProto(message: QueryParamsRequest): Uint8Array;
+    toProtoMsg(message: QueryParamsRequest): QueryParamsRequestProtoMsg;
+    registerTypeUrl(): void;
+};
+export declare const QueryParamsResponse: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is QueryParamsResponse;
+    isAmino(o: any): o is QueryParamsResponseAmino;
+    encode(message: QueryParamsResponse, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): QueryParamsResponse;
+    fromPartial(object: DeepPartial<QueryParamsResponse>): QueryParamsResponse;
+    fromAmino(object: QueryParamsResponseAmino): QueryParamsResponse;
+    toAmino(message: QueryParamsResponse): QueryParamsResponseAmino;
+    fromAminoMsg(object: QueryParamsResponseAminoMsg): QueryParamsResponse;
+    toAminoMsg(message: QueryParamsResponse): QueryParamsResponseAminoMsg;
+    fromProtoMsg(message: QueryParamsResponseProtoMsg): QueryParamsResponse;
+    toProto(message: QueryParamsResponse): Uint8Array;
+    toProtoMsg(message: QueryParamsResponse): QueryParamsResponseProtoMsg;
+    registerTypeUrl(): void;
+};

package/ibc/applications/interchain_accounts/host/v1/query.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryParamsResponse = exports.QueryParamsRequest = void 0;
+const host_1 = require("./host");
+const binary_1 = require("../../../../../binary");
+function createBaseQueryParamsRequest() {
+    return {};
+}
+exports.QueryParamsRequest = {
+    typeUrl: "/ibc.applications.interchain_accounts.host.v1.QueryParamsRequest",
+    aminoType: "cosmos-sdk/QueryParamsRequest",
+    is(o) {
+        return o && o.$typeUrl === exports.QueryParamsRequest.typeUrl;
+    },
+    isAmino(o) {
+        return o && o.$typeUrl === exports.QueryParamsRequest.typeUrl;
+    },
+    encode(_, writer = binary_1.BinaryWriter.create()) {
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryParamsRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseQueryParamsRequest();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseQueryParamsRequest();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.QueryParamsRequest.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/QueryParamsRequest",
+            value: exports.QueryParamsRequest.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return exports.QueryParamsRequest.decode(message.value);
+    },
+    toProto(message) {
+        return exports.QueryParamsRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/ibc.applications.interchain_accounts.host.v1.QueryParamsRequest",
+            value: exports.QueryParamsRequest.encode(message).finish()
+        };
+    },
+    registerTypeUrl() { }
+};
+function createBaseQueryParamsResponse() {
+    return {
+        params: undefined
+    };
+}
+exports.QueryParamsResponse = {
+    typeUrl: "/ibc.applications.interchain_accounts.host.v1.QueryParamsResponse",
+    aminoType: "cosmos-sdk/QueryParamsResponse",
+    is(o) {
+        return o && o.$typeUrl === exports.QueryParamsResponse.typeUrl;
+    },
+    isAmino(o) {
+        return o && o.$typeUrl === exports.QueryParamsResponse.typeUrl;
+    },
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.params !== undefined) {
+            host_1.Params.encode(message.params, writer.uint32(10).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryParamsResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.params = host_1.Params.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryParamsResponse();
+        message.params = object.params !== undefined && object.params !== null ? host_1.Params.fromPartial(object.params) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryParamsResponse();
+        if (object.params !== undefined && object.params !== null) {
+            message.params = host_1.Params.fromAmino(object.params);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.params = message.params ? host_1.Params.toAmino(message.params) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.QueryParamsResponse.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/QueryParamsResponse",
+            value: exports.QueryParamsResponse.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return exports.QueryParamsResponse.decode(message.value);
+    },
+    toProto(message) {
+        return exports.QueryParamsResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/ibc.applications.interchain_accounts.host.v1.QueryParamsResponse",
+            value: exports.QueryParamsResponse.encode(message).finish()
+        };
+    },
+    registerTypeUrl() {
+        host_1.Params.registerTypeUrl();
+    }
+};

package/ibc/applications/interchain_accounts/host/v1/query.rpc.func.d.ts

@@ -0,0 +1,3 @@
+import { RpcResolver } from "../../../../../helper-func-types";
+import { QueryParamsRequest, QueryParamsResponse } from "./query";
+export declare const createGetParams: (clientResolver?: RpcResolver) => (request: QueryParamsRequest) => Promise<QueryParamsResponse>;

package/ibc/applications/interchain_accounts/host/v1/query.rpc.func.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createGetParams = void 0;
+const helper_func_types_1 = require("../../../../../helper-func-types");
+const query_1 = require("./query");
+const createGetParams = (clientResolver) => (0, helper_func_types_1.buildQuery)({
+    encode: query_1.QueryParamsRequest.encode,
+    decode: query_1.QueryParamsResponse.decode,
+    service: "ibc.applications.interchain_accounts.host.v1.Query",
+    method: "Params",
+    clientResolver,
+    deps: [query_1.QueryParamsRequest, query_1.QueryParamsResponse]
+});
+exports.createGetParams = createGetParams;

package/ibc/applications/interchain_accounts/host/v1/query.rpc.react.d.ts

@@ -0,0 +1,2 @@
+import { QueryParamsRequest, QueryParamsResponse } from "./query";
+export declare const useGetParams: <TData = QueryParamsResponse>({ request, options, clientResolver, customizedQueryKey, }: import("../../../../../react-query").UseQueryParams<QueryParamsRequest, QueryParamsResponse, TData>) => import("@tanstack/react-query").UseQueryResult<TData, Error>;

package/ibc/applications/interchain_accounts/host/v1/query.rpc.react.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useGetParams = void 0;
+const react_query_1 = require("../../../../../react-query");
+const query_rpc_func_1 = require("./query.rpc.func");
+exports.useGetParams = (0, react_query_1.buildUseQuery)({
+    builderQueryFn: query_rpc_func_1.createGetParams,
+    queryKeyPrefix: "ParamsQuery"
+});

package/ibc/applications/interchain_accounts/host/v1/tx.d.ts

@@ -0,0 +1,159 @@
+import { Params, ParamsAmino, QueryRequest, QueryRequestAmino } from "./host";
+import { BinaryReader, BinaryWriter } from "../../../../../binary";
+import { DeepPartial } from "../../../../../helpers";
+/** MsgUpdateParams defines the payload for Msg/UpdateParams */
+export interface MsgUpdateParams {
+    /** signer address */
+    signer: string;
+    /**
+     * params defines the 27-interchain-accounts/host parameters to update.
+     *
+     * NOTE: All parameters must be supplied.
+     */
+    params: Params;
+}
+export interface MsgUpdateParamsProtoMsg {
+    typeUrl: "/ibc.applications.interchain_accounts.host.v1.MsgUpdateParams";
+    value: Uint8Array;
+}
+/** MsgUpdateParams defines the payload for Msg/UpdateParams */
+export interface MsgUpdateParamsAmino {
+    /** signer address */
+    signer: string;
+    /**
+     * params defines the 27-interchain-accounts/host parameters to update.
+     *
+     * NOTE: All parameters must be supplied.
+     */
+    params: ParamsAmino;
+}
+export interface MsgUpdateParamsAminoMsg {
+    type: "cosmos-sdk/MsgUpdateParams";
+    value: MsgUpdateParamsAmino;
+}
+/** MsgUpdateParamsResponse defines the response for Msg/UpdateParams */
+export interface MsgUpdateParamsResponse {
+}
+export interface MsgUpdateParamsResponseProtoMsg {
+    typeUrl: "/ibc.applications.interchain_accounts.host.v1.MsgUpdateParamsResponse";
+    value: Uint8Array;
+}
+/** MsgUpdateParamsResponse defines the response for Msg/UpdateParams */
+export interface MsgUpdateParamsResponseAmino {
+}
+export interface MsgUpdateParamsResponseAminoMsg {
+    type: "cosmos-sdk/MsgUpdateParamsResponse";
+    value: MsgUpdateParamsResponseAmino;
+}
+/** MsgModuleQuerySafe defines the payload for Msg/ModuleQuerySafe */
+export interface MsgModuleQuerySafe {
+    /** signer address */
+    signer: string;
+    /** requests defines the module safe queries to execute. */
+    requests: QueryRequest[];
+}
+export interface MsgModuleQuerySafeProtoMsg {
+    typeUrl: "/ibc.applications.interchain_accounts.host.v1.MsgModuleQuerySafe";
+    value: Uint8Array;
+}
+/** MsgModuleQuerySafe defines the payload for Msg/ModuleQuerySafe */
+export interface MsgModuleQuerySafeAmino {
+    /** signer address */
+    signer: string;
+    /** requests defines the module safe queries to execute. */
+    requests: QueryRequestAmino[];
+}
+export interface MsgModuleQuerySafeAminoMsg {
+    type: "cosmos-sdk/MsgModuleQuerySafe";
+    value: MsgModuleQuerySafeAmino;
+}
+/** MsgModuleQuerySafeResponse defines the response for Msg/ModuleQuerySafe */
+export interface MsgModuleQuerySafeResponse {
+    /** height at which the responses were queried */
+    height: bigint;
+    /** protobuf encoded responses for each query */
+    responses: Uint8Array[];
+}
+export interface MsgModuleQuerySafeResponseProtoMsg {
+    typeUrl: "/ibc.applications.interchain_accounts.host.v1.MsgModuleQuerySafeResponse";
+    value: Uint8Array;
+}
+/** MsgModuleQuerySafeResponse defines the response for Msg/ModuleQuerySafe */
+export interface MsgModuleQuerySafeResponseAmino {
+    /** height at which the responses were queried */
+    height: string;
+    /** protobuf encoded responses for each query */
+    responses: string[];
+}
+export interface MsgModuleQuerySafeResponseAminoMsg {
+    type: "cosmos-sdk/MsgModuleQuerySafeResponse";
+    value: MsgModuleQuerySafeResponseAmino;
+}
+export declare const MsgUpdateParams: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is MsgUpdateParams;
+    isAmino(o: any): o is MsgUpdateParamsAmino;
+    encode(message: MsgUpdateParams, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): MsgUpdateParams;
+    fromPartial(object: DeepPartial<MsgUpdateParams>): MsgUpdateParams;
+    fromAmino(object: MsgUpdateParamsAmino): MsgUpdateParams;
+    toAmino(message: MsgUpdateParams): MsgUpdateParamsAmino;
+    fromAminoMsg(object: MsgUpdateParamsAminoMsg): MsgUpdateParams;
+    toAminoMsg(message: MsgUpdateParams): MsgUpdateParamsAminoMsg;
+    fromProtoMsg(message: MsgUpdateParamsProtoMsg): MsgUpdateParams;
+    toProto(message: MsgUpdateParams): Uint8Array;
+    toProtoMsg(message: MsgUpdateParams): MsgUpdateParamsProtoMsg;
+    registerTypeUrl(): void;
+};
+export declare const MsgUpdateParamsResponse: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is MsgUpdateParamsResponse;
+    isAmino(o: any): o is MsgUpdateParamsResponseAmino;
+    encode(_: MsgUpdateParamsResponse, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): MsgUpdateParamsResponse;
+    fromPartial(_: DeepPartial<MsgUpdateParamsResponse>): MsgUpdateParamsResponse;
+    fromAmino(_: MsgUpdateParamsResponseAmino): MsgUpdateParamsResponse;
+    toAmino(_: MsgUpdateParamsResponse): MsgUpdateParamsResponseAmino;
+    fromAminoMsg(object: MsgUpdateParamsResponseAminoMsg): MsgUpdateParamsResponse;
+    toAminoMsg(message: MsgUpdateParamsResponse): MsgUpdateParamsResponseAminoMsg;
+    fromProtoMsg(message: MsgUpdateParamsResponseProtoMsg): MsgUpdateParamsResponse;
+    toProto(message: MsgUpdateParamsResponse): Uint8Array;
+    toProtoMsg(message: MsgUpdateParamsResponse): MsgUpdateParamsResponseProtoMsg;
+    registerTypeUrl(): void;
+};
+export declare const MsgModuleQuerySafe: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is MsgModuleQuerySafe;
+    isAmino(o: any): o is MsgModuleQuerySafeAmino;
+    encode(message: MsgModuleQuerySafe, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): MsgModuleQuerySafe;
+    fromPartial(object: DeepPartial<MsgModuleQuerySafe>): MsgModuleQuerySafe;
+    fromAmino(object: MsgModuleQuerySafeAmino): MsgModuleQuerySafe;
+    toAmino(message: MsgModuleQuerySafe): MsgModuleQuerySafeAmino;
+    fromAminoMsg(object: MsgModuleQuerySafeAminoMsg): MsgModuleQuerySafe;
+    toAminoMsg(message: MsgModuleQuerySafe): MsgModuleQuerySafeAminoMsg;
+    fromProtoMsg(message: MsgModuleQuerySafeProtoMsg): MsgModuleQuerySafe;
+    toProto(message: MsgModuleQuerySafe): Uint8Array;
+    toProtoMsg(message: MsgModuleQuerySafe): MsgModuleQuerySafeProtoMsg;
+    registerTypeUrl(): void;
+};
+export declare const MsgModuleQuerySafeResponse: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is MsgModuleQuerySafeResponse;
+    isAmino(o: any): o is MsgModuleQuerySafeResponseAmino;
+    encode(message: MsgModuleQuerySafeResponse, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): MsgModuleQuerySafeResponse;
+    fromPartial(object: DeepPartial<MsgModuleQuerySafeResponse>): MsgModuleQuerySafeResponse;
+    fromAmino(object: MsgModuleQuerySafeResponseAmino): MsgModuleQuerySafeResponse;
+    toAmino(message: MsgModuleQuerySafeResponse): MsgModuleQuerySafeResponseAmino;
+    fromAminoMsg(object: MsgModuleQuerySafeResponseAminoMsg): MsgModuleQuerySafeResponse;
+    toAminoMsg(message: MsgModuleQuerySafeResponse): MsgModuleQuerySafeResponseAminoMsg;
+    fromProtoMsg(message: MsgModuleQuerySafeResponseProtoMsg): MsgModuleQuerySafeResponse;
+    toProto(message: MsgModuleQuerySafeResponse): Uint8Array;
+    toProtoMsg(message: MsgModuleQuerySafeResponse): MsgModuleQuerySafeResponseProtoMsg;
+    registerTypeUrl(): void;
+};