carbon-js-sdk 0.3.52 → 0.3.53

package/lib/codec/cosmos/app/module/v1alpha1/module.d.ts

@@ -0,0 +1,18 @@
+import Long from "long";
+import _m0 from "protobufjs/minimal";
+export declare const protobufPackage = "cosmos.app.module.v1alpha1";
+/** Module is the module config object for the cosmos.app v1 app module. */
+export interface Module {
+}
+export declare const Module: {
+    encode(_: Module, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number | undefined): Module;
+    fromJSON(_: any): Module;
+    toJSON(_: Module): unknown;
+    fromPartial(_: DeepPartial<Module>): Module;
+};
+declare type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+export declare type DeepPartial<T> = T extends Builtin ? T : T extends Long ? string | number | Long : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+export {};

package/lib/codec/cosmos/app/module/v1alpha1/module.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Module = exports.protobufPackage = void 0;
+/* eslint-disable */
+const long_1 = __importDefault(require("long"));
+const minimal_1 = __importDefault(require("protobufjs/minimal"));
+exports.protobufPackage = "cosmos.app.module.v1alpha1";
+const baseModule = {};
+exports.Module = {
+    encode(_, writer = minimal_1.default.Writer.create()) {
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = Object.assign({}, baseModule);
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(_) {
+        const message = Object.assign({}, baseModule);
+        return message;
+    },
+    toJSON(_) {
+        const obj = {};
+        return obj;
+    },
+    fromPartial(_) {
+        const message = Object.assign({}, baseModule);
+        return message;
+    },
+};
+if (minimal_1.default.util.Long !== long_1.default) {
+    minimal_1.default.util.Long = long_1.default;
+    minimal_1.default.configure();
+}

package/lib/codec/cosmos/app/v1alpha1/config.d.ts

@@ -0,0 +1,57 @@
+import Long from "long";
+import _m0 from "protobufjs/minimal";
+import { Any } from "../../../google/protobuf/any";
+export declare const protobufPackage = "cosmos.app.v1alpha1";
+/**
+ * Config represents the configuration for a Cosmos SDK ABCI app.
+ * It is intended that all state machine logic including the version of
+ * baseapp and tx handlers (and possibly even Tendermint) that an app needs
+ * can be described in a config object. For compatibility, the framework should
+ * allow a mixture of declarative and imperative app wiring, however, apps
+ * that strive for the maximum ease of maintainability should be able to describe
+ * their state machine with a config object alone.
+ */
+export interface Config {
+    /** modules are the module configurations for the app. */
+    modules: ModuleConfig[];
+}
+/** ModuleConfig is a module configuration for an app. */
+export interface ModuleConfig {
+    /**
+     * name is the unique name of the module within the app. It should be a name
+     * that persists between different versions of a module so that modules
+     * can be smoothly upgraded to new versions.
+     *
+     * For example, for the module cosmos.bank.module.v1.Module, we may chose
+     * to simply name the module "bank" in the app. When we upgrade to
+     * cosmos.bank.module.v2.Module, the app-specific name "bank" stays the same
+     * and the framework knows that the v2 module should receive all the same state
+     * that the v1 module had. Note: modules should provide info on which versions
+     * they can migrate from in the ModuleDescriptor.can_migration_from field.
+     */
+    name: string;
+    /**
+     * config is the config object for the module. Module config messages should
+     * define a ModuleDescriptor using the cosmos.app.v1alpha1.is_module extension.
+     */
+    config?: Any;
+}
+export declare const Config: {
+    encode(message: Config, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number | undefined): Config;
+    fromJSON(object: any): Config;
+    toJSON(message: Config): unknown;
+    fromPartial(object: DeepPartial<Config>): Config;
+};
+export declare const ModuleConfig: {
+    encode(message: ModuleConfig, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number | undefined): ModuleConfig;
+    fromJSON(object: any): ModuleConfig;
+    toJSON(message: ModuleConfig): unknown;
+    fromPartial(object: DeepPartial<ModuleConfig>): ModuleConfig;
+};
+declare type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+export declare type DeepPartial<T> = T extends Builtin ? T : T extends Long ? string | number | Long : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+export {};

package/lib/codec/cosmos/app/v1alpha1/config.js

@@ -0,0 +1,125 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModuleConfig = exports.Config = exports.protobufPackage = void 0;
+/* eslint-disable */
+const long_1 = __importDefault(require("long"));
+const minimal_1 = __importDefault(require("protobufjs/minimal"));
+const any_1 = require("../../../google/protobuf/any");
+exports.protobufPackage = "cosmos.app.v1alpha1";
+const baseConfig = {};
+exports.Config = {
+    encode(message, writer = minimal_1.default.Writer.create()) {
+        for (const v of message.modules) {
+            exports.ModuleConfig.encode(v, writer.uint32(10).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = Object.assign({}, baseConfig);
+        message.modules = [];
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.modules.push(exports.ModuleConfig.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        var _a;
+        const message = Object.assign({}, baseConfig);
+        message.modules = ((_a = object.modules) !== null && _a !== void 0 ? _a : []).map((e) => exports.ModuleConfig.fromJSON(e));
+        return message;
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.modules) {
+            obj.modules = message.modules.map((e) => e ? exports.ModuleConfig.toJSON(e) : undefined);
+        }
+        else {
+            obj.modules = [];
+        }
+        return obj;
+    },
+    fromPartial(object) {
+        var _a;
+        const message = Object.assign({}, baseConfig);
+        message.modules = ((_a = object.modules) !== null && _a !== void 0 ? _a : []).map((e) => exports.ModuleConfig.fromPartial(e));
+        return message;
+    },
+};
+const baseModuleConfig = { name: "" };
+exports.ModuleConfig = {
+    encode(message, writer = minimal_1.default.Writer.create()) {
+        if (message.name !== "") {
+            writer.uint32(10).string(message.name);
+        }
+        if (message.config !== undefined) {
+            any_1.Any.encode(message.config, writer.uint32(18).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = Object.assign({}, baseModuleConfig);
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.name = reader.string();
+                    break;
+                case 2:
+                    message.config = any_1.Any.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        const message = Object.assign({}, baseModuleConfig);
+        message.name =
+            object.name !== undefined && object.name !== null
+                ? String(object.name)
+                : "";
+        message.config =
+            object.config !== undefined && object.config !== null
+                ? any_1.Any.fromJSON(object.config)
+                : undefined;
+        return message;
+    },
+    toJSON(message) {
+        const obj = {};
+        message.name !== undefined && (obj.name = message.name);
+        message.config !== undefined &&
+            (obj.config = message.config ? any_1.Any.toJSON(message.config) : undefined);
+        return obj;
+    },
+    fromPartial(object) {
+        var _a;
+        const message = Object.assign({}, baseModuleConfig);
+        message.name = (_a = object.name) !== null && _a !== void 0 ? _a : "";
+        message.config =
+            object.config !== undefined && object.config !== null
+                ? any_1.Any.fromPartial(object.config)
+                : undefined;
+        return message;
+    },
+};
+if (minimal_1.default.util.Long !== long_1.default) {
+    minimal_1.default.util.Long = long_1.default;
+    minimal_1.default.configure();
+}

package/lib/codec/cosmos/app/v1alpha1/export.d.ts

@@ -0,0 +1,3 @@
+export { Config, ModuleConfig } from "./config";
+export { ModuleDescriptor, PackageReference, MigrateFromInfo } from "./module";
+export { QueryConfigRequest, QueryConfigResponse } from "./query";

package/lib/codec/cosmos/app/v1alpha1/export.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryConfigResponse = exports.QueryConfigRequest = exports.MigrateFromInfo = exports.PackageReference = exports.ModuleDescriptor = exports.ModuleConfig = exports.Config = void 0;
+var config_1 = require("./config");
+Object.defineProperty(exports, "Config", { enumerable: true, get: function () { return config_1.Config; } });
+Object.defineProperty(exports, "ModuleConfig", { enumerable: true, get: function () { return config_1.ModuleConfig; } });
+var module_1 = require("./module");
+Object.defineProperty(exports, "ModuleDescriptor", { enumerable: true, get: function () { return module_1.ModuleDescriptor; } });
+Object.defineProperty(exports, "PackageReference", { enumerable: true, get: function () { return module_1.PackageReference; } });
+Object.defineProperty(exports, "MigrateFromInfo", { enumerable: true, get: function () { return module_1.MigrateFromInfo; } });
+var query_1 = require("./query");
+Object.defineProperty(exports, "QueryConfigRequest", { enumerable: true, get: function () { return query_1.QueryConfigRequest; } });
+Object.defineProperty(exports, "QueryConfigResponse", { enumerable: true, get: function () { return query_1.QueryConfigResponse; } });

package/lib/codec/cosmos/app/v1alpha1/module.d.ts

@@ -0,0 +1,109 @@
+import Long from "long";
+import _m0 from "protobufjs/minimal";
+export declare const protobufPackage = "cosmos.app.v1alpha1";
+/** ModuleDescriptor describes an app module. */
+export interface ModuleDescriptor {
+    /**
+     * go_import names the package that should be imported by an app to load the
+     * module in the runtime module registry. It is required to make debugging
+     * of configuration errors easier for users.
+     */
+    goImport: string;
+    /**
+     * use_package refers to a protobuf package that this module
+     * uses and exposes to the world. In an app, only one module should "use"
+     * or own a single protobuf package. It is assumed that the module uses
+     * all of the .proto files in a single package.
+     */
+    usePackage: PackageReference[];
+    /**
+     * can_migrate_from defines which module versions this module can migrate
+     * state from. The framework will check that one module version is able to
+     * migrate from a previous module version before attempting to update its
+     * config. It is assumed that modules can transitively migrate from earlier
+     * versions. For instance if v3 declares it can migrate from v2, and v2
+     * declares it can migrate from v1, the framework knows how to migrate
+     * from v1 to v3, assuming all 3 module versions are registered at runtime.
+     */
+    canMigrateFrom: MigrateFromInfo[];
+}
+/** PackageReference is a reference to a protobuf package used by a module. */
+export interface PackageReference {
+    /** name is the fully-qualified name of the package. */
+    name: string;
+    /**
+     * revision is the optional revision of the package that is being used.
+     * Protobuf packages used in Cosmos should generally have a major version
+     * as the last part of the package name, ex. foo.bar.baz.v1.
+     * The revision of a package can be thought of as the minor version of a
+     * package which has additional backwards compatible definitions that weren't
+     * present in a previous version.
+     *
+     * A package should indicate its revision with a source code comment
+     * above the package declaration in one of its files containing the
+     * text "Revision N" where N is an integer revision. All packages start
+     * at revision 0 the first time they are released in a module.
+     *
+     * When a new version of a module is released and items are added to existing
+     * .proto files, these definitions should contain comments of the form
+     * "Since Revision N" where N is an integer revision.
+     *
+     * When the module runtime starts up, it will check the pinned proto
+     * image and panic if there are runtime protobuf definitions that are not
+     * in the pinned descriptor which do not have
+     * a "Since Revision N" comment or have a "Since Revision N" comment where
+     * N is <= to the revision specified here. This indicates that the protobuf
+     * files have been updated, but the pinned file descriptor hasn't.
+     *
+     * If there are items in the pinned file descriptor with a revision
+     * greater than the value indicated here, this will also cause a panic
+     * as it may mean that the pinned descriptor for a legacy module has been
+     * improperly updated or that there is some other versioning discrepancy.
+     * Runtime protobuf definitions will also be checked for compatibility
+     * with pinned file descriptors to make sure there are no incompatible changes.
+     *
+     * This behavior ensures that:
+     * * pinned proto images are up-to-date
+     * * protobuf files are carefully annotated with revision comments which
+     *   are important good client UX
+     * * protobuf files are changed in backwards and forwards compatible ways
+     */
+    revision: number;
+}
+/**
+ * MigrateFromInfo is information on a module version that a newer module
+ * can migrate from.
+ */
+export interface MigrateFromInfo {
+    /**
+     * module is the fully-qualified protobuf name of the module config object
+     * for the previous module version, ex: "cosmos.group.module.v1.Module".
+     */
+    module: string;
+}
+export declare const ModuleDescriptor: {
+    encode(message: ModuleDescriptor, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number | undefined): ModuleDescriptor;
+    fromJSON(object: any): ModuleDescriptor;
+    toJSON(message: ModuleDescriptor): unknown;
+    fromPartial(object: DeepPartial<ModuleDescriptor>): ModuleDescriptor;
+};
+export declare const PackageReference: {
+    encode(message: PackageReference, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number | undefined): PackageReference;
+    fromJSON(object: any): PackageReference;
+    toJSON(message: PackageReference): unknown;
+    fromPartial(object: DeepPartial<PackageReference>): PackageReference;
+};
+export declare const MigrateFromInfo: {
+    encode(message: MigrateFromInfo, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number | undefined): MigrateFromInfo;
+    fromJSON(object: any): MigrateFromInfo;
+    toJSON(message: MigrateFromInfo): unknown;
+    fromPartial(object: DeepPartial<MigrateFromInfo>): MigrateFromInfo;
+};
+declare type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+export declare type DeepPartial<T> = T extends Builtin ? T : T extends Long ? string | number | Long : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+export {};

package/lib/codec/cosmos/app/v1alpha1/module.js

@@ -0,0 +1,192 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MigrateFromInfo = exports.PackageReference = exports.ModuleDescriptor = exports.protobufPackage = void 0;
+/* eslint-disable */
+const long_1 = __importDefault(require("long"));
+const minimal_1 = __importDefault(require("protobufjs/minimal"));
+exports.protobufPackage = "cosmos.app.v1alpha1";
+const baseModuleDescriptor = { goImport: "" };
+exports.ModuleDescriptor = {
+    encode(message, writer = minimal_1.default.Writer.create()) {
+        if (message.goImport !== "") {
+            writer.uint32(10).string(message.goImport);
+        }
+        for (const v of message.usePackage) {
+            exports.PackageReference.encode(v, writer.uint32(18).fork()).ldelim();
+        }
+        for (const v of message.canMigrateFrom) {
+            exports.MigrateFromInfo.encode(v, writer.uint32(26).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = Object.assign({}, baseModuleDescriptor);
+        message.usePackage = [];
+        message.canMigrateFrom = [];
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.goImport = reader.string();
+                    break;
+                case 2:
+                    message.usePackage.push(exports.PackageReference.decode(reader, reader.uint32()));
+                    break;
+                case 3:
+                    message.canMigrateFrom.push(exports.MigrateFromInfo.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        var _a, _b;
+        const message = Object.assign({}, baseModuleDescriptor);
+        message.goImport =
+            object.goImport !== undefined && object.goImport !== null
+                ? String(object.goImport)
+                : "";
+        message.usePackage = ((_a = object.usePackage) !== null && _a !== void 0 ? _a : []).map((e) => exports.PackageReference.fromJSON(e));
+        message.canMigrateFrom = ((_b = object.canMigrateFrom) !== null && _b !== void 0 ? _b : []).map((e) => exports.MigrateFromInfo.fromJSON(e));
+        return message;
+    },
+    toJSON(message) {
+        const obj = {};
+        message.goImport !== undefined && (obj.goImport = message.goImport);
+        if (message.usePackage) {
+            obj.usePackage = message.usePackage.map((e) => e ? exports.PackageReference.toJSON(e) : undefined);
+        }
+        else {
+            obj.usePackage = [];
+        }
+        if (message.canMigrateFrom) {
+            obj.canMigrateFrom = message.canMigrateFrom.map((e) => e ? exports.MigrateFromInfo.toJSON(e) : undefined);
+        }
+        else {
+            obj.canMigrateFrom = [];
+        }
+        return obj;
+    },
+    fromPartial(object) {
+        var _a, _b, _c;
+        const message = Object.assign({}, baseModuleDescriptor);
+        message.goImport = (_a = object.goImport) !== null && _a !== void 0 ? _a : "";
+        message.usePackage = ((_b = object.usePackage) !== null && _b !== void 0 ? _b : []).map((e) => exports.PackageReference.fromPartial(e));
+        message.canMigrateFrom = ((_c = object.canMigrateFrom) !== null && _c !== void 0 ? _c : []).map((e) => exports.MigrateFromInfo.fromPartial(e));
+        return message;
+    },
+};
+const basePackageReference = { name: "", revision: 0 };
+exports.PackageReference = {
+    encode(message, writer = minimal_1.default.Writer.create()) {
+        if (message.name !== "") {
+            writer.uint32(10).string(message.name);
+        }
+        if (message.revision !== 0) {
+            writer.uint32(16).uint32(message.revision);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = Object.assign({}, basePackageReference);
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.name = reader.string();
+                    break;
+                case 2:
+                    message.revision = reader.uint32();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        const message = Object.assign({}, basePackageReference);
+        message.name =
+            object.name !== undefined && object.name !== null
+                ? String(object.name)
+                : "";
+        message.revision =
+            object.revision !== undefined && object.revision !== null
+                ? Number(object.revision)
+                : 0;
+        return message;
+    },
+    toJSON(message) {
+        const obj = {};
+        message.name !== undefined && (obj.name = message.name);
+        message.revision !== undefined && (obj.revision = message.revision);
+        return obj;
+    },
+    fromPartial(object) {
+        var _a, _b;
+        const message = Object.assign({}, basePackageReference);
+        message.name = (_a = object.name) !== null && _a !== void 0 ? _a : "";
+        message.revision = (_b = object.revision) !== null && _b !== void 0 ? _b : 0;
+        return message;
+    },
+};
+const baseMigrateFromInfo = { module: "" };
+exports.MigrateFromInfo = {
+    encode(message, writer = minimal_1.default.Writer.create()) {
+        if (message.module !== "") {
+            writer.uint32(10).string(message.module);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = Object.assign({}, baseMigrateFromInfo);
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.module = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        const message = Object.assign({}, baseMigrateFromInfo);
+        message.module =
+            object.module !== undefined && object.module !== null
+                ? String(object.module)
+                : "";
+        return message;
+    },
+    toJSON(message) {
+        const obj = {};
+        message.module !== undefined && (obj.module = message.module);
+        return obj;
+    },
+    fromPartial(object) {
+        var _a;
+        const message = Object.assign({}, baseMigrateFromInfo);
+        message.module = (_a = object.module) !== null && _a !== void 0 ? _a : "";
+        return message;
+    },
+};
+if (minimal_1.default.util.Long !== long_1.default) {
+    minimal_1.default.util.Long = long_1.default;
+    minimal_1.default.configure();
+}

package/lib/codec/cosmos/app/v1alpha1/query.d.ts

@@ -0,0 +1,44 @@
+import Long from "long";
+import _m0 from "protobufjs/minimal";
+import { Config } from "./config";
+export declare const protobufPackage = "cosmos.app.v1alpha1";
+/** QueryConfigRequest is the Query/Config request type. */
+export interface QueryConfigRequest {
+}
+/** QueryConfigRequest is the Query/Config response type. */
+export interface QueryConfigResponse {
+    /** config is the current app config. */
+    config?: Config;
+}
+export declare const QueryConfigRequest: {
+    encode(_: QueryConfigRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number | undefined): QueryConfigRequest;
+    fromJSON(_: any): QueryConfigRequest;
+    toJSON(_: QueryConfigRequest): unknown;
+    fromPartial(_: DeepPartial<QueryConfigRequest>): QueryConfigRequest;
+};
+export declare const QueryConfigResponse: {
+    encode(message: QueryConfigResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number | undefined): QueryConfigResponse;
+    fromJSON(object: any): QueryConfigResponse;
+    toJSON(message: QueryConfigResponse): unknown;
+    fromPartial(object: DeepPartial<QueryConfigResponse>): QueryConfigResponse;
+};
+/** Query is the app module query service. */
+export interface Query {
+    /** Config returns the current app config. */
+    Config(request: QueryConfigRequest): Promise<QueryConfigResponse>;
+}
+export declare class QueryClientImpl implements Query {
+    private readonly rpc;
+    constructor(rpc: Rpc);
+    Config(request: QueryConfigRequest): Promise<QueryConfigResponse>;
+}
+interface Rpc {
+    request(service: string, method: string, data: Uint8Array): Promise<Uint8Array>;
+}
+declare type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+export declare type DeepPartial<T> = T extends Builtin ? T : T extends Long ? string | number | Long : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+export {};