atlas.js-protos 0.1.0

package/dist/types/atlas/filetree/v1/query.mjs

@@ -0,0 +1,531 @@
+//@ts-nocheck
+import { Params } from "./params";
+import { TreeNode } from "./tree";
+import * as _m0 from "protobufjs/minimal";
+import { GlobalDecoderRegistry } from "../../../registry";
+function createBaseQueryParamsRequest() {
+    return {};
+}
+/**
+ * QueryParamsRequest is request type for the Query/Params RPC method.
+ * @name QueryParamsRequest
+ * @package atlas.filetree.v1
+ * @see proto type: atlas.filetree.v1.QueryParamsRequest
+ */
+export const QueryParamsRequest = {
+    typeUrl: "/atlas.filetree.v1.QueryParamsRequest",
+    is(o) {
+        return o && o.$typeUrl === QueryParamsRequest.typeUrl;
+    },
+    isSDK(o) {
+        return o && o.$typeUrl === QueryParamsRequest.typeUrl;
+    },
+    encode(_, writer = _m0.Writer.create()) {
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(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;
+    },
+    fromProtoMsg(message) {
+        return QueryParamsRequest.decode(message.value);
+    },
+    toProto(message) {
+        return QueryParamsRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/atlas.filetree.v1.QueryParamsRequest",
+            value: QueryParamsRequest.encode(message).finish()
+        };
+    },
+    registerTypeUrl() { }
+};
+GlobalDecoderRegistry.register(QueryParamsRequest.typeUrl, QueryParamsRequest);
+function createBaseQueryParamsResponse() {
+    return {
+        params: Params.fromPartial({})
+    };
+}
+/**
+ * QueryParamsResponse is response type for the Query/Params RPC method.
+ * @name QueryParamsResponse
+ * @package atlas.filetree.v1
+ * @see proto type: atlas.filetree.v1.QueryParamsResponse
+ */
+export const QueryParamsResponse = {
+    typeUrl: "/atlas.filetree.v1.QueryParamsResponse",
+    is(o) {
+        return o && (o.$typeUrl === QueryParamsResponse.typeUrl || Params.is(o.params));
+    },
+    isSDK(o) {
+        return o && (o.$typeUrl === QueryParamsResponse.typeUrl || Params.isSDK(o.params));
+    },
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.params !== undefined) {
+            Params.encode(message.params, writer.uint32(10).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(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 = 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 ? Params.fromPartial(object.params) : undefined;
+        return message;
+    },
+    fromProtoMsg(message) {
+        return QueryParamsResponse.decode(message.value);
+    },
+    toProto(message) {
+        return QueryParamsResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/atlas.filetree.v1.QueryParamsResponse",
+            value: QueryParamsResponse.encode(message).finish()
+        };
+    },
+    registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(QueryParamsResponse.typeUrl)) {
+            return;
+        }
+        Params.registerTypeUrl();
+    }
+};
+GlobalDecoderRegistry.register(QueryParamsResponse.typeUrl, QueryParamsResponse);
+function createBaseQueryTreeNodeRequest() {
+    return {
+        owner: "",
+        path: ""
+    };
+}
+/**
+ * QueryTreeNodeRequest defines the QueryTreeNodeRequest message.
+ * @name QueryTreeNodeRequest
+ * @package atlas.filetree.v1
+ * @see proto type: atlas.filetree.v1.QueryTreeNodeRequest
+ */
+export const QueryTreeNodeRequest = {
+    typeUrl: "/atlas.filetree.v1.QueryTreeNodeRequest",
+    is(o) {
+        return o && (o.$typeUrl === QueryTreeNodeRequest.typeUrl || typeof o.owner === "string" && typeof o.path === "string");
+    },
+    isSDK(o) {
+        return o && (o.$typeUrl === QueryTreeNodeRequest.typeUrl || typeof o.owner === "string" && typeof o.path === "string");
+    },
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.owner !== "") {
+            writer.uint32(10).string(message.owner);
+        }
+        if (message.path !== "") {
+            writer.uint32(18).string(message.path);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryTreeNodeRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.owner = reader.string();
+                    break;
+                case 2:
+                    message.path = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryTreeNodeRequest();
+        message.owner = object.owner ?? "";
+        message.path = object.path ?? "";
+        return message;
+    },
+    fromProtoMsg(message) {
+        return QueryTreeNodeRequest.decode(message.value);
+    },
+    toProto(message) {
+        return QueryTreeNodeRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/atlas.filetree.v1.QueryTreeNodeRequest",
+            value: QueryTreeNodeRequest.encode(message).finish()
+        };
+    },
+    registerTypeUrl() { }
+};
+GlobalDecoderRegistry.register(QueryTreeNodeRequest.typeUrl, QueryTreeNodeRequest);
+function createBaseQueryTreeNodeResponse() {
+    return {
+        node: undefined
+    };
+}
+/**
+ * QueryTreeNodeResponse defines the QueryTreeNodeResponse message.
+ * @name QueryTreeNodeResponse
+ * @package atlas.filetree.v1
+ * @see proto type: atlas.filetree.v1.QueryTreeNodeResponse
+ */
+export const QueryTreeNodeResponse = {
+    typeUrl: "/atlas.filetree.v1.QueryTreeNodeResponse",
+    is(o) {
+        return o && o.$typeUrl === QueryTreeNodeResponse.typeUrl;
+    },
+    isSDK(o) {
+        return o && o.$typeUrl === QueryTreeNodeResponse.typeUrl;
+    },
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.node !== undefined) {
+            TreeNode.encode(message.node, writer.uint32(10).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryTreeNodeResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.node = TreeNode.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryTreeNodeResponse();
+        message.node = object.node !== undefined && object.node !== null ? TreeNode.fromPartial(object.node) : undefined;
+        return message;
+    },
+    fromProtoMsg(message) {
+        return QueryTreeNodeResponse.decode(message.value);
+    },
+    toProto(message) {
+        return QueryTreeNodeResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/atlas.filetree.v1.QueryTreeNodeResponse",
+            value: QueryTreeNodeResponse.encode(message).finish()
+        };
+    },
+    registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(QueryTreeNodeResponse.typeUrl)) {
+            return;
+        }
+        TreeNode.registerTypeUrl();
+    }
+};
+GlobalDecoderRegistry.register(QueryTreeNodeResponse.typeUrl, QueryTreeNodeResponse);
+function createBaseQueryFileTreePathsRequest() {
+    return {
+        owner: "",
+        basepath: ""
+    };
+}
+/**
+ * QueryFileTreePathsRequest defines the QueryFileTreePathsRequest message.
+ * @name QueryFileTreePathsRequest
+ * @package atlas.filetree.v1
+ * @see proto type: atlas.filetree.v1.QueryFileTreePathsRequest
+ */
+export const QueryFileTreePathsRequest = {
+    typeUrl: "/atlas.filetree.v1.QueryFileTreePathsRequest",
+    is(o) {
+        return o && (o.$typeUrl === QueryFileTreePathsRequest.typeUrl || typeof o.owner === "string" && typeof o.basepath === "string");
+    },
+    isSDK(o) {
+        return o && (o.$typeUrl === QueryFileTreePathsRequest.typeUrl || typeof o.owner === "string" && typeof o.basepath === "string");
+    },
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.owner !== "") {
+            writer.uint32(10).string(message.owner);
+        }
+        if (message.basepath !== "") {
+            writer.uint32(18).string(message.basepath);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryFileTreePathsRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.owner = reader.string();
+                    break;
+                case 2:
+                    message.basepath = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryFileTreePathsRequest();
+        message.owner = object.owner ?? "";
+        message.basepath = object.basepath ?? "";
+        return message;
+    },
+    fromProtoMsg(message) {
+        return QueryFileTreePathsRequest.decode(message.value);
+    },
+    toProto(message) {
+        return QueryFileTreePathsRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/atlas.filetree.v1.QueryFileTreePathsRequest",
+            value: QueryFileTreePathsRequest.encode(message).finish()
+        };
+    },
+    registerTypeUrl() { }
+};
+GlobalDecoderRegistry.register(QueryFileTreePathsRequest.typeUrl, QueryFileTreePathsRequest);
+function createBaseQueryFileTreePathsResponse() {
+    return {
+        paths: []
+    };
+}
+/**
+ * QueryFileTreePathsResponse defines the QueryFileTreePathsResponse message.
+ * @name QueryFileTreePathsResponse
+ * @package atlas.filetree.v1
+ * @see proto type: atlas.filetree.v1.QueryFileTreePathsResponse
+ */
+export const QueryFileTreePathsResponse = {
+    typeUrl: "/atlas.filetree.v1.QueryFileTreePathsResponse",
+    is(o) {
+        return o && (o.$typeUrl === QueryFileTreePathsResponse.typeUrl || Array.isArray(o.paths) && (!o.paths.length || typeof o.paths[0] === "string"));
+    },
+    isSDK(o) {
+        return o && (o.$typeUrl === QueryFileTreePathsResponse.typeUrl || Array.isArray(o.paths) && (!o.paths.length || typeof o.paths[0] === "string"));
+    },
+    encode(message, writer = _m0.Writer.create()) {
+        for (const v of message.paths) {
+            writer.uint32(10).string(v);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryFileTreePathsResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.paths.push(reader.string());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryFileTreePathsResponse();
+        message.paths = object.paths?.map(e => e) || [];
+        return message;
+    },
+    fromProtoMsg(message) {
+        return QueryFileTreePathsResponse.decode(message.value);
+    },
+    toProto(message) {
+        return QueryFileTreePathsResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/atlas.filetree.v1.QueryFileTreePathsResponse",
+            value: QueryFileTreePathsResponse.encode(message).finish()
+        };
+    },
+    registerTypeUrl() { }
+};
+GlobalDecoderRegistry.register(QueryFileTreePathsResponse.typeUrl, QueryFileTreePathsResponse);
+function createBaseQueryTreeNodeChildrenRequest() {
+    return {
+        owner: "",
+        path: ""
+    };
+}
+/**
+ * QueryTreeNodeChildrenRequest defines the QueryTreeNodeChildrenRequest message.
+ * @name QueryTreeNodeChildrenRequest
+ * @package atlas.filetree.v1
+ * @see proto type: atlas.filetree.v1.QueryTreeNodeChildrenRequest
+ */
+export const QueryTreeNodeChildrenRequest = {
+    typeUrl: "/atlas.filetree.v1.QueryTreeNodeChildrenRequest",
+    is(o) {
+        return o && (o.$typeUrl === QueryTreeNodeChildrenRequest.typeUrl || typeof o.owner === "string" && typeof o.path === "string");
+    },
+    isSDK(o) {
+        return o && (o.$typeUrl === QueryTreeNodeChildrenRequest.typeUrl || typeof o.owner === "string" && typeof o.path === "string");
+    },
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.owner !== "") {
+            writer.uint32(10).string(message.owner);
+        }
+        if (message.path !== "") {
+            writer.uint32(18).string(message.path);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryTreeNodeChildrenRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.owner = reader.string();
+                    break;
+                case 2:
+                    message.path = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryTreeNodeChildrenRequest();
+        message.owner = object.owner ?? "";
+        message.path = object.path ?? "";
+        return message;
+    },
+    fromProtoMsg(message) {
+        return QueryTreeNodeChildrenRequest.decode(message.value);
+    },
+    toProto(message) {
+        return QueryTreeNodeChildrenRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/atlas.filetree.v1.QueryTreeNodeChildrenRequest",
+            value: QueryTreeNodeChildrenRequest.encode(message).finish()
+        };
+    },
+    registerTypeUrl() { }
+};
+GlobalDecoderRegistry.register(QueryTreeNodeChildrenRequest.typeUrl, QueryTreeNodeChildrenRequest);
+function createBaseQueryTreeNodeChildrenResponse() {
+    return {
+        nodes: []
+    };
+}
+/**
+ * QueryTreeNodeChildrenResponse defines the QueryTreeNodeChildrenResponse message.
+ * @name QueryTreeNodeChildrenResponse
+ * @package atlas.filetree.v1
+ * @see proto type: atlas.filetree.v1.QueryTreeNodeChildrenResponse
+ */
+export const QueryTreeNodeChildrenResponse = {
+    typeUrl: "/atlas.filetree.v1.QueryTreeNodeChildrenResponse",
+    is(o) {
+        return o && (o.$typeUrl === QueryTreeNodeChildrenResponse.typeUrl || Array.isArray(o.nodes) && (!o.nodes.length || TreeNode.is(o.nodes[0])));
+    },
+    isSDK(o) {
+        return o && (o.$typeUrl === QueryTreeNodeChildrenResponse.typeUrl || Array.isArray(o.nodes) && (!o.nodes.length || TreeNode.isSDK(o.nodes[0])));
+    },
+    encode(message, writer = _m0.Writer.create()) {
+        for (const v of message.nodes) {
+            TreeNode.encode(v, writer.uint32(10).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryTreeNodeChildrenResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.nodes.push(TreeNode.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryTreeNodeChildrenResponse();
+        message.nodes = object.nodes?.map(e => TreeNode.fromPartial(e)) || [];
+        return message;
+    },
+    fromProtoMsg(message) {
+        return QueryTreeNodeChildrenResponse.decode(message.value);
+    },
+    toProto(message) {
+        return QueryTreeNodeChildrenResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/atlas.filetree.v1.QueryTreeNodeChildrenResponse",
+            value: QueryTreeNodeChildrenResponse.encode(message).finish()
+        };
+    },
+    registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(QueryTreeNodeChildrenResponse.typeUrl)) {
+            return;
+        }
+        TreeNode.registerTypeUrl();
+    }
+};
+GlobalDecoderRegistry.register(QueryTreeNodeChildrenResponse.typeUrl, QueryTreeNodeChildrenResponse);

package/dist/types/atlas/filetree/v1/query.rpc.Query.d.ts

@@ -0,0 +1,28 @@
+import { TxRpc } from "../../../types";
+import { QueryClient } from "@cosmjs/stargate";
+import { QueryParamsRequest, QueryParamsResponse, QueryTreeNodeRequest, QueryTreeNodeResponse, QueryFileTreePathsRequest, QueryFileTreePathsResponse, QueryTreeNodeChildrenRequest, QueryTreeNodeChildrenResponse } from "./query";
+/** Query defines the gRPC querier service. */
+export interface Query {
+    /** Parameters queries the parameters of the module. */
+    params(request?: QueryParamsRequest): Promise<QueryParamsResponse>;
+    /** TreeNode Queries a list of TreeNode items. */
+    treeNode(request: QueryTreeNodeRequest): Promise<QueryTreeNodeResponse>;
+    /** FileTreePaths Queries a list of FileTreePaths items. */
+    fileTreePaths(request: QueryFileTreePathsRequest): Promise<QueryFileTreePathsResponse>;
+    /** TreeNodeChildren Queries a list of TreeNodeChildren items. */
+    treeNodeChildren(request: QueryTreeNodeChildrenRequest): Promise<QueryTreeNodeChildrenResponse>;
+}
+export declare class QueryClientImpl implements Query {
+    private readonly rpc;
+    constructor(rpc: TxRpc);
+    params(request?: QueryParamsRequest): Promise<QueryParamsResponse>;
+    treeNode(request: QueryTreeNodeRequest): Promise<QueryTreeNodeResponse>;
+    fileTreePaths(request: QueryFileTreePathsRequest): Promise<QueryFileTreePathsResponse>;
+    treeNodeChildren(request: QueryTreeNodeChildrenRequest): Promise<QueryTreeNodeChildrenResponse>;
+}
+export declare const createRpcQueryExtension: (base: QueryClient) => {
+    params(request?: QueryParamsRequest): Promise<QueryParamsResponse>;
+    treeNode(request: QueryTreeNodeRequest): Promise<QueryTreeNodeResponse>;
+    fileTreePaths(request: QueryFileTreePathsRequest): Promise<QueryFileTreePathsResponse>;
+    treeNodeChildren(request: QueryTreeNodeChildrenRequest): Promise<QueryTreeNodeChildrenResponse>;
+};

package/dist/types/atlas/filetree/v1/query.rpc.Query.js

@@ -0,0 +1,89 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRpcQueryExtension = exports.QueryClientImpl = void 0;
+const _m0 = __importStar(require("protobufjs/minimal"));
+const stargate_1 = require("@cosmjs/stargate");
+const query_1 = require("./query");
+class QueryClientImpl {
+    rpc;
+    constructor(rpc) {
+        this.rpc = rpc;
+        this.params = this.params.bind(this);
+        this.treeNode = this.treeNode.bind(this);
+        this.fileTreePaths = this.fileTreePaths.bind(this);
+        this.treeNodeChildren = this.treeNodeChildren.bind(this);
+    }
+    params(request = {}) {
+        const data = query_1.QueryParamsRequest.encode(request).finish();
+        const promise = this.rpc.request("atlas.filetree.v1.Query", "Params", data);
+        return promise.then(data => query_1.QueryParamsResponse.decode(new _m0.Reader(data)));
+    }
+    treeNode(request) {
+        const data = query_1.QueryTreeNodeRequest.encode(request).finish();
+        const promise = this.rpc.request("atlas.filetree.v1.Query", "TreeNode", data);
+        return promise.then(data => query_1.QueryTreeNodeResponse.decode(new _m0.Reader(data)));
+    }
+    fileTreePaths(request) {
+        const data = query_1.QueryFileTreePathsRequest.encode(request).finish();
+        const promise = this.rpc.request("atlas.filetree.v1.Query", "FileTreePaths", data);
+        return promise.then(data => query_1.QueryFileTreePathsResponse.decode(new _m0.Reader(data)));
+    }
+    treeNodeChildren(request) {
+        const data = query_1.QueryTreeNodeChildrenRequest.encode(request).finish();
+        const promise = this.rpc.request("atlas.filetree.v1.Query", "TreeNodeChildren", data);
+        return promise.then(data => query_1.QueryTreeNodeChildrenResponse.decode(new _m0.Reader(data)));
+    }
+}
+exports.QueryClientImpl = QueryClientImpl;
+const createRpcQueryExtension = (base) => {
+    const rpc = (0, stargate_1.createProtobufRpcClient)(base);
+    const queryService = new QueryClientImpl(rpc);
+    return {
+        params(request) {
+            return queryService.params(request);
+        },
+        treeNode(request) {
+            return queryService.treeNode(request);
+        },
+        fileTreePaths(request) {
+            return queryService.fileTreePaths(request);
+        },
+        treeNodeChildren(request) {
+            return queryService.treeNodeChildren(request);
+        }
+    };
+};
+exports.createRpcQueryExtension = createRpcQueryExtension;

package/dist/types/atlas/filetree/v1/query.rpc.Query.mjs

@@ -0,0 +1,51 @@
+import * as _m0 from "protobufjs/minimal";
+import { createProtobufRpcClient } from "@cosmjs/stargate";
+import { QueryParamsRequest, QueryParamsResponse, QueryTreeNodeRequest, QueryTreeNodeResponse, QueryFileTreePathsRequest, QueryFileTreePathsResponse, QueryTreeNodeChildrenRequest, QueryTreeNodeChildrenResponse } from "./query";
+export class QueryClientImpl {
+    rpc;
+    constructor(rpc) {
+        this.rpc = rpc;
+        this.params = this.params.bind(this);
+        this.treeNode = this.treeNode.bind(this);
+        this.fileTreePaths = this.fileTreePaths.bind(this);
+        this.treeNodeChildren = this.treeNodeChildren.bind(this);
+    }
+    params(request = {}) {
+        const data = QueryParamsRequest.encode(request).finish();
+        const promise = this.rpc.request("atlas.filetree.v1.Query", "Params", data);
+        return promise.then(data => QueryParamsResponse.decode(new _m0.Reader(data)));
+    }
+    treeNode(request) {
+        const data = QueryTreeNodeRequest.encode(request).finish();
+        const promise = this.rpc.request("atlas.filetree.v1.Query", "TreeNode", data);
+        return promise.then(data => QueryTreeNodeResponse.decode(new _m0.Reader(data)));
+    }
+    fileTreePaths(request) {
+        const data = QueryFileTreePathsRequest.encode(request).finish();
+        const promise = this.rpc.request("atlas.filetree.v1.Query", "FileTreePaths", data);
+        return promise.then(data => QueryFileTreePathsResponse.decode(new _m0.Reader(data)));
+    }
+    treeNodeChildren(request) {
+        const data = QueryTreeNodeChildrenRequest.encode(request).finish();
+        const promise = this.rpc.request("atlas.filetree.v1.Query", "TreeNodeChildren", data);
+        return promise.then(data => QueryTreeNodeChildrenResponse.decode(new _m0.Reader(data)));
+    }
+}
+export const createRpcQueryExtension = (base) => {
+    const rpc = createProtobufRpcClient(base);
+    const queryService = new QueryClientImpl(rpc);
+    return {
+        params(request) {
+            return queryService.params(request);
+        },
+        treeNode(request) {
+            return queryService.treeNode(request);
+        },
+        fileTreePaths(request) {
+            return queryService.fileTreePaths(request);
+        },
+        treeNodeChildren(request) {
+            return queryService.treeNodeChildren(request);
+        }
+    };
+};