@sparkdreamnft/sparkdreamjs 0.0.7 → 0.0.9

package/sparkdream/forum/v1/thread_lock_record.d.ts

@@ -0,0 +1,60 @@
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+/**
+ * ThreadLockRecord defines the ThreadLockRecord message.
+ * @name ThreadLockRecord
+ * @package sparkdream.forum.v1
+ * @see proto type: sparkdream.forum.v1.ThreadLockRecord
+ */
+export interface ThreadLockRecord {
+    rootId: bigint;
+    sentinel: string;
+    lockedAt: bigint;
+    sentinelBondSnapshot: string;
+    sentinelBackingSnapshot: string;
+    lockReason: string;
+    appealPending: boolean;
+    initiativeId: bigint;
+}
+export interface ThreadLockRecordProtoMsg {
+    typeUrl: "/sparkdream.forum.v1.ThreadLockRecord";
+    value: Uint8Array;
+}
+/**
+ * ThreadLockRecord defines the ThreadLockRecord message.
+ * @name ThreadLockRecordAmino
+ * @package sparkdream.forum.v1
+ * @see proto type: sparkdream.forum.v1.ThreadLockRecord
+ */
+export interface ThreadLockRecordAmino {
+    root_id?: string;
+    sentinel?: string;
+    locked_at?: string;
+    sentinel_bond_snapshot?: string;
+    sentinel_backing_snapshot?: string;
+    lock_reason?: string;
+    appeal_pending?: boolean;
+    initiative_id?: string;
+}
+export interface ThreadLockRecordAminoMsg {
+    type: "/sparkdream.forum.v1.ThreadLockRecord";
+    value: ThreadLockRecordAmino;
+}
+/**
+ * ThreadLockRecord defines the ThreadLockRecord message.
+ * @name ThreadLockRecord
+ * @package sparkdream.forum.v1
+ * @see proto type: sparkdream.forum.v1.ThreadLockRecord
+ */
+export declare const ThreadLockRecord: {
+    typeUrl: string;
+    encode(message: ThreadLockRecord, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): ThreadLockRecord;
+    fromPartial(object: DeepPartial<ThreadLockRecord>): ThreadLockRecord;
+    fromAmino(object: ThreadLockRecordAmino): ThreadLockRecord;
+    toAmino(message: ThreadLockRecord): ThreadLockRecordAmino;
+    fromAminoMsg(object: ThreadLockRecordAminoMsg): ThreadLockRecord;
+    fromProtoMsg(message: ThreadLockRecordProtoMsg): ThreadLockRecord;
+    toProto(message: ThreadLockRecord): Uint8Array;
+    toProtoMsg(message: ThreadLockRecord): ThreadLockRecordProtoMsg;
+};

package/sparkdream/forum/v1/thread_lock_record.js

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ThreadLockRecord = void 0;
+//@ts-nocheck
+const binary_1 = require("../../../binary");
+function createBaseThreadLockRecord() {
+    return {
+        rootId: BigInt(0),
+        sentinel: "",
+        lockedAt: BigInt(0),
+        sentinelBondSnapshot: "",
+        sentinelBackingSnapshot: "",
+        lockReason: "",
+        appealPending: false,
+        initiativeId: BigInt(0)
+    };
+}
+/**
+ * ThreadLockRecord defines the ThreadLockRecord message.
+ * @name ThreadLockRecord
+ * @package sparkdream.forum.v1
+ * @see proto type: sparkdream.forum.v1.ThreadLockRecord
+ */
+exports.ThreadLockRecord = {
+    typeUrl: "/sparkdream.forum.v1.ThreadLockRecord",
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.rootId !== BigInt(0)) {
+            writer.uint32(8).uint64(message.rootId);
+        }
+        if (message.sentinel !== "") {
+            writer.uint32(18).string(message.sentinel);
+        }
+        if (message.lockedAt !== BigInt(0)) {
+            writer.uint32(24).int64(message.lockedAt);
+        }
+        if (message.sentinelBondSnapshot !== "") {
+            writer.uint32(34).string(message.sentinelBondSnapshot);
+        }
+        if (message.sentinelBackingSnapshot !== "") {
+            writer.uint32(42).string(message.sentinelBackingSnapshot);
+        }
+        if (message.lockReason !== "") {
+            writer.uint32(50).string(message.lockReason);
+        }
+        if (message.appealPending === true) {
+            writer.uint32(56).bool(message.appealPending);
+        }
+        if (message.initiativeId !== BigInt(0)) {
+            writer.uint32(64).uint64(message.initiativeId);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseThreadLockRecord();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.rootId = reader.uint64();
+                    break;
+                case 2:
+                    message.sentinel = reader.string();
+                    break;
+                case 3:
+                    message.lockedAt = reader.int64();
+                    break;
+                case 4:
+                    message.sentinelBondSnapshot = reader.string();
+                    break;
+                case 5:
+                    message.sentinelBackingSnapshot = reader.string();
+                    break;
+                case 6:
+                    message.lockReason = reader.string();
+                    break;
+                case 7:
+                    message.appealPending = reader.bool();
+                    break;
+                case 8:
+                    message.initiativeId = reader.uint64();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseThreadLockRecord();
+        message.rootId = object.rootId !== undefined && object.rootId !== null ? BigInt(object.rootId.toString()) : BigInt(0);
+        message.sentinel = object.sentinel ?? "";
+        message.lockedAt = object.lockedAt !== undefined && object.lockedAt !== null ? BigInt(object.lockedAt.toString()) : BigInt(0);
+        message.sentinelBondSnapshot = object.sentinelBondSnapshot ?? "";
+        message.sentinelBackingSnapshot = object.sentinelBackingSnapshot ?? "";
+        message.lockReason = object.lockReason ?? "";
+        message.appealPending = object.appealPending ?? false;
+        message.initiativeId = object.initiativeId !== undefined && object.initiativeId !== null ? BigInt(object.initiativeId.toString()) : BigInt(0);
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseThreadLockRecord();
+        if (object.root_id !== undefined && object.root_id !== null) {
+            message.rootId = BigInt(object.root_id);
+        }
+        if (object.sentinel !== undefined && object.sentinel !== null) {
+            message.sentinel = object.sentinel;
+        }
+        if (object.locked_at !== undefined && object.locked_at !== null) {
+            message.lockedAt = BigInt(object.locked_at);
+        }
+        if (object.sentinel_bond_snapshot !== undefined && object.sentinel_bond_snapshot !== null) {
+            message.sentinelBondSnapshot = object.sentinel_bond_snapshot;
+        }
+        if (object.sentinel_backing_snapshot !== undefined && object.sentinel_backing_snapshot !== null) {
+            message.sentinelBackingSnapshot = object.sentinel_backing_snapshot;
+        }
+        if (object.lock_reason !== undefined && object.lock_reason !== null) {
+            message.lockReason = object.lock_reason;
+        }
+        if (object.appeal_pending !== undefined && object.appeal_pending !== null) {
+            message.appealPending = object.appeal_pending;
+        }
+        if (object.initiative_id !== undefined && object.initiative_id !== null) {
+            message.initiativeId = BigInt(object.initiative_id);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.root_id = message.rootId !== BigInt(0) ? message.rootId?.toString() : undefined;
+        obj.sentinel = message.sentinel === "" ? undefined : message.sentinel;
+        obj.locked_at = message.lockedAt !== BigInt(0) ? message.lockedAt?.toString() : undefined;
+        obj.sentinel_bond_snapshot = message.sentinelBondSnapshot === "" ? undefined : message.sentinelBondSnapshot;
+        obj.sentinel_backing_snapshot = message.sentinelBackingSnapshot === "" ? undefined : message.sentinelBackingSnapshot;
+        obj.lock_reason = message.lockReason === "" ? undefined : message.lockReason;
+        obj.appeal_pending = message.appealPending === false ? undefined : message.appealPending;
+        obj.initiative_id = message.initiativeId !== BigInt(0) ? message.initiativeId?.toString() : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.ThreadLockRecord.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.ThreadLockRecord.decode(message.value);
+    },
+    toProto(message) {
+        return exports.ThreadLockRecord.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.forum.v1.ThreadLockRecord",
+            value: exports.ThreadLockRecord.encode(message).finish()
+        };
+    }
+};

package/sparkdream/forum/v1/thread_metadata.d.ts

@@ -0,0 +1,63 @@
+import { PinnedReplyRecord, PinnedReplyRecordAmino } from "./types";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+/**
+ * ThreadMetadata defines the ThreadMetadata message.
+ * @name ThreadMetadata
+ * @package sparkdream.forum.v1
+ * @see proto type: sparkdream.forum.v1.ThreadMetadata
+ */
+export interface ThreadMetadata {
+    threadId: bigint;
+    acceptedReplyId: bigint;
+    acceptedBy: string;
+    acceptedAt: bigint;
+    proposedReplyId: bigint;
+    proposedBy: string;
+    proposedAt: bigint;
+    pinnedReplyIds: bigint[];
+    pinnedRecords: PinnedReplyRecord[];
+}
+export interface ThreadMetadataProtoMsg {
+    typeUrl: "/sparkdream.forum.v1.ThreadMetadata";
+    value: Uint8Array;
+}
+/**
+ * ThreadMetadata defines the ThreadMetadata message.
+ * @name ThreadMetadataAmino
+ * @package sparkdream.forum.v1
+ * @see proto type: sparkdream.forum.v1.ThreadMetadata
+ */
+export interface ThreadMetadataAmino {
+    thread_id?: string;
+    accepted_reply_id?: string;
+    accepted_by?: string;
+    accepted_at?: string;
+    proposed_reply_id?: string;
+    proposed_by?: string;
+    proposed_at?: string;
+    pinned_reply_ids?: string[];
+    pinned_records?: PinnedReplyRecordAmino[];
+}
+export interface ThreadMetadataAminoMsg {
+    type: "/sparkdream.forum.v1.ThreadMetadata";
+    value: ThreadMetadataAmino;
+}
+/**
+ * ThreadMetadata defines the ThreadMetadata message.
+ * @name ThreadMetadata
+ * @package sparkdream.forum.v1
+ * @see proto type: sparkdream.forum.v1.ThreadMetadata
+ */
+export declare const ThreadMetadata: {
+    typeUrl: string;
+    encode(message: ThreadMetadata, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): ThreadMetadata;
+    fromPartial(object: DeepPartial<ThreadMetadata>): ThreadMetadata;
+    fromAmino(object: ThreadMetadataAmino): ThreadMetadata;
+    toAmino(message: ThreadMetadata): ThreadMetadataAmino;
+    fromAminoMsg(object: ThreadMetadataAminoMsg): ThreadMetadata;
+    fromProtoMsg(message: ThreadMetadataProtoMsg): ThreadMetadata;
+    toProto(message: ThreadMetadata): Uint8Array;
+    toProtoMsg(message: ThreadMetadata): ThreadMetadataProtoMsg;
+};

package/sparkdream/forum/v1/thread_metadata.js

@@ -0,0 +1,187 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ThreadMetadata = void 0;
+//@ts-nocheck
+const types_1 = require("./types");
+const binary_1 = require("../../../binary");
+function createBaseThreadMetadata() {
+    return {
+        threadId: BigInt(0),
+        acceptedReplyId: BigInt(0),
+        acceptedBy: "",
+        acceptedAt: BigInt(0),
+        proposedReplyId: BigInt(0),
+        proposedBy: "",
+        proposedAt: BigInt(0),
+        pinnedReplyIds: [],
+        pinnedRecords: []
+    };
+}
+/**
+ * ThreadMetadata defines the ThreadMetadata message.
+ * @name ThreadMetadata
+ * @package sparkdream.forum.v1
+ * @see proto type: sparkdream.forum.v1.ThreadMetadata
+ */
+exports.ThreadMetadata = {
+    typeUrl: "/sparkdream.forum.v1.ThreadMetadata",
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.threadId !== BigInt(0)) {
+            writer.uint32(8).uint64(message.threadId);
+        }
+        if (message.acceptedReplyId !== BigInt(0)) {
+            writer.uint32(16).uint64(message.acceptedReplyId);
+        }
+        if (message.acceptedBy !== "") {
+            writer.uint32(26).string(message.acceptedBy);
+        }
+        if (message.acceptedAt !== BigInt(0)) {
+            writer.uint32(32).int64(message.acceptedAt);
+        }
+        if (message.proposedReplyId !== BigInt(0)) {
+            writer.uint32(40).uint64(message.proposedReplyId);
+        }
+        if (message.proposedBy !== "") {
+            writer.uint32(50).string(message.proposedBy);
+        }
+        if (message.proposedAt !== BigInt(0)) {
+            writer.uint32(56).int64(message.proposedAt);
+        }
+        writer.uint32(82).fork();
+        for (const v of message.pinnedReplyIds) {
+            writer.uint64(v);
+        }
+        writer.ldelim();
+        for (const v of message.pinnedRecords) {
+            types_1.PinnedReplyRecord.encode(v, writer.uint32(90).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseThreadMetadata();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.threadId = reader.uint64();
+                    break;
+                case 2:
+                    message.acceptedReplyId = reader.uint64();
+                    break;
+                case 3:
+                    message.acceptedBy = reader.string();
+                    break;
+                case 4:
+                    message.acceptedAt = reader.int64();
+                    break;
+                case 5:
+                    message.proposedReplyId = reader.uint64();
+                    break;
+                case 6:
+                    message.proposedBy = reader.string();
+                    break;
+                case 7:
+                    message.proposedAt = reader.int64();
+                    break;
+                case 10:
+                    if ((tag & 7) === 2) {
+                        const end2 = reader.uint32() + reader.pos;
+                        while (reader.pos < end2) {
+                            message.pinnedReplyIds.push(reader.uint64());
+                        }
+                    }
+                    else {
+                        message.pinnedReplyIds.push(reader.uint64());
+                    }
+                    break;
+                case 11:
+                    message.pinnedRecords.push(types_1.PinnedReplyRecord.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseThreadMetadata();
+        message.threadId = object.threadId !== undefined && object.threadId !== null ? BigInt(object.threadId.toString()) : BigInt(0);
+        message.acceptedReplyId = object.acceptedReplyId !== undefined && object.acceptedReplyId !== null ? BigInt(object.acceptedReplyId.toString()) : BigInt(0);
+        message.acceptedBy = object.acceptedBy ?? "";
+        message.acceptedAt = object.acceptedAt !== undefined && object.acceptedAt !== null ? BigInt(object.acceptedAt.toString()) : BigInt(0);
+        message.proposedReplyId = object.proposedReplyId !== undefined && object.proposedReplyId !== null ? BigInt(object.proposedReplyId.toString()) : BigInt(0);
+        message.proposedBy = object.proposedBy ?? "";
+        message.proposedAt = object.proposedAt !== undefined && object.proposedAt !== null ? BigInt(object.proposedAt.toString()) : BigInt(0);
+        message.pinnedReplyIds = object.pinnedReplyIds?.map(e => BigInt(e.toString())) || [];
+        message.pinnedRecords = object.pinnedRecords?.map(e => types_1.PinnedReplyRecord.fromPartial(e)) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseThreadMetadata();
+        if (object.thread_id !== undefined && object.thread_id !== null) {
+            message.threadId = BigInt(object.thread_id);
+        }
+        if (object.accepted_reply_id !== undefined && object.accepted_reply_id !== null) {
+            message.acceptedReplyId = BigInt(object.accepted_reply_id);
+        }
+        if (object.accepted_by !== undefined && object.accepted_by !== null) {
+            message.acceptedBy = object.accepted_by;
+        }
+        if (object.accepted_at !== undefined && object.accepted_at !== null) {
+            message.acceptedAt = BigInt(object.accepted_at);
+        }
+        if (object.proposed_reply_id !== undefined && object.proposed_reply_id !== null) {
+            message.proposedReplyId = BigInt(object.proposed_reply_id);
+        }
+        if (object.proposed_by !== undefined && object.proposed_by !== null) {
+            message.proposedBy = object.proposed_by;
+        }
+        if (object.proposed_at !== undefined && object.proposed_at !== null) {
+            message.proposedAt = BigInt(object.proposed_at);
+        }
+        message.pinnedReplyIds = object.pinned_reply_ids?.map(e => BigInt(e)) || [];
+        message.pinnedRecords = object.pinned_records?.map(e => types_1.PinnedReplyRecord.fromAmino(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.thread_id = message.threadId !== BigInt(0) ? message.threadId?.toString() : undefined;
+        obj.accepted_reply_id = message.acceptedReplyId !== BigInt(0) ? message.acceptedReplyId?.toString() : undefined;
+        obj.accepted_by = message.acceptedBy === "" ? undefined : message.acceptedBy;
+        obj.accepted_at = message.acceptedAt !== BigInt(0) ? message.acceptedAt?.toString() : undefined;
+        obj.proposed_reply_id = message.proposedReplyId !== BigInt(0) ? message.proposedReplyId?.toString() : undefined;
+        obj.proposed_by = message.proposedBy === "" ? undefined : message.proposedBy;
+        obj.proposed_at = message.proposedAt !== BigInt(0) ? message.proposedAt?.toString() : undefined;
+        if (message.pinnedReplyIds) {
+            obj.pinned_reply_ids = message.pinnedReplyIds.map(e => e.toString());
+        }
+        else {
+            obj.pinned_reply_ids = message.pinnedReplyIds;
+        }
+        if (message.pinnedRecords) {
+            obj.pinned_records = message.pinnedRecords.map(e => e ? types_1.PinnedReplyRecord.toAmino(e) : undefined);
+        }
+        else {
+            obj.pinned_records = message.pinnedRecords;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.ThreadMetadata.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.ThreadMetadata.decode(message.value);
+    },
+    toProto(message) {
+        return exports.ThreadMetadata.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.forum.v1.ThreadMetadata",
+            value: exports.ThreadMetadata.encode(message).finish()
+        };
+    }
+};

package/sparkdream/forum/v1/thread_move_record.d.ts

@@ -0,0 +1,64 @@
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+/**
+ * ThreadMoveRecord defines the ThreadMoveRecord message.
+ * @name ThreadMoveRecord
+ * @package sparkdream.forum.v1
+ * @see proto type: sparkdream.forum.v1.ThreadMoveRecord
+ */
+export interface ThreadMoveRecord {
+    rootId: bigint;
+    sentinel: string;
+    originalCategoryId: bigint;
+    newCategoryId: bigint;
+    movedAt: bigint;
+    sentinelBondSnapshot: string;
+    sentinelBackingSnapshot: string;
+    moveReason: string;
+    appealPending: boolean;
+    initiativeId: bigint;
+}
+export interface ThreadMoveRecordProtoMsg {
+    typeUrl: "/sparkdream.forum.v1.ThreadMoveRecord";
+    value: Uint8Array;
+}
+/**
+ * ThreadMoveRecord defines the ThreadMoveRecord message.
+ * @name ThreadMoveRecordAmino
+ * @package sparkdream.forum.v1
+ * @see proto type: sparkdream.forum.v1.ThreadMoveRecord
+ */
+export interface ThreadMoveRecordAmino {
+    root_id?: string;
+    sentinel?: string;
+    original_category_id?: string;
+    new_category_id?: string;
+    moved_at?: string;
+    sentinel_bond_snapshot?: string;
+    sentinel_backing_snapshot?: string;
+    move_reason?: string;
+    appeal_pending?: boolean;
+    initiative_id?: string;
+}
+export interface ThreadMoveRecordAminoMsg {
+    type: "/sparkdream.forum.v1.ThreadMoveRecord";
+    value: ThreadMoveRecordAmino;
+}
+/**
+ * ThreadMoveRecord defines the ThreadMoveRecord message.
+ * @name ThreadMoveRecord
+ * @package sparkdream.forum.v1
+ * @see proto type: sparkdream.forum.v1.ThreadMoveRecord
+ */
+export declare const ThreadMoveRecord: {
+    typeUrl: string;
+    encode(message: ThreadMoveRecord, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): ThreadMoveRecord;
+    fromPartial(object: DeepPartial<ThreadMoveRecord>): ThreadMoveRecord;
+    fromAmino(object: ThreadMoveRecordAmino): ThreadMoveRecord;
+    toAmino(message: ThreadMoveRecord): ThreadMoveRecordAmino;
+    fromAminoMsg(object: ThreadMoveRecordAminoMsg): ThreadMoveRecord;
+    fromProtoMsg(message: ThreadMoveRecordProtoMsg): ThreadMoveRecord;
+    toProto(message: ThreadMoveRecord): Uint8Array;
+    toProtoMsg(message: ThreadMoveRecord): ThreadMoveRecordProtoMsg;
+};