atlas.js-protos 0.1.0

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

@@ -0,0 +1,413 @@
+//@ts-nocheck
+import { Params } from "./params";
+import * as _m0 from "protobufjs/minimal";
+import { GlobalDecoderRegistry } from "../../../registry";
+function createBaseMsgUpdateParams() {
+    return {
+        authority: "",
+        params: Params.fromPartial({})
+    };
+}
+/**
+ * MsgUpdateParams is the Msg/UpdateParams request type.
+ * @name MsgUpdateParams
+ * @package atlas.filetree.v1
+ * @see proto type: atlas.filetree.v1.MsgUpdateParams
+ */
+export const MsgUpdateParams = {
+    typeUrl: "/atlas.filetree.v1.MsgUpdateParams",
+    aminoType: "atlas/x/filetree/MsgUpdateParams",
+    is(o) {
+        return o && (o.$typeUrl === MsgUpdateParams.typeUrl || typeof o.authority === "string" && Params.is(o.params));
+    },
+    isSDK(o) {
+        return o && (o.$typeUrl === MsgUpdateParams.typeUrl || typeof o.authority === "string" && Params.isSDK(o.params));
+    },
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.authority !== "") {
+            writer.uint32(10).string(message.authority);
+        }
+        if (message.params !== undefined) {
+            Params.encode(message.params, writer.uint32(18).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 = createBaseMsgUpdateParams();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.authority = reader.string();
+                    break;
+                case 2:
+                    message.params = Params.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgUpdateParams();
+        message.authority = object.authority ?? "";
+        message.params = object.params !== undefined && object.params !== null ? Params.fromPartial(object.params) : undefined;
+        return message;
+    },
+    fromProtoMsg(message) {
+        return MsgUpdateParams.decode(message.value);
+    },
+    toProto(message) {
+        return MsgUpdateParams.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/atlas.filetree.v1.MsgUpdateParams",
+            value: MsgUpdateParams.encode(message).finish()
+        };
+    },
+    registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(MsgUpdateParams.typeUrl)) {
+            return;
+        }
+        Params.registerTypeUrl();
+    }
+};
+GlobalDecoderRegistry.register(MsgUpdateParams.typeUrl, MsgUpdateParams);
+GlobalDecoderRegistry.registerAminoProtoMapping(MsgUpdateParams.aminoType, MsgUpdateParams.typeUrl);
+function createBaseMsgUpdateParamsResponse() {
+    return {};
+}
+/**
+ * MsgUpdateParamsResponse defines the response structure for executing a
+ * MsgUpdateParams message.
+ * @name MsgUpdateParamsResponse
+ * @package atlas.filetree.v1
+ * @see proto type: atlas.filetree.v1.MsgUpdateParamsResponse
+ */
+export const MsgUpdateParamsResponse = {
+    typeUrl: "/atlas.filetree.v1.MsgUpdateParamsResponse",
+    is(o) {
+        return o && o.$typeUrl === MsgUpdateParamsResponse.typeUrl;
+    },
+    isSDK(o) {
+        return o && o.$typeUrl === MsgUpdateParamsResponse.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 = createBaseMsgUpdateParamsResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseMsgUpdateParamsResponse();
+        return message;
+    },
+    fromProtoMsg(message) {
+        return MsgUpdateParamsResponse.decode(message.value);
+    },
+    toProto(message) {
+        return MsgUpdateParamsResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/atlas.filetree.v1.MsgUpdateParamsResponse",
+            value: MsgUpdateParamsResponse.encode(message).finish()
+        };
+    },
+    registerTypeUrl() { }
+};
+GlobalDecoderRegistry.register(MsgUpdateParamsResponse.typeUrl, MsgUpdateParamsResponse);
+function createBaseMsgPostNode() {
+    return {
+        creator: "",
+        path: "",
+        nodeType: "",
+        contents: "",
+        viewers: "",
+        editors: ""
+    };
+}
+/**
+ * MsgPostNode defines the MsgPostNode message.
+ * @name MsgPostNode
+ * @package atlas.filetree.v1
+ * @see proto type: atlas.filetree.v1.MsgPostNode
+ */
+export const MsgPostNode = {
+    typeUrl: "/atlas.filetree.v1.MsgPostNode",
+    is(o) {
+        return o && (o.$typeUrl === MsgPostNode.typeUrl || typeof o.creator === "string" && typeof o.path === "string" && typeof o.nodeType === "string" && typeof o.contents === "string" && typeof o.viewers === "string" && typeof o.editors === "string");
+    },
+    isSDK(o) {
+        return o && (o.$typeUrl === MsgPostNode.typeUrl || typeof o.creator === "string" && typeof o.path === "string" && typeof o.node_type === "string" && typeof o.contents === "string" && typeof o.viewers === "string" && typeof o.editors === "string");
+    },
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.creator !== "") {
+            writer.uint32(10).string(message.creator);
+        }
+        if (message.path !== "") {
+            writer.uint32(18).string(message.path);
+        }
+        if (message.nodeType !== "") {
+            writer.uint32(26).string(message.nodeType);
+        }
+        if (message.contents !== "") {
+            writer.uint32(34).string(message.contents);
+        }
+        if (message.viewers !== "") {
+            writer.uint32(42).string(message.viewers);
+        }
+        if (message.editors !== "") {
+            writer.uint32(50).string(message.editors);
+        }
+        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 = createBaseMsgPostNode();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.creator = reader.string();
+                    break;
+                case 2:
+                    message.path = reader.string();
+                    break;
+                case 3:
+                    message.nodeType = reader.string();
+                    break;
+                case 4:
+                    message.contents = reader.string();
+                    break;
+                case 5:
+                    message.viewers = reader.string();
+                    break;
+                case 6:
+                    message.editors = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgPostNode();
+        message.creator = object.creator ?? "";
+        message.path = object.path ?? "";
+        message.nodeType = object.nodeType ?? "";
+        message.contents = object.contents ?? "";
+        message.viewers = object.viewers ?? "";
+        message.editors = object.editors ?? "";
+        return message;
+    },
+    fromProtoMsg(message) {
+        return MsgPostNode.decode(message.value);
+    },
+    toProto(message) {
+        return MsgPostNode.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/atlas.filetree.v1.MsgPostNode",
+            value: MsgPostNode.encode(message).finish()
+        };
+    },
+    registerTypeUrl() { }
+};
+GlobalDecoderRegistry.register(MsgPostNode.typeUrl, MsgPostNode);
+function createBaseMsgPostNodeResponse() {
+    return {};
+}
+/**
+ * MsgPostNodeResponse defines the MsgPostNodeResponse message.
+ * @name MsgPostNodeResponse
+ * @package atlas.filetree.v1
+ * @see proto type: atlas.filetree.v1.MsgPostNodeResponse
+ */
+export const MsgPostNodeResponse = {
+    typeUrl: "/atlas.filetree.v1.MsgPostNodeResponse",
+    is(o) {
+        return o && o.$typeUrl === MsgPostNodeResponse.typeUrl;
+    },
+    isSDK(o) {
+        return o && o.$typeUrl === MsgPostNodeResponse.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 = createBaseMsgPostNodeResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseMsgPostNodeResponse();
+        return message;
+    },
+    fromProtoMsg(message) {
+        return MsgPostNodeResponse.decode(message.value);
+    },
+    toProto(message) {
+        return MsgPostNodeResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/atlas.filetree.v1.MsgPostNodeResponse",
+            value: MsgPostNodeResponse.encode(message).finish()
+        };
+    },
+    registerTypeUrl() { }
+};
+GlobalDecoderRegistry.register(MsgPostNodeResponse.typeUrl, MsgPostNodeResponse);
+function createBaseMsgDeleteNode() {
+    return {
+        creator: "",
+        path: ""
+    };
+}
+/**
+ * MsgDeleteNode defines the MsgDeleteNode message.
+ * @name MsgDeleteNode
+ * @package atlas.filetree.v1
+ * @see proto type: atlas.filetree.v1.MsgDeleteNode
+ */
+export const MsgDeleteNode = {
+    typeUrl: "/atlas.filetree.v1.MsgDeleteNode",
+    is(o) {
+        return o && (o.$typeUrl === MsgDeleteNode.typeUrl || typeof o.creator === "string" && typeof o.path === "string");
+    },
+    isSDK(o) {
+        return o && (o.$typeUrl === MsgDeleteNode.typeUrl || typeof o.creator === "string" && typeof o.path === "string");
+    },
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.creator !== "") {
+            writer.uint32(10).string(message.creator);
+        }
+        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 = createBaseMsgDeleteNode();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.creator = reader.string();
+                    break;
+                case 2:
+                    message.path = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgDeleteNode();
+        message.creator = object.creator ?? "";
+        message.path = object.path ?? "";
+        return message;
+    },
+    fromProtoMsg(message) {
+        return MsgDeleteNode.decode(message.value);
+    },
+    toProto(message) {
+        return MsgDeleteNode.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/atlas.filetree.v1.MsgDeleteNode",
+            value: MsgDeleteNode.encode(message).finish()
+        };
+    },
+    registerTypeUrl() { }
+};
+GlobalDecoderRegistry.register(MsgDeleteNode.typeUrl, MsgDeleteNode);
+function createBaseMsgDeleteNodeResponse() {
+    return {};
+}
+/**
+ * MsgDeleteNodeResponse defines the MsgDeleteNodeResponse message.
+ * @name MsgDeleteNodeResponse
+ * @package atlas.filetree.v1
+ * @see proto type: atlas.filetree.v1.MsgDeleteNodeResponse
+ */
+export const MsgDeleteNodeResponse = {
+    typeUrl: "/atlas.filetree.v1.MsgDeleteNodeResponse",
+    is(o) {
+        return o && o.$typeUrl === MsgDeleteNodeResponse.typeUrl;
+    },
+    isSDK(o) {
+        return o && o.$typeUrl === MsgDeleteNodeResponse.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 = createBaseMsgDeleteNodeResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseMsgDeleteNodeResponse();
+        return message;
+    },
+    fromProtoMsg(message) {
+        return MsgDeleteNodeResponse.decode(message.value);
+    },
+    toProto(message) {
+        return MsgDeleteNodeResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/atlas.filetree.v1.MsgDeleteNodeResponse",
+            value: MsgDeleteNodeResponse.encode(message).finish()
+        };
+    },
+    registerTypeUrl() { }
+};
+GlobalDecoderRegistry.register(MsgDeleteNodeResponse.typeUrl, MsgDeleteNodeResponse);

package/dist/types/atlas/filetree/v1/tx.rpc.func.d.ts

@@ -0,0 +1,23 @@
+import { MsgUpdateParams, MsgPostNode, MsgDeleteNode } from "./tx";
+/**
+ * UpdateParams defines a (governance) operation for updating the module
+ * parameters. The authority defaults to the x/gov module account.
+ * @name updateParams
+ * @package atlas.filetree.v1
+ * @see proto service: atlas.filetree.v1.UpdateParams
+ */
+export declare const updateParams: (client: import("@interchainjs/cosmos").ISigningClient, signerAddress: string, message: MsgUpdateParams | MsgUpdateParams[], fee: import("../../..").StdFee | "auto", memo: string) => Promise<import("@interchainjs/types").DeliverTxResponse>;
+/**
+ * PostNode defines the PostNode RPC.
+ * @name postNode
+ * @package atlas.filetree.v1
+ * @see proto service: atlas.filetree.v1.PostNode
+ */
+export declare const postNode: (client: import("@interchainjs/cosmos").ISigningClient, signerAddress: string, message: MsgPostNode | MsgPostNode[], fee: import("../../..").StdFee | "auto", memo: string) => Promise<import("@interchainjs/types").DeliverTxResponse>;
+/**
+ * DeleteNode defines the DeleteNode RPC.
+ * @name deleteNode
+ * @package atlas.filetree.v1
+ * @see proto service: atlas.filetree.v1.DeleteNode
+ */
+export declare const deleteNode: (client: import("@interchainjs/cosmos").ISigningClient, signerAddress: string, message: MsgDeleteNode | MsgDeleteNode[], fee: import("../../..").StdFee | "auto", memo: string) => Promise<import("@interchainjs/types").DeliverTxResponse>;

package/dist/types/atlas/filetree/v1/tx.rpc.func.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteNode = exports.postNode = exports.updateParams = void 0;
+//@ts-nocheck
+const helper_func_types_1 = require("../../../helper-func-types");
+const tx_1 = require("./tx");
+/**
+ * UpdateParams defines a (governance) operation for updating the module
+ * parameters. The authority defaults to the x/gov module account.
+ * @name updateParams
+ * @package atlas.filetree.v1
+ * @see proto service: atlas.filetree.v1.UpdateParams
+ */
+exports.updateParams = (0, helper_func_types_1.buildTx)({
+    msg: tx_1.MsgUpdateParams
+});
+/**
+ * PostNode defines the PostNode RPC.
+ * @name postNode
+ * @package atlas.filetree.v1
+ * @see proto service: atlas.filetree.v1.PostNode
+ */
+exports.postNode = (0, helper_func_types_1.buildTx)({
+    msg: tx_1.MsgPostNode
+});
+/**
+ * DeleteNode defines the DeleteNode RPC.
+ * @name deleteNode
+ * @package atlas.filetree.v1
+ * @see proto service: atlas.filetree.v1.DeleteNode
+ */
+exports.deleteNode = (0, helper_func_types_1.buildTx)({
+    msg: tx_1.MsgDeleteNode
+});

package/dist/types/atlas/filetree/v1/tx.rpc.func.mjs

@@ -0,0 +1,31 @@
+//@ts-nocheck
+import { buildTx } from "../../../helper-func-types";
+import { MsgUpdateParams, MsgPostNode, MsgDeleteNode } from "./tx";
+/**
+ * UpdateParams defines a (governance) operation for updating the module
+ * parameters. The authority defaults to the x/gov module account.
+ * @name updateParams
+ * @package atlas.filetree.v1
+ * @see proto service: atlas.filetree.v1.UpdateParams
+ */
+export const updateParams = buildTx({
+    msg: MsgUpdateParams
+});
+/**
+ * PostNode defines the PostNode RPC.
+ * @name postNode
+ * @package atlas.filetree.v1
+ * @see proto service: atlas.filetree.v1.PostNode
+ */
+export const postNode = buildTx({
+    msg: MsgPostNode
+});
+/**
+ * DeleteNode defines the DeleteNode RPC.
+ * @name deleteNode
+ * @package atlas.filetree.v1
+ * @see proto service: atlas.filetree.v1.DeleteNode
+ */
+export const deleteNode = buildTx({
+    msg: MsgDeleteNode
+});

package/dist/types/atlas/filetree/v1/tx.rpc.msg.d.ts

@@ -0,0 +1,22 @@
+import { TxRpc } from "../../../types";
+import { MsgUpdateParams, MsgUpdateParamsResponse, MsgPostNode, MsgPostNodeResponse, MsgDeleteNode, MsgDeleteNodeResponse } from "./tx";
+/** Msg defines the Msg service. */
+export interface Msg {
+    /**
+     * UpdateParams defines a (governance) operation for updating the module
+     * parameters. The authority defaults to the x/gov module account.
+     */
+    updateParams(request: MsgUpdateParams): Promise<MsgUpdateParamsResponse>;
+    /** PostNode defines the PostNode RPC. */
+    postNode(request: MsgPostNode): Promise<MsgPostNodeResponse>;
+    /** DeleteNode defines the DeleteNode RPC. */
+    deleteNode(request: MsgDeleteNode): Promise<MsgDeleteNodeResponse>;
+}
+export declare class MsgClientImpl implements Msg {
+    private readonly rpc;
+    constructor(rpc: TxRpc);
+    updateParams(request: MsgUpdateParams): Promise<MsgUpdateParamsResponse>;
+    postNode(request: MsgPostNode): Promise<MsgPostNodeResponse>;
+    deleteNode(request: MsgDeleteNode): Promise<MsgDeleteNodeResponse>;
+}
+export declare const createClientImpl: (rpc: TxRpc) => MsgClientImpl;

package/dist/types/atlas/filetree/v1/tx.rpc.msg.js

@@ -0,0 +1,67 @@
+"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.createClientImpl = exports.MsgClientImpl = void 0;
+const _m0 = __importStar(require("protobufjs/minimal"));
+const tx_1 = require("./tx");
+class MsgClientImpl {
+    rpc;
+    constructor(rpc) {
+        this.rpc = rpc;
+        this.updateParams = this.updateParams.bind(this);
+        this.postNode = this.postNode.bind(this);
+        this.deleteNode = this.deleteNode.bind(this);
+    }
+    updateParams(request) {
+        const data = tx_1.MsgUpdateParams.encode(request).finish();
+        const promise = this.rpc.request("atlas.filetree.v1.Msg", "UpdateParams", data);
+        return promise.then(data => tx_1.MsgUpdateParamsResponse.decode(new _m0.Reader(data)));
+    }
+    postNode(request) {
+        const data = tx_1.MsgPostNode.encode(request).finish();
+        const promise = this.rpc.request("atlas.filetree.v1.Msg", "PostNode", data);
+        return promise.then(data => tx_1.MsgPostNodeResponse.decode(new _m0.Reader(data)));
+    }
+    deleteNode(request) {
+        const data = tx_1.MsgDeleteNode.encode(request).finish();
+        const promise = this.rpc.request("atlas.filetree.v1.Msg", "DeleteNode", data);
+        return promise.then(data => tx_1.MsgDeleteNodeResponse.decode(new _m0.Reader(data)));
+    }
+}
+exports.MsgClientImpl = MsgClientImpl;
+const createClientImpl = (rpc) => {
+    return new MsgClientImpl(rpc);
+};
+exports.createClientImpl = createClientImpl;

package/dist/types/atlas/filetree/v1/tx.rpc.msg.mjs

@@ -0,0 +1,29 @@
+import * as _m0 from "protobufjs/minimal";
+import { MsgUpdateParams, MsgUpdateParamsResponse, MsgPostNode, MsgPostNodeResponse, MsgDeleteNode, MsgDeleteNodeResponse } from "./tx";
+export class MsgClientImpl {
+    rpc;
+    constructor(rpc) {
+        this.rpc = rpc;
+        this.updateParams = this.updateParams.bind(this);
+        this.postNode = this.postNode.bind(this);
+        this.deleteNode = this.deleteNode.bind(this);
+    }
+    updateParams(request) {
+        const data = MsgUpdateParams.encode(request).finish();
+        const promise = this.rpc.request("atlas.filetree.v1.Msg", "UpdateParams", data);
+        return promise.then(data => MsgUpdateParamsResponse.decode(new _m0.Reader(data)));
+    }
+    postNode(request) {
+        const data = MsgPostNode.encode(request).finish();
+        const promise = this.rpc.request("atlas.filetree.v1.Msg", "PostNode", data);
+        return promise.then(data => MsgPostNodeResponse.decode(new _m0.Reader(data)));
+    }
+    deleteNode(request) {
+        const data = MsgDeleteNode.encode(request).finish();
+        const promise = this.rpc.request("atlas.filetree.v1.Msg", "DeleteNode", data);
+        return promise.then(data => MsgDeleteNodeResponse.decode(new _m0.Reader(data)));
+    }
+}
+export const createClientImpl = (rpc) => {
+    return new MsgClientImpl(rpc);
+};

package/dist/types/atlas/rpc.query.d.ts

@@ -0,0 +1,49 @@
+import { HttpEndpoint } from "@cosmjs/tendermint-rpc";
+export declare const createRPCQueryClient: ({ rpcEndpoint }: {
+    rpcEndpoint: string | HttpEndpoint;
+}) => Promise<{
+    atlas: {
+        filetree: {
+            v1: {
+                params(request?: import("./filetree/v1/query").QueryParamsRequest): Promise<import("./filetree/v1/query").QueryParamsResponse>;
+                treeNode(request: import("./filetree/v1/query").QueryTreeNodeRequest): Promise<import("./filetree/v1/query").QueryTreeNodeResponse>;
+                fileTreePaths(request: import("./filetree/v1/query").QueryFileTreePathsRequest): Promise<import("./filetree/v1/query").QueryFileTreePathsResponse>;
+                treeNodeChildren(request: import("./filetree/v1/query").QueryTreeNodeChildrenRequest): Promise<import("./filetree/v1/query").QueryTreeNodeChildrenResponse>;
+            };
+        };
+        storage: {
+            v1: {
+                params(request?: import("./storage/v1/query").QueryParamsRequest): Promise<import("./storage/v1/query").QueryParamsResponse>;
+                provider(request: import("./storage/v1/query").QueryProviderRequest): Promise<import("./storage/v1/query").QueryProviderResponse>;
+                providers(request?: import("./storage/v1/query").QueryProvidersRequest): Promise<import("./storage/v1/query").QueryProvidersResponse>;
+                file(request: import("./storage/v1/query").QueryFileRequest): Promise<import("./storage/v1/query").QueryFileResponse>;
+                files(request: import("./storage/v1/query").QueryFilesRequest): Promise<import("./storage/v1/query").QueryFilesResponse>;
+                subscription(request: import("./storage/v1/query").QuerySubscriptionRequest): Promise<import("./storage/v1/query").QuerySubscriptionResponse>;
+                subscriptions(request: import("./storage/v1/query").QuerySubscriptionsRequest): Promise<import("./storage/v1/query").QuerySubscriptionsResponse>;
+                challenges(request: import("./storage/v1/query").QueryChallengesRequest): Promise<import("./storage/v1/query").QueryChallengesResponse>;
+                storageStats(request?: import("./storage/v1/query").QueryStorageStatsRequest): Promise<import("./storage/v1/query").QueryStorageStatsResponse>;
+                fileStats(request?: import("./storage/v1/query").QueryFileStatsRequest): Promise<import("./storage/v1/query").QueryFileStatsResponse>;
+                strays(request?: import("./storage/v1/query").QueryStraysRequest): Promise<import("./storage/v1/query").QueryStraysResponse>;
+            };
+        };
+    };
+    cosmos: {
+        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>;
+                denomOwnersByQuery(request: import("../cosmos/bank/v1beta1/query").QueryDenomOwnersByQueryRequest): Promise<import("../cosmos/bank/v1beta1/query").QueryDenomOwnersByQueryResponse>;
+                sendEnabled(request: import("../cosmos/bank/v1beta1/query").QuerySendEnabledRequest): Promise<import("../cosmos/bank/v1beta1/query").QuerySendEnabledResponse>;
+            };
+        };
+    };
+}>;