@jackallabs/jackal.nodejs-protos/dist/index.cjs

Package of all protos used by Jackal.nodejs

'use strict';

var grpcWeb = require('@improbable-eng/grpc-web');
var browserHeaders = require('browser-headers');
var _m0 = require('protobufjs');
var Long = require('long');
var protoSigning = require('@cosmjs/proto-signing');
var stargate = require('@cosmjs/stargate');
var grpcWebNodeHttpTransport = require('@improbable-eng/grpc-web-node-http-transport');

/* eslint-disable */
const protobufPackage$X = "cosmos.base.query.v1beta1";
function createBasePageRequest() {
    return { key: new Uint8Array(0), offset: 0, limit: 0, countTotal: false, reverse: false };
}
const PageRequest = {
    encode(message, writer = _m0.Writer.create()) {
        if (message.key.length !== 0) {
            writer.uint32(10).bytes(message.key);
        }
        if (message.offset !== 0) {
            writer.uint32(16).uint64(message.offset);
        }
        if (message.limit !== 0) {
            writer.uint32(24).uint64(message.limit);
        }
        if (message.countTotal === true) {
            writer.uint32(32).bool(message.countTotal);
        }
        if (message.reverse === true) {
            writer.uint32(40).bool(message.reverse);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBasePageRequest();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    if (tag !== 10) {
                        break;
                    }
                    message.key = reader.bytes();
                    continue;
                case 2:
                    if (tag !== 16) {
                        break;
                    }
                    message.offset = longToNumber$q(reader.uint64());
                    continue;
                case 3:
                    if (tag !== 24) {
                        break;
                    }
                    message.limit = longToNumber$q(reader.uint64());
                    continue;
                case 4:
                    if (tag !== 32) {
                        break;
                    }
                    message.countTotal = reader.bool();
                    continue;
                case 5:
                    if (tag !== 40) {
                        break;
                    }
                    message.reverse = reader.bool();
                    continue;
            }
            if ((tag & 7) === 4 || tag === 0) {
                break;
            }
            reader.skipType(tag & 7);
        }
        return message;
    },
    fromJSON(object) {
        return {
            key: isSet$V(object.key) ? bytesFromBase64$9(object.key) : new Uint8Array(0),
            offset: isSet$V(object.offset) ? Number(object.offset) : 0,
            limit: isSet$V(object.limit) ? Number(object.limit) : 0,
            countTotal: isSet$V(object.countTotal) ? Boolean(object.countTotal) : false,
            reverse: isSet$V(object.reverse) ? Boolean(object.reverse) : false,
        };
    },
    toJSON(message) {
        const obj = {};
        if (message.key.length !== 0) {
            obj.key = base64FromBytes$9(message.key);
        }
        if (message.offset !== 0) {
            obj.offset = Math.round(message.offset);
        }
        if (message.limit !== 0) {
            obj.limit = Math.round(message.limit);
        }
        if (message.countTotal === true) {
            obj.countTotal = message.countTotal;
        }
        if (message.reverse === true) {
            obj.reverse = message.reverse;
        }
        return obj;
    },
    create(base) {
        return PageRequest.fromPartial(base ?? {});
    },
    fromPartial(object) {
        const message = createBasePageRequest();
        message.key = object.key ?? new Uint8Array(0);
        message.offset = object.offset ?? 0;
        message.limit = object.limit ?? 0;
        message.countTotal = object.countTotal ?? false;
        message.reverse = object.reverse ?? false;
        return message;
    },
};
function createBasePageResponse() {
    return { nextKey: new Uint8Array(0), total: 0 };
}
const PageResponse = {
    encode(message, writer = _m0.Writer.create()) {
        if (message.nextKey.length !== 0) {
            writer.uint32(10).bytes(message.nextKey);
        }
        if (message.total !== 0) {
            writer.uint32(16).uint64(message.total);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBasePageResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    if (tag !== 10) {
                        break;
                    }
                    message.nextKey = reader.bytes();
                    continue;
                case 2:
                    if (tag !== 16) {
                        break;
                    }
                    message.total = longToNumber$q(reader.uint64());
                    continue;
            }
            if ((tag & 7) === 4 || tag === 0) {
                break;
            }
            reader.skipType(tag & 7);
        }
        return message;
    },
    fromJSON(object) {
        return {
            nextKey: isSet$V(object.nextKey) ? bytesFromBase64$9(object.nextKey) : new Uint8Array(0),
            total: isSet$V(object.total) ? Number(object.total) : 0,
        };
    },
    toJSON(message) {
        const obj = {};
        if (message.nextKey.length !== 0) {
            obj.nextKey = base64FromBytes$9(message.nextKey);
        }
        if (message.total !== 0) {
            obj.total = Math.round(message.total);
        }
        return obj;
    },
    create(base) {
        return PageResponse.fromPartial(base ?? {});
    },
    fromPartial(object) {
        const message = createBasePageResponse();
        message.nextKey = object.nextKey ?? new Uint8Array(0);
        message.total = object.total ?? 0;
        return message;
    },
};
const tsProtoGlobalThis$G = (() => {
    if (typeof globalThis !== "undefined") {
        return globalThis;
    }
    if (typeof self !== "undefined") {
        return self;
    }
    if (typeof window !== "undefined") {
        return window;
    }
    if (typeof global !== "undefined") {
        return global;
    }
    throw "Unable to locate global object";
})();
function bytesFromBase64$9(b64) {
    if (tsProtoGlobalThis$G.Buffer) {
        return Uint8Array.from(tsProtoGlobalThis$G.Buffer.from(b64, "base64"));
    }
    else {
        const bin = tsProtoGlobalThis$G.atob(b64);
        const arr = new Uint8Array(bin.length);
        for (let i = 0; i < bin.length; ++i) {
            arr[i] = bin.charCodeAt(i);
        }
        return arr;
    }
}
function base64FromBytes$9(arr) {
    if (tsProtoGlobalThis$G.Buffer) {
        return tsProtoGlobalThis$G.Buffer.from(arr).toString("base64");
    }
    else {
        const bin = [];
        arr.forEach((byte) => {
            bin.push(String.fromCharCode(byte));
        });
        return tsProtoGlobalThis$G.btoa(bin.join(""));
    }
}
function longToNumber$q(long) {
    if (long.gt(Number.MAX_SAFE_INTEGER)) {
        throw new tsProtoGlobalThis$G.Error("Value is larger than Number.MAX_SAFE_INTEGER");
    }
    return long.toNumber();
}
if (_m0.util.Long !== Long) {
    _m0.util.Long = Long;
    _m0.configure();
}
function isSet$V(value) {
    return value !== null && value !== undefined;
}

/* eslint-disable */
const protobufPackage$W = "canine_chain.filetree";
function createBaseFiles() {
    return { address: "", contents: "", owner: "", viewingAccess: "", editAccess: "", trackingNumber: "" };
}
const Files = {
    encode(message, writer = _m0.Writer.create()) {
        if (message.address !== "") {
            writer.uint32(10).string(message.address);
        }
        if (message.contents !== "") {
            writer.uint32(18).string(message.contents);
        }
        if (message.owner !== "") {
            writer.uint32(26).string(message.owner);
        }
        if (message.viewingAccess !== "") {
            writer.uint32(34).string(message.viewingAccess);
        }
        if (message.editAccess !== "") {
            writer.uint32(42).string(message.editAccess);
        }
        if (message.trackingNumber !== "") {
            writer.uint32(50).string(message.trackingNumber);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseFiles();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    if (tag !== 10) {
                        break;
                    }
                    message.address = reader.string();
                    continue;
                case 2:
                    if (tag !== 18) {
                        break;
                    }
                    message.contents = reader.string();
                    continue;
                case 3:
                    if (tag !== 26) {
                        break;
                    }
                    message.owner = reader.string();
                    continue;
                case 4:
                    if (tag !== 34) {
                        break;
                    }
                    message.viewingAccess = reader.string();
                    continue;
                case 5:
                    if (tag !== 42) {
                        break;
                    }
                    message.editAccess = reader.string();
                    continue;
                case 6:
                    if (tag !== 50) {
                        break;
                    }
                    message.trackingNumber = reader.string();
                    continue;
            }
            if ((tag & 7) === 4 || tag === 0) {
                break;
            }
            reader.skipType(tag & 7);
        }
        return message;
    },
    fromJSON(object) {
        return {
            address: isSet$U(object.address) ? String(object.address) : "",
            contents: isSet$U(object.contents) ? String(object.contents) : "",
            owner: isSet$U(object.owner) ? String(object.owner) : "",
            viewingAccess: isSet$U(object.viewingAccess) ? String(object.viewingAccess) : "",
            editAccess: isSet$U(object.editAccess) ? String(object.editAccess) : "",
            trackingNumber: isSet$U(object.trackingNumber) ? String(object.trackingNumber) : "",
        };
    },
    toJSON(message) {
        const obj = {};
        if (message.address !== "") {
            obj.address = message.address;
        }
        if (message.contents !== "") {
            obj.contents = message.contents;
        }
        if (message.owner !== "") {
            obj.owner = message.owner;
        }
        if (message.viewingAccess !== "") {
            obj.viewingAccess = message.viewingAccess;
        }
        if (message.editAccess !== "") {
            obj.editAccess = message.editAccess;
        }
        if (message.trackingNumber !== "") {
            obj.trackingNumber = message.trackingNumber;
        }
        return obj;
    },
    create(base) {
        return Files.fromPartial(base ?? {});
    },
    fromPartial(object) {
        const message = createBaseFiles();
        message.address = object.address ?? "";
        message.contents = object.contents ?? "";
        message.owner = object.owner ?? "";
        message.viewingAccess = object.viewingAccess ?? "";
        message.editAccess = object.editAccess ?? "";
        message.trackingNumber = object.trackingNumber ?? "";
        return message;
    },
};
function isSet$U(value) {
    return value !== null && value !== undefined;
}

/* eslint-disable */
const protobufPackage$V = "canine_chain.filetree";
function createBaseParams$9() {
    return {};
}
const Params$9 = {
    encode(_, writer = _m0.Writer.create()) {
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseParams$9();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
            }
            if ((tag & 7) === 4 || tag === 0) {
                break;
            }
            reader.skipType(tag & 7);
        }
        return message;
    },
    fromJSON(_) {
        return {};
    },
    toJSON(_) {
        const obj = {};
        return obj;
    },
    create(base) {
        return Params$9.fromPartial(base ?? {});
    },
    fromPartial(_) {
        const message = createBaseParams$9();
        return message;
    },
};

/* eslint-disable */
const protobufPackage$U = "canine_chain.filetree";
function createBasePubkey() {
    return { address: "", key: "" };
}
const Pubkey = {
    encode(message, writer = _m0.Writer.create()) {
        if (message.address !== "") {
            writer.uint32(10).string(message.address);
        }
        if (message.key !== "") {
            writer.uint32(18).string(message.key);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBasePubkey();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    if (tag !== 10) {
                        break;
                    }
                    message.address = reader.string();
                    continue;
                case 2:
                    if (tag !== 18) {
                        break;
                    }
                    message.key = reader.string();
                    continue;
            }
            if ((tag & 7) === 4 || tag === 0) {
                break;
            }
            reader.skipType(tag & 7);
        }
        return message;
    },
    fromJSON(object) {
        return {
            address: isSet$T(object.address) ? String(object.address) : "",
            key: isSet$T(object.key) ? String(object.key) : "",
        };
    },
    toJSON(message) {
        const obj = {};
        if (message.address !== "") {
            obj.address = message.address;
        }
        if (message.key !== "") {
            obj.key = message.key;
        }
        return obj;
    },
    create(base) {
        return Pubkey.fromPartial(base ?? {});
    },
    fromPartial(object) {
        const message = createBasePubkey();
        message.address = object.address ?? "";
        message.key = object.key ?? "";
        return message;
    },
};
function isSet$T(value) {
    return value !== null && value !== undefined;
}

/* eslint-disable */
const protobufPackage$T = "canine_chain.filetree";
function createBaseQueryParamsRequest$a() {
    return {};
}
const QueryParamsRequest$a = {
    encode(_, writer = _m0.Writer.create()) {
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseQueryParamsRequest$a();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
            }
            if ((tag & 7) === 4 || tag === 0) {
                break;
            }
            reader.skipType(tag & 7);
        }
        return message;
    },
    fromJSON(_) {
        return {};
    },
    toJSON(_) {
        const obj = {};
        return obj;
    },
    create(base) {
        return QueryParamsRequest$a.fromPartial(base ?? {});
    },
    fromPartial(_) {
        const message = createBaseQueryParamsRequest$a();
        return message;
    },
};
function createBaseQueryParamsResponse$a() {
    return { params: undefined };
}
const QueryParamsResponse$a = {
    encode(message, writer = _m0.Writer.create()) {
        if (message.params !== undefined) {
            Params$9.encode(message.params, writer.uint32(10).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseQueryParamsResponse$a();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    if (tag !== 10) {
                        break;
                    }
                    message.params = Params$9.decode(reader, reader.uint32());
                    continue;
            }
            if ((tag & 7) === 4 || tag === 0) {
                break;
            }
            reader.skipType(tag & 7);
        }
        return message;
    },
    fromJSON(object) {
        return { params: isSet$S(object.params) ? Params$9.fromJSON(object.params) : undefined };
    },
    toJSON(message) {
        const obj = {};
        if (message.params !== undefined) {
            obj.params = Params$9.toJSON(message.params);
        }
        return obj;
    },
    create(base) {
        return QueryParamsResponse$a.fromPartial(base ?? {});
    },
    fromPartial(object) {
        const message = createBaseQueryParamsResponse$a();
        message.params = (object.params !== undefined && object.params !== null)
            ? Params$9.fromPartial(object.params)
            : undefined;
        return message;
    },
};
function createBaseQueryEncryptRequest() {
    return { address: "", message: "" };
}
const QueryEncryptRequest = {
    encode(message, writer = _m0.Writer.create()) {
        if (message.address !== "") {
            writer.uint32(10).string(message.address);
        }
        if (message.message !== "") {
            writer.uint32(18).string(message.message);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseQueryEncryptRequest();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    if (tag !== 10) {
                        break;
                    }
                    message.address = reader.string();
                    continue;
                case 2:
                    if (tag !== 18) {
                        break;
                    }
                    message.message = reader.string();
                    continue;
            }
            if ((tag & 7) === 4 || tag === 0) {
                break;
            }
            reader.skipType(tag & 7);
        }
        return message;
    },
    fromJSON(object) {
        return {
            address: isSet$S(object.address) ? String(object.address) : "",
            message: isSet$S(object.message) ? String(object.message) : "",
        };
    },
    toJSON(message) {
        const obj = {};
        if (message.address !== "") {
            obj.address = message.address;
        }
        if (message.message !== "") {
            obj.message = message.message;
        }
        return obj;
    },
    create(base) {
        return QueryEncryptRequest.fromPartial(base ?? {});
    },
    fromPartial(object) {
        const message = createBaseQueryEncryptRequest();
        message.address = object.address ?? "";
        message.message = object.message ?? "";
        return message;
    },
};
function createBaseQueryEncryptResponse() {
    return { encryptionData: "" };
}
const QueryEncryptResponse = {
    encode(message, writer = _m0.Writer.create()) {
        if (message.encryptionData !== "") {
            writer.uint32(10).string(message.encryptionData);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseQueryEncryptResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    if (tag !== 10) {
                        break;
                    }
                    message.encryptionData = reader.string();
                    continue;
            }
            if ((tag & 7) === 4 || tag === 0) {
                break;
            }
            reader.skipType(tag & 7);
        }
        return message;
    },
    fromJSON(object) {
        return { encryptionData: isSet$S(object.encryptionData) ? String(object.encryptionData) : "" };
    },
    toJSON(message) {
        const obj = {};
        if (message.encryptionData !== "") {
            obj.encryptionData = message.encryptionData;
        }
        return obj;
    },
    create(base) {
        return QueryEncryptResponse.fromPartial(base ?? {});
    },
    fromPartial(object) {
        const message = createBaseQueryEncryptResponse();
        message.encryptionData = object.encryptionData ?? "";
        return message;
    },
};
function createBaseQueryDecryptRequest() {
    return { message: "" };
}
const QueryDecryptRequest = {
    encode(message, writer = _m0.Writer.create()) {
        if (message.message !== "") {
            writer.uint32(10).string(message.message);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseQueryDecryptRequest();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    if (tag !== 10) {
                        break;
                    }
                    message.message = reader.string();
                    continue;
            }
            if ((tag & 7) === 4 || tag === 0) {
                break;
            }
            reader.skipType(tag & 7);
        }
        return message;
    },
    fromJSON(object) {
        return { message: isSet$S(object.message) ? String(object.message) : "" };
    },
    toJSON(message) {
        const obj = {};
        if (message.message !== "") {
            obj.message = message.message;
        }
        return obj;
    },
    create(base) {
        return QueryDecryptRequest.fromPartial(base ?? {});
    },
    fromPartial(object) {
        const message = createBaseQueryDecryptRequest();
        message.message = object.message ?? "";
        return message;
    },
};
function createBaseQueryDecryptResponse() {
    return { data: "" };
}
const QueryDecryptResponse = {
    encode(message, writer = _m0.Writer.create()) {
        if (message.data !== "") {
            writer.uint32(10).string(message.data);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseQueryDecryptResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    if (tag !== 10) {
                        break;
                    }
                    message.data = reader.string();
                    continue;
            }
            if ((tag & 7) === 4 || tag === 0) {
                break;
            }
            reader.skipType(tag & 7);
        }
        return message;
    },
    fromJSON(object) {
        return { data: isSet$S(object.data) ? String(object.data) : "" };
    },
    toJSON(message) {
        const obj = {};
        if (message.data !== "") {
            obj.data = message.data;
        }
        return obj;
    },
    create(base) {
        return QueryDecryptResponse.fromPartial(base ?? {});
    },
    fromPartial(object) {
        const message = createBaseQueryDecryptResponse();
        message.data = object.data ?? "";
        return message;
    },
};
function createBaseQueryFileRequest() {
    return { address: "", ownerAddress: "" };
}
const QueryFileRequest = {
    encode(message, writer = _m0.Writer.create()) {
        if (message.address !== "") {
            writer.uint32(10).string(message.address);
        }
        if (message.ownerAddress !== "") {
            writer.uint32(18).string(message.ownerAddress);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseQueryFileRequest();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    if (tag !== 10) {
                        break;
                    }
                    message.address = reader.string();
                    continue;
                case 2:
                    if (tag !== 18) {
                        break;
                    }
                    message.ownerAddress = reader.string();
                    continue;
            }
            if ((tag & 7) === 4 || tag === 0) {
                break;
            }
            reader.skipType(tag & 7);
        }
        return message;
    },
    fromJSON(object) {
        return {
            address: isSet$S(object.address) ? String(object.address) : "",
            ownerAddress: isSet$S(object.ownerAddress) ? String(object.ownerAddress) : "",
        };
    },
    toJSON(message) {
        const obj = {};
        if (message.address !== "") {
            obj.address = message.address;
        }
        if (message.ownerAddress !== "") {
            obj.ownerAddress = message.ownerAddress;
        }
        return obj;
    },
    create(base) {
        return QueryFileRequest.fromPartial(base ?? {});
    },
    fromPartial(object) {
        const message = createBaseQueryFileRequest();
        message.address = object.address ?? "";
        message.ownerAddress = object.ownerAddress ?? "";
        return message;
    },
};
function createBaseQueryFileResponse() {
    return { files: undefined };
}
const QueryFileResponse = {
    encode(message, writer = _m0.Writer.create()) {
        if (message.files !== undefined) {
            Files.encode(message.files, writer.uint32(10).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseQueryFileResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    if (tag !== 10) {
                        break;
                    }
                    message.files = Files.decode(reader, reader.uint32());
                    continue;
            }
            if ((tag & 7) === 4 || tag === 0) {
                break;
            }
            reader.skipType(tag & 7);
        }
        return message;
    },
    fromJSON(object) {
        return { files: isSet$S(object.files) ? Files.fromJSON(object.files) : undefined };
    },
    toJSON(message) {
        const obj = {};
        if (message.files !== undefined) {
            obj.files = Files.toJSON(message.files);
        }
        return obj;
    },
    create(base) {
        return QueryFileResponse.fromPartial(base ?? {});
    },
    fromPartial(object) {
        const message = createBaseQueryFileResponse();
        message.files = (object.files !== undefined && object.files !== null) ? Files.fromPartial(object.files) : undefined;
        return message;
    },
};
function createBaseQueryAllFilesRequest() {
    return { pagination: undefined };
}
const QueryAllFilesRequest = {
    encode(message, writer = _m0.Writer.create()) {
        if (message.pagination !== undefined) {
            PageRequest.encode(message.pagination, writer.uint32(10).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseQueryAllFilesRequest();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    if (tag !== 10) {
                        break;
                    }
                    message.pagination = PageRequest.decode(reader, reader.uint32());
                    continue;
            }
            if ((tag & 7) === 4 || tag === 0) {
                break;
            }
            reader.skipType(tag & 7);
        }
        return message;
    },
    fromJSON(object) {
        return { pagination: isSet$S(object.pagination) ? PageRequest.fromJSON(object.pagination) : undefined };
    },
    toJSON(message) {
        const obj = {};
        if (message.pagination !== undefined) {
            obj.pagination = PageRequest.toJSON(message.pagination);
        }
        return obj;
    },
    create(base) {
        return QueryAllFilesRequest.fromPartial(base ?? {});
    },
    fromPartial(object) {
        const message = createBaseQueryAllFilesRequest();
        message.pagination = (object.pagination !== undefined && object.pagination !== null)
            ? PageRequest.fromPartial(object.pagination)
            : undefined;
        return message;
    },
};
function createBaseQueryAllFilesResponse() {
    return { files: [], pagination: undefined };
}
const QueryAllFilesResponse = {
    encode(message, writer = _m0.Writer.create()) {
        for (const v of message.files) {
            Files.encode(v, writer.uint32(10).fork()).ldelim();
        }
        if (message.pagination !== undefined) {
            PageResponse.encode(message.pagination, writer.uint32(18).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseQueryAllFilesResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    if (tag !== 10) {
                        break;
                    }
                    message.files.push(Files.decode(reader, reader.uint32()));
                    continue;
                case 2:
                    if (tag !== 18) {
                        break;
                    }
                    message.pagination = PageResponse.decode(reader, reader.uint32());
                    continue;
            }
            if ((tag & 7) === 4 || tag === 0) {
                break;
            }
            reader.skipType(tag & 7);
        }
        return message;
    },
    fromJSON(object) {
        return {
            files: Array.isArray(object?.files) ? object.files.map((e) => Files.fromJSON(e)) : [],
            pagination: isSet$S(object.pagination) ? PageResponse.fromJSON(object.pagination) : undefined,
        };
    },
    toJSON(message) {
        const obj = {};
        if (message.files?.length) {
            obj.files = message.files.map((e) => Files.toJSON(e));
        }
        if (message.pagination !== undefined) {
            obj.pagination = PageResponse.toJSON(message.pagination);
        }
        return obj;
    },
    create(base) {
        return QueryAllFilesResponse.fromPartial(base ?? {});
    },
    fromPartial(object) {
        const message = createBaseQueryAllFilesResponse();
        message.files = object.files?.map((e) => Files.fromPartial(e)) || [];
        message.pagination = (object.pagination !== undefined && object.pagination !== null)
            ? PageResponse.fromPartial(object.pagination)
            : undefined;
        return message;
    },
};
function createBaseQueryPubkeyRequest() {
    return { address: "" };
}
const QueryPubkeyRequest = {
    encode(message, writer = _m0.Writer.create()) {
        if (message.address !== "") {
            writer.uint32(10).string(message.address);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseQueryPubkeyRequest();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    if (tag !== 10) {
                        break;
                    }
                    message.address = reader.string();
                    continue;
            }
            if ((tag & 7) === 4 || tag === 0) {
                break;
            }
            reader.skipType(tag & 7);
        }
        return message;
    },
    fromJSON(object) {
        return { address: isSet$S(object.address) ? String(object.address) : "" };
    },
    toJSON(message) {
        const obj = {};
        if (message.address !== "") {
            obj.address = message.address;
        }
        return obj;
    },
    create(base) {
        return QueryPubkeyRequest.fromPartial(base ?? {});
    },
    fromPartial(object) {
        const message = createBaseQueryPubkeyRequest();
        message.address = object.address ?? "";
        return message;
    },
};
function createBaseQueryPubkeyResponse() {
    return { pubkey: undefined };
}
const QueryPubkeyResponse = {
    encode(message, writer = _m0.Writer.create()) {
        if (message.pubkey !== undefined) {
            Pubkey.encode(message.pubkey, writer.uint32(10).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseQueryPubkeyResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    if (tag !== 10) {
                        break;
                    }
                    message.pubkey = Pubkey.decode(reader, reader.uint32());
                    continue;
            }
            if ((tag & 7) === 4 || tag === 0) {
                break;
            }
            reader.skipType(tag & 7);
        }
        return message;
    },
    fromJSON(object) {
        return { pubkey: isSet$S(object.pubkey) ? Pubkey.fromJSON(object.pubkey) : undefined };
    },
    toJSON(message) {
        const obj = {};
        if (message.pubkey !== undefined) {
            obj.pubkey = Pubkey.toJSON(message.pubkey);
        }
        return obj;
    },
    create(base) {
        return QueryPubkeyResponse.fromPartial(base ?? {});
    },
    fromPartial(object) {
        const message = createBaseQueryPubkeyResponse();
        message.pubkey = (object.pubkey !== undefined && object.pubkey !== null)
            ? Pubkey.fromPartial(object.pubkey)
            : undefined;
        return message;
    },
};
function createBaseQueryAllPubkeysRequest() {
    return { pagination: undefined };
}
const QueryAllPubkeysRequest = {
    encode(message, writer = _m0.Writer.create()) {
        if (message.pagination !== undefined) {
            PageRequest.encode(message.pagination, writer.uint32(10).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseQueryAllPubkeysRequest();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    if (tag !== 10) {
                        break;
                    }
                    message.pagination = PageRequest.decode(reader, reader.uint32());
                    continue;
            }
            if ((tag & 7) === 4 || tag === 0) {
                break;
            }
            reader.skipType(tag & 7);
        }
        return message;
    },
    fromJSON(object) {
        return { pagination: isSet$S(object.pagination) ? PageRequest.fromJSON(object.pagination) : undefined };
    },
    toJSON(message) {
        const obj = {};
        if (message.pagination !== undefined) {
            obj.pagination = PageRequest.toJSON(message.pagination);
        }
        return obj;
    },
    create(base) {
        return QueryAllPubkeysRequest.fromPartial(base ?? {});
    },
    fromPartial(object) {
        const message = createBaseQueryAllPubkeysRequest();
        message.pagination = (object.pagination !== undefined && object.pagination !== null)
            ? PageRequest.fromPartial(object.pagination)
            : undefined;
        return message;
    },
};
function createBaseQueryAllPubkeysResponse() {
    return { pubkey: [], pagination: undefined };
}
const QueryAllPubkeysResponse = {
    encode(message, writer = _m0.Writer.create()) {
        for (const v of message.pubkey) {
            Pubkey.encode(v, writer.uint32(10).fork()).ldelim();
        }
        if (message.pagination !== undefined) {
            PageResponse.encode(message.pagination, writer.uint32(18).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseQueryAllPubkeysResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    if (tag !== 10) {
                        break;
                    }
                    message.pubkey.push(Pubkey.decode(reader, reader.uint32()));
                    continue;
                case 2:
                    if (tag !== 18) {
                        break;
                    }
                    message.pagination = PageResponse.decode(reader, reader.uint32());
                    continue;
            }
            if ((tag & 7) === 4 || tag === 0) {
                break;
            }
            reader.skipType(tag & 7);
        }
        return message;
    },
    fromJSON(object) {
        return {
            pubkey: Array.isArray(object?.pubkey) ? object.pubkey.map((e) => Pubkey.fromJSON(e)) : [],
            pagination: isSet$S(object.pagination) ? PageResponse.fromJSON(object.pagination) : undefined,
        };
    },
    toJSON(message) {
        const obj = {};
        if (message.pubkey?.length) {
            obj.pubkey = message.pubkey.map((e) => Pubkey.toJSON(e));
        }
        if (message.pagination !== undefined) {
            obj.pagination = PageResponse.toJSON(message.pagination);
        }
        return obj;
    },
    create(base) {
        return QueryAllPubkeysResponse.fromPartial(base ?? {});
    },
    fromPartial(object) {
        const message = createBaseQueryAllPubkeysResponse();
        message.pubkey = object.pubkey?.map((e) => Pubkey.fromPartial(e)) || [];
        message.pagination = (object.pagination !== undefined && object.pagination !== null)
            ? PageResponse.fromPartial(object.pagination)
            : undefined;
        return message;
    },
};
let QueryClientImpl$a = class QueryClientImpl {
    rpc;
    constructor(rpc) {
        this.rpc = rpc;
        this.Params = this.Params.bind(this);
        this.Encrypt = this.Encrypt.bind(this);
        this.Decrypt = this.Decrypt.bind(this);
        this.Files = this.Files.bind(this);
        this.FilesAll = this.FilesAll.bind(this);
        this.Pubkey = this.Pubkey.bind(this);
        this.PubkeyAll = this.PubkeyAll.bind(this);
    }
    Params(request, metadata) {
        return this.rpc.unary(QueryParamsDesc$a, QueryParamsRequest$a.fromPartial(request), metadata);
    }
    Encrypt(request, metadata) {
        return this.rpc.unary(QueryEncryptDesc, QueryEncryptRequest.fromPartial(request), metadata);
    }
    Decrypt(request, metadata) {
        return this.rpc.unary(QueryDecryptDesc, QueryDecryptRequest.fromPartial(request), metadata);
    }
    Files(request, metadata) {
        return this.rpc.unary(QueryFilesDesc, QueryFileRequest.fromPartial(request), metadata);
    }
    FilesAll(request, metadata) {
        return this.rpc.unary(QueryFilesAllDesc, QueryAllFilesRequest.fromPartial(request), metadata);
    }
    Pubkey(request, metadata) {
        return this.rpc.unary(QueryPubkeyDesc, QueryPubkeyRequest.fromPartial(request), metadata);
    }
    PubkeyAll(request, metadata) {
        return this.rpc.unary(QueryPubkeyAllDesc, QueryAllPubkeysRequest.fromPartial(request), metadata);
    }
};
const QueryDesc$a = { serviceName: "canine_chain.filetree.Query" };
const QueryParamsDesc$a = {
    methodName: "Params",
    service: QueryDesc$a,
    requestStream: false,
    responseStream: false,
    requestType: {
        serializeBinary() {
            return QueryParamsRequest$a.encode(this).finish();
        },
    },
    responseType: {
        deserializeBinary(data) {
            const value = QueryParamsResponse$a.decode(data);
            return {
                ...value,
                toObject() {
                    return value;
                },
            };
        },
    },
};
const QueryEncryptDesc = {
    methodName: "Encrypt",
    service: QueryDesc$a,
    requestStream: false,
    responseStream: false,
    requestType: {
        serializeBinary() {
            return QueryEncryptRequest.encode(this).finish();
        },
    },
    responseType: {
        deserializeBinary(data) {
            const value = QueryEncryptResponse.decode(data);
            return {
                ...value,
                toObject() {
                    return value;
                },
            };
        },
    },
};
const QueryDecryptDesc = {
    methodName: "Decrypt",
    service: QueryDesc$a,
    requestStream: false,
    responseStream: false,
    requestType: {
        serializeBinary() {
            return QueryDecryptRequest.encode(this).finish();
        },
    },
    responseType: {
        deserializeBinary(data) {
            const value = QueryDecryptResponse.decode(data);
            return {
                ...value,
                toObject() {
                    return value;
                },
            };
        },
    },
};
const QueryFilesDesc = {
    methodName: "Files",
    service: QueryDesc$a,
    requestStream: false,
    responseStream: false,
    requestType: {
        serializeBinary() {
            return QueryFileRequest.encode(this).finish();
        },
    },
    responseType: {
        deserializeBinary(data) {
            const value = QueryFileResponse.decode(data);
            return {
                ...value,
                toObject() {
                    return value;
                },
            };
        },
    },
};
const QueryFilesAllDesc = {
    methodName: "FilesAll",
    service: QueryDesc$a,
    requestStream: false,
    responseStream: false,
    requestType: {
        serializeBinary() {
            return QueryAllFilesRequest.encode(this).finish();
        },
    },
    responseType: {
        deserializeBinary(data) {
            const value = QueryAllFilesResponse.decode(data);
            return {
                ...value,
                toObject() {
                    return value;
                },
            };
        },
    },
};
const QueryPubkeyDesc = {
    methodName: "Pubkey",
    service: QueryDesc$a,
    requestStream: false,
    responseStream: false,
    requestType: {
        serializeBinary() {
            return QueryPubkeyRequest.encode(this).finish();
        },
    },
    responseType: {
        deserializeBinary(data) {
            const value = QueryPubkeyResponse.decode(data);
            return {
                ...value,
                toObject() {
                    return value;
                },
            };
        },
    },
};
const QueryPubkeyAllDesc = {
    methodName: "PubkeyAll",
    service: QueryDesc$a,
    requestStream: false,
    responseStream: false,
    requestType: {
        serializeBinary() {
            return QueryAllPubkeysRequest.encode(this).finish();
        },
    },
    responseType: {
        deserializeBinary(data) {
            const value = QueryAllPubkeysResponse.decode(data);
            return {
                ...value,
                toObject() {
                    return value;
                },
            };
        },
    },
};
let GrpcWebImpl$l = class GrpcWebImpl {
    host;
    options;
    constructor(host, options) {
        this.host = host;
        this.options = options;
    }
    unary(methodDesc, _request, metadata) {
        const request = { ..._request, ...methodDesc.requestType };
        const maybeCombinedMetadata = metadata && this.options.metadata
            ? new browserHeaders.BrowserHeaders({ ...this.options?.metadata.headersMap, ...metadata?.headersMap })
            : metadata ?? this.options.metadata;
        return new Promise((resolve, reject) => {
            grpcWeb.grpc.unary(methodDesc, {
                request,
                host: this.host,
                metadata: maybeCombinedMetadata ?? {},
                ...(this.options.transport !== undefined ? { transport: this.options.transport } : {}),
                debug: this.options.debug ?? false,
                onEnd: function (response) {
                    if (response.status === grpcWeb.grpc.Code.OK) {
                        resolve(response.message.toObject());
                    }
                    else {
                        const err = new GrpcWebError$l(response.statusMessage, response.status, response.trailers);
                        reject(err);
                    }
                },
            });
        });
    }
};
const tsProtoGlobalThis$F = (() => {
    if (typeof globalThis !== "undefined") {
        return globalThis;
    }
    if (typeof self !== "undefined") {
        return self;
    }
    if (typeof window !== "undefined") {
        return window;
    }
    if (typeof global !== "undefined") {
        return global;
    }
    throw "Unable to locate global object";
})();
function isSet$S(value) {
    return value !== null && value !== undefined;
}
let GrpcWebError$l = class GrpcWebError extends tsProtoGlobalThis$F.Error {
    code;
    metadata;
    constructor(message, code, metadata) {
        super(message);
        this.code = code;
        this.metadata = metadata;
    }
};

/* eslint-disable */
const protobufPackage$S = "canine_chain.jklmint";
function createBaseParams$8() {
    return { mintDenom: "" };
}
const Params$8 = {
    encode(message, writer = _m0.Writer.create()) {
        if (message.mintDenom !== "") {
            writer.uint32(10).string(message.mintDenom);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseParams$8();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    if (tag !== 10) {
                        break;
                    }
                    message.mintDenom = reader.string();
                    continue;
            }
            if ((tag & 7) === 4 || tag === 0) {
                break;
            }
            reader.skipType(tag & 7);
        }
        return message;
    },
    fromJSON(object) {
        return { mintDenom: isSet$R(object.mintDenom) ? String(object.mintDenom) : "" };
    },
    toJSON(message) {
        const obj = {};
        if (message.mintDenom !== "") {
            obj.mintDenom = message.mintDenom;
        }
        return obj;
    },
    create(base) {
        return Params$8.fromPartial(base ?? {});
    },
    fromPartial(object) {
        const message = createBaseParams$8();
        message.mintDenom = object.mintDenom ?? "";
        return message;
    },
};
function isSet$R(value) {
    return value !== null && value !== undefined;
}

/* eslint-disable */
const protobufPackage$R = "canine_chain.jklmint";
functi