@sparkdreamnft/sparkdreamjs 0.0.7 → 0.0.9

package/esm/sparkdream/collect/v1/query.js

@@ -0,0 +1,3790 @@
+//@ts-nocheck
+import { PageRequest, PageResponse } from "../../../cosmos/base/query/v1beta1/pagination";
+import { Collection, Item, Collaborator, Curator, CurationSummary, CurationReview, SponsorshipRequest, CollectionFlag, HideRecord, Endorsement } from "./types";
+import { Params } from "./params";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { Decimal } from "@interchainjs/math";
+function createBaseQueryParamsRequest() {
+    return {};
+}
+/**
+ * @name QueryParamsRequest
+ * @package sparkdream.collect.v1
+ * @see proto type: sparkdream.collect.v1.QueryParamsRequest
+ */
+export const QueryParamsRequest = {
+    typeUrl: "/sparkdream.collect.v1.QueryParamsRequest",
+    encode(_, writer = BinaryWriter.create()) {
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryParamsRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseQueryParamsRequest();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseQueryParamsRequest();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryParamsRequest.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryParamsRequest.decode(message.value);
+    },
+    toProto(message) {
+        return QueryParamsRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.collect.v1.QueryParamsRequest",
+            value: QueryParamsRequest.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryParamsResponse() {
+    return {
+        params: Params.fromPartial({})
+    };
+}
+/**
+ * @name QueryParamsResponse
+ * @package sparkdream.collect.v1
+ * @see proto type: sparkdream.collect.v1.QueryParamsResponse
+ */
+export const QueryParamsResponse = {
+    typeUrl: "/sparkdream.collect.v1.QueryParamsResponse",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.params !== undefined) {
+            Params.encode(message.params, writer.uint32(10).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryParamsResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.params = 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;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryParamsResponse();
+        if (object.params !== undefined && object.params !== null) {
+            message.params = Params.fromAmino(object.params);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.params = message.params ? Params.toAmino(message.params) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryParamsResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryParamsResponse.decode(message.value);
+    },
+    toProto(message) {
+        return QueryParamsResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.collect.v1.QueryParamsResponse",
+            value: QueryParamsResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryCollectionRequest() {
+    return {
+        id: BigInt(0)
+    };
+}
+/**
+ * @name QueryCollectionRequest
+ * @package sparkdream.collect.v1
+ * @see proto type: sparkdream.collect.v1.QueryCollectionRequest
+ */
+export const QueryCollectionRequest = {
+    typeUrl: "/sparkdream.collect.v1.QueryCollectionRequest",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.id !== BigInt(0)) {
+            writer.uint32(8).uint64(message.id);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryCollectionRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.id = reader.uint64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryCollectionRequest();
+        message.id = object.id !== undefined && object.id !== null ? BigInt(object.id.toString()) : BigInt(0);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryCollectionRequest();
+        if (object.id !== undefined && object.id !== null) {
+            message.id = BigInt(object.id);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.id = message.id !== BigInt(0) ? message.id?.toString() : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryCollectionRequest.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryCollectionRequest.decode(message.value);
+    },
+    toProto(message) {
+        return QueryCollectionRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.collect.v1.QueryCollectionRequest",
+            value: QueryCollectionRequest.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryCollectionResponse() {
+    return {
+        collection: Collection.fromPartial({})
+    };
+}
+/**
+ * @name QueryCollectionResponse
+ * @package sparkdream.collect.v1
+ * @see proto type: sparkdream.collect.v1.QueryCollectionResponse
+ */
+export const QueryCollectionResponse = {
+    typeUrl: "/sparkdream.collect.v1.QueryCollectionResponse",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.collection !== undefined) {
+            Collection.encode(message.collection, writer.uint32(10).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryCollectionResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.collection = Collection.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryCollectionResponse();
+        message.collection = object.collection !== undefined && object.collection !== null ? Collection.fromPartial(object.collection) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryCollectionResponse();
+        if (object.collection !== undefined && object.collection !== null) {
+            message.collection = Collection.fromAmino(object.collection);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.collection = message.collection ? Collection.toAmino(message.collection) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryCollectionResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryCollectionResponse.decode(message.value);
+    },
+    toProto(message) {
+        return QueryCollectionResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.collect.v1.QueryCollectionResponse",
+            value: QueryCollectionResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryCollectionsByOwnerRequest() {
+    return {
+        owner: "",
+        pagination: undefined
+    };
+}
+/**
+ * @name QueryCollectionsByOwnerRequest
+ * @package sparkdream.collect.v1
+ * @see proto type: sparkdream.collect.v1.QueryCollectionsByOwnerRequest
+ */
+export const QueryCollectionsByOwnerRequest = {
+    typeUrl: "/sparkdream.collect.v1.QueryCollectionsByOwnerRequest",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.owner !== "") {
+            writer.uint32(10).string(message.owner);
+        }
+        if (message.pagination !== undefined) {
+            PageRequest.encode(message.pagination, writer.uint32(18).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryCollectionsByOwnerRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.owner = reader.string();
+                    break;
+                case 2:
+                    message.pagination = PageRequest.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryCollectionsByOwnerRequest();
+        message.owner = object.owner ?? "";
+        message.pagination = object.pagination !== undefined && object.pagination !== null ? PageRequest.fromPartial(object.pagination) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryCollectionsByOwnerRequest();
+        if (object.owner !== undefined && object.owner !== null) {
+            message.owner = object.owner;
+        }
+        if (object.pagination !== undefined && object.pagination !== null) {
+            message.pagination = PageRequest.fromAmino(object.pagination);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.owner = message.owner === "" ? undefined : message.owner;
+        obj.pagination = message.pagination ? PageRequest.toAmino(message.pagination) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryCollectionsByOwnerRequest.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryCollectionsByOwnerRequest.decode(message.value);
+    },
+    toProto(message) {
+        return QueryCollectionsByOwnerRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.collect.v1.QueryCollectionsByOwnerRequest",
+            value: QueryCollectionsByOwnerRequest.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryCollectionsByOwnerResponse() {
+    return {
+        collections: [],
+        pagination: undefined
+    };
+}
+/**
+ * @name QueryCollectionsByOwnerResponse
+ * @package sparkdream.collect.v1
+ * @see proto type: sparkdream.collect.v1.QueryCollectionsByOwnerResponse
+ */
+export const QueryCollectionsByOwnerResponse = {
+    typeUrl: "/sparkdream.collect.v1.QueryCollectionsByOwnerResponse",
+    encode(message, writer = BinaryWriter.create()) {
+        for (const v of message.collections) {
+            Collection.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 BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryCollectionsByOwnerResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.collections.push(Collection.decode(reader, reader.uint32()));
+                    break;
+                case 2:
+                    message.pagination = PageResponse.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryCollectionsByOwnerResponse();
+        message.collections = object.collections?.map(e => Collection.fromPartial(e)) || [];
+        message.pagination = object.pagination !== undefined && object.pagination !== null ? PageResponse.fromPartial(object.pagination) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryCollectionsByOwnerResponse();
+        message.collections = object.collections?.map(e => Collection.fromAmino(e)) || [];
+        if (object.pagination !== undefined && object.pagination !== null) {
+            message.pagination = PageResponse.fromAmino(object.pagination);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        if (message.collections) {
+            obj.collections = message.collections.map(e => e ? Collection.toAmino(e) : undefined);
+        }
+        else {
+            obj.collections = message.collections;
+        }
+        obj.pagination = message.pagination ? PageResponse.toAmino(message.pagination) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryCollectionsByOwnerResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryCollectionsByOwnerResponse.decode(message.value);
+    },
+    toProto(message) {
+        return QueryCollectionsByOwnerResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.collect.v1.QueryCollectionsByOwnerResponse",
+            value: QueryCollectionsByOwnerResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryPublicCollectionsRequest() {
+    return {
+        pagination: undefined
+    };
+}
+/**
+ * @name QueryPublicCollectionsRequest
+ * @package sparkdream.collect.v1
+ * @see proto type: sparkdream.collect.v1.QueryPublicCollectionsRequest
+ */
+export const QueryPublicCollectionsRequest = {
+    typeUrl: "/sparkdream.collect.v1.QueryPublicCollectionsRequest",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.pagination !== undefined) {
+            PageRequest.encode(message.pagination, writer.uint32(10).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryPublicCollectionsRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.pagination = PageRequest.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryPublicCollectionsRequest();
+        message.pagination = object.pagination !== undefined && object.pagination !== null ? PageRequest.fromPartial(object.pagination) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryPublicCollectionsRequest();
+        if (object.pagination !== undefined && object.pagination !== null) {
+            message.pagination = PageRequest.fromAmino(object.pagination);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.pagination = message.pagination ? PageRequest.toAmino(message.pagination) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryPublicCollectionsRequest.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryPublicCollectionsRequest.decode(message.value);
+    },
+    toProto(message) {
+        return QueryPublicCollectionsRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.collect.v1.QueryPublicCollectionsRequest",
+            value: QueryPublicCollectionsRequest.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryPublicCollectionsResponse() {
+    return {
+        collections: [],
+        pagination: undefined
+    };
+}
+/**
+ * @name QueryPublicCollectionsResponse
+ * @package sparkdream.collect.v1
+ * @see proto type: sparkdream.collect.v1.QueryPublicCollectionsResponse
+ */
+export const QueryPublicCollectionsResponse = {
+    typeUrl: "/sparkdream.collect.v1.QueryPublicCollectionsResponse",
+    encode(message, writer = BinaryWriter.create()) {
+        for (const v of message.collections) {
+            Collection.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 BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryPublicCollectionsResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.collections.push(Collection.decode(reader, reader.uint32()));
+                    break;
+                case 2:
+                    message.pagination = PageResponse.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryPublicCollectionsResponse();
+        message.collections = object.collections?.map(e => Collection.fromPartial(e)) || [];
+        message.pagination = object.pagination !== undefined && object.pagination !== null ? PageResponse.fromPartial(object.pagination) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryPublicCollectionsResponse();
+        message.collections = object.collections?.map(e => Collection.fromAmino(e)) || [];
+        if (object.pagination !== undefined && object.pagination !== null) {
+            message.pagination = PageResponse.fromAmino(object.pagination);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        if (message.collections) {
+            obj.collections = message.collections.map(e => e ? Collection.toAmino(e) : undefined);
+        }
+        else {
+            obj.collections = message.collections;
+        }
+        obj.pagination = message.pagination ? PageResponse.toAmino(message.pagination) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryPublicCollectionsResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryPublicCollectionsResponse.decode(message.value);
+    },
+    toProto(message) {
+        return QueryPublicCollectionsResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.collect.v1.QueryPublicCollectionsResponse",
+            value: QueryPublicCollectionsResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryPublicCollectionsByTypeRequest() {
+    return {
+        collectionType: BigInt(0),
+        pagination: undefined
+    };
+}
+/**
+ * @name QueryPublicCollectionsByTypeRequest
+ * @package sparkdream.collect.v1
+ * @see proto type: sparkdream.collect.v1.QueryPublicCollectionsByTypeRequest
+ */
+export const QueryPublicCollectionsByTypeRequest = {
+    typeUrl: "/sparkdream.collect.v1.QueryPublicCollectionsByTypeRequest",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.collectionType !== BigInt(0)) {
+            writer.uint32(8).uint64(message.collectionType);
+        }
+        if (message.pagination !== undefined) {
+            PageRequest.encode(message.pagination, writer.uint32(18).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryPublicCollectionsByTypeRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.collectionType = reader.uint64();
+                    break;
+                case 2:
+                    message.pagination = PageRequest.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryPublicCollectionsByTypeRequest();
+        message.collectionType = object.collectionType !== undefined && object.collectionType !== null ? BigInt(object.collectionType.toString()) : BigInt(0);
+        message.pagination = object.pagination !== undefined && object.pagination !== null ? PageRequest.fromPartial(object.pagination) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryPublicCollectionsByTypeRequest();
+        if (object.collection_type !== undefined && object.collection_type !== null) {
+            message.collectionType = BigInt(object.collection_type);
+        }
+        if (object.pagination !== undefined && object.pagination !== null) {
+            message.pagination = PageRequest.fromAmino(object.pagination);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.collection_type = message.collectionType !== BigInt(0) ? message.collectionType?.toString() : undefined;
+        obj.pagination = message.pagination ? PageRequest.toAmino(message.pagination) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryPublicCollectionsByTypeRequest.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryPublicCollectionsByTypeRequest.decode(message.value);
+    },
+    toProto(message) {
+        return QueryPublicCollectionsByTypeRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.collect.v1.QueryPublicCollectionsByTypeRequest",
+            value: QueryPublicCollectionsByTypeRequest.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryPublicCollectionsByTypeResponse() {
+    return {
+        collections: [],
+        pagination: undefined
+    };
+}
+/**
+ * @name QueryPublicCollectionsByTypeResponse
+ * @package sparkdream.collect.v1
+ * @see proto type: sparkdream.collect.v1.QueryPublicCollectionsByTypeResponse
+ */
+export const QueryPublicCollectionsByTypeResponse = {
+    typeUrl: "/sparkdream.collect.v1.QueryPublicCollectionsByTypeResponse",
+    encode(message, writer = BinaryWriter.create()) {
+        for (const v of message.collections) {
+            Collection.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 BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryPublicCollectionsByTypeResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.collections.push(Collection.decode(reader, reader.uint32()));
+                    break;
+                case 2:
+                    message.pagination = PageResponse.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryPublicCollectionsByTypeResponse();
+        message.collections = object.collections?.map(e => Collection.fromPartial(e)) || [];
+        message.pagination = object.pagination !== undefined && object.pagination !== null ? PageResponse.fromPartial(object.pagination) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryPublicCollectionsByTypeResponse();
+        message.collections = object.collections?.map(e => Collection.fromAmino(e)) || [];
+        if (object.pagination !== undefined && object.pagination !== null) {
+            message.pagination = PageResponse.fromAmino(object.pagination);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        if (message.collections) {
+            obj.collections = message.collections.map(e => e ? Collection.toAmino(e) : undefined);
+        }
+        else {
+            obj.collections = message.collections;
+        }
+        obj.pagination = message.pagination ? PageResponse.toAmino(message.pagination) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryPublicCollectionsByTypeResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryPublicCollectionsByTypeResponse.decode(message.value);
+    },
+    toProto(message) {
+        return QueryPublicCollectionsByTypeResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.collect.v1.QueryPublicCollectionsByTypeResponse",
+            value: QueryPublicCollectionsByTypeResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryCollectionsByCollaboratorRequest() {
+    return {
+        address: "",
+        pagination: undefined
+    };
+}
+/**
+ * @name QueryCollectionsByCollaboratorRequest
+ * @package sparkdream.collect.v1
+ * @see proto type: sparkdream.collect.v1.QueryCollectionsByCollaboratorRequest
+ */
+export const QueryCollectionsByCollaboratorRequest = {
+    typeUrl: "/sparkdream.collect.v1.QueryCollectionsByCollaboratorRequest",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.address !== "") {
+            writer.uint32(10).string(message.address);
+        }
+        if (message.pagination !== undefined) {
+            PageRequest.encode(message.pagination, writer.uint32(18).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryCollectionsByCollaboratorRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.address = reader.string();
+                    break;
+                case 2:
+                    message.pagination = PageRequest.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryCollectionsByCollaboratorRequest();
+        message.address = object.address ?? "";
+        message.pagination = object.pagination !== undefined && object.pagination !== null ? PageRequest.fromPartial(object.pagination) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryCollectionsByCollaboratorRequest();
+        if (object.address !== undefined && object.address !== null) {
+            message.address = object.address;
+        }
+        if (object.pagination !== undefined && object.pagination !== null) {
+            message.pagination = PageRequest.fromAmino(object.pagination);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.address = message.address === "" ? undefined : message.address;
+        obj.pagination = message.pagination ? PageRequest.toAmino(message.pagination) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryCollectionsByCollaboratorRequest.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryCollectionsByCollaboratorRequest.decode(message.value);
+    },
+    toProto(message) {
+        return QueryCollectionsByCollaboratorRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.collect.v1.QueryCollectionsByCollaboratorRequest",
+            value: QueryCollectionsByCollaboratorRequest.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryCollectionsByCollaboratorResponse() {
+    return {
+        collections: [],
+        pagination: undefined
+    };
+}
+/**
+ * @name QueryCollectionsByCollaboratorResponse
+ * @package sparkdream.collect.v1
+ * @see proto type: sparkdream.collect.v1.QueryCollectionsByCollaboratorResponse
+ */
+export const QueryCollectionsByCollaboratorResponse = {
+    typeUrl: "/sparkdream.collect.v1.QueryCollectionsByCollaboratorResponse",
+    encode(message, writer = BinaryWriter.create()) {
+        for (const v of message.collections) {
+            Collection.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 BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryCollectionsByCollaboratorResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.collections.push(Collection.decode(reader, reader.uint32()));
+                    break;
+                case 2:
+                    message.pagination = PageResponse.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryCollectionsByCollaboratorResponse();
+        message.collections = object.collections?.map(e => Collection.fromPartial(e)) || [];
+        message.pagination = object.pagination !== undefined && object.pagination !== null ? PageResponse.fromPartial(object.pagination) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryCollectionsByCollaboratorResponse();
+        message.collections = object.collections?.map(e => Collection.fromAmino(e)) || [];
+        if (object.pagination !== undefined && object.pagination !== null) {
+            message.pagination = PageResponse.fromAmino(object.pagination);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        if (message.collections) {
+            obj.collections = message.collections.map(e => e ? Collection.toAmino(e) : undefined);
+        }
+        else {
+            obj.collections = message.collections;
+        }
+        obj.pagination = message.pagination ? PageResponse.toAmino(message.pagination) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryCollectionsByCollaboratorResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryCollectionsByCollaboratorResponse.decode(message.value);
+    },
+    toProto(message) {
+        return QueryCollectionsByCollaboratorResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.collect.v1.QueryCollectionsByCollaboratorResponse",
+            value: QueryCollectionsByCollaboratorResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryItemRequest() {
+    return {
+        id: BigInt(0)
+    };
+}
+/**
+ * @name QueryItemRequest
+ * @package sparkdream.collect.v1
+ * @see proto type: sparkdream.collect.v1.QueryItemRequest
+ */
+export const QueryItemRequest = {
+    typeUrl: "/sparkdream.collect.v1.QueryItemRequest",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.id !== BigInt(0)) {
+            writer.uint32(8).uint64(message.id);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryItemRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.id = reader.uint64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryItemRequest();
+        message.id = object.id !== undefined && object.id !== null ? BigInt(object.id.toString()) : BigInt(0);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryItemRequest();
+        if (object.id !== undefined && object.id !== null) {
+            message.id = BigInt(object.id);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.id = message.id !== BigInt(0) ? message.id?.toString() : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryItemRequest.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryItemRequest.decode(message.value);
+    },
+    toProto(message) {
+        return QueryItemRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.collect.v1.QueryItemRequest",
+            value: QueryItemRequest.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryItemResponse() {
+    return {
+        item: Item.fromPartial({})
+    };
+}
+/**
+ * @name QueryItemResponse
+ * @package sparkdream.collect.v1
+ * @see proto type: sparkdream.collect.v1.QueryItemResponse
+ */
+export const QueryItemResponse = {
+    typeUrl: "/sparkdream.collect.v1.QueryItemResponse",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.item !== undefined) {
+            Item.encode(message.item, writer.uint32(10).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryItemResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.item = Item.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryItemResponse();
+        message.item = object.item !== undefined && object.item !== null ? Item.fromPartial(object.item) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryItemResponse();
+        if (object.item !== undefined && object.item !== null) {
+            message.item = Item.fromAmino(object.item);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.item = message.item ? Item.toAmino(message.item) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryItemResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryItemResponse.decode(message.value);
+    },
+    toProto(message) {
+        return QueryItemResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.collect.v1.QueryItemResponse",
+            value: QueryItemResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryItemsRequest() {
+    return {
+        collectionId: BigInt(0),
+        pagination: undefined
+    };
+}
+/**
+ * @name QueryItemsRequest
+ * @package sparkdream.collect.v1
+ * @see proto type: sparkdream.collect.v1.QueryItemsRequest
+ */
+export const QueryItemsRequest = {
+    typeUrl: "/sparkdream.collect.v1.QueryItemsRequest",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.collectionId !== BigInt(0)) {
+            writer.uint32(8).uint64(message.collectionId);
+        }
+        if (message.pagination !== undefined) {
+            PageRequest.encode(message.pagination, writer.uint32(18).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryItemsRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.collectionId = reader.uint64();
+                    break;
+                case 2:
+                    message.pagination = PageRequest.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryItemsRequest();
+        message.collectionId = object.collectionId !== undefined && object.collectionId !== null ? BigInt(object.collectionId.toString()) : BigInt(0);
+        message.pagination = object.pagination !== undefined && object.pagination !== null ? PageRequest.fromPartial(object.pagination) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryItemsRequest();
+        if (object.collection_id !== undefined && object.collection_id !== null) {
+            message.collectionId = BigInt(object.collection_id);
+        }
+        if (object.pagination !== undefined && object.pagination !== null) {
+            message.pagination = PageRequest.fromAmino(object.pagination);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.collection_id = message.collectionId !== BigInt(0) ? message.collectionId?.toString() : undefined;
+        obj.pagination = message.pagination ? PageRequest.toAmino(message.pagination) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryItemsRequest.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryItemsRequest.decode(message.value);
+    },
+    toProto(message) {
+        return QueryItemsRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.collect.v1.QueryItemsRequest",
+            value: QueryItemsRequest.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryItemsResponse() {
+    return {
+        items: [],
+        pagination: undefined
+    };
+}
+/**
+ * @name QueryItemsResponse
+ * @package sparkdream.collect.v1
+ * @see proto type: sparkdream.collect.v1.QueryItemsResponse
+ */
+export const QueryItemsResponse = {
+    typeUrl: "/sparkdream.collect.v1.QueryItemsResponse",
+    encode(message, writer = BinaryWriter.create()) {
+        for (const v of message.items) {
+            Item.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 BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryItemsResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.items.push(Item.decode(reader, reader.uint32()));
+                    break;
+                case 2:
+                    message.pagination = PageResponse.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryItemsResponse();
+        message.items = object.items?.map(e => Item.fromPartial(e)) || [];
+        message.pagination = object.pagination !== undefined && object.pagination !== null ? PageResponse.fromPartial(object.pagination) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryItemsResponse();
+        message.items = object.items?.map(e => Item.fromAmino(e)) || [];
+        if (object.pagination !== undefined && object.pagination !== null) {
+            message.pagination = PageResponse.fromAmino(object.pagination);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        if (message.items) {
+            obj.items = message.items.map(e => e ? Item.toAmino(e) : undefined);
+        }
+        else {
+            obj.items = message.items;
+        }
+        obj.pagination = message.pagination ? PageResponse.toAmino(message.pagination) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryItemsResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryItemsResponse.decode(message.value);
+    },
+    toProto(message) {
+        return QueryItemsResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.collect.v1.QueryItemsResponse",
+            value: QueryItemsResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryItemsByOwnerRequest() {
+    return {
+        owner: "",
+        pagination: undefined
+    };
+}
+/**
+ * @name QueryItemsByOwnerRequest
+ * @package sparkdream.collect.v1
+ * @see proto type: sparkdream.collect.v1.QueryItemsByOwnerRequest
+ */
+export const QueryItemsByOwnerRequest = {
+    typeUrl: "/sparkdream.collect.v1.QueryItemsByOwnerRequest",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.owner !== "") {
+            writer.uint32(10).string(message.owner);
+        }
+        if (message.pagination !== undefined) {
+            PageRequest.encode(message.pagination, writer.uint32(18).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryItemsByOwnerRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.owner = reader.string();
+                    break;
+                case 2:
+                    message.pagination = PageRequest.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryItemsByOwnerRequest();
+        message.owner = object.owner ?? "";
+        message.pagination = object.pagination !== undefined && object.pagination !== null ? PageRequest.fromPartial(object.pagination) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryItemsByOwnerRequest();
+        if (object.owner !== undefined && object.owner !== null) {
+            message.owner = object.owner;
+        }
+        if (object.pagination !== undefined && object.pagination !== null) {
+            message.pagination = PageRequest.fromAmino(object.pagination);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.owner = message.owner === "" ? undefined : message.owner;
+        obj.pagination = message.pagination ? PageRequest.toAmino(message.pagination) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryItemsByOwnerRequest.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryItemsByOwnerRequest.decode(message.value);
+    },
+    toProto(message) {
+        return QueryItemsByOwnerRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.collect.v1.QueryItemsByOwnerRequest",
+            value: QueryItemsByOwnerRequest.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryItemsByOwnerResponse() {
+    return {
+        items: [],
+        pagination: undefined
+    };
+}
+/**
+ * @name QueryItemsByOwnerResponse
+ * @package sparkdream.collect.v1
+ * @see proto type: sparkdream.collect.v1.QueryItemsByOwnerResponse
+ */
+export const QueryItemsByOwnerResponse = {
+    typeUrl: "/sparkdream.collect.v1.QueryItemsByOwnerResponse",
+    encode(message, writer = BinaryWriter.create()) {
+        for (const v of message.items) {
+            Item.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 BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryItemsByOwnerResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.items.push(Item.decode(reader, reader.uint32()));
+                    break;
+                case 2:
+                    message.pagination = PageResponse.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryItemsByOwnerResponse();
+        message.items = object.items?.map(e => Item.fromPartial(e)) || [];
+        message.pagination = object.pagination !== undefined && object.pagination !== null ? PageResponse.fromPartial(object.pagination) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryItemsByOwnerResponse();
+        message.items = object.items?.map(e => Item.fromAmino(e)) || [];
+        if (object.pagination !== undefined && object.pagination !== null) {
+            message.pagination = PageResponse.fromAmino(object.pagination);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        if (message.items) {
+            obj.items = message.items.map(e => e ? Item.toAmino(e) : undefined);
+        }
+        else {
+            obj.items = message.items;
+        }
+        obj.pagination = message.pagination ? PageResponse.toAmino(message.pagination) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryItemsByOwnerResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryItemsByOwnerResponse.decode(message.value);
+    },
+    toProto(message) {
+        return QueryItemsByOwnerResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.collect.v1.QueryItemsByOwnerResponse",
+            value: QueryItemsByOwnerResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryCollaboratorsRequest() {
+    return {
+        collectionId: BigInt(0)
+    };
+}
+/**
+ * @name QueryCollaboratorsRequest
+ * @package sparkdream.collect.v1
+ * @see proto type: sparkdream.collect.v1.QueryCollaboratorsRequest
+ */
+export const QueryCollaboratorsRequest = {
+    typeUrl: "/sparkdream.collect.v1.QueryCollaboratorsRequest",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.collectionId !== BigInt(0)) {
+            writer.uint32(8).uint64(message.collectionId);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryCollaboratorsRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.collectionId = reader.uint64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryCollaboratorsRequest();
+        message.collectionId = object.collectionId !== undefined && object.collectionId !== null ? BigInt(object.collectionId.toString()) : BigInt(0);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryCollaboratorsRequest();
+        if (object.collection_id !== undefined && object.collection_id !== null) {
+            message.collectionId = BigInt(object.collection_id);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.collection_id = message.collectionId !== BigInt(0) ? message.collectionId?.toString() : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryCollaboratorsRequest.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryCollaboratorsRequest.decode(message.value);
+    },
+    toProto(message) {
+        return QueryCollaboratorsRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.collect.v1.QueryCollaboratorsRequest",
+            value: QueryCollaboratorsRequest.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryCollaboratorsResponse() {
+    return {
+        collaborators: []
+    };
+}
+/**
+ * @name QueryCollaboratorsResponse
+ * @package sparkdream.collect.v1
+ * @see proto type: sparkdream.collect.v1.QueryCollaboratorsResponse
+ */
+export const QueryCollaboratorsResponse = {
+    typeUrl: "/sparkdream.collect.v1.QueryCollaboratorsResponse",
+    encode(message, writer = BinaryWriter.create()) {
+        for (const v of message.collaborators) {
+            Collaborator.encode(v, writer.uint32(10).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryCollaboratorsResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.collaborators.push(Collaborator.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryCollaboratorsResponse();
+        message.collaborators = object.collaborators?.map(e => Collaborator.fromPartial(e)) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryCollaboratorsResponse();
+        message.collaborators = object.collaborators?.map(e => Collaborator.fromAmino(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        if (message.collaborators) {
+            obj.collaborators = message.collaborators.map(e => e ? Collaborator.toAmino(e) : undefined);
+        }
+        else {
+            obj.collaborators = message.collaborators;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryCollaboratorsResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryCollaboratorsResponse.decode(message.value);
+    },
+    toProto(message) {
+        return QueryCollaboratorsResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.collect.v1.QueryCollaboratorsResponse",
+            value: QueryCollaboratorsResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryCuratorRequest() {
+    return {
+        address: ""
+    };
+}
+/**
+ * @name QueryCuratorRequest
+ * @package sparkdream.collect.v1
+ * @see proto type: sparkdream.collect.v1.QueryCuratorRequest
+ */
+export const QueryCuratorRequest = {
+    typeUrl: "/sparkdream.collect.v1.QueryCuratorRequest",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.address !== "") {
+            writer.uint32(10).string(message.address);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryCuratorRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.address = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryCuratorRequest();
+        message.address = object.address ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryCuratorRequest();
+        if (object.address !== undefined && object.address !== null) {
+            message.address = object.address;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.address = message.address === "" ? undefined : message.address;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryCuratorRequest.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryCuratorRequest.decode(message.value);
+    },
+    toProto(message) {
+        return QueryCuratorRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.collect.v1.QueryCuratorRequest",
+            value: QueryCuratorRequest.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryCuratorResponse() {
+    return {
+        curator: Curator.fromPartial({})
+    };
+}
+/**
+ * @name QueryCuratorResponse
+ * @package sparkdream.collect.v1
+ * @see proto type: sparkdream.collect.v1.QueryCuratorResponse
+ */
+export const QueryCuratorResponse = {
+    typeUrl: "/sparkdream.collect.v1.QueryCuratorResponse",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.curator !== undefined) {
+            Curator.encode(message.curator, writer.uint32(10).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryCuratorResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.curator = Curator.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryCuratorResponse();
+        message.curator = object.curator !== undefined && object.curator !== null ? Curator.fromPartial(object.curator) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryCuratorResponse();
+        if (object.curator !== undefined && object.curator !== null) {
+            message.curator = Curator.fromAmino(object.curator);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.curator = message.curator ? Curator.toAmino(message.curator) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryCuratorResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryCuratorResponse.decode(message.value);
+    },
+    toProto(message) {
+        return QueryCuratorResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.collect.v1.QueryCuratorResponse",
+            value: QueryCuratorResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryActiveCuratorsRequest() {
+    return {
+        pagination: undefined
+    };
+}
+/**
+ * @name QueryActiveCuratorsRequest
+ * @package sparkdream.collect.v1
+ * @see proto type: sparkdream.collect.v1.QueryActiveCuratorsRequest
+ */
+export const QueryActiveCuratorsRequest = {
+    typeUrl: "/sparkdream.collect.v1.QueryActiveCuratorsRequest",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.pagination !== undefined) {
+            PageRequest.encode(message.pagination, writer.uint32(10).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryActiveCuratorsRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.pagination = PageRequest.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryActiveCuratorsRequest();
+        message.pagination = object.pagination !== undefined && object.pagination !== null ? PageRequest.fromPartial(object.pagination) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryActiveCuratorsRequest();
+        if (object.pagination !== undefined && object.pagination !== null) {
+            message.pagination = PageRequest.fromAmino(object.pagination);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.pagination = message.pagination ? PageRequest.toAmino(message.pagination) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryActiveCuratorsRequest.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryActiveCuratorsRequest.decode(message.value);
+    },
+    toProto(message) {
+        return QueryActiveCuratorsRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.collect.v1.QueryActiveCuratorsRequest",
+            value: QueryActiveCuratorsRequest.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryActiveCuratorsResponse() {
+    return {
+        curators: [],
+        pagination: undefined
+    };
+}
+/**
+ * @name QueryActiveCuratorsResponse
+ * @package sparkdream.collect.v1
+ * @see proto type: sparkdream.collect.v1.QueryActiveCuratorsResponse
+ */
+export const QueryActiveCuratorsResponse = {
+    typeUrl: "/sparkdream.collect.v1.QueryActiveCuratorsResponse",
+    encode(message, writer = BinaryWriter.create()) {
+        for (const v of message.curators) {
+            Curator.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 BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryActiveCuratorsResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.curators.push(Curator.decode(reader, reader.uint32()));
+                    break;
+                case 2:
+                    message.pagination = PageResponse.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryActiveCuratorsResponse();
+        message.curators = object.curators?.map(e => Curator.fromPartial(e)) || [];
+        message.pagination = object.pagination !== undefined && object.pagination !== null ? PageResponse.fromPartial(object.pagination) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryActiveCuratorsResponse();
+        message.curators = object.curators?.map(e => Curator.fromAmino(e)) || [];
+        if (object.pagination !== undefined && object.pagination !== null) {
+            message.pagination = PageResponse.fromAmino(object.pagination);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        if (message.curators) {
+            obj.curators = message.curators.map(e => e ? Curator.toAmino(e) : undefined);
+        }
+        else {
+            obj.curators = message.curators;
+        }
+        obj.pagination = message.pagination ? PageResponse.toAmino(message.pagination) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryActiveCuratorsResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryActiveCuratorsResponse.decode(message.value);
+    },
+    toProto(message) {
+        return QueryActiveCuratorsResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.collect.v1.QueryActiveCuratorsResponse",
+            value: QueryActiveCuratorsResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryCurationSummaryRequest() {
+    return {
+        collectionId: BigInt(0)
+    };
+}
+/**
+ * @name QueryCurationSummaryRequest
+ * @package sparkdream.collect.v1
+ * @see proto type: sparkdream.collect.v1.QueryCurationSummaryRequest
+ */
+export const QueryCurationSummaryRequest = {
+    typeUrl: "/sparkdream.collect.v1.QueryCurationSummaryRequest",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.collectionId !== BigInt(0)) {
+            writer.uint32(8).uint64(message.collectionId);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryCurationSummaryRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.collectionId = reader.uint64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryCurationSummaryRequest();
+        message.collectionId = object.collectionId !== undefined && object.collectionId !== null ? BigInt(object.collectionId.toString()) : BigInt(0);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryCurationSummaryRequest();
+        if (object.collection_id !== undefined && object.collection_id !== null) {
+            message.collectionId = BigInt(object.collection_id);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.collection_id = message.collectionId !== BigInt(0) ? message.collectionId?.toString() : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryCurationSummaryRequest.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryCurationSummaryRequest.decode(message.value);
+    },
+    toProto(message) {
+        return QueryCurationSummaryRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.collect.v1.QueryCurationSummaryRequest",
+            value: QueryCurationSummaryRequest.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryCurationSummaryResponse() {
+    return {
+        summary: CurationSummary.fromPartial({})
+    };
+}
+/**
+ * @name QueryCurationSummaryResponse
+ * @package sparkdream.collect.v1
+ * @see proto type: sparkdream.collect.v1.QueryCurationSummaryResponse
+ */
+export const QueryCurationSummaryResponse = {
+    typeUrl: "/sparkdream.collect.v1.QueryCurationSummaryResponse",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.summary !== undefined) {
+            CurationSummary.encode(message.summary, writer.uint32(10).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryCurationSummaryResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.summary = CurationSummary.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryCurationSummaryResponse();
+        message.summary = object.summary !== undefined && object.summary !== null ? CurationSummary.fromPartial(object.summary) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryCurationSummaryResponse();
+        if (object.summary !== undefined && object.summary !== null) {
+            message.summary = CurationSummary.fromAmino(object.summary);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.summary = message.summary ? CurationSummary.toAmino(message.summary) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryCurationSummaryResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryCurationSummaryResponse.decode(message.value);
+    },
+    toProto(message) {
+        return QueryCurationSummaryResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.collect.v1.QueryCurationSummaryResponse",
+            value: QueryCurationSummaryResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryCurationReviewsRequest() {
+    return {
+        collectionId: BigInt(0),
+        pagination: undefined
+    };
+}
+/**
+ * @name QueryCurationReviewsRequest
+ * @package sparkdream.collect.v1
+ * @see proto type: sparkdream.collect.v1.QueryCurationReviewsRequest
+ */
+export const QueryCurationReviewsRequest = {
+    typeUrl: "/sparkdream.collect.v1.QueryCurationReviewsRequest",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.collectionId !== BigInt(0)) {
+            writer.uint32(8).uint64(message.collectionId);
+        }
+        if (message.pagination !== undefined) {
+            PageRequest.encode(message.pagination, writer.uint32(18).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryCurationReviewsRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.collectionId = reader.uint64();
+                    break;
+                case 2:
+                    message.pagination = PageRequest.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryCurationReviewsRequest();
+        message.collectionId = object.collectionId !== undefined && object.collectionId !== null ? BigInt(object.collectionId.toString()) : BigInt(0);
+        message.pagination = object.pagination !== undefined && object.pagination !== null ? PageRequest.fromPartial(object.pagination) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryCurationReviewsRequest();
+        if (object.collection_id !== undefined && object.collection_id !== null) {
+            message.collectionId = BigInt(object.collection_id);
+        }
+        if (object.pagination !== undefined && object.pagination !== null) {
+            message.pagination = PageRequest.fromAmino(object.pagination);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.collection_id = message.collectionId !== BigInt(0) ? message.collectionId?.toString() : undefined;
+        obj.pagination = message.pagination ? PageRequest.toAmino(message.pagination) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryCurationReviewsRequest.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryCurationReviewsRequest.decode(message.value);
+    },
+    toProto(message) {
+        return QueryCurationReviewsRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.collect.v1.QueryCurationReviewsRequest",
+            value: QueryCurationReviewsRequest.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryCurationReviewsResponse() {
+    return {
+        reviews: [],
+        pagination: undefined
+    };
+}
+/**
+ * @name QueryCurationReviewsResponse
+ * @package sparkdream.collect.v1
+ * @see proto type: sparkdream.collect.v1.QueryCurationReviewsResponse
+ */
+export const QueryCurationReviewsResponse = {
+    typeUrl: "/sparkdream.collect.v1.QueryCurationReviewsResponse",
+    encode(message, writer = BinaryWriter.create()) {
+        for (const v of message.reviews) {
+            CurationReview.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 BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryCurationReviewsResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.reviews.push(CurationReview.decode(reader, reader.uint32()));
+                    break;
+                case 2:
+                    message.pagination = PageResponse.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryCurationReviewsResponse();
+        message.reviews = object.reviews?.map(e => CurationReview.fromPartial(e)) || [];
+        message.pagination = object.pagination !== undefined && object.pagination !== null ? PageResponse.fromPartial(object.pagination) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryCurationReviewsResponse();
+        message.reviews = object.reviews?.map(e => CurationReview.fromAmino(e)) || [];
+        if (object.pagination !== undefined && object.pagination !== null) {
+            message.pagination = PageResponse.fromAmino(object.pagination);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        if (message.reviews) {
+            obj.reviews = message.reviews.map(e => e ? CurationReview.toAmino(e) : undefined);
+        }
+        else {
+            obj.reviews = message.reviews;
+        }
+        obj.pagination = message.pagination ? PageResponse.toAmino(message.pagination) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryCurationReviewsResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryCurationReviewsResponse.decode(message.value);
+    },
+    toProto(message) {
+        return QueryCurationReviewsResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.collect.v1.QueryCurationReviewsResponse",
+            value: QueryCurationReviewsResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryCurationReviewsByCuratorRequest() {
+    return {
+        curator: "",
+        pagination: undefined
+    };
+}
+/**
+ * @name QueryCurationReviewsByCuratorRequest
+ * @package sparkdream.collect.v1
+ * @see proto type: sparkdream.collect.v1.QueryCurationReviewsByCuratorRequest
+ */
+export const QueryCurationReviewsByCuratorRequest = {
+    typeUrl: "/sparkdream.collect.v1.QueryCurationReviewsByCuratorRequest",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.curator !== "") {
+            writer.uint32(10).string(message.curator);
+        }
+        if (message.pagination !== undefined) {
+            PageRequest.encode(message.pagination, writer.uint32(18).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryCurationReviewsByCuratorRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.curator = reader.string();
+                    break;
+                case 2:
+                    message.pagination = PageRequest.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryCurationReviewsByCuratorRequest();
+        message.curator = object.curator ?? "";
+        message.pagination = object.pagination !== undefined && object.pagination !== null ? PageRequest.fromPartial(object.pagination) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryCurationReviewsByCuratorRequest();
+        if (object.curator !== undefined && object.curator !== null) {
+            message.curator = object.curator;
+        }
+        if (object.pagination !== undefined && object.pagination !== null) {
+            message.pagination = PageRequest.fromAmino(object.pagination);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.curator = message.curator === "" ? undefined : message.curator;
+        obj.pagination = message.pagination ? PageRequest.toAmino(message.pagination) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryCurationReviewsByCuratorRequest.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryCurationReviewsByCuratorRequest.decode(message.value);
+    },
+    toProto(message) {
+        return QueryCurationReviewsByCuratorRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.collect.v1.QueryCurationReviewsByCuratorRequest",
+            value: QueryCurationReviewsByCuratorRequest.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryCurationReviewsByCuratorResponse() {
+    return {
+        reviews: [],
+        pagination: undefined
+    };
+}
+/**
+ * @name QueryCurationReviewsByCuratorResponse
+ * @package sparkdream.collect.v1
+ * @see proto type: sparkdream.collect.v1.QueryCurationReviewsByCuratorResponse
+ */
+export const QueryCurationReviewsByCuratorResponse = {
+    typeUrl: "/sparkdream.collect.v1.QueryCurationReviewsByCuratorResponse",
+    encode(message, writer = BinaryWriter.create()) {
+        for (const v of message.reviews) {
+            CurationReview.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 BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryCurationReviewsByCuratorResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.reviews.push(CurationReview.decode(reader, reader.uint32()));
+                    break;
+                case 2:
+                    message.pagination = PageResponse.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryCurationReviewsByCuratorResponse();
+        message.reviews = object.reviews?.map(e => CurationReview.fromPartial(e)) || [];
+        message.pagination = object.pagination !== undefined && object.pagination !== null ? PageResponse.fromPartial(object.pagination) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryCurationReviewsByCuratorResponse();
+        message.reviews = object.reviews?.map(e => CurationReview.fromAmino(e)) || [];
+        if (object.pagination !== undefined && object.pagination !== null) {
+            message.pagination = PageResponse.fromAmino(object.pagination);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        if (message.reviews) {
+            obj.reviews = message.reviews.map(e => e ? CurationReview.toAmino(e) : undefined);
+        }
+        else {
+            obj.reviews = message.reviews;
+        }
+        obj.pagination = message.pagination ? PageResponse.toAmino(message.pagination) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryCurationReviewsByCuratorResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryCurationReviewsByCuratorResponse.decode(message.value);
+    },
+    toProto(message) {
+        return QueryCurationReviewsByCuratorResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.collect.v1.QueryCurationReviewsByCuratorResponse",
+            value: QueryCurationReviewsByCuratorResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseQuerySponsorshipRequestRequest() {
+    return {
+        collectionId: BigInt(0)
+    };
+}
+/**
+ * @name QuerySponsorshipRequestRequest
+ * @package sparkdream.collect.v1
+ * @see proto type: sparkdream.collect.v1.QuerySponsorshipRequestRequest
+ */
+export const QuerySponsorshipRequestRequest = {
+    typeUrl: "/sparkdream.collect.v1.QuerySponsorshipRequestRequest",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.collectionId !== BigInt(0)) {
+            writer.uint32(8).uint64(message.collectionId);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQuerySponsorshipRequestRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.collectionId = reader.uint64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQuerySponsorshipRequestRequest();
+        message.collectionId = object.collectionId !== undefined && object.collectionId !== null ? BigInt(object.collectionId.toString()) : BigInt(0);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQuerySponsorshipRequestRequest();
+        if (object.collection_id !== undefined && object.collection_id !== null) {
+            message.collectionId = BigInt(object.collection_id);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.collection_id = message.collectionId !== BigInt(0) ? message.collectionId?.toString() : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QuerySponsorshipRequestRequest.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QuerySponsorshipRequestRequest.decode(message.value);
+    },
+    toProto(message) {
+        return QuerySponsorshipRequestRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.collect.v1.QuerySponsorshipRequestRequest",
+            value: QuerySponsorshipRequestRequest.encode(message).finish()
+        };
+    }
+};
+function createBaseQuerySponsorshipRequestResponse() {
+    return {
+        sponsorshipRequest: SponsorshipRequest.fromPartial({})
+    };
+}
+/**
+ * @name QuerySponsorshipRequestResponse
+ * @package sparkdream.collect.v1
+ * @see proto type: sparkdream.collect.v1.QuerySponsorshipRequestResponse
+ */
+export const QuerySponsorshipRequestResponse = {
+    typeUrl: "/sparkdream.collect.v1.QuerySponsorshipRequestResponse",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.sponsorshipRequest !== undefined) {
+            SponsorshipRequest.encode(message.sponsorshipRequest, writer.uint32(10).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQuerySponsorshipRequestResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.sponsorshipRequest = SponsorshipRequest.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQuerySponsorshipRequestResponse();
+        message.sponsorshipRequest = object.sponsorshipRequest !== undefined && object.sponsorshipRequest !== null ? SponsorshipRequest.fromPartial(object.sponsorshipRequest) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQuerySponsorshipRequestResponse();
+        if (object.sponsorship_request !== undefined && object.sponsorship_request !== null) {
+            message.sponsorshipRequest = SponsorshipRequest.fromAmino(object.sponsorship_request);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.sponsorship_request = message.sponsorshipRequest ? SponsorshipRequest.toAmino(message.sponsorshipRequest) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QuerySponsorshipRequestResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QuerySponsorshipRequestResponse.decode(message.value);
+    },
+    toProto(message) {
+        return QuerySponsorshipRequestResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.collect.v1.QuerySponsorshipRequestResponse",
+            value: QuerySponsorshipRequestResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseQuerySponsorshipRequestsRequest() {
+    return {
+        pagination: undefined
+    };
+}
+/**
+ * @name QuerySponsorshipRequestsRequest
+ * @package sparkdream.collect.v1
+ * @see proto type: sparkdream.collect.v1.QuerySponsorshipRequestsRequest
+ */
+export const QuerySponsorshipRequestsRequest = {
+    typeUrl: "/sparkdream.collect.v1.QuerySponsorshipRequestsRequest",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.pagination !== undefined) {
+            PageRequest.encode(message.pagination, writer.uint32(10).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQuerySponsorshipRequestsRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.pagination = PageRequest.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQuerySponsorshipRequestsRequest();
+        message.pagination = object.pagination !== undefined && object.pagination !== null ? PageRequest.fromPartial(object.pagination) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQuerySponsorshipRequestsRequest();
+        if (object.pagination !== undefined && object.pagination !== null) {
+            message.pagination = PageRequest.fromAmino(object.pagination);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.pagination = message.pagination ? PageRequest.toAmino(message.pagination) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QuerySponsorshipRequestsRequest.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QuerySponsorshipRequestsRequest.decode(message.value);
+    },
+    toProto(message) {
+        return QuerySponsorshipRequestsRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.collect.v1.QuerySponsorshipRequestsRequest",
+            value: QuerySponsorshipRequestsRequest.encode(message).finish()
+        };
+    }
+};
+function createBaseQuerySponsorshipRequestsResponse() {
+    return {
+        sponsorshipRequests: [],
+        pagination: undefined
+    };
+}
+/**
+ * @name QuerySponsorshipRequestsResponse
+ * @package sparkdream.collect.v1
+ * @see proto type: sparkdream.collect.v1.QuerySponsorshipRequestsResponse
+ */
+export const QuerySponsorshipRequestsResponse = {
+    typeUrl: "/sparkdream.collect.v1.QuerySponsorshipRequestsResponse",
+    encode(message, writer = BinaryWriter.create()) {
+        for (const v of message.sponsorshipRequests) {
+            SponsorshipRequest.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 BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQuerySponsorshipRequestsResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.sponsorshipRequests.push(SponsorshipRequest.decode(reader, reader.uint32()));
+                    break;
+                case 2:
+                    message.pagination = PageResponse.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQuerySponsorshipRequestsResponse();
+        message.sponsorshipRequests = object.sponsorshipRequests?.map(e => SponsorshipRequest.fromPartial(e)) || [];
+        message.pagination = object.pagination !== undefined && object.pagination !== null ? PageResponse.fromPartial(object.pagination) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQuerySponsorshipRequestsResponse();
+        message.sponsorshipRequests = object.sponsorship_requests?.map(e => SponsorshipRequest.fromAmino(e)) || [];
+        if (object.pagination !== undefined && object.pagination !== null) {
+            message.pagination = PageResponse.fromAmino(object.pagination);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        if (message.sponsorshipRequests) {
+            obj.sponsorship_requests = message.sponsorshipRequests.map(e => e ? SponsorshipRequest.toAmino(e) : undefined);
+        }
+        else {
+            obj.sponsorship_requests = message.sponsorshipRequests;
+        }
+        obj.pagination = message.pagination ? PageResponse.toAmino(message.pagination) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QuerySponsorshipRequestsResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QuerySponsorshipRequestsResponse.decode(message.value);
+    },
+    toProto(message) {
+        return QuerySponsorshipRequestsResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.collect.v1.QuerySponsorshipRequestsResponse",
+            value: QuerySponsorshipRequestsResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryContentFlagRequest() {
+    return {
+        targetId: BigInt(0),
+        targetType: 0
+    };
+}
+/**
+ * QueryContentFlagRequest defines the QueryContentFlagRequest message.
+ * @name QueryContentFlagRequest
+ * @package sparkdream.collect.v1
+ * @see proto type: sparkdream.collect.v1.QueryContentFlagRequest
+ */
+export const QueryContentFlagRequest = {
+    typeUrl: "/sparkdream.collect.v1.QueryContentFlagRequest",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.targetId !== BigInt(0)) {
+            writer.uint32(8).uint64(message.targetId);
+        }
+        if (message.targetType !== 0) {
+            writer.uint32(16).int32(message.targetType);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryContentFlagRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.targetId = reader.uint64();
+                    break;
+                case 2:
+                    message.targetType = reader.int32();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryContentFlagRequest();
+        message.targetId = object.targetId !== undefined && object.targetId !== null ? BigInt(object.targetId.toString()) : BigInt(0);
+        message.targetType = object.targetType ?? 0;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryContentFlagRequest();
+        if (object.target_id !== undefined && object.target_id !== null) {
+            message.targetId = BigInt(object.target_id);
+        }
+        if (object.target_type !== undefined && object.target_type !== null) {
+            message.targetType = object.target_type;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.target_id = message.targetId !== BigInt(0) ? message.targetId?.toString() : undefined;
+        obj.target_type = message.targetType === 0 ? undefined : message.targetType;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryContentFlagRequest.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryContentFlagRequest.decode(message.value);
+    },
+    toProto(message) {
+        return QueryContentFlagRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.collect.v1.QueryContentFlagRequest",
+            value: QueryContentFlagRequest.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryContentFlagResponse() {
+    return {
+        collectionFlag: CollectionFlag.fromPartial({})
+    };
+}
+/**
+ * QueryContentFlagResponse defines the QueryContentFlagResponse message.
+ * @name QueryContentFlagResponse
+ * @package sparkdream.collect.v1
+ * @see proto type: sparkdream.collect.v1.QueryContentFlagResponse
+ */
+export const QueryContentFlagResponse = {
+    typeUrl: "/sparkdream.collect.v1.QueryContentFlagResponse",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.collectionFlag !== undefined) {
+            CollectionFlag.encode(message.collectionFlag, writer.uint32(10).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryContentFlagResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.collectionFlag = CollectionFlag.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryContentFlagResponse();
+        message.collectionFlag = object.collectionFlag !== undefined && object.collectionFlag !== null ? CollectionFlag.fromPartial(object.collectionFlag) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryContentFlagResponse();
+        if (object.collection_flag !== undefined && object.collection_flag !== null) {
+            message.collectionFlag = CollectionFlag.fromAmino(object.collection_flag);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.collection_flag = message.collectionFlag ? CollectionFlag.toAmino(message.collectionFlag) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryContentFlagResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryContentFlagResponse.decode(message.value);
+    },
+    toProto(message) {
+        return QueryContentFlagResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.collect.v1.QueryContentFlagResponse",
+            value: QueryContentFlagResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryFlaggedContentRequest() {
+    return {
+        pagination: undefined
+    };
+}
+/**
+ * QueryFlaggedContentRequest defines the QueryFlaggedContentRequest message.
+ * @name QueryFlaggedContentRequest
+ * @package sparkdream.collect.v1
+ * @see proto type: sparkdream.collect.v1.QueryFlaggedContentRequest
+ */
+export const QueryFlaggedContentRequest = {
+    typeUrl: "/sparkdream.collect.v1.QueryFlaggedContentRequest",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.pagination !== undefined) {
+            PageRequest.encode(message.pagination, writer.uint32(10).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryFlaggedContentRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.pagination = PageRequest.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryFlaggedContentRequest();
+        message.pagination = object.pagination !== undefined && object.pagination !== null ? PageRequest.fromPartial(object.pagination) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryFlaggedContentRequest();
+        if (object.pagination !== undefined && object.pagination !== null) {
+            message.pagination = PageRequest.fromAmino(object.pagination);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.pagination = message.pagination ? PageRequest.toAmino(message.pagination) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryFlaggedContentRequest.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryFlaggedContentRequest.decode(message.value);
+    },
+    toProto(message) {
+        return QueryFlaggedContentRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.collect.v1.QueryFlaggedContentRequest",
+            value: QueryFlaggedContentRequest.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryFlaggedContentResponse() {
+    return {
+        collectionFlags: [],
+        pagination: undefined
+    };
+}
+/**
+ * QueryFlaggedContentResponse defines the QueryFlaggedContentResponse message.
+ * @name QueryFlaggedContentResponse
+ * @package sparkdream.collect.v1
+ * @see proto type: sparkdream.collect.v1.QueryFlaggedContentResponse
+ */
+export const QueryFlaggedContentResponse = {
+    typeUrl: "/sparkdream.collect.v1.QueryFlaggedContentResponse",
+    encode(message, writer = BinaryWriter.create()) {
+        for (const v of message.collectionFlags) {
+            CollectionFlag.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 BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryFlaggedContentResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.collectionFlags.push(CollectionFlag.decode(reader, reader.uint32()));
+                    break;
+                case 2:
+                    message.pagination = PageResponse.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryFlaggedContentResponse();
+        message.collectionFlags = object.collectionFlags?.map(e => CollectionFlag.fromPartial(e)) || [];
+        message.pagination = object.pagination !== undefined && object.pagination !== null ? PageResponse.fromPartial(object.pagination) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryFlaggedContentResponse();
+        message.collectionFlags = object.collection_flags?.map(e => CollectionFlag.fromAmino(e)) || [];
+        if (object.pagination !== undefined && object.pagination !== null) {
+            message.pagination = PageResponse.fromAmino(object.pagination);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        if (message.collectionFlags) {
+            obj.collection_flags = message.collectionFlags.map(e => e ? CollectionFlag.toAmino(e) : undefined);
+        }
+        else {
+            obj.collection_flags = message.collectionFlags;
+        }
+        obj.pagination = message.pagination ? PageResponse.toAmino(message.pagination) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryFlaggedContentResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryFlaggedContentResponse.decode(message.value);
+    },
+    toProto(message) {
+        return QueryFlaggedContentResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.collect.v1.QueryFlaggedContentResponse",
+            value: QueryFlaggedContentResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryHideRecordRequest() {
+    return {
+        id: BigInt(0)
+    };
+}
+/**
+ * QueryHideRecordRequest defines the QueryHideRecordRequest message.
+ * @name QueryHideRecordRequest
+ * @package sparkdream.collect.v1
+ * @see proto type: sparkdream.collect.v1.QueryHideRecordRequest
+ */
+export const QueryHideRecordRequest = {
+    typeUrl: "/sparkdream.collect.v1.QueryHideRecordRequest",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.id !== BigInt(0)) {
+            writer.uint32(8).uint64(message.id);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryHideRecordRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.id = reader.uint64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryHideRecordRequest();
+        message.id = object.id !== undefined && object.id !== null ? BigInt(object.id.toString()) : BigInt(0);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryHideRecordRequest();
+        if (object.id !== undefined && object.id !== null) {
+            message.id = BigInt(object.id);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.id = message.id !== BigInt(0) ? message.id?.toString() : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryHideRecordRequest.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryHideRecordRequest.decode(message.value);
+    },
+    toProto(message) {
+        return QueryHideRecordRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.collect.v1.QueryHideRecordRequest",
+            value: QueryHideRecordRequest.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryHideRecordResponse() {
+    return {
+        hideRecord: HideRecord.fromPartial({})
+    };
+}
+/**
+ * QueryHideRecordResponse defines the QueryHideRecordResponse message.
+ * @name QueryHideRecordResponse
+ * @package sparkdream.collect.v1
+ * @see proto type: sparkdream.collect.v1.QueryHideRecordResponse
+ */
+export const QueryHideRecordResponse = {
+    typeUrl: "/sparkdream.collect.v1.QueryHideRecordResponse",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.hideRecord !== undefined) {
+            HideRecord.encode(message.hideRecord, writer.uint32(10).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryHideRecordResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.hideRecord = HideRecord.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryHideRecordResponse();
+        message.hideRecord = object.hideRecord !== undefined && object.hideRecord !== null ? HideRecord.fromPartial(object.hideRecord) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryHideRecordResponse();
+        if (object.hide_record !== undefined && object.hide_record !== null) {
+            message.hideRecord = HideRecord.fromAmino(object.hide_record);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.hide_record = message.hideRecord ? HideRecord.toAmino(message.hideRecord) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryHideRecordResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryHideRecordResponse.decode(message.value);
+    },
+    toProto(message) {
+        return QueryHideRecordResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.collect.v1.QueryHideRecordResponse",
+            value: QueryHideRecordResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryHideRecordsByTargetRequest() {
+    return {
+        targetId: BigInt(0),
+        targetType: 0
+    };
+}
+/**
+ * QueryHideRecordsByTargetRequest defines the QueryHideRecordsByTargetRequest message.
+ * @name QueryHideRecordsByTargetRequest
+ * @package sparkdream.collect.v1
+ * @see proto type: sparkdream.collect.v1.QueryHideRecordsByTargetRequest
+ */
+export const QueryHideRecordsByTargetRequest = {
+    typeUrl: "/sparkdream.collect.v1.QueryHideRecordsByTargetRequest",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.targetId !== BigInt(0)) {
+            writer.uint32(8).uint64(message.targetId);
+        }
+        if (message.targetType !== 0) {
+            writer.uint32(16).int32(message.targetType);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryHideRecordsByTargetRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.targetId = reader.uint64();
+                    break;
+                case 2:
+                    message.targetType = reader.int32();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryHideRecordsByTargetRequest();
+        message.targetId = object.targetId !== undefined && object.targetId !== null ? BigInt(object.targetId.toString()) : BigInt(0);
+        message.targetType = object.targetType ?? 0;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryHideRecordsByTargetRequest();
+        if (object.target_id !== undefined && object.target_id !== null) {
+            message.targetId = BigInt(object.target_id);
+        }
+        if (object.target_type !== undefined && object.target_type !== null) {
+            message.targetType = object.target_type;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.target_id = message.targetId !== BigInt(0) ? message.targetId?.toString() : undefined;
+        obj.target_type = message.targetType === 0 ? undefined : message.targetType;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryHideRecordsByTargetRequest.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryHideRecordsByTargetRequest.decode(message.value);
+    },
+    toProto(message) {
+        return QueryHideRecordsByTargetRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.collect.v1.QueryHideRecordsByTargetRequest",
+            value: QueryHideRecordsByTargetRequest.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryHideRecordsByTargetResponse() {
+    return {
+        hideRecords: []
+    };
+}
+/**
+ * QueryHideRecordsByTargetResponse defines the QueryHideRecordsByTargetResponse message.
+ * @name QueryHideRecordsByTargetResponse
+ * @package sparkdream.collect.v1
+ * @see proto type: sparkdream.collect.v1.QueryHideRecordsByTargetResponse
+ */
+export const QueryHideRecordsByTargetResponse = {
+    typeUrl: "/sparkdream.collect.v1.QueryHideRecordsByTargetResponse",
+    encode(message, writer = BinaryWriter.create()) {
+        for (const v of message.hideRecords) {
+            HideRecord.encode(v, writer.uint32(10).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryHideRecordsByTargetResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.hideRecords.push(HideRecord.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryHideRecordsByTargetResponse();
+        message.hideRecords = object.hideRecords?.map(e => HideRecord.fromPartial(e)) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryHideRecordsByTargetResponse();
+        message.hideRecords = object.hide_records?.map(e => HideRecord.fromAmino(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        if (message.hideRecords) {
+            obj.hide_records = message.hideRecords.map(e => e ? HideRecord.toAmino(e) : undefined);
+        }
+        else {
+            obj.hide_records = message.hideRecords;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryHideRecordsByTargetResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryHideRecordsByTargetResponse.decode(message.value);
+    },
+    toProto(message) {
+        return QueryHideRecordsByTargetResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.collect.v1.QueryHideRecordsByTargetResponse",
+            value: QueryHideRecordsByTargetResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryPendingCollectionsRequest() {
+    return {
+        pagination: undefined
+    };
+}
+/**
+ * QueryPendingCollectionsRequest defines the QueryPendingCollectionsRequest message.
+ * @name QueryPendingCollectionsRequest
+ * @package sparkdream.collect.v1
+ * @see proto type: sparkdream.collect.v1.QueryPendingCollectionsRequest
+ */
+export const QueryPendingCollectionsRequest = {
+    typeUrl: "/sparkdream.collect.v1.QueryPendingCollectionsRequest",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.pagination !== undefined) {
+            PageRequest.encode(message.pagination, writer.uint32(10).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryPendingCollectionsRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.pagination = PageRequest.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryPendingCollectionsRequest();
+        message.pagination = object.pagination !== undefined && object.pagination !== null ? PageRequest.fromPartial(object.pagination) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryPendingCollectionsRequest();
+        if (object.pagination !== undefined && object.pagination !== null) {
+            message.pagination = PageRequest.fromAmino(object.pagination);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.pagination = message.pagination ? PageRequest.toAmino(message.pagination) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryPendingCollectionsRequest.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryPendingCollectionsRequest.decode(message.value);
+    },
+    toProto(message) {
+        return QueryPendingCollectionsRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.collect.v1.QueryPendingCollectionsRequest",
+            value: QueryPendingCollectionsRequest.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryPendingCollectionsResponse() {
+    return {
+        collections: [],
+        pagination: undefined
+    };
+}
+/**
+ * QueryPendingCollectionsResponse defines the QueryPendingCollectionsResponse message.
+ * @name QueryPendingCollectionsResponse
+ * @package sparkdream.collect.v1
+ * @see proto type: sparkdream.collect.v1.QueryPendingCollectionsResponse
+ */
+export const QueryPendingCollectionsResponse = {
+    typeUrl: "/sparkdream.collect.v1.QueryPendingCollectionsResponse",
+    encode(message, writer = BinaryWriter.create()) {
+        for (const v of message.collections) {
+            Collection.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 BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryPendingCollectionsResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.collections.push(Collection.decode(reader, reader.uint32()));
+                    break;
+                case 2:
+                    message.pagination = PageResponse.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryPendingCollectionsResponse();
+        message.collections = object.collections?.map(e => Collection.fromPartial(e)) || [];
+        message.pagination = object.pagination !== undefined && object.pagination !== null ? PageResponse.fromPartial(object.pagination) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryPendingCollectionsResponse();
+        message.collections = object.collections?.map(e => Collection.fromAmino(e)) || [];
+        if (object.pagination !== undefined && object.pagination !== null) {
+            message.pagination = PageResponse.fromAmino(object.pagination);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        if (message.collections) {
+            obj.collections = message.collections.map(e => e ? Collection.toAmino(e) : undefined);
+        }
+        else {
+            obj.collections = message.collections;
+        }
+        obj.pagination = message.pagination ? PageResponse.toAmino(message.pagination) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryPendingCollectionsResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryPendingCollectionsResponse.decode(message.value);
+    },
+    toProto(message) {
+        return QueryPendingCollectionsResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.collect.v1.QueryPendingCollectionsResponse",
+            value: QueryPendingCollectionsResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryEndorsementRequest() {
+    return {
+        collectionId: BigInt(0)
+    };
+}
+/**
+ * QueryEndorsementRequest defines the QueryEndorsementRequest message.
+ * @name QueryEndorsementRequest
+ * @package sparkdream.collect.v1
+ * @see proto type: sparkdream.collect.v1.QueryEndorsementRequest
+ */
+export const QueryEndorsementRequest = {
+    typeUrl: "/sparkdream.collect.v1.QueryEndorsementRequest",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.collectionId !== BigInt(0)) {
+            writer.uint32(8).uint64(message.collectionId);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryEndorsementRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.collectionId = reader.uint64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryEndorsementRequest();
+        message.collectionId = object.collectionId !== undefined && object.collectionId !== null ? BigInt(object.collectionId.toString()) : BigInt(0);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryEndorsementRequest();
+        if (object.collection_id !== undefined && object.collection_id !== null) {
+            message.collectionId = BigInt(object.collection_id);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.collection_id = message.collectionId !== BigInt(0) ? message.collectionId?.toString() : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryEndorsementRequest.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryEndorsementRequest.decode(message.value);
+    },
+    toProto(message) {
+        return QueryEndorsementRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.collect.v1.QueryEndorsementRequest",
+            value: QueryEndorsementRequest.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryEndorsementResponse() {
+    return {
+        endorsement: Endorsement.fromPartial({})
+    };
+}
+/**
+ * QueryEndorsementResponse defines the QueryEndorsementResponse message.
+ * @name QueryEndorsementResponse
+ * @package sparkdream.collect.v1
+ * @see proto type: sparkdream.collect.v1.QueryEndorsementResponse
+ */
+export const QueryEndorsementResponse = {
+    typeUrl: "/sparkdream.collect.v1.QueryEndorsementResponse",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.endorsement !== undefined) {
+            Endorsement.encode(message.endorsement, writer.uint32(10).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryEndorsementResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.endorsement = Endorsement.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryEndorsementResponse();
+        message.endorsement = object.endorsement !== undefined && object.endorsement !== null ? Endorsement.fromPartial(object.endorsement) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryEndorsementResponse();
+        if (object.endorsement !== undefined && object.endorsement !== null) {
+            message.endorsement = Endorsement.fromAmino(object.endorsement);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.endorsement = message.endorsement ? Endorsement.toAmino(message.endorsement) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryEndorsementResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryEndorsementResponse.decode(message.value);
+    },
+    toProto(message) {
+        return QueryEndorsementResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.collect.v1.QueryEndorsementResponse",
+            value: QueryEndorsementResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryCollectionsByContentRequest() {
+    return {
+        module: "",
+        entityType: "",
+        entityId: "",
+        pagination: undefined
+    };
+}
+/**
+ * QueryCollectionsByContentRequest returns collections referencing on-chain content.
+ * @name QueryCollectionsByContentRequest
+ * @package sparkdream.collect.v1
+ * @see proto type: sparkdream.collect.v1.QueryCollectionsByContentRequest
+ */
+export const QueryCollectionsByContentRequest = {
+    typeUrl: "/sparkdream.collect.v1.QueryCollectionsByContentRequest",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.module !== "") {
+            writer.uint32(10).string(message.module);
+        }
+        if (message.entityType !== "") {
+            writer.uint32(18).string(message.entityType);
+        }
+        if (message.entityId !== "") {
+            writer.uint32(26).string(message.entityId);
+        }
+        if (message.pagination !== undefined) {
+            PageRequest.encode(message.pagination, writer.uint32(34).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryCollectionsByContentRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.module = reader.string();
+                    break;
+                case 2:
+                    message.entityType = reader.string();
+                    break;
+                case 3:
+                    message.entityId = reader.string();
+                    break;
+                case 4:
+                    message.pagination = PageRequest.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryCollectionsByContentRequest();
+        message.module = object.module ?? "";
+        message.entityType = object.entityType ?? "";
+        message.entityId = object.entityId ?? "";
+        message.pagination = object.pagination !== undefined && object.pagination !== null ? PageRequest.fromPartial(object.pagination) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryCollectionsByContentRequest();
+        if (object.module !== undefined && object.module !== null) {
+            message.module = object.module;
+        }
+        if (object.entity_type !== undefined && object.entity_type !== null) {
+            message.entityType = object.entity_type;
+        }
+        if (object.entity_id !== undefined && object.entity_id !== null) {
+            message.entityId = object.entity_id;
+        }
+        if (object.pagination !== undefined && object.pagination !== null) {
+            message.pagination = PageRequest.fromAmino(object.pagination);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.module = message.module === "" ? undefined : message.module;
+        obj.entity_type = message.entityType === "" ? undefined : message.entityType;
+        obj.entity_id = message.entityId === "" ? undefined : message.entityId;
+        obj.pagination = message.pagination ? PageRequest.toAmino(message.pagination) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryCollectionsByContentRequest.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryCollectionsByContentRequest.decode(message.value);
+    },
+    toProto(message) {
+        return QueryCollectionsByContentRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.collect.v1.QueryCollectionsByContentRequest",
+            value: QueryCollectionsByContentRequest.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryCollectionsByContentResponse() {
+    return {
+        collections: [],
+        pagination: undefined
+    };
+}
+/**
+ * QueryCollectionsByContentResponse is the response for CollectionsByContent.
+ * @name QueryCollectionsByContentResponse
+ * @package sparkdream.collect.v1
+ * @see proto type: sparkdream.collect.v1.QueryCollectionsByContentResponse
+ */
+export const QueryCollectionsByContentResponse = {
+    typeUrl: "/sparkdream.collect.v1.QueryCollectionsByContentResponse",
+    encode(message, writer = BinaryWriter.create()) {
+        for (const v of message.collections) {
+            Collection.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 BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryCollectionsByContentResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.collections.push(Collection.decode(reader, reader.uint32()));
+                    break;
+                case 2:
+                    message.pagination = PageResponse.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryCollectionsByContentResponse();
+        message.collections = object.collections?.map(e => Collection.fromPartial(e)) || [];
+        message.pagination = object.pagination !== undefined && object.pagination !== null ? PageResponse.fromPartial(object.pagination) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryCollectionsByContentResponse();
+        message.collections = object.collections?.map(e => Collection.fromAmino(e)) || [];
+        if (object.pagination !== undefined && object.pagination !== null) {
+            message.pagination = PageResponse.fromAmino(object.pagination);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        if (message.collections) {
+            obj.collections = message.collections.map(e => e ? Collection.toAmino(e) : undefined);
+        }
+        else {
+            obj.collections = message.collections;
+        }
+        obj.pagination = message.pagination ? PageResponse.toAmino(message.pagination) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryCollectionsByContentResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryCollectionsByContentResponse.decode(message.value);
+    },
+    toProto(message) {
+        return QueryCollectionsByContentResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.collect.v1.QueryCollectionsByContentResponse",
+            value: QueryCollectionsByContentResponse.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryCollectionConvictionRequest() {
+    return {
+        collectionId: BigInt(0)
+    };
+}
+/**
+ * QueryCollectionConvictionRequest defines the QueryCollectionConviction request.
+ * @name QueryCollectionConvictionRequest
+ * @package sparkdream.collect.v1
+ * @see proto type: sparkdream.collect.v1.QueryCollectionConvictionRequest
+ */
+export const QueryCollectionConvictionRequest = {
+    typeUrl: "/sparkdream.collect.v1.QueryCollectionConvictionRequest",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.collectionId !== BigInt(0)) {
+            writer.uint32(8).uint64(message.collectionId);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryCollectionConvictionRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.collectionId = reader.uint64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryCollectionConvictionRequest();
+        message.collectionId = object.collectionId !== undefined && object.collectionId !== null ? BigInt(object.collectionId.toString()) : BigInt(0);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryCollectionConvictionRequest();
+        if (object.collection_id !== undefined && object.collection_id !== null) {
+            message.collectionId = BigInt(object.collection_id);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.collection_id = message.collectionId !== BigInt(0) ? message.collectionId?.toString() : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryCollectionConvictionRequest.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryCollectionConvictionRequest.decode(message.value);
+    },
+    toProto(message) {
+        return QueryCollectionConvictionRequest.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.collect.v1.QueryCollectionConvictionRequest",
+            value: QueryCollectionConvictionRequest.encode(message).finish()
+        };
+    }
+};
+function createBaseQueryCollectionConvictionResponse() {
+    return {
+        convictionScore: "",
+        stakeCount: 0,
+        totalStaked: "",
+        authorBond: ""
+    };
+}
+/**
+ * QueryCollectionConvictionResponse defines the QueryCollectionConviction response.
+ * @name QueryCollectionConvictionResponse
+ * @package sparkdream.collect.v1
+ * @see proto type: sparkdream.collect.v1.QueryCollectionConvictionResponse
+ */
+export const QueryCollectionConvictionResponse = {
+    typeUrl: "/sparkdream.collect.v1.QueryCollectionConvictionResponse",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.convictionScore !== "") {
+            writer.uint32(10).string(Decimal.fromUserInput(message.convictionScore, 18).atomics);
+        }
+        if (message.stakeCount !== 0) {
+            writer.uint32(16).uint32(message.stakeCount);
+        }
+        if (message.totalStaked !== "") {
+            writer.uint32(26).string(message.totalStaked);
+        }
+        if (message.authorBond !== "") {
+            writer.uint32(34).string(message.authorBond);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseQueryCollectionConvictionResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.convictionScore = Decimal.fromAtomics(reader.string(), 18).toString();
+                    break;
+                case 2:
+                    message.stakeCount = reader.uint32();
+                    break;
+                case 3:
+                    message.totalStaked = reader.string();
+                    break;
+                case 4:
+                    message.authorBond = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseQueryCollectionConvictionResponse();
+        message.convictionScore = object.convictionScore ?? "";
+        message.stakeCount = object.stakeCount ?? 0;
+        message.totalStaked = object.totalStaked ?? "";
+        message.authorBond = object.authorBond ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseQueryCollectionConvictionResponse();
+        if (object.conviction_score !== undefined && object.conviction_score !== null) {
+            message.convictionScore = object.conviction_score;
+        }
+        if (object.stake_count !== undefined && object.stake_count !== null) {
+            message.stakeCount = object.stake_count;
+        }
+        if (object.total_staked !== undefined && object.total_staked !== null) {
+            message.totalStaked = object.total_staked;
+        }
+        if (object.author_bond !== undefined && object.author_bond !== null) {
+            message.authorBond = object.author_bond;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.conviction_score = message.convictionScore === "" ? undefined : message.convictionScore;
+        obj.stake_count = message.stakeCount === 0 ? undefined : message.stakeCount;
+        obj.total_staked = message.totalStaked === "" ? undefined : message.totalStaked;
+        obj.author_bond = message.authorBond === "" ? undefined : message.authorBond;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return QueryCollectionConvictionResponse.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return QueryCollectionConvictionResponse.decode(message.value);
+    },
+    toProto(message) {
+        return QueryCollectionConvictionResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.collect.v1.QueryCollectionConvictionResponse",
+            value: QueryCollectionConvictionResponse.encode(message).finish()
+        };
+    }
+};