@gitopia/gitopiajs 0.0.4 → 0.0.5

package/dist/esm/gitopia/gitopia/gitopia/comment.js

@@ -0,0 +1,488 @@
+//@ts-nocheck
+import { Attachment } from "./attachment";
+import { Reaction } from "./reaction";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+export var CommentType;
+(function (CommentType) {
+    CommentType[CommentType["COMMENT_TYPE_NONE"] = 0] = "COMMENT_TYPE_NONE";
+    CommentType[CommentType["COMMENT_TYPE_REPLY"] = 1] = "COMMENT_TYPE_REPLY";
+    CommentType[CommentType["COMMENT_TYPE_ADD_LABELS"] = 2] = "COMMENT_TYPE_ADD_LABELS";
+    CommentType[CommentType["COMMENT_TYPE_REMOVE_LABELS"] = 3] = "COMMENT_TYPE_REMOVE_LABELS";
+    CommentType[CommentType["COMMENT_TYPE_ADD_ASSIGNEES"] = 4] = "COMMENT_TYPE_ADD_ASSIGNEES";
+    CommentType[CommentType["COMMENT_TYPE_REMOVE_ASSIGNEES"] = 5] = "COMMENT_TYPE_REMOVE_ASSIGNEES";
+    CommentType[CommentType["COMMENT_TYPE_ADD_REVIEWERS"] = 6] = "COMMENT_TYPE_ADD_REVIEWERS";
+    CommentType[CommentType["COMMENT_TYPE_REMOVE_REVIEWERS"] = 7] = "COMMENT_TYPE_REMOVE_REVIEWERS";
+    CommentType[CommentType["COMMENT_TYPE_MODIFIED_TITLE"] = 8] = "COMMENT_TYPE_MODIFIED_TITLE";
+    CommentType[CommentType["COMMENT_TYPE_MODIFIED_DESCRIPTION"] = 9] = "COMMENT_TYPE_MODIFIED_DESCRIPTION";
+    CommentType[CommentType["COMMENT_TYPE_ISSUE_CLOSED"] = 10] = "COMMENT_TYPE_ISSUE_CLOSED";
+    CommentType[CommentType["COMMENT_TYPE_ISSUE_OPENED"] = 11] = "COMMENT_TYPE_ISSUE_OPENED";
+    CommentType[CommentType["COMMENT_TYPE_PULL_REQUEST_CLOSED"] = 12] = "COMMENT_TYPE_PULL_REQUEST_CLOSED";
+    CommentType[CommentType["COMMENT_TYPE_PULL_REQUEST_OPENED"] = 13] = "COMMENT_TYPE_PULL_REQUEST_OPENED";
+    CommentType[CommentType["COMMENT_TYPE_PULL_REQUEST_MERGED"] = 14] = "COMMENT_TYPE_PULL_REQUEST_MERGED";
+    CommentType[CommentType["COMMENT_TYPE_REVIEW"] = 15] = "COMMENT_TYPE_REVIEW";
+    CommentType[CommentType["COMMENT_TYPE_ADD_BOUNTY"] = 16] = "COMMENT_TYPE_ADD_BOUNTY";
+    CommentType[CommentType["COMMENT_TYPE_MODIFIED_BOUNTY"] = 17] = "COMMENT_TYPE_MODIFIED_BOUNTY";
+    CommentType[CommentType["COMMENT_TYPE_CLOSED_BOUNTY"] = 18] = "COMMENT_TYPE_CLOSED_BOUNTY";
+    CommentType[CommentType["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(CommentType || (CommentType = {}));
+export const CommentTypeSDKType = CommentType;
+export const CommentTypeAmino = CommentType;
+export function commentTypeFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "COMMENT_TYPE_NONE":
+            return CommentType.COMMENT_TYPE_NONE;
+        case 1:
+        case "COMMENT_TYPE_REPLY":
+            return CommentType.COMMENT_TYPE_REPLY;
+        case 2:
+        case "COMMENT_TYPE_ADD_LABELS":
+            return CommentType.COMMENT_TYPE_ADD_LABELS;
+        case 3:
+        case "COMMENT_TYPE_REMOVE_LABELS":
+            return CommentType.COMMENT_TYPE_REMOVE_LABELS;
+        case 4:
+        case "COMMENT_TYPE_ADD_ASSIGNEES":
+            return CommentType.COMMENT_TYPE_ADD_ASSIGNEES;
+        case 5:
+        case "COMMENT_TYPE_REMOVE_ASSIGNEES":
+            return CommentType.COMMENT_TYPE_REMOVE_ASSIGNEES;
+        case 6:
+        case "COMMENT_TYPE_ADD_REVIEWERS":
+            return CommentType.COMMENT_TYPE_ADD_REVIEWERS;
+        case 7:
+        case "COMMENT_TYPE_REMOVE_REVIEWERS":
+            return CommentType.COMMENT_TYPE_REMOVE_REVIEWERS;
+        case 8:
+        case "COMMENT_TYPE_MODIFIED_TITLE":
+            return CommentType.COMMENT_TYPE_MODIFIED_TITLE;
+        case 9:
+        case "COMMENT_TYPE_MODIFIED_DESCRIPTION":
+            return CommentType.COMMENT_TYPE_MODIFIED_DESCRIPTION;
+        case 10:
+        case "COMMENT_TYPE_ISSUE_CLOSED":
+            return CommentType.COMMENT_TYPE_ISSUE_CLOSED;
+        case 11:
+        case "COMMENT_TYPE_ISSUE_OPENED":
+            return CommentType.COMMENT_TYPE_ISSUE_OPENED;
+        case 12:
+        case "COMMENT_TYPE_PULL_REQUEST_CLOSED":
+            return CommentType.COMMENT_TYPE_PULL_REQUEST_CLOSED;
+        case 13:
+        case "COMMENT_TYPE_PULL_REQUEST_OPENED":
+            return CommentType.COMMENT_TYPE_PULL_REQUEST_OPENED;
+        case 14:
+        case "COMMENT_TYPE_PULL_REQUEST_MERGED":
+            return CommentType.COMMENT_TYPE_PULL_REQUEST_MERGED;
+        case 15:
+        case "COMMENT_TYPE_REVIEW":
+            return CommentType.COMMENT_TYPE_REVIEW;
+        case 16:
+        case "COMMENT_TYPE_ADD_BOUNTY":
+            return CommentType.COMMENT_TYPE_ADD_BOUNTY;
+        case 17:
+        case "COMMENT_TYPE_MODIFIED_BOUNTY":
+            return CommentType.COMMENT_TYPE_MODIFIED_BOUNTY;
+        case 18:
+        case "COMMENT_TYPE_CLOSED_BOUNTY":
+            return CommentType.COMMENT_TYPE_CLOSED_BOUNTY;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return CommentType.UNRECOGNIZED;
+    }
+}
+export function commentTypeToJSON(object) {
+    switch (object) {
+        case CommentType.COMMENT_TYPE_NONE:
+            return "COMMENT_TYPE_NONE";
+        case CommentType.COMMENT_TYPE_REPLY:
+            return "COMMENT_TYPE_REPLY";
+        case CommentType.COMMENT_TYPE_ADD_LABELS:
+            return "COMMENT_TYPE_ADD_LABELS";
+        case CommentType.COMMENT_TYPE_REMOVE_LABELS:
+            return "COMMENT_TYPE_REMOVE_LABELS";
+        case CommentType.COMMENT_TYPE_ADD_ASSIGNEES:
+            return "COMMENT_TYPE_ADD_ASSIGNEES";
+        case CommentType.COMMENT_TYPE_REMOVE_ASSIGNEES:
+            return "COMMENT_TYPE_REMOVE_ASSIGNEES";
+        case CommentType.COMMENT_TYPE_ADD_REVIEWERS:
+            return "COMMENT_TYPE_ADD_REVIEWERS";
+        case CommentType.COMMENT_TYPE_REMOVE_REVIEWERS:
+            return "COMMENT_TYPE_REMOVE_REVIEWERS";
+        case CommentType.COMMENT_TYPE_MODIFIED_TITLE:
+            return "COMMENT_TYPE_MODIFIED_TITLE";
+        case CommentType.COMMENT_TYPE_MODIFIED_DESCRIPTION:
+            return "COMMENT_TYPE_MODIFIED_DESCRIPTION";
+        case CommentType.COMMENT_TYPE_ISSUE_CLOSED:
+            return "COMMENT_TYPE_ISSUE_CLOSED";
+        case CommentType.COMMENT_TYPE_ISSUE_OPENED:
+            return "COMMENT_TYPE_ISSUE_OPENED";
+        case CommentType.COMMENT_TYPE_PULL_REQUEST_CLOSED:
+            return "COMMENT_TYPE_PULL_REQUEST_CLOSED";
+        case CommentType.COMMENT_TYPE_PULL_REQUEST_OPENED:
+            return "COMMENT_TYPE_PULL_REQUEST_OPENED";
+        case CommentType.COMMENT_TYPE_PULL_REQUEST_MERGED:
+            return "COMMENT_TYPE_PULL_REQUEST_MERGED";
+        case CommentType.COMMENT_TYPE_REVIEW:
+            return "COMMENT_TYPE_REVIEW";
+        case CommentType.COMMENT_TYPE_ADD_BOUNTY:
+            return "COMMENT_TYPE_ADD_BOUNTY";
+        case CommentType.COMMENT_TYPE_MODIFIED_BOUNTY:
+            return "COMMENT_TYPE_MODIFIED_BOUNTY";
+        case CommentType.COMMENT_TYPE_CLOSED_BOUNTY:
+            return "COMMENT_TYPE_CLOSED_BOUNTY";
+        case CommentType.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+export var CommentParent;
+(function (CommentParent) {
+    CommentParent[CommentParent["COMMENT_PARENT_NONE"] = 0] = "COMMENT_PARENT_NONE";
+    CommentParent[CommentParent["COMMENT_PARENT_ISSUE"] = 1] = "COMMENT_PARENT_ISSUE";
+    CommentParent[CommentParent["COMMENT_PARENT_PULL_REQUEST"] = 2] = "COMMENT_PARENT_PULL_REQUEST";
+    CommentParent[CommentParent["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(CommentParent || (CommentParent = {}));
+export const CommentParentSDKType = CommentParent;
+export const CommentParentAmino = CommentParent;
+export function commentParentFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "COMMENT_PARENT_NONE":
+            return CommentParent.COMMENT_PARENT_NONE;
+        case 1:
+        case "COMMENT_PARENT_ISSUE":
+            return CommentParent.COMMENT_PARENT_ISSUE;
+        case 2:
+        case "COMMENT_PARENT_PULL_REQUEST":
+            return CommentParent.COMMENT_PARENT_PULL_REQUEST;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return CommentParent.UNRECOGNIZED;
+    }
+}
+export function commentParentToJSON(object) {
+    switch (object) {
+        case CommentParent.COMMENT_PARENT_NONE:
+            return "COMMENT_PARENT_NONE";
+        case CommentParent.COMMENT_PARENT_ISSUE:
+            return "COMMENT_PARENT_ISSUE";
+        case CommentParent.COMMENT_PARENT_PULL_REQUEST:
+            return "COMMENT_PARENT_PULL_REQUEST";
+        case CommentParent.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+function createBaseComment() {
+    return {
+        creator: "",
+        id: BigInt(0),
+        repositoryId: BigInt(0),
+        parentIid: BigInt(0),
+        parent: 0,
+        commentIid: BigInt(0),
+        body: "",
+        attachments: [],
+        diffHunk: "",
+        path: "",
+        position: BigInt(0),
+        system: false,
+        authorAssociation: "",
+        createdAt: BigInt(0),
+        updatedAt: BigInt(0),
+        commentType: 0,
+        resolved: false,
+        replies: [],
+        reactions: [],
+        hidden: false
+    };
+}
+export const Comment = {
+    typeUrl: "/gitopia.gitopia.gitopia.Comment",
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.creator !== "") {
+            writer.uint32(10).string(message.creator);
+        }
+        if (message.id !== BigInt(0)) {
+            writer.uint32(16).uint64(message.id);
+        }
+        if (message.repositoryId !== BigInt(0)) {
+            writer.uint32(24).uint64(message.repositoryId);
+        }
+        if (message.parentIid !== BigInt(0)) {
+            writer.uint32(32).uint64(message.parentIid);
+        }
+        if (message.parent !== 0) {
+            writer.uint32(40).int32(message.parent);
+        }
+        if (message.commentIid !== BigInt(0)) {
+            writer.uint32(48).uint64(message.commentIid);
+        }
+        if (message.body !== "") {
+            writer.uint32(58).string(message.body);
+        }
+        for (const v of message.attachments) {
+            Attachment.encode(v, writer.uint32(66).fork()).ldelim();
+        }
+        if (message.diffHunk !== "") {
+            writer.uint32(74).string(message.diffHunk);
+        }
+        if (message.path !== "") {
+            writer.uint32(82).string(message.path);
+        }
+        if (message.position !== BigInt(0)) {
+            writer.uint32(88).uint64(message.position);
+        }
+        if (message.system === true) {
+            writer.uint32(96).bool(message.system);
+        }
+        if (message.authorAssociation !== "") {
+            writer.uint32(106).string(message.authorAssociation);
+        }
+        if (message.createdAt !== BigInt(0)) {
+            writer.uint32(112).int64(message.createdAt);
+        }
+        if (message.updatedAt !== BigInt(0)) {
+            writer.uint32(120).int64(message.updatedAt);
+        }
+        if (message.commentType !== 0) {
+            writer.uint32(128).int32(message.commentType);
+        }
+        if (message.resolved === true) {
+            writer.uint32(136).bool(message.resolved);
+        }
+        writer.uint32(146).fork();
+        for (const v of message.replies) {
+            writer.uint64(v);
+        }
+        writer.ldelim();
+        for (const v of message.reactions) {
+            Reaction.encode(v, writer.uint32(154).fork()).ldelim();
+        }
+        if (message.hidden === true) {
+            writer.uint32(160).bool(message.hidden);
+        }
+        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 = createBaseComment();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.creator = reader.string();
+                    break;
+                case 2:
+                    message.id = reader.uint64();
+                    break;
+                case 3:
+                    message.repositoryId = reader.uint64();
+                    break;
+                case 4:
+                    message.parentIid = reader.uint64();
+                    break;
+                case 5:
+                    message.parent = reader.int32();
+                    break;
+                case 6:
+                    message.commentIid = reader.uint64();
+                    break;
+                case 7:
+                    message.body = reader.string();
+                    break;
+                case 8:
+                    message.attachments.push(Attachment.decode(reader, reader.uint32()));
+                    break;
+                case 9:
+                    message.diffHunk = reader.string();
+                    break;
+                case 10:
+                    message.path = reader.string();
+                    break;
+                case 11:
+                    message.position = reader.uint64();
+                    break;
+                case 12:
+                    message.system = reader.bool();
+                    break;
+                case 13:
+                    message.authorAssociation = reader.string();
+                    break;
+                case 14:
+                    message.createdAt = reader.int64();
+                    break;
+                case 15:
+                    message.updatedAt = reader.int64();
+                    break;
+                case 16:
+                    message.commentType = reader.int32();
+                    break;
+                case 17:
+                    message.resolved = reader.bool();
+                    break;
+                case 18:
+                    if ((tag & 7) === 2) {
+                        const end2 = reader.uint32() + reader.pos;
+                        while (reader.pos < end2) {
+                            message.replies.push(reader.uint64());
+                        }
+                    }
+                    else {
+                        message.replies.push(reader.uint64());
+                    }
+                    break;
+                case 19:
+                    message.reactions.push(Reaction.decode(reader, reader.uint32()));
+                    break;
+                case 20:
+                    message.hidden = reader.bool();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseComment();
+        message.creator = object.creator ?? "";
+        message.id = object.id !== undefined && object.id !== null ? BigInt(object.id.toString()) : BigInt(0);
+        message.repositoryId = object.repositoryId !== undefined && object.repositoryId !== null ? BigInt(object.repositoryId.toString()) : BigInt(0);
+        message.parentIid = object.parentIid !== undefined && object.parentIid !== null ? BigInt(object.parentIid.toString()) : BigInt(0);
+        message.parent = object.parent ?? 0;
+        message.commentIid = object.commentIid !== undefined && object.commentIid !== null ? BigInt(object.commentIid.toString()) : BigInt(0);
+        message.body = object.body ?? "";
+        message.attachments = object.attachments?.map(e => Attachment.fromPartial(e)) || [];
+        message.diffHunk = object.diffHunk ?? "";
+        message.path = object.path ?? "";
+        message.position = object.position !== undefined && object.position !== null ? BigInt(object.position.toString()) : BigInt(0);
+        message.system = object.system ?? false;
+        message.authorAssociation = object.authorAssociation ?? "";
+        message.createdAt = object.createdAt !== undefined && object.createdAt !== null ? BigInt(object.createdAt.toString()) : BigInt(0);
+        message.updatedAt = object.updatedAt !== undefined && object.updatedAt !== null ? BigInt(object.updatedAt.toString()) : BigInt(0);
+        message.commentType = object.commentType ?? 0;
+        message.resolved = object.resolved ?? false;
+        message.replies = object.replies?.map(e => BigInt(e.toString())) || [];
+        message.reactions = object.reactions?.map(e => Reaction.fromPartial(e)) || [];
+        message.hidden = object.hidden ?? false;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseComment();
+        if (object.creator !== undefined && object.creator !== null) {
+            message.creator = object.creator;
+        }
+        if (object.id !== undefined && object.id !== null) {
+            message.id = BigInt(object.id);
+        }
+        if (object.repositoryId !== undefined && object.repositoryId !== null) {
+            message.repositoryId = BigInt(object.repositoryId);
+        }
+        if (object.parentIid !== undefined && object.parentIid !== null) {
+            message.parentIid = BigInt(object.parentIid);
+        }
+        if (object.parent !== undefined && object.parent !== null) {
+            message.parent = object.parent;
+        }
+        if (object.commentIid !== undefined && object.commentIid !== null) {
+            message.commentIid = BigInt(object.commentIid);
+        }
+        if (object.body !== undefined && object.body !== null) {
+            message.body = object.body;
+        }
+        message.attachments = object.attachments?.map(e => Attachment.fromAmino(e)) || [];
+        if (object.diffHunk !== undefined && object.diffHunk !== null) {
+            message.diffHunk = object.diffHunk;
+        }
+        if (object.path !== undefined && object.path !== null) {
+            message.path = object.path;
+        }
+        if (object.position !== undefined && object.position !== null) {
+            message.position = BigInt(object.position);
+        }
+        if (object.system !== undefined && object.system !== null) {
+            message.system = object.system;
+        }
+        if (object.authorAssociation !== undefined && object.authorAssociation !== null) {
+            message.authorAssociation = object.authorAssociation;
+        }
+        if (object.createdAt !== undefined && object.createdAt !== null) {
+            message.createdAt = BigInt(object.createdAt);
+        }
+        if (object.updatedAt !== undefined && object.updatedAt !== null) {
+            message.updatedAt = BigInt(object.updatedAt);
+        }
+        if (object.commentType !== undefined && object.commentType !== null) {
+            message.commentType = object.commentType;
+        }
+        if (object.resolved !== undefined && object.resolved !== null) {
+            message.resolved = object.resolved;
+        }
+        message.replies = object.replies?.map(e => BigInt(e)) || [];
+        message.reactions = object.reactions?.map(e => Reaction.fromAmino(e)) || [];
+        if (object.hidden !== undefined && object.hidden !== null) {
+            message.hidden = object.hidden;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.creator = message.creator === "" ? undefined : message.creator;
+        obj.id = message.id !== BigInt(0) ? message.id?.toString() : undefined;
+        obj.repositoryId = message.repositoryId !== BigInt(0) ? message.repositoryId?.toString() : undefined;
+        obj.parentIid = message.parentIid !== BigInt(0) ? message.parentIid?.toString() : undefined;
+        obj.parent = message.parent === 0 ? undefined : message.parent;
+        obj.commentIid = message.commentIid !== BigInt(0) ? message.commentIid?.toString() : undefined;
+        obj.body = message.body === "" ? undefined : message.body;
+        if (message.attachments) {
+            obj.attachments = message.attachments.map(e => e ? Attachment.toAmino(e) : undefined);
+        }
+        else {
+            obj.attachments = message.attachments;
+        }
+        obj.diffHunk = message.diffHunk === "" ? undefined : message.diffHunk;
+        obj.path = message.path === "" ? undefined : message.path;
+        obj.position = message.position !== BigInt(0) ? message.position?.toString() : undefined;
+        obj.system = message.system === false ? undefined : message.system;
+        obj.authorAssociation = message.authorAssociation === "" ? undefined : message.authorAssociation;
+        obj.createdAt = message.createdAt !== BigInt(0) ? message.createdAt?.toString() : undefined;
+        obj.updatedAt = message.updatedAt !== BigInt(0) ? message.updatedAt?.toString() : undefined;
+        obj.commentType = message.commentType === 0 ? undefined : message.commentType;
+        obj.resolved = message.resolved === false ? undefined : message.resolved;
+        if (message.replies) {
+            obj.replies = message.replies.map(e => e.toString());
+        }
+        else {
+            obj.replies = message.replies;
+        }
+        if (message.reactions) {
+            obj.reactions = message.reactions.map(e => e ? Reaction.toAmino(e) : undefined);
+        }
+        else {
+            obj.reactions = message.reactions;
+        }
+        obj.hidden = message.hidden === false ? undefined : message.hidden;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return Comment.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return Comment.decode(message.value);
+    },
+    toProto(message) {
+        return Comment.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/gitopia.gitopia.gitopia.Comment",
+            value: Comment.encode(message).finish()
+        };
+    }
+};