@sparkdreamnft/sparkdreamjs 0.0.7 → 0.0.8

package/esm/sparkdream/common/v1/content_type.js

@@ -0,0 +1,96 @@
+//@ts-nocheck
+/**
+ * ContentType tells the frontend how to interpret post content.
+ * On-chain text types (0-9) are human-readable strings.
+ * On-chain compressed types (10-19) are base64-encoded binary strings.
+ * Off-chain reference types (20+) are URI/hash strings.
+ */
+export var ContentType;
+(function (ContentType) {
+    ContentType[ContentType["CONTENT_TYPE_UNSPECIFIED"] = 0] = "CONTENT_TYPE_UNSPECIFIED";
+    /** CONTENT_TYPE_TEXT - On-chain text formats (human-readable strings) */
+    ContentType[ContentType["CONTENT_TYPE_TEXT"] = 1] = "CONTENT_TYPE_TEXT";
+    /** CONTENT_TYPE_HTML - HTML content */
+    ContentType[ContentType["CONTENT_TYPE_HTML"] = 2] = "CONTENT_TYPE_HTML";
+    /** CONTENT_TYPE_MARKDOWN - Markdown content */
+    ContentType[ContentType["CONTENT_TYPE_MARKDOWN"] = 3] = "CONTENT_TYPE_MARKDOWN";
+    /** CONTENT_TYPE_GZIP - On-chain compressed formats (base64-encoded strings) */
+    ContentType[ContentType["CONTENT_TYPE_GZIP"] = 10] = "CONTENT_TYPE_GZIP";
+    /** CONTENT_TYPE_ZSTD - Zstandard-compressed (frontend decompresses) */
+    ContentType[ContentType["CONTENT_TYPE_ZSTD"] = 11] = "CONTENT_TYPE_ZSTD";
+    /** CONTENT_TYPE_IPFS - Off-chain references (hash/CID strings) */
+    ContentType[ContentType["CONTENT_TYPE_IPFS"] = 20] = "CONTENT_TYPE_IPFS";
+    /** CONTENT_TYPE_ARWEAVE - Arweave TX ID (frontend fetches from Arweave gateway) */
+    ContentType[ContentType["CONTENT_TYPE_ARWEAVE"] = 21] = "CONTENT_TYPE_ARWEAVE";
+    /** CONTENT_TYPE_FILECOIN - Filecoin CID (frontend fetches from Filecoin gateway) */
+    ContentType[ContentType["CONTENT_TYPE_FILECOIN"] = 22] = "CONTENT_TYPE_FILECOIN";
+    /** CONTENT_TYPE_JACKAL - Jackal FID (frontend fetches from Jackal gateway) */
+    ContentType[ContentType["CONTENT_TYPE_JACKAL"] = 23] = "CONTENT_TYPE_JACKAL";
+    ContentType[ContentType["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(ContentType || (ContentType = {}));
+export const ContentTypeAmino = ContentType;
+export function contentTypeFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "CONTENT_TYPE_UNSPECIFIED":
+            return ContentType.CONTENT_TYPE_UNSPECIFIED;
+        case 1:
+        case "CONTENT_TYPE_TEXT":
+            return ContentType.CONTENT_TYPE_TEXT;
+        case 2:
+        case "CONTENT_TYPE_HTML":
+            return ContentType.CONTENT_TYPE_HTML;
+        case 3:
+        case "CONTENT_TYPE_MARKDOWN":
+            return ContentType.CONTENT_TYPE_MARKDOWN;
+        case 10:
+        case "CONTENT_TYPE_GZIP":
+            return ContentType.CONTENT_TYPE_GZIP;
+        case 11:
+        case "CONTENT_TYPE_ZSTD":
+            return ContentType.CONTENT_TYPE_ZSTD;
+        case 20:
+        case "CONTENT_TYPE_IPFS":
+            return ContentType.CONTENT_TYPE_IPFS;
+        case 21:
+        case "CONTENT_TYPE_ARWEAVE":
+            return ContentType.CONTENT_TYPE_ARWEAVE;
+        case 22:
+        case "CONTENT_TYPE_FILECOIN":
+            return ContentType.CONTENT_TYPE_FILECOIN;
+        case 23:
+        case "CONTENT_TYPE_JACKAL":
+            return ContentType.CONTENT_TYPE_JACKAL;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return ContentType.UNRECOGNIZED;
+    }
+}
+export function contentTypeToJSON(object) {
+    switch (object) {
+        case ContentType.CONTENT_TYPE_UNSPECIFIED:
+            return "CONTENT_TYPE_UNSPECIFIED";
+        case ContentType.CONTENT_TYPE_TEXT:
+            return "CONTENT_TYPE_TEXT";
+        case ContentType.CONTENT_TYPE_HTML:
+            return "CONTENT_TYPE_HTML";
+        case ContentType.CONTENT_TYPE_MARKDOWN:
+            return "CONTENT_TYPE_MARKDOWN";
+        case ContentType.CONTENT_TYPE_GZIP:
+            return "CONTENT_TYPE_GZIP";
+        case ContentType.CONTENT_TYPE_ZSTD:
+            return "CONTENT_TYPE_ZSTD";
+        case ContentType.CONTENT_TYPE_IPFS:
+            return "CONTENT_TYPE_IPFS";
+        case ContentType.CONTENT_TYPE_ARWEAVE:
+            return "CONTENT_TYPE_ARWEAVE";
+        case ContentType.CONTENT_TYPE_FILECOIN:
+            return "CONTENT_TYPE_FILECOIN";
+        case ContentType.CONTENT_TYPE_JACKAL:
+            return "CONTENT_TYPE_JACKAL";
+        case ContentType.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}

package/esm/sparkdream/common/v1/flag_record.js

@@ -0,0 +1,119 @@
+import { BinaryReader, BinaryWriter } from "../../../binary";
+function createBaseFlagRecord() {
+    return {
+        flagger: "",
+        reason: 0,
+        reasonText: "",
+        flaggedAt: BigInt(0),
+        weight: ""
+    };
+}
+/**
+ * FlagRecord records a single member's flag on a piece of content.
+ * Shared across modules (x/forum, x/collect) for consistent moderation records.
+ * @name FlagRecord
+ * @package sparkdream.common.v1
+ * @see proto type: sparkdream.common.v1.FlagRecord
+ */
+export const FlagRecord = {
+    typeUrl: "/sparkdream.common.v1.FlagRecord",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.flagger !== "") {
+            writer.uint32(10).string(message.flagger);
+        }
+        if (message.reason !== 0) {
+            writer.uint32(16).int32(message.reason);
+        }
+        if (message.reasonText !== "") {
+            writer.uint32(26).string(message.reasonText);
+        }
+        if (message.flaggedAt !== BigInt(0)) {
+            writer.uint32(32).int64(message.flaggedAt);
+        }
+        if (message.weight !== "") {
+            writer.uint32(42).string(message.weight);
+        }
+        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 = createBaseFlagRecord();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.flagger = reader.string();
+                    break;
+                case 2:
+                    message.reason = reader.int32();
+                    break;
+                case 3:
+                    message.reasonText = reader.string();
+                    break;
+                case 4:
+                    message.flaggedAt = reader.int64();
+                    break;
+                case 5:
+                    message.weight = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseFlagRecord();
+        message.flagger = object.flagger ?? "";
+        message.reason = object.reason ?? 0;
+        message.reasonText = object.reasonText ?? "";
+        message.flaggedAt = object.flaggedAt !== undefined && object.flaggedAt !== null ? BigInt(object.flaggedAt.toString()) : BigInt(0);
+        message.weight = object.weight ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseFlagRecord();
+        if (object.flagger !== undefined && object.flagger !== null) {
+            message.flagger = object.flagger;
+        }
+        if (object.reason !== undefined && object.reason !== null) {
+            message.reason = object.reason;
+        }
+        if (object.reason_text !== undefined && object.reason_text !== null) {
+            message.reasonText = object.reason_text;
+        }
+        if (object.flagged_at !== undefined && object.flagged_at !== null) {
+            message.flaggedAt = BigInt(object.flagged_at);
+        }
+        if (object.weight !== undefined && object.weight !== null) {
+            message.weight = object.weight;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.flagger = message.flagger === "" ? undefined : message.flagger;
+        obj.reason = message.reason === 0 ? undefined : message.reason;
+        obj.reason_text = message.reasonText === "" ? undefined : message.reasonText;
+        obj.flagged_at = message.flaggedAt !== BigInt(0) ? message.flaggedAt?.toString() : undefined;
+        obj.weight = message.weight === "" ? undefined : message.weight;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return FlagRecord.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return FlagRecord.decode(message.value);
+    },
+    toProto(message) {
+        return FlagRecord.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.common.v1.FlagRecord",
+            value: FlagRecord.encode(message).finish()
+        };
+    }
+};

package/esm/sparkdream/common/v1/moderation_reason.js

@@ -0,0 +1,115 @@
+//@ts-nocheck
+/**
+ * ModerationReason defines the reason for flagging or hiding content.
+ * Shared across modules (x/forum, x/collect) for consistent moderation vocabulary.
+ */
+export var ModerationReason;
+(function (ModerationReason) {
+    ModerationReason[ModerationReason["MODERATION_REASON_UNSPECIFIED"] = 0] = "MODERATION_REASON_UNSPECIFIED";
+    /** MODERATION_REASON_SPAM - Unsolicited commercial content, repetitive posts */
+    ModerationReason[ModerationReason["MODERATION_REASON_SPAM"] = 1] = "MODERATION_REASON_SPAM";
+    /** MODERATION_REASON_HARASSMENT - Personal attacks, bullying, threats */
+    ModerationReason[ModerationReason["MODERATION_REASON_HARASSMENT"] = 2] = "MODERATION_REASON_HARASSMENT";
+    /** MODERATION_REASON_MISINFORMATION - False claims, misleading content */
+    ModerationReason[ModerationReason["MODERATION_REASON_MISINFORMATION"] = 3] = "MODERATION_REASON_MISINFORMATION";
+    /** MODERATION_REASON_OFF_TOPIC - Content unrelated to category/thread */
+    ModerationReason[ModerationReason["MODERATION_REASON_OFF_TOPIC"] = 4] = "MODERATION_REASON_OFF_TOPIC";
+    /** MODERATION_REASON_LOW_QUALITY - Low-effort posts, unclear content */
+    ModerationReason[ModerationReason["MODERATION_REASON_LOW_QUALITY"] = 5] = "MODERATION_REASON_LOW_QUALITY";
+    /** MODERATION_REASON_INAPPROPRIATE - Adult content, graphic material */
+    ModerationReason[ModerationReason["MODERATION_REASON_INAPPROPRIATE"] = 6] = "MODERATION_REASON_INAPPROPRIATE";
+    /** MODERATION_REASON_IMPERSONATION - Pretending to be someone else */
+    ModerationReason[ModerationReason["MODERATION_REASON_IMPERSONATION"] = 7] = "MODERATION_REASON_IMPERSONATION";
+    /** MODERATION_REASON_POLICY_VIOLATION - Violates community guidelines */
+    ModerationReason[ModerationReason["MODERATION_REASON_POLICY_VIOLATION"] = 8] = "MODERATION_REASON_POLICY_VIOLATION";
+    /** MODERATION_REASON_DUPLICATE - Duplicate/cross-posted content */
+    ModerationReason[ModerationReason["MODERATION_REASON_DUPLICATE"] = 9] = "MODERATION_REASON_DUPLICATE";
+    /** MODERATION_REASON_SCAM - Fraudulent content, phishing attempts */
+    ModerationReason[ModerationReason["MODERATION_REASON_SCAM"] = 10] = "MODERATION_REASON_SCAM";
+    /** MODERATION_REASON_COPYRIGHT - Copyright infringement */
+    ModerationReason[ModerationReason["MODERATION_REASON_COPYRIGHT"] = 11] = "MODERATION_REASON_COPYRIGHT";
+    /** MODERATION_REASON_OTHER - Requires custom reason field */
+    ModerationReason[ModerationReason["MODERATION_REASON_OTHER"] = 12] = "MODERATION_REASON_OTHER";
+    ModerationReason[ModerationReason["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(ModerationReason || (ModerationReason = {}));
+export const ModerationReasonAmino = ModerationReason;
+export function moderationReasonFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "MODERATION_REASON_UNSPECIFIED":
+            return ModerationReason.MODERATION_REASON_UNSPECIFIED;
+        case 1:
+        case "MODERATION_REASON_SPAM":
+            return ModerationReason.MODERATION_REASON_SPAM;
+        case 2:
+        case "MODERATION_REASON_HARASSMENT":
+            return ModerationReason.MODERATION_REASON_HARASSMENT;
+        case 3:
+        case "MODERATION_REASON_MISINFORMATION":
+            return ModerationReason.MODERATION_REASON_MISINFORMATION;
+        case 4:
+        case "MODERATION_REASON_OFF_TOPIC":
+            return ModerationReason.MODERATION_REASON_OFF_TOPIC;
+        case 5:
+        case "MODERATION_REASON_LOW_QUALITY":
+            return ModerationReason.MODERATION_REASON_LOW_QUALITY;
+        case 6:
+        case "MODERATION_REASON_INAPPROPRIATE":
+            return ModerationReason.MODERATION_REASON_INAPPROPRIATE;
+        case 7:
+        case "MODERATION_REASON_IMPERSONATION":
+            return ModerationReason.MODERATION_REASON_IMPERSONATION;
+        case 8:
+        case "MODERATION_REASON_POLICY_VIOLATION":
+            return ModerationReason.MODERATION_REASON_POLICY_VIOLATION;
+        case 9:
+        case "MODERATION_REASON_DUPLICATE":
+            return ModerationReason.MODERATION_REASON_DUPLICATE;
+        case 10:
+        case "MODERATION_REASON_SCAM":
+            return ModerationReason.MODERATION_REASON_SCAM;
+        case 11:
+        case "MODERATION_REASON_COPYRIGHT":
+            return ModerationReason.MODERATION_REASON_COPYRIGHT;
+        case 12:
+        case "MODERATION_REASON_OTHER":
+            return ModerationReason.MODERATION_REASON_OTHER;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return ModerationReason.UNRECOGNIZED;
+    }
+}
+export function moderationReasonToJSON(object) {
+    switch (object) {
+        case ModerationReason.MODERATION_REASON_UNSPECIFIED:
+            return "MODERATION_REASON_UNSPECIFIED";
+        case ModerationReason.MODERATION_REASON_SPAM:
+            return "MODERATION_REASON_SPAM";
+        case ModerationReason.MODERATION_REASON_HARASSMENT:
+            return "MODERATION_REASON_HARASSMENT";
+        case ModerationReason.MODERATION_REASON_MISINFORMATION:
+            return "MODERATION_REASON_MISINFORMATION";
+        case ModerationReason.MODERATION_REASON_OFF_TOPIC:
+            return "MODERATION_REASON_OFF_TOPIC";
+        case ModerationReason.MODERATION_REASON_LOW_QUALITY:
+            return "MODERATION_REASON_LOW_QUALITY";
+        case ModerationReason.MODERATION_REASON_INAPPROPRIATE:
+            return "MODERATION_REASON_INAPPROPRIATE";
+        case ModerationReason.MODERATION_REASON_IMPERSONATION:
+            return "MODERATION_REASON_IMPERSONATION";
+        case ModerationReason.MODERATION_REASON_POLICY_VIOLATION:
+            return "MODERATION_REASON_POLICY_VIOLATION";
+        case ModerationReason.MODERATION_REASON_DUPLICATE:
+            return "MODERATION_REASON_DUPLICATE";
+        case ModerationReason.MODERATION_REASON_SCAM:
+            return "MODERATION_REASON_SCAM";
+        case ModerationReason.MODERATION_REASON_COPYRIGHT:
+            return "MODERATION_REASON_COPYRIGHT";
+        case ModerationReason.MODERATION_REASON_OTHER:
+            return "MODERATION_REASON_OTHER";
+        case ModerationReason.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}

package/esm/sparkdream/common/v1/reserved_tag.js

@@ -0,0 +1,96 @@
+//@ts-nocheck
+import { BinaryReader, BinaryWriter } from "../../../binary";
+function createBaseReservedTag() {
+    return {
+        name: "",
+        authority: "",
+        membersCanUse: false
+    };
+}
+/**
+ * ReservedTag defines a tag reserved by authority (governance or council).
+ * Storage is owned by x/forum; other modules check reservation via the TagKeeper interface.
+ * @name ReservedTag
+ * @package sparkdream.common.v1
+ * @see proto type: sparkdream.common.v1.ReservedTag
+ */
+export const ReservedTag = {
+    typeUrl: "/sparkdream.common.v1.ReservedTag",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.name !== "") {
+            writer.uint32(10).string(message.name);
+        }
+        if (message.authority !== "") {
+            writer.uint32(18).string(message.authority);
+        }
+        if (message.membersCanUse === true) {
+            writer.uint32(24).bool(message.membersCanUse);
+        }
+        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 = createBaseReservedTag();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.name = reader.string();
+                    break;
+                case 2:
+                    message.authority = reader.string();
+                    break;
+                case 3:
+                    message.membersCanUse = reader.bool();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseReservedTag();
+        message.name = object.name ?? "";
+        message.authority = object.authority ?? "";
+        message.membersCanUse = object.membersCanUse ?? false;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseReservedTag();
+        if (object.name !== undefined && object.name !== null) {
+            message.name = object.name;
+        }
+        if (object.authority !== undefined && object.authority !== null) {
+            message.authority = object.authority;
+        }
+        if (object.members_can_use !== undefined && object.members_can_use !== null) {
+            message.membersCanUse = object.members_can_use;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.name = message.name === "" ? undefined : message.name;
+        obj.authority = message.authority === "" ? undefined : message.authority;
+        obj.members_can_use = message.membersCanUse === false ? undefined : message.membersCanUse;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return ReservedTag.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return ReservedTag.decode(message.value);
+    },
+    toProto(message) {
+        return ReservedTag.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.common.v1.ReservedTag",
+            value: ReservedTag.encode(message).finish()
+        };
+    }
+};

package/esm/sparkdream/common/v1/tag.js

@@ -0,0 +1,120 @@
+//@ts-nocheck
+import { BinaryReader, BinaryWriter } from "../../../binary";
+function createBaseTag() {
+    return {
+        name: "",
+        usageCount: BigInt(0),
+        createdAt: BigInt(0),
+        lastUsedAt: BigInt(0),
+        expirationIndex: BigInt(0)
+    };
+}
+/**
+ * Tag defines a content-tagging label shared across modules.
+ * Storage is owned by x/forum; other modules access tags via the TagKeeper interface.
+ * @name Tag
+ * @package sparkdream.common.v1
+ * @see proto type: sparkdream.common.v1.Tag
+ */
+export const Tag = {
+    typeUrl: "/sparkdream.common.v1.Tag",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.name !== "") {
+            writer.uint32(10).string(message.name);
+        }
+        if (message.usageCount !== BigInt(0)) {
+            writer.uint32(16).uint64(message.usageCount);
+        }
+        if (message.createdAt !== BigInt(0)) {
+            writer.uint32(24).int64(message.createdAt);
+        }
+        if (message.lastUsedAt !== BigInt(0)) {
+            writer.uint32(32).int64(message.lastUsedAt);
+        }
+        if (message.expirationIndex !== BigInt(0)) {
+            writer.uint32(40).int64(message.expirationIndex);
+        }
+        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 = createBaseTag();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.name = reader.string();
+                    break;
+                case 2:
+                    message.usageCount = reader.uint64();
+                    break;
+                case 3:
+                    message.createdAt = reader.int64();
+                    break;
+                case 4:
+                    message.lastUsedAt = reader.int64();
+                    break;
+                case 5:
+                    message.expirationIndex = reader.int64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseTag();
+        message.name = object.name ?? "";
+        message.usageCount = object.usageCount !== undefined && object.usageCount !== null ? BigInt(object.usageCount.toString()) : BigInt(0);
+        message.createdAt = object.createdAt !== undefined && object.createdAt !== null ? BigInt(object.createdAt.toString()) : BigInt(0);
+        message.lastUsedAt = object.lastUsedAt !== undefined && object.lastUsedAt !== null ? BigInt(object.lastUsedAt.toString()) : BigInt(0);
+        message.expirationIndex = object.expirationIndex !== undefined && object.expirationIndex !== null ? BigInt(object.expirationIndex.toString()) : BigInt(0);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseTag();
+        if (object.name !== undefined && object.name !== null) {
+            message.name = object.name;
+        }
+        if (object.usage_count !== undefined && object.usage_count !== null) {
+            message.usageCount = BigInt(object.usage_count);
+        }
+        if (object.created_at !== undefined && object.created_at !== null) {
+            message.createdAt = BigInt(object.created_at);
+        }
+        if (object.last_used_at !== undefined && object.last_used_at !== null) {
+            message.lastUsedAt = BigInt(object.last_used_at);
+        }
+        if (object.expiration_index !== undefined && object.expiration_index !== null) {
+            message.expirationIndex = BigInt(object.expiration_index);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.name = message.name === "" ? undefined : message.name;
+        obj.usage_count = message.usageCount !== BigInt(0) ? message.usageCount?.toString() : undefined;
+        obj.created_at = message.createdAt !== BigInt(0) ? message.createdAt?.toString() : undefined;
+        obj.last_used_at = message.lastUsedAt !== BigInt(0) ? message.lastUsedAt?.toString() : undefined;
+        obj.expiration_index = message.expirationIndex !== BigInt(0) ? message.expirationIndex?.toString() : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return Tag.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return Tag.decode(message.value);
+    },
+    toProto(message) {
+        return Tag.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.common.v1.Tag",
+            value: Tag.encode(message).finish()
+        };
+    }
+};

package/esm/sparkdream/commons/module/v1/module.js

@@ -0,0 +1,71 @@
+//@ts-nocheck
+import { BinaryReader, BinaryWriter } from "../../../../binary";
+function createBaseModule() {
+    return {
+        authority: ""
+    };
+}
+/**
+ * Module is the config object for the module.
+ * @name Module
+ * @package sparkdream.commons.module.v1
+ * @see proto type: sparkdream.commons.module.v1.Module
+ */
+export const Module = {
+    typeUrl: "/sparkdream.commons.module.v1.Module",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.authority !== "") {
+            writer.uint32(10).string(message.authority);
+        }
+        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 = createBaseModule();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.authority = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseModule();
+        message.authority = object.authority ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseModule();
+        if (object.authority !== undefined && object.authority !== null) {
+            message.authority = object.authority;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.authority = message.authority === "" ? undefined : message.authority;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return Module.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return Module.decode(message.value);
+    },
+    toProto(message) {
+        return Module.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.commons.module.v1.Module",
+            value: Module.encode(message).finish()
+        };
+    }
+};