@huni_ee/nazu 0.0.0-stage → 0.1.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/LICENSE +201 -0
- package/README.md +72 -2
- package/dist/api/auth.d.ts +10 -0
- package/dist/api/auth.d.ts.map +1 -0
- package/dist/api/auth.js +81 -0
- package/dist/api/auth.js.map +1 -0
- package/dist/api/friends.d.ts +12 -0
- package/dist/api/friends.d.ts.map +1 -0
- package/dist/api/friends.js +126 -0
- package/dist/api/friends.js.map +1 -0
- package/dist/api/index.d.ts +5 -0
- package/dist/api/index.d.ts.map +1 -0
- package/dist/api/index.js +9 -0
- package/dist/api/index.js.map +1 -0
- package/dist/api/self-profile.d.ts +8 -0
- package/dist/api/self-profile.d.ts.map +1 -0
- package/dist/api/self-profile.js +89 -0
- package/dist/api/self-profile.js.map +1 -0
- package/dist/api/types.d.ts +133 -0
- package/dist/api/types.d.ts.map +1 -0
- package/dist/api/types.js +7 -0
- package/dist/api/types.js.map +1 -0
- package/dist/channel/channel.d.ts +122 -0
- package/dist/channel/channel.d.ts.map +1 -0
- package/dist/channel/channel.js +280 -0
- package/dist/channel/channel.js.map +1 -0
- package/dist/channel/index.d.ts +5 -0
- package/dist/channel/index.d.ts.map +1 -0
- package/dist/channel/index.js +9 -0
- package/dist/channel/index.js.map +1 -0
- package/dist/channel/media.d.ts +4 -0
- package/dist/channel/media.d.ts.map +1 -0
- package/dist/channel/media.js +42 -0
- package/dist/channel/media.js.map +1 -0
- package/dist/channel/normal-channel.d.ts +27 -0
- package/dist/channel/normal-channel.d.ts.map +1 -0
- package/dist/channel/normal-channel.js +39 -0
- package/dist/channel/normal-channel.js.map +1 -0
- package/dist/channel/open-channel.d.ts +25 -0
- package/dist/channel/open-channel.d.ts.map +1 -0
- package/dist/channel/open-channel.js +34 -0
- package/dist/channel/open-channel.js.map +1 -0
- package/dist/chat/attachment.d.ts +5 -0
- package/dist/chat/attachment.d.ts.map +1 -0
- package/dist/chat/attachment.js +90 -0
- package/dist/chat/attachment.js.map +1 -0
- package/dist/chat/chat-type.d.ts +31 -0
- package/dist/chat/chat-type.d.ts.map +1 -0
- package/dist/chat/chat-type.js +39 -0
- package/dist/chat/chat-type.js.map +1 -0
- package/dist/chat/chat.d.ts +15 -0
- package/dist/chat/chat.d.ts.map +1 -0
- package/dist/chat/chat.js +23 -0
- package/dist/chat/chat.js.map +1 -0
- package/dist/chat/feed.d.ts +231 -0
- package/dist/chat/feed.d.ts.map +1 -0
- package/dist/chat/feed.js +374 -0
- package/dist/chat/feed.js.map +1 -0
- package/dist/chat/index.d.ts +5 -0
- package/dist/chat/index.d.ts.map +1 -0
- package/dist/chat/index.js +9 -0
- package/dist/chat/index.js.map +1 -0
- package/dist/chat/message.d.ts +170 -0
- package/dist/chat/message.d.ts.map +1 -0
- package/dist/chat/message.js +345 -0
- package/dist/chat/message.js.map +1 -0
- package/dist/client/arisa-client.d.ts +150 -0
- package/dist/client/arisa-client.d.ts.map +1 -0
- package/dist/client/arisa-client.js +439 -0
- package/dist/client/arisa-client.js.map +1 -0
- package/dist/client/client-helper.d.ts +58 -0
- package/dist/client/client-helper.d.ts.map +1 -0
- package/dist/client/client-helper.js +270 -0
- package/dist/client/client-helper.js.map +1 -0
- package/dist/client/event-handler.d.ts +19 -0
- package/dist/client/event-handler.d.ts.map +1 -0
- package/dist/client/event-handler.js +243 -0
- package/dist/client/event-handler.js.map +1 -0
- package/dist/client/index.d.ts +4 -0
- package/dist/client/index.d.ts.map +1 -0
- package/dist/client/index.js +7 -0
- package/dist/client/index.js.map +1 -0
- package/dist/client/listeners.d.ts +34 -0
- package/dist/client/listeners.d.ts.map +1 -0
- package/dist/client/listeners.js +68 -0
- package/dist/client/listeners.js.map +1 -0
- package/dist/client/open-profile-watcher.d.ts +25 -0
- package/dist/client/open-profile-watcher.d.ts.map +1 -0
- package/dist/client/open-profile-watcher.js +85 -0
- package/dist/client/open-profile-watcher.js.map +1 -0
- package/dist/dashboard/server/client-adapter.d.ts +4 -0
- package/dist/dashboard/server/client-adapter.d.ts.map +1 -0
- package/dist/dashboard/server/client-adapter.js +277 -0
- package/dist/dashboard/server/client-adapter.js.map +1 -0
- package/dist/dashboard/server/credential.d.ts +5 -0
- package/dist/dashboard/server/credential.d.ts.map +1 -0
- package/dist/dashboard/server/credential.js +20 -0
- package/dist/dashboard/server/credential.js.map +1 -0
- package/dist/dashboard/server/handler.d.ts +8 -0
- package/dist/dashboard/server/handler.d.ts.map +1 -0
- package/dist/dashboard/server/handler.js +61 -0
- package/dist/dashboard/server/handler.js.map +1 -0
- package/dist/dashboard/server/http.d.ts +11 -0
- package/dist/dashboard/server/http.d.ts.map +1 -0
- package/dist/dashboard/server/http.js +60 -0
- package/dist/dashboard/server/http.js.map +1 -0
- package/dist/dashboard/server/index.d.ts +7 -0
- package/dist/dashboard/server/index.d.ts.map +1 -0
- package/dist/dashboard/server/index.js +252 -0
- package/dist/dashboard/server/index.js.map +1 -0
- package/dist/dashboard/server/posts.d.ts +5 -0
- package/dist/dashboard/server/posts.d.ts.map +1 -0
- package/dist/dashboard/server/posts.js +30 -0
- package/dist/dashboard/server/posts.js.map +1 -0
- package/dist/dashboard/server/role-store.d.ts +13 -0
- package/dist/dashboard/server/role-store.d.ts.map +1 -0
- package/dist/dashboard/server/role-store.js +60 -0
- package/dist/dashboard/server/role-store.js.map +1 -0
- package/dist/dashboard/server/routes/channels.d.ts +4 -0
- package/dist/dashboard/server/routes/channels.d.ts.map +1 -0
- package/dist/dashboard/server/routes/channels.js +262 -0
- package/dist/dashboard/server/routes/channels.js.map +1 -0
- package/dist/dashboard/server/routes/friends.d.ts +7 -0
- package/dist/dashboard/server/routes/friends.d.ts.map +1 -0
- package/dist/dashboard/server/routes/friends.js +130 -0
- package/dist/dashboard/server/routes/friends.js.map +1 -0
- package/dist/dashboard/server/routes/index.d.ts +8 -0
- package/dist/dashboard/server/routes/index.d.ts.map +1 -0
- package/dist/dashboard/server/routes/index.js +13 -0
- package/dist/dashboard/server/routes/index.js.map +1 -0
- package/dist/dashboard/server/routes/me.d.ts +4 -0
- package/dist/dashboard/server/routes/me.d.ts.map +1 -0
- package/dist/dashboard/server/routes/me.js +77 -0
- package/dist/dashboard/server/routes/me.js.map +1 -0
- package/dist/dashboard/server/routes/media-uploads.d.ts +8 -0
- package/dist/dashboard/server/routes/media-uploads.d.ts.map +1 -0
- package/dist/dashboard/server/routes/media-uploads.js +253 -0
- package/dist/dashboard/server/routes/media-uploads.js.map +1 -0
- package/dist/dashboard/server/routes/roles.d.ts +4 -0
- package/dist/dashboard/server/routes/roles.d.ts.map +1 -0
- package/dist/dashboard/server/routes/roles.js +57 -0
- package/dist/dashboard/server/routes/roles.js.map +1 -0
- package/dist/dashboard/server/routes/static.d.ts +4 -0
- package/dist/dashboard/server/routes/static.d.ts.map +1 -0
- package/dist/dashboard/server/routes/static.js +96 -0
- package/dist/dashboard/server/routes/static.js.map +1 -0
- package/dist/dashboard/server/routes/tools.d.ts +4 -0
- package/dist/dashboard/server/routes/tools.d.ts.map +1 -0
- package/dist/dashboard/server/routes/tools.js +355 -0
- package/dist/dashboard/server/routes/tools.js.map +1 -0
- package/dist/dashboard/server/self-profile.d.ts +19 -0
- package/dist/dashboard/server/self-profile.d.ts.map +1 -0
- package/dist/dashboard/server/self-profile.js +68 -0
- package/dist/dashboard/server/self-profile.js.map +1 -0
- package/dist/dashboard/server/sql.d.ts +3 -0
- package/dist/dashboard/server/sql.d.ts.map +1 -0
- package/dist/dashboard/server/sql.js +142 -0
- package/dist/dashboard/server/sql.js.map +1 -0
- package/dist/dashboard/server/types.d.ts +125 -0
- package/dist/dashboard/server/types.d.ts.map +1 -0
- package/dist/dashboard/server/types.js +7 -0
- package/dist/dashboard/server/types.js.map +1 -0
- package/dist/dashboard/server/validation.d.ts +9 -0
- package/dist/dashboard/server/validation.d.ts.map +1 -0
- package/dist/dashboard/server/validation.js +43 -0
- package/dist/dashboard/server/validation.js.map +1 -0
- package/dist/dashboard/web/assets/dashboard-Bta0crBA.js +3 -0
- package/dist/dashboard/web/assets/index-0JKvA2WI.js +2 -0
- package/dist/dashboard/web/assets/index-DIlIxwIo.css +1 -0
- package/dist/dashboard/web/assets/theme-init.js +32 -0
- package/dist/dashboard/web/fonts/PretendardVariable.woff2 +0 -0
- package/dist/dashboard/web/icons/profile-certified.svg +12 -0
- package/dist/dashboard/web/images/favicon.ico +0 -0
- package/dist/dashboard/web/index.html +16 -0
- package/dist/dashboard/web/licenses/LICENSE-FontAwesome-Free +165 -0
- package/dist/dashboard/web/licenses/LICENSE-Fuwari-MIT +21 -0
- package/dist/dashboard/web/licenses/LICENSE-KiwiTalk-APACHE +201 -0
- package/dist/dashboard/web/licenses/LICENSE-Lucide +43 -0
- package/dist/dashboard/web/licenses/LICENSE-MageIcons-APACHE +202 -0
- package/dist/dashboard/web/licenses/LICENSE-MaterialSymbols-APACHE +202 -0
- package/dist/dashboard/web/licenses/LICENSE-Pretendard-OFL +104 -0
- package/dist/dashboard/web/licenses/LICENSE-RemixIcon-APACHE +201 -0
- package/dist/dashboard/web/licenses/LICENSE-Tabler-MIT +21 -0
- package/dist/decorators/index.d.ts +47 -0
- package/dist/decorators/index.d.ts.map +1 -0
- package/dist/decorators/index.js +95 -0
- package/dist/decorators/index.js.map +1 -0
- package/dist/grpc/arisa-grpc.d.ts +62 -0
- package/dist/grpc/arisa-grpc.d.ts.map +1 -0
- package/dist/grpc/arisa-grpc.js +242 -0
- package/dist/grpc/arisa-grpc.js.map +1 -0
- package/dist/grpc/generated/arisa.pb.d.ts +493 -0
- package/dist/grpc/generated/arisa.pb.d.ts.map +1 -0
- package/dist/grpc/generated/arisa.pb.js +3315 -0
- package/dist/grpc/generated/arisa.pb.js.map +1 -0
- package/dist/grpc/generated/google/protobuf/empty.pb.d.ts +38 -0
- package/dist/grpc/generated/google/protobuf/empty.pb.d.ts.map +1 -0
- package/dist/grpc/generated/google/protobuf/empty.pb.js +49 -0
- package/dist/grpc/generated/google/protobuf/empty.pb.js.map +1 -0
- package/dist/grpc/grpc-store.d.ts +32 -0
- package/dist/grpc/grpc-store.d.ts.map +1 -0
- package/dist/grpc/grpc-store.js +376 -0
- package/dist/grpc/grpc-store.js.map +1 -0
- package/dist/grpc/store.d.ts +77 -0
- package/dist/grpc/store.d.ts.map +1 -0
- package/dist/grpc/store.js +7 -0
- package/dist/grpc/store.js.map +1 -0
- package/dist/index.d.ts +12 -0
- package/dist/index.d.ts.map +1 -0
- package/dist/index.js +12 -0
- package/dist/index.js.map +1 -0
- package/dist/kakao-link/index.d.ts +2 -0
- package/dist/kakao-link/index.d.ts.map +1 -0
- package/dist/kakao-link/index.js +7 -0
- package/dist/kakao-link/index.js.map +1 -0
- package/dist/kakao-link/kakao-link.d.ts +112 -0
- package/dist/kakao-link/kakao-link.d.ts.map +1 -0
- package/dist/kakao-link/kakao-link.js +334 -0
- package/dist/kakao-link/kakao-link.js.map +1 -0
- package/dist/types/channel.d.ts +83 -0
- package/dist/types/channel.d.ts.map +1 -0
- package/dist/types/channel.js +7 -0
- package/dist/types/channel.js.map +1 -0
- package/dist/types/chat.d.ts +233 -0
- package/dist/types/chat.d.ts.map +1 -0
- package/dist/types/chat.js +7 -0
- package/dist/types/chat.js.map +1 -0
- package/dist/types/client.d.ts +26 -0
- package/dist/types/client.d.ts.map +1 -0
- package/dist/types/client.js +7 -0
- package/dist/types/client.js.map +1 -0
- package/dist/types/event.d.ts +66 -0
- package/dist/types/event.d.ts.map +1 -0
- package/dist/types/event.js +7 -0
- package/dist/types/event.js.map +1 -0
- package/dist/types/user.d.ts +76 -0
- package/dist/types/user.d.ts.map +1 -0
- package/dist/types/user.js +7 -0
- package/dist/types/user.js.map +1 -0
- package/dist/user/bot-user.d.ts +16 -0
- package/dist/user/bot-user.d.ts.map +1 -0
- package/dist/user/bot-user.js +35 -0
- package/dist/user/bot-user.js.map +1 -0
- package/dist/user/event-user.d.ts +78 -0
- package/dist/user/event-user.d.ts.map +1 -0
- package/dist/user/event-user.js +123 -0
- package/dist/user/event-user.js.map +1 -0
- package/dist/user/index.d.ts +8 -0
- package/dist/user/index.d.ts.map +1 -0
- package/dist/user/index.js +12 -0
- package/dist/user/index.js.map +1 -0
- package/dist/user/normal-user.d.ts +18 -0
- package/dist/user/normal-user.d.ts.map +1 -0
- package/dist/user/normal-user.js +42 -0
- package/dist/user/normal-user.js.map +1 -0
- package/dist/user/open-user.d.ts +20 -0
- package/dist/user/open-user.d.ts.map +1 -0
- package/dist/user/open-user.js +73 -0
- package/dist/user/open-user.js.map +1 -0
- package/dist/user/user-self.d.ts +24 -0
- package/dist/user/user-self.d.ts.map +1 -0
- package/dist/user/user-self.js +72 -0
- package/dist/user/user-self.js.map +1 -0
- package/dist/user/user.d.ts +47 -0
- package/dist/user/user.d.ts.map +1 -0
- package/dist/user/user.js +108 -0
- package/dist/user/user.js.map +1 -0
- package/dist/utils/database/index.d.ts +6 -0
- package/dist/utils/database/index.d.ts.map +1 -0
- package/dist/utils/database/index.js +90 -0
- package/dist/utils/database/index.js.map +1 -0
- package/dist/utils/id/index.d.ts +3 -0
- package/dist/utils/id/index.d.ts.map +1 -0
- package/dist/utils/id/index.js +11 -0
- package/dist/utils/id/index.js.map +1 -0
- package/dist/utils/json/index.d.ts +6 -0
- package/dist/utils/json/index.d.ts.map +1 -0
- package/dist/utils/json/index.js +25 -0
- package/dist/utils/json/index.js.map +1 -0
- package/package.json +83 -4
|
@@ -0,0 +1,3315 @@
|
|
|
1
|
+
// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
|
|
2
|
+
// versions:
|
|
3
|
+
// protoc-gen-ts_proto v2.12.3
|
|
4
|
+
// protoc v7.36.0
|
|
5
|
+
// source: arisa.proto
|
|
6
|
+
/* eslint-disable */
|
|
7
|
+
import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
|
|
8
|
+
import { Empty } from "./google/protobuf/empty.pb.js";
|
|
9
|
+
export const protobufPackage = "arisa.v1";
|
|
10
|
+
export var MediaMode;
|
|
11
|
+
(function (MediaMode) {
|
|
12
|
+
MediaMode[MediaMode["MEDIA_MODE_SINGLE"] = 0] = "MEDIA_MODE_SINGLE";
|
|
13
|
+
MediaMode[MediaMode["MEDIA_MODE_MULTIPLE"] = 1] = "MEDIA_MODE_MULTIPLE";
|
|
14
|
+
MediaMode[MediaMode["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
|
|
15
|
+
})(MediaMode || (MediaMode = {}));
|
|
16
|
+
export var ProfileType;
|
|
17
|
+
(function (ProfileType) {
|
|
18
|
+
ProfileType[ProfileType["PROFILE_TYPE_UNKNOWN"] = 0] = "PROFILE_TYPE_UNKNOWN";
|
|
19
|
+
ProfileType[ProfileType["PROFILE_TYPE_DEFAULT"] = 1] = "PROFILE_TYPE_DEFAULT";
|
|
20
|
+
ProfileType[ProfileType["PROFILE_TYPE_KAKAO"] = 2] = "PROFILE_TYPE_KAKAO";
|
|
21
|
+
ProfileType[ProfileType["PROFILE_TYPE_OPEN"] = 3] = "PROFILE_TYPE_OPEN";
|
|
22
|
+
ProfileType[ProfileType["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
|
|
23
|
+
})(ProfileType || (ProfileType = {}));
|
|
24
|
+
export var LinkMemberType;
|
|
25
|
+
(function (LinkMemberType) {
|
|
26
|
+
LinkMemberType[LinkMemberType["LINK_MEMBER_TYPE_UNKNOWN"] = 0] = "LINK_MEMBER_TYPE_UNKNOWN";
|
|
27
|
+
LinkMemberType[LinkMemberType["LINK_MEMBER_TYPE_HOST"] = 1] = "LINK_MEMBER_TYPE_HOST";
|
|
28
|
+
LinkMemberType[LinkMemberType["LINK_MEMBER_TYPE_MEMBER"] = 2] = "LINK_MEMBER_TYPE_MEMBER";
|
|
29
|
+
LinkMemberType[LinkMemberType["LINK_MEMBER_TYPE_MODERATOR"] = 3] = "LINK_MEMBER_TYPE_MODERATOR";
|
|
30
|
+
LinkMemberType[LinkMemberType["LINK_MEMBER_TYPE_BOT"] = 4] = "LINK_MEMBER_TYPE_BOT";
|
|
31
|
+
LinkMemberType[LinkMemberType["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
|
|
32
|
+
})(LinkMemberType || (LinkMemberType = {}));
|
|
33
|
+
export var MessageScope;
|
|
34
|
+
(function (MessageScope) {
|
|
35
|
+
MessageScope[MessageScope["MESSAGE_SCOPE_UNKNOWN"] = 0] = "MESSAGE_SCOPE_UNKNOWN";
|
|
36
|
+
MessageScope[MessageScope["MESSAGE_SCOPE_CHANNEL"] = 1] = "MESSAGE_SCOPE_CHANNEL";
|
|
37
|
+
MessageScope[MessageScope["MESSAGE_SCOPE_THREAD"] = 2] = "MESSAGE_SCOPE_THREAD";
|
|
38
|
+
MessageScope[MessageScope["MESSAGE_SCOPE_ALL"] = 3] = "MESSAGE_SCOPE_ALL";
|
|
39
|
+
MessageScope[MessageScope["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
|
|
40
|
+
})(MessageScope || (MessageScope = {}));
|
|
41
|
+
function createBaseSubscribeEventsRequest() {
|
|
42
|
+
return {};
|
|
43
|
+
}
|
|
44
|
+
export const SubscribeEventsRequest = {
|
|
45
|
+
encode(_, writer = new BinaryWriter()) {
|
|
46
|
+
return writer;
|
|
47
|
+
},
|
|
48
|
+
decode(input, length) {
|
|
49
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
50
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
51
|
+
if (previousRecursionDepth >= 100) {
|
|
52
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
53
|
+
}
|
|
54
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
55
|
+
try {
|
|
56
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
57
|
+
const message = createBaseSubscribeEventsRequest();
|
|
58
|
+
while (reader.pos < end) {
|
|
59
|
+
const tag = reader.uint32();
|
|
60
|
+
switch (tag >>> 3) {
|
|
61
|
+
}
|
|
62
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
63
|
+
break;
|
|
64
|
+
}
|
|
65
|
+
reader.skip(tag & 7);
|
|
66
|
+
}
|
|
67
|
+
return message;
|
|
68
|
+
}
|
|
69
|
+
finally {
|
|
70
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
71
|
+
}
|
|
72
|
+
},
|
|
73
|
+
create(base) {
|
|
74
|
+
return SubscribeEventsRequest.fromPartial(base ?? {});
|
|
75
|
+
},
|
|
76
|
+
fromPartial(_) {
|
|
77
|
+
const message = createBaseSubscribeEventsRequest();
|
|
78
|
+
return message;
|
|
79
|
+
},
|
|
80
|
+
};
|
|
81
|
+
function createBaseReplyRequest() {
|
|
82
|
+
return { channelId: "0", message: "", threadId: undefined };
|
|
83
|
+
}
|
|
84
|
+
export const ReplyRequest = {
|
|
85
|
+
encode(message, writer = new BinaryWriter()) {
|
|
86
|
+
if (message.channelId !== "0") {
|
|
87
|
+
writer.uint32(8).int64(message.channelId);
|
|
88
|
+
}
|
|
89
|
+
if (message.message !== "") {
|
|
90
|
+
writer.uint32(18).string(message.message);
|
|
91
|
+
}
|
|
92
|
+
if (message.threadId !== undefined) {
|
|
93
|
+
writer.uint32(24).int64(message.threadId);
|
|
94
|
+
}
|
|
95
|
+
return writer;
|
|
96
|
+
},
|
|
97
|
+
decode(input, length) {
|
|
98
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
99
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
100
|
+
if (previousRecursionDepth >= 100) {
|
|
101
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
102
|
+
}
|
|
103
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
104
|
+
try {
|
|
105
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
106
|
+
const message = createBaseReplyRequest();
|
|
107
|
+
while (reader.pos < end) {
|
|
108
|
+
const tag = reader.uint32();
|
|
109
|
+
switch (tag >>> 3) {
|
|
110
|
+
case 1: {
|
|
111
|
+
if (tag !== 8) {
|
|
112
|
+
break;
|
|
113
|
+
}
|
|
114
|
+
message.channelId = reader.int64().toString();
|
|
115
|
+
continue;
|
|
116
|
+
}
|
|
117
|
+
case 2: {
|
|
118
|
+
if (tag !== 18) {
|
|
119
|
+
break;
|
|
120
|
+
}
|
|
121
|
+
message.message = reader.string();
|
|
122
|
+
continue;
|
|
123
|
+
}
|
|
124
|
+
case 3: {
|
|
125
|
+
if (tag !== 24) {
|
|
126
|
+
break;
|
|
127
|
+
}
|
|
128
|
+
message.threadId = reader.int64().toString();
|
|
129
|
+
continue;
|
|
130
|
+
}
|
|
131
|
+
}
|
|
132
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
133
|
+
break;
|
|
134
|
+
}
|
|
135
|
+
reader.skip(tag & 7);
|
|
136
|
+
}
|
|
137
|
+
return message;
|
|
138
|
+
}
|
|
139
|
+
finally {
|
|
140
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
141
|
+
}
|
|
142
|
+
},
|
|
143
|
+
create(base) {
|
|
144
|
+
return ReplyRequest.fromPartial(base ?? {});
|
|
145
|
+
},
|
|
146
|
+
fromPartial(object) {
|
|
147
|
+
const message = createBaseReplyRequest();
|
|
148
|
+
message.channelId = object.channelId ?? "0";
|
|
149
|
+
message.message = object.message ?? "";
|
|
150
|
+
message.threadId = object.threadId ?? undefined;
|
|
151
|
+
return message;
|
|
152
|
+
},
|
|
153
|
+
};
|
|
154
|
+
function createBaseMarkReadRequest() {
|
|
155
|
+
return { channelId: "0" };
|
|
156
|
+
}
|
|
157
|
+
export const MarkReadRequest = {
|
|
158
|
+
encode(message, writer = new BinaryWriter()) {
|
|
159
|
+
if (message.channelId !== "0") {
|
|
160
|
+
writer.uint32(8).int64(message.channelId);
|
|
161
|
+
}
|
|
162
|
+
return writer;
|
|
163
|
+
},
|
|
164
|
+
decode(input, length) {
|
|
165
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
166
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
167
|
+
if (previousRecursionDepth >= 100) {
|
|
168
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
169
|
+
}
|
|
170
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
171
|
+
try {
|
|
172
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
173
|
+
const message = createBaseMarkReadRequest();
|
|
174
|
+
while (reader.pos < end) {
|
|
175
|
+
const tag = reader.uint32();
|
|
176
|
+
switch (tag >>> 3) {
|
|
177
|
+
case 1: {
|
|
178
|
+
if (tag !== 8) {
|
|
179
|
+
break;
|
|
180
|
+
}
|
|
181
|
+
message.channelId = reader.int64().toString();
|
|
182
|
+
continue;
|
|
183
|
+
}
|
|
184
|
+
}
|
|
185
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
186
|
+
break;
|
|
187
|
+
}
|
|
188
|
+
reader.skip(tag & 7);
|
|
189
|
+
}
|
|
190
|
+
return message;
|
|
191
|
+
}
|
|
192
|
+
finally {
|
|
193
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
194
|
+
}
|
|
195
|
+
},
|
|
196
|
+
create(base) {
|
|
197
|
+
return MarkReadRequest.fromPartial(base ?? {});
|
|
198
|
+
},
|
|
199
|
+
fromPartial(object) {
|
|
200
|
+
const message = createBaseMarkReadRequest();
|
|
201
|
+
message.channelId = object.channelId ?? "0";
|
|
202
|
+
return message;
|
|
203
|
+
},
|
|
204
|
+
};
|
|
205
|
+
function createBaseEnterChannelRequest() {
|
|
206
|
+
return { channelId: "0" };
|
|
207
|
+
}
|
|
208
|
+
export const EnterChannelRequest = {
|
|
209
|
+
encode(message, writer = new BinaryWriter()) {
|
|
210
|
+
if (message.channelId !== "0") {
|
|
211
|
+
writer.uint32(8).int64(message.channelId);
|
|
212
|
+
}
|
|
213
|
+
return writer;
|
|
214
|
+
},
|
|
215
|
+
decode(input, length) {
|
|
216
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
217
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
218
|
+
if (previousRecursionDepth >= 100) {
|
|
219
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
220
|
+
}
|
|
221
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
222
|
+
try {
|
|
223
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
224
|
+
const message = createBaseEnterChannelRequest();
|
|
225
|
+
while (reader.pos < end) {
|
|
226
|
+
const tag = reader.uint32();
|
|
227
|
+
switch (tag >>> 3) {
|
|
228
|
+
case 1: {
|
|
229
|
+
if (tag !== 8) {
|
|
230
|
+
break;
|
|
231
|
+
}
|
|
232
|
+
message.channelId = reader.int64().toString();
|
|
233
|
+
continue;
|
|
234
|
+
}
|
|
235
|
+
}
|
|
236
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
237
|
+
break;
|
|
238
|
+
}
|
|
239
|
+
reader.skip(tag & 7);
|
|
240
|
+
}
|
|
241
|
+
return message;
|
|
242
|
+
}
|
|
243
|
+
finally {
|
|
244
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
245
|
+
}
|
|
246
|
+
},
|
|
247
|
+
create(base) {
|
|
248
|
+
return EnterChannelRequest.fromPartial(base ?? {});
|
|
249
|
+
},
|
|
250
|
+
fromPartial(object) {
|
|
251
|
+
const message = createBaseEnterChannelRequest();
|
|
252
|
+
message.channelId = object.channelId ?? "0";
|
|
253
|
+
return message;
|
|
254
|
+
},
|
|
255
|
+
};
|
|
256
|
+
function createBaseMediaFile() {
|
|
257
|
+
return { name: undefined, mime: "", data: Buffer.alloc(0) };
|
|
258
|
+
}
|
|
259
|
+
export const MediaFile = {
|
|
260
|
+
encode(message, writer = new BinaryWriter()) {
|
|
261
|
+
if (message.name !== undefined) {
|
|
262
|
+
writer.uint32(10).string(message.name);
|
|
263
|
+
}
|
|
264
|
+
if (message.mime !== "") {
|
|
265
|
+
writer.uint32(18).string(message.mime);
|
|
266
|
+
}
|
|
267
|
+
if (message.data.length !== 0) {
|
|
268
|
+
writer.uint32(26).bytes(message.data);
|
|
269
|
+
}
|
|
270
|
+
return writer;
|
|
271
|
+
},
|
|
272
|
+
decode(input, length) {
|
|
273
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
274
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
275
|
+
if (previousRecursionDepth >= 100) {
|
|
276
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
277
|
+
}
|
|
278
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
279
|
+
try {
|
|
280
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
281
|
+
const message = createBaseMediaFile();
|
|
282
|
+
while (reader.pos < end) {
|
|
283
|
+
const tag = reader.uint32();
|
|
284
|
+
switch (tag >>> 3) {
|
|
285
|
+
case 1: {
|
|
286
|
+
if (tag !== 10) {
|
|
287
|
+
break;
|
|
288
|
+
}
|
|
289
|
+
message.name = reader.string();
|
|
290
|
+
continue;
|
|
291
|
+
}
|
|
292
|
+
case 2: {
|
|
293
|
+
if (tag !== 18) {
|
|
294
|
+
break;
|
|
295
|
+
}
|
|
296
|
+
message.mime = reader.string();
|
|
297
|
+
continue;
|
|
298
|
+
}
|
|
299
|
+
case 3: {
|
|
300
|
+
if (tag !== 26) {
|
|
301
|
+
break;
|
|
302
|
+
}
|
|
303
|
+
message.data = Buffer.from(reader.bytes());
|
|
304
|
+
continue;
|
|
305
|
+
}
|
|
306
|
+
}
|
|
307
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
308
|
+
break;
|
|
309
|
+
}
|
|
310
|
+
reader.skip(tag & 7);
|
|
311
|
+
}
|
|
312
|
+
return message;
|
|
313
|
+
}
|
|
314
|
+
finally {
|
|
315
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
316
|
+
}
|
|
317
|
+
},
|
|
318
|
+
create(base) {
|
|
319
|
+
return MediaFile.fromPartial(base ?? {});
|
|
320
|
+
},
|
|
321
|
+
fromPartial(object) {
|
|
322
|
+
const message = createBaseMediaFile();
|
|
323
|
+
message.name = object.name ?? undefined;
|
|
324
|
+
message.mime = object.mime ?? "";
|
|
325
|
+
message.data = object.data ?? Buffer.alloc(0);
|
|
326
|
+
return message;
|
|
327
|
+
},
|
|
328
|
+
};
|
|
329
|
+
function createBaseSendMediaRequest() {
|
|
330
|
+
return { channelId: "0", mode: 0, files: [] };
|
|
331
|
+
}
|
|
332
|
+
export const SendMediaRequest = {
|
|
333
|
+
encode(message, writer = new BinaryWriter()) {
|
|
334
|
+
if (message.channelId !== "0") {
|
|
335
|
+
writer.uint32(8).int64(message.channelId);
|
|
336
|
+
}
|
|
337
|
+
if (message.mode !== 0) {
|
|
338
|
+
writer.uint32(16).int32(message.mode);
|
|
339
|
+
}
|
|
340
|
+
for (const v of message.files) {
|
|
341
|
+
MediaFile.encode(v, writer.uint32(26).fork()).join();
|
|
342
|
+
}
|
|
343
|
+
return writer;
|
|
344
|
+
},
|
|
345
|
+
decode(input, length) {
|
|
346
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
347
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
348
|
+
if (previousRecursionDepth >= 100) {
|
|
349
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
350
|
+
}
|
|
351
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
352
|
+
try {
|
|
353
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
354
|
+
const message = createBaseSendMediaRequest();
|
|
355
|
+
while (reader.pos < end) {
|
|
356
|
+
const tag = reader.uint32();
|
|
357
|
+
switch (tag >>> 3) {
|
|
358
|
+
case 1: {
|
|
359
|
+
if (tag !== 8) {
|
|
360
|
+
break;
|
|
361
|
+
}
|
|
362
|
+
message.channelId = reader.int64().toString();
|
|
363
|
+
continue;
|
|
364
|
+
}
|
|
365
|
+
case 2: {
|
|
366
|
+
if (tag !== 16) {
|
|
367
|
+
break;
|
|
368
|
+
}
|
|
369
|
+
message.mode = reader.int32();
|
|
370
|
+
continue;
|
|
371
|
+
}
|
|
372
|
+
case 3: {
|
|
373
|
+
if (tag !== 26) {
|
|
374
|
+
break;
|
|
375
|
+
}
|
|
376
|
+
message.files.push(MediaFile.decode(reader, reader.uint32()));
|
|
377
|
+
continue;
|
|
378
|
+
}
|
|
379
|
+
}
|
|
380
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
381
|
+
break;
|
|
382
|
+
}
|
|
383
|
+
reader.skip(tag & 7);
|
|
384
|
+
}
|
|
385
|
+
return message;
|
|
386
|
+
}
|
|
387
|
+
finally {
|
|
388
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
389
|
+
}
|
|
390
|
+
},
|
|
391
|
+
create(base) {
|
|
392
|
+
return SendMediaRequest.fromPartial(base ?? {});
|
|
393
|
+
},
|
|
394
|
+
fromPartial(object) {
|
|
395
|
+
const message = createBaseSendMediaRequest();
|
|
396
|
+
message.channelId = object.channelId ?? "0";
|
|
397
|
+
message.mode = object.mode ?? 0;
|
|
398
|
+
message.files = object.files?.map((e) => MediaFile.fromPartial(e)) || [];
|
|
399
|
+
return message;
|
|
400
|
+
},
|
|
401
|
+
};
|
|
402
|
+
function createBaseSendMediaByChunkRequest() {
|
|
403
|
+
return { payload: undefined };
|
|
404
|
+
}
|
|
405
|
+
export const SendMediaByChunkRequest = {
|
|
406
|
+
encode(message, writer = new BinaryWriter()) {
|
|
407
|
+
switch (message.payload?.$case) {
|
|
408
|
+
case "metadata":
|
|
409
|
+
SendMediaByChunkMetadata.encode(message.payload.metadata, writer.uint32(10).fork()).join();
|
|
410
|
+
break;
|
|
411
|
+
case "fileMetadata":
|
|
412
|
+
MediaFileMetadata.encode(message.payload.fileMetadata, writer.uint32(18).fork()).join();
|
|
413
|
+
break;
|
|
414
|
+
case "chunk":
|
|
415
|
+
writer.uint32(26).bytes(message.payload.chunk);
|
|
416
|
+
break;
|
|
417
|
+
}
|
|
418
|
+
return writer;
|
|
419
|
+
},
|
|
420
|
+
decode(input, length) {
|
|
421
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
422
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
423
|
+
if (previousRecursionDepth >= 100) {
|
|
424
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
425
|
+
}
|
|
426
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
427
|
+
try {
|
|
428
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
429
|
+
const message = createBaseSendMediaByChunkRequest();
|
|
430
|
+
while (reader.pos < end) {
|
|
431
|
+
const tag = reader.uint32();
|
|
432
|
+
switch (tag >>> 3) {
|
|
433
|
+
case 1: {
|
|
434
|
+
if (tag !== 10) {
|
|
435
|
+
break;
|
|
436
|
+
}
|
|
437
|
+
message.payload = { $case: "metadata", metadata: SendMediaByChunkMetadata.decode(reader, reader.uint32()) };
|
|
438
|
+
continue;
|
|
439
|
+
}
|
|
440
|
+
case 2: {
|
|
441
|
+
if (tag !== 18) {
|
|
442
|
+
break;
|
|
443
|
+
}
|
|
444
|
+
message.payload = {
|
|
445
|
+
$case: "fileMetadata",
|
|
446
|
+
fileMetadata: MediaFileMetadata.decode(reader, reader.uint32()),
|
|
447
|
+
};
|
|
448
|
+
continue;
|
|
449
|
+
}
|
|
450
|
+
case 3: {
|
|
451
|
+
if (tag !== 26) {
|
|
452
|
+
break;
|
|
453
|
+
}
|
|
454
|
+
message.payload = { $case: "chunk", chunk: Buffer.from(reader.bytes()) };
|
|
455
|
+
continue;
|
|
456
|
+
}
|
|
457
|
+
}
|
|
458
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
459
|
+
break;
|
|
460
|
+
}
|
|
461
|
+
reader.skip(tag & 7);
|
|
462
|
+
}
|
|
463
|
+
return message;
|
|
464
|
+
}
|
|
465
|
+
finally {
|
|
466
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
467
|
+
}
|
|
468
|
+
},
|
|
469
|
+
create(base) {
|
|
470
|
+
return SendMediaByChunkRequest.fromPartial(base ?? {});
|
|
471
|
+
},
|
|
472
|
+
fromPartial(object) {
|
|
473
|
+
const message = createBaseSendMediaByChunkRequest();
|
|
474
|
+
switch (object.payload?.$case) {
|
|
475
|
+
case "metadata": {
|
|
476
|
+
if (object.payload?.metadata !== undefined && object.payload?.metadata !== null) {
|
|
477
|
+
message.payload = {
|
|
478
|
+
$case: "metadata",
|
|
479
|
+
metadata: SendMediaByChunkMetadata.fromPartial(object.payload.metadata),
|
|
480
|
+
};
|
|
481
|
+
}
|
|
482
|
+
break;
|
|
483
|
+
}
|
|
484
|
+
case "fileMetadata": {
|
|
485
|
+
if (object.payload?.fileMetadata !== undefined && object.payload?.fileMetadata !== null) {
|
|
486
|
+
message.payload = {
|
|
487
|
+
$case: "fileMetadata",
|
|
488
|
+
fileMetadata: MediaFileMetadata.fromPartial(object.payload.fileMetadata),
|
|
489
|
+
};
|
|
490
|
+
}
|
|
491
|
+
break;
|
|
492
|
+
}
|
|
493
|
+
case "chunk": {
|
|
494
|
+
if (object.payload?.chunk !== undefined && object.payload?.chunk !== null) {
|
|
495
|
+
message.payload = { $case: "chunk", chunk: object.payload.chunk };
|
|
496
|
+
}
|
|
497
|
+
break;
|
|
498
|
+
}
|
|
499
|
+
}
|
|
500
|
+
return message;
|
|
501
|
+
},
|
|
502
|
+
};
|
|
503
|
+
function createBaseSendMediaByChunkMetadata() {
|
|
504
|
+
return { channelId: "0", fileCount: 0, mode: 0 };
|
|
505
|
+
}
|
|
506
|
+
export const SendMediaByChunkMetadata = {
|
|
507
|
+
encode(message, writer = new BinaryWriter()) {
|
|
508
|
+
if (message.channelId !== "0") {
|
|
509
|
+
writer.uint32(8).int64(message.channelId);
|
|
510
|
+
}
|
|
511
|
+
if (message.fileCount !== 0) {
|
|
512
|
+
writer.uint32(16).uint32(message.fileCount);
|
|
513
|
+
}
|
|
514
|
+
if (message.mode !== 0) {
|
|
515
|
+
writer.uint32(24).int32(message.mode);
|
|
516
|
+
}
|
|
517
|
+
return writer;
|
|
518
|
+
},
|
|
519
|
+
decode(input, length) {
|
|
520
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
521
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
522
|
+
if (previousRecursionDepth >= 100) {
|
|
523
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
524
|
+
}
|
|
525
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
526
|
+
try {
|
|
527
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
528
|
+
const message = createBaseSendMediaByChunkMetadata();
|
|
529
|
+
while (reader.pos < end) {
|
|
530
|
+
const tag = reader.uint32();
|
|
531
|
+
switch (tag >>> 3) {
|
|
532
|
+
case 1: {
|
|
533
|
+
if (tag !== 8) {
|
|
534
|
+
break;
|
|
535
|
+
}
|
|
536
|
+
message.channelId = reader.int64().toString();
|
|
537
|
+
continue;
|
|
538
|
+
}
|
|
539
|
+
case 2: {
|
|
540
|
+
if (tag !== 16) {
|
|
541
|
+
break;
|
|
542
|
+
}
|
|
543
|
+
message.fileCount = reader.uint32();
|
|
544
|
+
continue;
|
|
545
|
+
}
|
|
546
|
+
case 3: {
|
|
547
|
+
if (tag !== 24) {
|
|
548
|
+
break;
|
|
549
|
+
}
|
|
550
|
+
message.mode = reader.int32();
|
|
551
|
+
continue;
|
|
552
|
+
}
|
|
553
|
+
}
|
|
554
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
555
|
+
break;
|
|
556
|
+
}
|
|
557
|
+
reader.skip(tag & 7);
|
|
558
|
+
}
|
|
559
|
+
return message;
|
|
560
|
+
}
|
|
561
|
+
finally {
|
|
562
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
563
|
+
}
|
|
564
|
+
},
|
|
565
|
+
create(base) {
|
|
566
|
+
return SendMediaByChunkMetadata.fromPartial(base ?? {});
|
|
567
|
+
},
|
|
568
|
+
fromPartial(object) {
|
|
569
|
+
const message = createBaseSendMediaByChunkMetadata();
|
|
570
|
+
message.channelId = object.channelId ?? "0";
|
|
571
|
+
message.fileCount = object.fileCount ?? 0;
|
|
572
|
+
message.mode = object.mode ?? 0;
|
|
573
|
+
return message;
|
|
574
|
+
},
|
|
575
|
+
};
|
|
576
|
+
function createBaseMediaFileMetadata() {
|
|
577
|
+
return { fileName: "", fileSize: "0", contentType: "" };
|
|
578
|
+
}
|
|
579
|
+
export const MediaFileMetadata = {
|
|
580
|
+
encode(message, writer = new BinaryWriter()) {
|
|
581
|
+
if (message.fileName !== "") {
|
|
582
|
+
writer.uint32(10).string(message.fileName);
|
|
583
|
+
}
|
|
584
|
+
if (message.fileSize !== "0") {
|
|
585
|
+
writer.uint32(16).uint64(message.fileSize);
|
|
586
|
+
}
|
|
587
|
+
if (message.contentType !== "") {
|
|
588
|
+
writer.uint32(26).string(message.contentType);
|
|
589
|
+
}
|
|
590
|
+
return writer;
|
|
591
|
+
},
|
|
592
|
+
decode(input, length) {
|
|
593
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
594
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
595
|
+
if (previousRecursionDepth >= 100) {
|
|
596
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
597
|
+
}
|
|
598
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
599
|
+
try {
|
|
600
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
601
|
+
const message = createBaseMediaFileMetadata();
|
|
602
|
+
while (reader.pos < end) {
|
|
603
|
+
const tag = reader.uint32();
|
|
604
|
+
switch (tag >>> 3) {
|
|
605
|
+
case 1: {
|
|
606
|
+
if (tag !== 10) {
|
|
607
|
+
break;
|
|
608
|
+
}
|
|
609
|
+
message.fileName = reader.string();
|
|
610
|
+
continue;
|
|
611
|
+
}
|
|
612
|
+
case 2: {
|
|
613
|
+
if (tag !== 16) {
|
|
614
|
+
break;
|
|
615
|
+
}
|
|
616
|
+
message.fileSize = reader.uint64().toString();
|
|
617
|
+
continue;
|
|
618
|
+
}
|
|
619
|
+
case 3: {
|
|
620
|
+
if (tag !== 26) {
|
|
621
|
+
break;
|
|
622
|
+
}
|
|
623
|
+
message.contentType = reader.string();
|
|
624
|
+
continue;
|
|
625
|
+
}
|
|
626
|
+
}
|
|
627
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
628
|
+
break;
|
|
629
|
+
}
|
|
630
|
+
reader.skip(tag & 7);
|
|
631
|
+
}
|
|
632
|
+
return message;
|
|
633
|
+
}
|
|
634
|
+
finally {
|
|
635
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
636
|
+
}
|
|
637
|
+
},
|
|
638
|
+
create(base) {
|
|
639
|
+
return MediaFileMetadata.fromPartial(base ?? {});
|
|
640
|
+
},
|
|
641
|
+
fromPartial(object) {
|
|
642
|
+
const message = createBaseMediaFileMetadata();
|
|
643
|
+
message.fileName = object.fileName ?? "";
|
|
644
|
+
message.fileSize = object.fileSize ?? "0";
|
|
645
|
+
message.contentType = object.contentType ?? "";
|
|
646
|
+
return message;
|
|
647
|
+
},
|
|
648
|
+
};
|
|
649
|
+
function createBaseGetUserRequest() {
|
|
650
|
+
return { channelId: "0", userId: "0" };
|
|
651
|
+
}
|
|
652
|
+
export const GetUserRequest = {
|
|
653
|
+
encode(message, writer = new BinaryWriter()) {
|
|
654
|
+
if (message.channelId !== "0") {
|
|
655
|
+
writer.uint32(8).int64(message.channelId);
|
|
656
|
+
}
|
|
657
|
+
if (message.userId !== "0") {
|
|
658
|
+
writer.uint32(16).int64(message.userId);
|
|
659
|
+
}
|
|
660
|
+
return writer;
|
|
661
|
+
},
|
|
662
|
+
decode(input, length) {
|
|
663
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
664
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
665
|
+
if (previousRecursionDepth >= 100) {
|
|
666
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
667
|
+
}
|
|
668
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
669
|
+
try {
|
|
670
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
671
|
+
const message = createBaseGetUserRequest();
|
|
672
|
+
while (reader.pos < end) {
|
|
673
|
+
const tag = reader.uint32();
|
|
674
|
+
switch (tag >>> 3) {
|
|
675
|
+
case 1: {
|
|
676
|
+
if (tag !== 8) {
|
|
677
|
+
break;
|
|
678
|
+
}
|
|
679
|
+
message.channelId = reader.int64().toString();
|
|
680
|
+
continue;
|
|
681
|
+
}
|
|
682
|
+
case 2: {
|
|
683
|
+
if (tag !== 16) {
|
|
684
|
+
break;
|
|
685
|
+
}
|
|
686
|
+
message.userId = reader.int64().toString();
|
|
687
|
+
continue;
|
|
688
|
+
}
|
|
689
|
+
}
|
|
690
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
691
|
+
break;
|
|
692
|
+
}
|
|
693
|
+
reader.skip(tag & 7);
|
|
694
|
+
}
|
|
695
|
+
return message;
|
|
696
|
+
}
|
|
697
|
+
finally {
|
|
698
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
699
|
+
}
|
|
700
|
+
},
|
|
701
|
+
create(base) {
|
|
702
|
+
return GetUserRequest.fromPartial(base ?? {});
|
|
703
|
+
},
|
|
704
|
+
fromPartial(object) {
|
|
705
|
+
const message = createBaseGetUserRequest();
|
|
706
|
+
message.channelId = object.channelId ?? "0";
|
|
707
|
+
message.userId = object.userId ?? "0";
|
|
708
|
+
return message;
|
|
709
|
+
},
|
|
710
|
+
};
|
|
711
|
+
function createBaseGetUsersRequest() {
|
|
712
|
+
return { channelId: "0", userIds: [] };
|
|
713
|
+
}
|
|
714
|
+
export const GetUsersRequest = {
|
|
715
|
+
encode(message, writer = new BinaryWriter()) {
|
|
716
|
+
if (message.channelId !== "0") {
|
|
717
|
+
writer.uint32(8).int64(message.channelId);
|
|
718
|
+
}
|
|
719
|
+
writer.uint32(18).fork();
|
|
720
|
+
for (const v of message.userIds) {
|
|
721
|
+
writer.int64(v);
|
|
722
|
+
}
|
|
723
|
+
writer.join();
|
|
724
|
+
return writer;
|
|
725
|
+
},
|
|
726
|
+
decode(input, length) {
|
|
727
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
728
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
729
|
+
if (previousRecursionDepth >= 100) {
|
|
730
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
731
|
+
}
|
|
732
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
733
|
+
try {
|
|
734
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
735
|
+
const message = createBaseGetUsersRequest();
|
|
736
|
+
while (reader.pos < end) {
|
|
737
|
+
const tag = reader.uint32();
|
|
738
|
+
switch (tag >>> 3) {
|
|
739
|
+
case 1: {
|
|
740
|
+
if (tag !== 8) {
|
|
741
|
+
break;
|
|
742
|
+
}
|
|
743
|
+
message.channelId = reader.int64().toString();
|
|
744
|
+
continue;
|
|
745
|
+
}
|
|
746
|
+
case 2: {
|
|
747
|
+
if (tag === 16) {
|
|
748
|
+
message.userIds.push(reader.int64().toString());
|
|
749
|
+
continue;
|
|
750
|
+
}
|
|
751
|
+
if (tag === 18) {
|
|
752
|
+
const end2 = reader.uint32() + reader.pos;
|
|
753
|
+
while (reader.pos < end2) {
|
|
754
|
+
message.userIds.push(reader.int64().toString());
|
|
755
|
+
}
|
|
756
|
+
continue;
|
|
757
|
+
}
|
|
758
|
+
break;
|
|
759
|
+
}
|
|
760
|
+
}
|
|
761
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
762
|
+
break;
|
|
763
|
+
}
|
|
764
|
+
reader.skip(tag & 7);
|
|
765
|
+
}
|
|
766
|
+
return message;
|
|
767
|
+
}
|
|
768
|
+
finally {
|
|
769
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
770
|
+
}
|
|
771
|
+
},
|
|
772
|
+
create(base) {
|
|
773
|
+
return GetUsersRequest.fromPartial(base ?? {});
|
|
774
|
+
},
|
|
775
|
+
fromPartial(object) {
|
|
776
|
+
const message = createBaseGetUsersRequest();
|
|
777
|
+
message.channelId = object.channelId ?? "0";
|
|
778
|
+
message.userIds = object.userIds?.map((e) => e) || [];
|
|
779
|
+
return message;
|
|
780
|
+
},
|
|
781
|
+
};
|
|
782
|
+
function createBaseGetUsersResponse() {
|
|
783
|
+
return { members: [] };
|
|
784
|
+
}
|
|
785
|
+
export const GetUsersResponse = {
|
|
786
|
+
encode(message, writer = new BinaryWriter()) {
|
|
787
|
+
for (const v of message.members) {
|
|
788
|
+
Member.encode(v, writer.uint32(10).fork()).join();
|
|
789
|
+
}
|
|
790
|
+
return writer;
|
|
791
|
+
},
|
|
792
|
+
decode(input, length) {
|
|
793
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
794
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
795
|
+
if (previousRecursionDepth >= 100) {
|
|
796
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
797
|
+
}
|
|
798
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
799
|
+
try {
|
|
800
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
801
|
+
const message = createBaseGetUsersResponse();
|
|
802
|
+
while (reader.pos < end) {
|
|
803
|
+
const tag = reader.uint32();
|
|
804
|
+
switch (tag >>> 3) {
|
|
805
|
+
case 1: {
|
|
806
|
+
if (tag !== 10) {
|
|
807
|
+
break;
|
|
808
|
+
}
|
|
809
|
+
message.members.push(Member.decode(reader, reader.uint32()));
|
|
810
|
+
continue;
|
|
811
|
+
}
|
|
812
|
+
}
|
|
813
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
814
|
+
break;
|
|
815
|
+
}
|
|
816
|
+
reader.skip(tag & 7);
|
|
817
|
+
}
|
|
818
|
+
return message;
|
|
819
|
+
}
|
|
820
|
+
finally {
|
|
821
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
822
|
+
}
|
|
823
|
+
},
|
|
824
|
+
create(base) {
|
|
825
|
+
return GetUsersResponse.fromPartial(base ?? {});
|
|
826
|
+
},
|
|
827
|
+
fromPartial(object) {
|
|
828
|
+
const message = createBaseGetUsersResponse();
|
|
829
|
+
message.members = object.members?.map((e) => Member.fromPartial(e)) || [];
|
|
830
|
+
return message;
|
|
831
|
+
},
|
|
832
|
+
};
|
|
833
|
+
function createBaseGetChannelRequest() {
|
|
834
|
+
return { channelId: "0" };
|
|
835
|
+
}
|
|
836
|
+
export const GetChannelRequest = {
|
|
837
|
+
encode(message, writer = new BinaryWriter()) {
|
|
838
|
+
if (message.channelId !== "0") {
|
|
839
|
+
writer.uint32(8).int64(message.channelId);
|
|
840
|
+
}
|
|
841
|
+
return writer;
|
|
842
|
+
},
|
|
843
|
+
decode(input, length) {
|
|
844
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
845
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
846
|
+
if (previousRecursionDepth >= 100) {
|
|
847
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
848
|
+
}
|
|
849
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
850
|
+
try {
|
|
851
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
852
|
+
const message = createBaseGetChannelRequest();
|
|
853
|
+
while (reader.pos < end) {
|
|
854
|
+
const tag = reader.uint32();
|
|
855
|
+
switch (tag >>> 3) {
|
|
856
|
+
case 1: {
|
|
857
|
+
if (tag !== 8) {
|
|
858
|
+
break;
|
|
859
|
+
}
|
|
860
|
+
message.channelId = reader.int64().toString();
|
|
861
|
+
continue;
|
|
862
|
+
}
|
|
863
|
+
}
|
|
864
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
865
|
+
break;
|
|
866
|
+
}
|
|
867
|
+
reader.skip(tag & 7);
|
|
868
|
+
}
|
|
869
|
+
return message;
|
|
870
|
+
}
|
|
871
|
+
finally {
|
|
872
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
873
|
+
}
|
|
874
|
+
},
|
|
875
|
+
create(base) {
|
|
876
|
+
return GetChannelRequest.fromPartial(base ?? {});
|
|
877
|
+
},
|
|
878
|
+
fromPartial(object) {
|
|
879
|
+
const message = createBaseGetChannelRequest();
|
|
880
|
+
message.channelId = object.channelId ?? "0";
|
|
881
|
+
return message;
|
|
882
|
+
},
|
|
883
|
+
};
|
|
884
|
+
function createBaseGetMessageRequest() {
|
|
885
|
+
return { channelId: "0", messageId: "0" };
|
|
886
|
+
}
|
|
887
|
+
export const GetMessageRequest = {
|
|
888
|
+
encode(message, writer = new BinaryWriter()) {
|
|
889
|
+
if (message.channelId !== "0") {
|
|
890
|
+
writer.uint32(8).int64(message.channelId);
|
|
891
|
+
}
|
|
892
|
+
if (message.messageId !== "0") {
|
|
893
|
+
writer.uint32(16).int64(message.messageId);
|
|
894
|
+
}
|
|
895
|
+
return writer;
|
|
896
|
+
},
|
|
897
|
+
decode(input, length) {
|
|
898
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
899
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
900
|
+
if (previousRecursionDepth >= 100) {
|
|
901
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
902
|
+
}
|
|
903
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
904
|
+
try {
|
|
905
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
906
|
+
const message = createBaseGetMessageRequest();
|
|
907
|
+
while (reader.pos < end) {
|
|
908
|
+
const tag = reader.uint32();
|
|
909
|
+
switch (tag >>> 3) {
|
|
910
|
+
case 1: {
|
|
911
|
+
if (tag !== 8) {
|
|
912
|
+
break;
|
|
913
|
+
}
|
|
914
|
+
message.channelId = reader.int64().toString();
|
|
915
|
+
continue;
|
|
916
|
+
}
|
|
917
|
+
case 2: {
|
|
918
|
+
if (tag !== 16) {
|
|
919
|
+
break;
|
|
920
|
+
}
|
|
921
|
+
message.messageId = reader.int64().toString();
|
|
922
|
+
continue;
|
|
923
|
+
}
|
|
924
|
+
}
|
|
925
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
926
|
+
break;
|
|
927
|
+
}
|
|
928
|
+
reader.skip(tag & 7);
|
|
929
|
+
}
|
|
930
|
+
return message;
|
|
931
|
+
}
|
|
932
|
+
finally {
|
|
933
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
934
|
+
}
|
|
935
|
+
},
|
|
936
|
+
create(base) {
|
|
937
|
+
return GetMessageRequest.fromPartial(base ?? {});
|
|
938
|
+
},
|
|
939
|
+
fromPartial(object) {
|
|
940
|
+
const message = createBaseGetMessageRequest();
|
|
941
|
+
message.channelId = object.channelId ?? "0";
|
|
942
|
+
message.messageId = object.messageId ?? "0";
|
|
943
|
+
return message;
|
|
944
|
+
},
|
|
945
|
+
};
|
|
946
|
+
function createBaseGetMessagesRequest() {
|
|
947
|
+
return { channelId: "0", messageIds: [] };
|
|
948
|
+
}
|
|
949
|
+
export const GetMessagesRequest = {
|
|
950
|
+
encode(message, writer = new BinaryWriter()) {
|
|
951
|
+
if (message.channelId !== "0") {
|
|
952
|
+
writer.uint32(8).int64(message.channelId);
|
|
953
|
+
}
|
|
954
|
+
writer.uint32(18).fork();
|
|
955
|
+
for (const v of message.messageIds) {
|
|
956
|
+
writer.int64(v);
|
|
957
|
+
}
|
|
958
|
+
writer.join();
|
|
959
|
+
return writer;
|
|
960
|
+
},
|
|
961
|
+
decode(input, length) {
|
|
962
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
963
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
964
|
+
if (previousRecursionDepth >= 100) {
|
|
965
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
966
|
+
}
|
|
967
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
968
|
+
try {
|
|
969
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
970
|
+
const message = createBaseGetMessagesRequest();
|
|
971
|
+
while (reader.pos < end) {
|
|
972
|
+
const tag = reader.uint32();
|
|
973
|
+
switch (tag >>> 3) {
|
|
974
|
+
case 1: {
|
|
975
|
+
if (tag !== 8) {
|
|
976
|
+
break;
|
|
977
|
+
}
|
|
978
|
+
message.channelId = reader.int64().toString();
|
|
979
|
+
continue;
|
|
980
|
+
}
|
|
981
|
+
case 2: {
|
|
982
|
+
if (tag === 16) {
|
|
983
|
+
message.messageIds.push(reader.int64().toString());
|
|
984
|
+
continue;
|
|
985
|
+
}
|
|
986
|
+
if (tag === 18) {
|
|
987
|
+
const end2 = reader.uint32() + reader.pos;
|
|
988
|
+
while (reader.pos < end2) {
|
|
989
|
+
message.messageIds.push(reader.int64().toString());
|
|
990
|
+
}
|
|
991
|
+
continue;
|
|
992
|
+
}
|
|
993
|
+
break;
|
|
994
|
+
}
|
|
995
|
+
}
|
|
996
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
997
|
+
break;
|
|
998
|
+
}
|
|
999
|
+
reader.skip(tag & 7);
|
|
1000
|
+
}
|
|
1001
|
+
return message;
|
|
1002
|
+
}
|
|
1003
|
+
finally {
|
|
1004
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
1005
|
+
}
|
|
1006
|
+
},
|
|
1007
|
+
create(base) {
|
|
1008
|
+
return GetMessagesRequest.fromPartial(base ?? {});
|
|
1009
|
+
},
|
|
1010
|
+
fromPartial(object) {
|
|
1011
|
+
const message = createBaseGetMessagesRequest();
|
|
1012
|
+
message.channelId = object.channelId ?? "0";
|
|
1013
|
+
message.messageIds = object.messageIds?.map((e) => e) || [];
|
|
1014
|
+
return message;
|
|
1015
|
+
},
|
|
1016
|
+
};
|
|
1017
|
+
function createBaseGetMessagesResponse() {
|
|
1018
|
+
return { events: [] };
|
|
1019
|
+
}
|
|
1020
|
+
export const GetMessagesResponse = {
|
|
1021
|
+
encode(message, writer = new BinaryWriter()) {
|
|
1022
|
+
for (const v of message.events) {
|
|
1023
|
+
Event.encode(v, writer.uint32(10).fork()).join();
|
|
1024
|
+
}
|
|
1025
|
+
return writer;
|
|
1026
|
+
},
|
|
1027
|
+
decode(input, length) {
|
|
1028
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
1029
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
1030
|
+
if (previousRecursionDepth >= 100) {
|
|
1031
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
1032
|
+
}
|
|
1033
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
1034
|
+
try {
|
|
1035
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
1036
|
+
const message = createBaseGetMessagesResponse();
|
|
1037
|
+
while (reader.pos < end) {
|
|
1038
|
+
const tag = reader.uint32();
|
|
1039
|
+
switch (tag >>> 3) {
|
|
1040
|
+
case 1: {
|
|
1041
|
+
if (tag !== 10) {
|
|
1042
|
+
break;
|
|
1043
|
+
}
|
|
1044
|
+
message.events.push(Event.decode(reader, reader.uint32()));
|
|
1045
|
+
continue;
|
|
1046
|
+
}
|
|
1047
|
+
}
|
|
1048
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
1049
|
+
break;
|
|
1050
|
+
}
|
|
1051
|
+
reader.skip(tag & 7);
|
|
1052
|
+
}
|
|
1053
|
+
return message;
|
|
1054
|
+
}
|
|
1055
|
+
finally {
|
|
1056
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
1057
|
+
}
|
|
1058
|
+
},
|
|
1059
|
+
create(base) {
|
|
1060
|
+
return GetMessagesResponse.fromPartial(base ?? {});
|
|
1061
|
+
},
|
|
1062
|
+
fromPartial(object) {
|
|
1063
|
+
const message = createBaseGetMessagesResponse();
|
|
1064
|
+
message.events = object.events?.map((e) => Event.fromPartial(e)) || [];
|
|
1065
|
+
return message;
|
|
1066
|
+
},
|
|
1067
|
+
};
|
|
1068
|
+
function createBaseGetChannelMembersRequest() {
|
|
1069
|
+
return { channelId: "0" };
|
|
1070
|
+
}
|
|
1071
|
+
export const GetChannelMembersRequest = {
|
|
1072
|
+
encode(message, writer = new BinaryWriter()) {
|
|
1073
|
+
if (message.channelId !== "0") {
|
|
1074
|
+
writer.uint32(8).int64(message.channelId);
|
|
1075
|
+
}
|
|
1076
|
+
return writer;
|
|
1077
|
+
},
|
|
1078
|
+
decode(input, length) {
|
|
1079
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
1080
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
1081
|
+
if (previousRecursionDepth >= 100) {
|
|
1082
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
1083
|
+
}
|
|
1084
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
1085
|
+
try {
|
|
1086
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
1087
|
+
const message = createBaseGetChannelMembersRequest();
|
|
1088
|
+
while (reader.pos < end) {
|
|
1089
|
+
const tag = reader.uint32();
|
|
1090
|
+
switch (tag >>> 3) {
|
|
1091
|
+
case 1: {
|
|
1092
|
+
if (tag !== 8) {
|
|
1093
|
+
break;
|
|
1094
|
+
}
|
|
1095
|
+
message.channelId = reader.int64().toString();
|
|
1096
|
+
continue;
|
|
1097
|
+
}
|
|
1098
|
+
}
|
|
1099
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
1100
|
+
break;
|
|
1101
|
+
}
|
|
1102
|
+
reader.skip(tag & 7);
|
|
1103
|
+
}
|
|
1104
|
+
return message;
|
|
1105
|
+
}
|
|
1106
|
+
finally {
|
|
1107
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
1108
|
+
}
|
|
1109
|
+
},
|
|
1110
|
+
create(base) {
|
|
1111
|
+
return GetChannelMembersRequest.fromPartial(base ?? {});
|
|
1112
|
+
},
|
|
1113
|
+
fromPartial(object) {
|
|
1114
|
+
const message = createBaseGetChannelMembersRequest();
|
|
1115
|
+
message.channelId = object.channelId ?? "0";
|
|
1116
|
+
return message;
|
|
1117
|
+
},
|
|
1118
|
+
};
|
|
1119
|
+
function createBaseRawQueryRequest() {
|
|
1120
|
+
return { sql: "", limit: undefined, paramsJson: "" };
|
|
1121
|
+
}
|
|
1122
|
+
export const RawQueryRequest = {
|
|
1123
|
+
encode(message, writer = new BinaryWriter()) {
|
|
1124
|
+
if (message.sql !== "") {
|
|
1125
|
+
writer.uint32(10).string(message.sql);
|
|
1126
|
+
}
|
|
1127
|
+
if (message.limit !== undefined) {
|
|
1128
|
+
writer.uint32(16).uint32(message.limit);
|
|
1129
|
+
}
|
|
1130
|
+
if (message.paramsJson !== "") {
|
|
1131
|
+
writer.uint32(26).string(message.paramsJson);
|
|
1132
|
+
}
|
|
1133
|
+
return writer;
|
|
1134
|
+
},
|
|
1135
|
+
decode(input, length) {
|
|
1136
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
1137
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
1138
|
+
if (previousRecursionDepth >= 100) {
|
|
1139
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
1140
|
+
}
|
|
1141
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
1142
|
+
try {
|
|
1143
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
1144
|
+
const message = createBaseRawQueryRequest();
|
|
1145
|
+
while (reader.pos < end) {
|
|
1146
|
+
const tag = reader.uint32();
|
|
1147
|
+
switch (tag >>> 3) {
|
|
1148
|
+
case 1: {
|
|
1149
|
+
if (tag !== 10) {
|
|
1150
|
+
break;
|
|
1151
|
+
}
|
|
1152
|
+
message.sql = reader.string();
|
|
1153
|
+
continue;
|
|
1154
|
+
}
|
|
1155
|
+
case 2: {
|
|
1156
|
+
if (tag !== 16) {
|
|
1157
|
+
break;
|
|
1158
|
+
}
|
|
1159
|
+
message.limit = reader.uint32();
|
|
1160
|
+
continue;
|
|
1161
|
+
}
|
|
1162
|
+
case 3: {
|
|
1163
|
+
if (tag !== 26) {
|
|
1164
|
+
break;
|
|
1165
|
+
}
|
|
1166
|
+
message.paramsJson = reader.string();
|
|
1167
|
+
continue;
|
|
1168
|
+
}
|
|
1169
|
+
}
|
|
1170
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
1171
|
+
break;
|
|
1172
|
+
}
|
|
1173
|
+
reader.skip(tag & 7);
|
|
1174
|
+
}
|
|
1175
|
+
return message;
|
|
1176
|
+
}
|
|
1177
|
+
finally {
|
|
1178
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
1179
|
+
}
|
|
1180
|
+
},
|
|
1181
|
+
create(base) {
|
|
1182
|
+
return RawQueryRequest.fromPartial(base ?? {});
|
|
1183
|
+
},
|
|
1184
|
+
fromPartial(object) {
|
|
1185
|
+
const message = createBaseRawQueryRequest();
|
|
1186
|
+
message.sql = object.sql ?? "";
|
|
1187
|
+
message.limit = object.limit ?? undefined;
|
|
1188
|
+
message.paramsJson = object.paramsJson ?? "";
|
|
1189
|
+
return message;
|
|
1190
|
+
},
|
|
1191
|
+
};
|
|
1192
|
+
function createBaseRawQueryResponse() {
|
|
1193
|
+
return { rowsJson: [] };
|
|
1194
|
+
}
|
|
1195
|
+
export const RawQueryResponse = {
|
|
1196
|
+
encode(message, writer = new BinaryWriter()) {
|
|
1197
|
+
for (const v of message.rowsJson) {
|
|
1198
|
+
writer.uint32(10).string(v);
|
|
1199
|
+
}
|
|
1200
|
+
return writer;
|
|
1201
|
+
},
|
|
1202
|
+
decode(input, length) {
|
|
1203
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
1204
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
1205
|
+
if (previousRecursionDepth >= 100) {
|
|
1206
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
1207
|
+
}
|
|
1208
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
1209
|
+
try {
|
|
1210
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
1211
|
+
const message = createBaseRawQueryResponse();
|
|
1212
|
+
while (reader.pos < end) {
|
|
1213
|
+
const tag = reader.uint32();
|
|
1214
|
+
switch (tag >>> 3) {
|
|
1215
|
+
case 1: {
|
|
1216
|
+
if (tag !== 10) {
|
|
1217
|
+
break;
|
|
1218
|
+
}
|
|
1219
|
+
message.rowsJson.push(reader.string());
|
|
1220
|
+
continue;
|
|
1221
|
+
}
|
|
1222
|
+
}
|
|
1223
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
1224
|
+
break;
|
|
1225
|
+
}
|
|
1226
|
+
reader.skip(tag & 7);
|
|
1227
|
+
}
|
|
1228
|
+
return message;
|
|
1229
|
+
}
|
|
1230
|
+
finally {
|
|
1231
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
1232
|
+
}
|
|
1233
|
+
},
|
|
1234
|
+
create(base) {
|
|
1235
|
+
return RawQueryResponse.fromPartial(base ?? {});
|
|
1236
|
+
},
|
|
1237
|
+
fromPartial(object) {
|
|
1238
|
+
const message = createBaseRawQueryResponse();
|
|
1239
|
+
message.rowsJson = object.rowsJson?.map((e) => e) || [];
|
|
1240
|
+
return message;
|
|
1241
|
+
},
|
|
1242
|
+
};
|
|
1243
|
+
function createBaseDecryptRequest() {
|
|
1244
|
+
return { ciphertext: "", enc: 0, userId: undefined };
|
|
1245
|
+
}
|
|
1246
|
+
export const DecryptRequest = {
|
|
1247
|
+
encode(message, writer = new BinaryWriter()) {
|
|
1248
|
+
if (message.ciphertext !== "") {
|
|
1249
|
+
writer.uint32(10).string(message.ciphertext);
|
|
1250
|
+
}
|
|
1251
|
+
if (message.enc !== 0) {
|
|
1252
|
+
writer.uint32(16).uint32(message.enc);
|
|
1253
|
+
}
|
|
1254
|
+
if (message.userId !== undefined) {
|
|
1255
|
+
writer.uint32(24).int64(message.userId);
|
|
1256
|
+
}
|
|
1257
|
+
return writer;
|
|
1258
|
+
},
|
|
1259
|
+
decode(input, length) {
|
|
1260
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
1261
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
1262
|
+
if (previousRecursionDepth >= 100) {
|
|
1263
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
1264
|
+
}
|
|
1265
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
1266
|
+
try {
|
|
1267
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
1268
|
+
const message = createBaseDecryptRequest();
|
|
1269
|
+
while (reader.pos < end) {
|
|
1270
|
+
const tag = reader.uint32();
|
|
1271
|
+
switch (tag >>> 3) {
|
|
1272
|
+
case 1: {
|
|
1273
|
+
if (tag !== 10) {
|
|
1274
|
+
break;
|
|
1275
|
+
}
|
|
1276
|
+
message.ciphertext = reader.string();
|
|
1277
|
+
continue;
|
|
1278
|
+
}
|
|
1279
|
+
case 2: {
|
|
1280
|
+
if (tag !== 16) {
|
|
1281
|
+
break;
|
|
1282
|
+
}
|
|
1283
|
+
message.enc = reader.uint32();
|
|
1284
|
+
continue;
|
|
1285
|
+
}
|
|
1286
|
+
case 3: {
|
|
1287
|
+
if (tag !== 24) {
|
|
1288
|
+
break;
|
|
1289
|
+
}
|
|
1290
|
+
message.userId = reader.int64().toString();
|
|
1291
|
+
continue;
|
|
1292
|
+
}
|
|
1293
|
+
}
|
|
1294
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
1295
|
+
break;
|
|
1296
|
+
}
|
|
1297
|
+
reader.skip(tag & 7);
|
|
1298
|
+
}
|
|
1299
|
+
return message;
|
|
1300
|
+
}
|
|
1301
|
+
finally {
|
|
1302
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
1303
|
+
}
|
|
1304
|
+
},
|
|
1305
|
+
create(base) {
|
|
1306
|
+
return DecryptRequest.fromPartial(base ?? {});
|
|
1307
|
+
},
|
|
1308
|
+
fromPartial(object) {
|
|
1309
|
+
const message = createBaseDecryptRequest();
|
|
1310
|
+
message.ciphertext = object.ciphertext ?? "";
|
|
1311
|
+
message.enc = object.enc ?? 0;
|
|
1312
|
+
message.userId = object.userId ?? undefined;
|
|
1313
|
+
return message;
|
|
1314
|
+
},
|
|
1315
|
+
};
|
|
1316
|
+
function createBaseDecryptResponse() {
|
|
1317
|
+
return { plaintext: "" };
|
|
1318
|
+
}
|
|
1319
|
+
export const DecryptResponse = {
|
|
1320
|
+
encode(message, writer = new BinaryWriter()) {
|
|
1321
|
+
if (message.plaintext !== "") {
|
|
1322
|
+
writer.uint32(10).string(message.plaintext);
|
|
1323
|
+
}
|
|
1324
|
+
return writer;
|
|
1325
|
+
},
|
|
1326
|
+
decode(input, length) {
|
|
1327
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
1328
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
1329
|
+
if (previousRecursionDepth >= 100) {
|
|
1330
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
1331
|
+
}
|
|
1332
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
1333
|
+
try {
|
|
1334
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
1335
|
+
const message = createBaseDecryptResponse();
|
|
1336
|
+
while (reader.pos < end) {
|
|
1337
|
+
const tag = reader.uint32();
|
|
1338
|
+
switch (tag >>> 3) {
|
|
1339
|
+
case 1: {
|
|
1340
|
+
if (tag !== 10) {
|
|
1341
|
+
break;
|
|
1342
|
+
}
|
|
1343
|
+
message.plaintext = reader.string();
|
|
1344
|
+
continue;
|
|
1345
|
+
}
|
|
1346
|
+
}
|
|
1347
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
1348
|
+
break;
|
|
1349
|
+
}
|
|
1350
|
+
reader.skip(tag & 7);
|
|
1351
|
+
}
|
|
1352
|
+
return message;
|
|
1353
|
+
}
|
|
1354
|
+
finally {
|
|
1355
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
1356
|
+
}
|
|
1357
|
+
},
|
|
1358
|
+
create(base) {
|
|
1359
|
+
return DecryptResponse.fromPartial(base ?? {});
|
|
1360
|
+
},
|
|
1361
|
+
fromPartial(object) {
|
|
1362
|
+
const message = createBaseDecryptResponse();
|
|
1363
|
+
message.plaintext = object.plaintext ?? "";
|
|
1364
|
+
return message;
|
|
1365
|
+
},
|
|
1366
|
+
};
|
|
1367
|
+
function createBaseCredential() {
|
|
1368
|
+
return { accessToken: "", refreshToken: "", deviceUuid: "" };
|
|
1369
|
+
}
|
|
1370
|
+
export const Credential = {
|
|
1371
|
+
encode(message, writer = new BinaryWriter()) {
|
|
1372
|
+
if (message.accessToken !== "") {
|
|
1373
|
+
writer.uint32(10).string(message.accessToken);
|
|
1374
|
+
}
|
|
1375
|
+
if (message.refreshToken !== "") {
|
|
1376
|
+
writer.uint32(18).string(message.refreshToken);
|
|
1377
|
+
}
|
|
1378
|
+
if (message.deviceUuid !== "") {
|
|
1379
|
+
writer.uint32(26).string(message.deviceUuid);
|
|
1380
|
+
}
|
|
1381
|
+
return writer;
|
|
1382
|
+
},
|
|
1383
|
+
decode(input, length) {
|
|
1384
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
1385
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
1386
|
+
if (previousRecursionDepth >= 100) {
|
|
1387
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
1388
|
+
}
|
|
1389
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
1390
|
+
try {
|
|
1391
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
1392
|
+
const message = createBaseCredential();
|
|
1393
|
+
while (reader.pos < end) {
|
|
1394
|
+
const tag = reader.uint32();
|
|
1395
|
+
switch (tag >>> 3) {
|
|
1396
|
+
case 1: {
|
|
1397
|
+
if (tag !== 10) {
|
|
1398
|
+
break;
|
|
1399
|
+
}
|
|
1400
|
+
message.accessToken = reader.string();
|
|
1401
|
+
continue;
|
|
1402
|
+
}
|
|
1403
|
+
case 2: {
|
|
1404
|
+
if (tag !== 18) {
|
|
1405
|
+
break;
|
|
1406
|
+
}
|
|
1407
|
+
message.refreshToken = reader.string();
|
|
1408
|
+
continue;
|
|
1409
|
+
}
|
|
1410
|
+
case 3: {
|
|
1411
|
+
if (tag !== 26) {
|
|
1412
|
+
break;
|
|
1413
|
+
}
|
|
1414
|
+
message.deviceUuid = reader.string();
|
|
1415
|
+
continue;
|
|
1416
|
+
}
|
|
1417
|
+
}
|
|
1418
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
1419
|
+
break;
|
|
1420
|
+
}
|
|
1421
|
+
reader.skip(tag & 7);
|
|
1422
|
+
}
|
|
1423
|
+
return message;
|
|
1424
|
+
}
|
|
1425
|
+
finally {
|
|
1426
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
1427
|
+
}
|
|
1428
|
+
},
|
|
1429
|
+
create(base) {
|
|
1430
|
+
return Credential.fromPartial(base ?? {});
|
|
1431
|
+
},
|
|
1432
|
+
fromPartial(object) {
|
|
1433
|
+
const message = createBaseCredential();
|
|
1434
|
+
message.accessToken = object.accessToken ?? "";
|
|
1435
|
+
message.refreshToken = object.refreshToken ?? "";
|
|
1436
|
+
message.deviceUuid = object.deviceUuid ?? "";
|
|
1437
|
+
return message;
|
|
1438
|
+
},
|
|
1439
|
+
};
|
|
1440
|
+
function createBaseChannel() {
|
|
1441
|
+
return { id: "0", channelType: "", name: undefined, privateName: undefined };
|
|
1442
|
+
}
|
|
1443
|
+
export const Channel = {
|
|
1444
|
+
encode(message, writer = new BinaryWriter()) {
|
|
1445
|
+
if (message.id !== "0") {
|
|
1446
|
+
writer.uint32(8).int64(message.id);
|
|
1447
|
+
}
|
|
1448
|
+
if (message.channelType !== "") {
|
|
1449
|
+
writer.uint32(18).string(message.channelType);
|
|
1450
|
+
}
|
|
1451
|
+
if (message.name !== undefined) {
|
|
1452
|
+
writer.uint32(26).string(message.name);
|
|
1453
|
+
}
|
|
1454
|
+
if (message.privateName !== undefined) {
|
|
1455
|
+
writer.uint32(34).string(message.privateName);
|
|
1456
|
+
}
|
|
1457
|
+
return writer;
|
|
1458
|
+
},
|
|
1459
|
+
decode(input, length) {
|
|
1460
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
1461
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
1462
|
+
if (previousRecursionDepth >= 100) {
|
|
1463
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
1464
|
+
}
|
|
1465
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
1466
|
+
try {
|
|
1467
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
1468
|
+
const message = createBaseChannel();
|
|
1469
|
+
while (reader.pos < end) {
|
|
1470
|
+
const tag = reader.uint32();
|
|
1471
|
+
switch (tag >>> 3) {
|
|
1472
|
+
case 1: {
|
|
1473
|
+
if (tag !== 8) {
|
|
1474
|
+
break;
|
|
1475
|
+
}
|
|
1476
|
+
message.id = reader.int64().toString();
|
|
1477
|
+
continue;
|
|
1478
|
+
}
|
|
1479
|
+
case 2: {
|
|
1480
|
+
if (tag !== 18) {
|
|
1481
|
+
break;
|
|
1482
|
+
}
|
|
1483
|
+
message.channelType = reader.string();
|
|
1484
|
+
continue;
|
|
1485
|
+
}
|
|
1486
|
+
case 3: {
|
|
1487
|
+
if (tag !== 26) {
|
|
1488
|
+
break;
|
|
1489
|
+
}
|
|
1490
|
+
message.name = reader.string();
|
|
1491
|
+
continue;
|
|
1492
|
+
}
|
|
1493
|
+
case 4: {
|
|
1494
|
+
if (tag !== 34) {
|
|
1495
|
+
break;
|
|
1496
|
+
}
|
|
1497
|
+
message.privateName = reader.string();
|
|
1498
|
+
continue;
|
|
1499
|
+
}
|
|
1500
|
+
}
|
|
1501
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
1502
|
+
break;
|
|
1503
|
+
}
|
|
1504
|
+
reader.skip(tag & 7);
|
|
1505
|
+
}
|
|
1506
|
+
return message;
|
|
1507
|
+
}
|
|
1508
|
+
finally {
|
|
1509
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
1510
|
+
}
|
|
1511
|
+
},
|
|
1512
|
+
create(base) {
|
|
1513
|
+
return Channel.fromPartial(base ?? {});
|
|
1514
|
+
},
|
|
1515
|
+
fromPartial(object) {
|
|
1516
|
+
const message = createBaseChannel();
|
|
1517
|
+
message.id = object.id ?? "0";
|
|
1518
|
+
message.channelType = object.channelType ?? "";
|
|
1519
|
+
message.name = object.name ?? undefined;
|
|
1520
|
+
message.privateName = object.privateName ?? undefined;
|
|
1521
|
+
return message;
|
|
1522
|
+
},
|
|
1523
|
+
};
|
|
1524
|
+
function createBaseChannelMembers() {
|
|
1525
|
+
return { channelId: "0", activeMemberIds: [] };
|
|
1526
|
+
}
|
|
1527
|
+
export const ChannelMembers = {
|
|
1528
|
+
encode(message, writer = new BinaryWriter()) {
|
|
1529
|
+
if (message.channelId !== "0") {
|
|
1530
|
+
writer.uint32(8).int64(message.channelId);
|
|
1531
|
+
}
|
|
1532
|
+
writer.uint32(18).fork();
|
|
1533
|
+
for (const v of message.activeMemberIds) {
|
|
1534
|
+
writer.int64(v);
|
|
1535
|
+
}
|
|
1536
|
+
writer.join();
|
|
1537
|
+
return writer;
|
|
1538
|
+
},
|
|
1539
|
+
decode(input, length) {
|
|
1540
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
1541
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
1542
|
+
if (previousRecursionDepth >= 100) {
|
|
1543
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
1544
|
+
}
|
|
1545
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
1546
|
+
try {
|
|
1547
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
1548
|
+
const message = createBaseChannelMembers();
|
|
1549
|
+
while (reader.pos < end) {
|
|
1550
|
+
const tag = reader.uint32();
|
|
1551
|
+
switch (tag >>> 3) {
|
|
1552
|
+
case 1: {
|
|
1553
|
+
if (tag !== 8) {
|
|
1554
|
+
break;
|
|
1555
|
+
}
|
|
1556
|
+
message.channelId = reader.int64().toString();
|
|
1557
|
+
continue;
|
|
1558
|
+
}
|
|
1559
|
+
case 2: {
|
|
1560
|
+
if (tag === 16) {
|
|
1561
|
+
message.activeMemberIds.push(reader.int64().toString());
|
|
1562
|
+
continue;
|
|
1563
|
+
}
|
|
1564
|
+
if (tag === 18) {
|
|
1565
|
+
const end2 = reader.uint32() + reader.pos;
|
|
1566
|
+
while (reader.pos < end2) {
|
|
1567
|
+
message.activeMemberIds.push(reader.int64().toString());
|
|
1568
|
+
}
|
|
1569
|
+
continue;
|
|
1570
|
+
}
|
|
1571
|
+
break;
|
|
1572
|
+
}
|
|
1573
|
+
}
|
|
1574
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
1575
|
+
break;
|
|
1576
|
+
}
|
|
1577
|
+
reader.skip(tag & 7);
|
|
1578
|
+
}
|
|
1579
|
+
return message;
|
|
1580
|
+
}
|
|
1581
|
+
finally {
|
|
1582
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
1583
|
+
}
|
|
1584
|
+
},
|
|
1585
|
+
create(base) {
|
|
1586
|
+
return ChannelMembers.fromPartial(base ?? {});
|
|
1587
|
+
},
|
|
1588
|
+
fromPartial(object) {
|
|
1589
|
+
const message = createBaseChannelMembers();
|
|
1590
|
+
message.channelId = object.channelId ?? "0";
|
|
1591
|
+
message.activeMemberIds = object.activeMemberIds?.map((e) => e) || [];
|
|
1592
|
+
return message;
|
|
1593
|
+
},
|
|
1594
|
+
};
|
|
1595
|
+
function createBaseMember() {
|
|
1596
|
+
return { id: "0", isMine: false, nickname: "", profileImageUrl: undefined, openChannel: undefined };
|
|
1597
|
+
}
|
|
1598
|
+
export const Member = {
|
|
1599
|
+
encode(message, writer = new BinaryWriter()) {
|
|
1600
|
+
if (message.id !== "0") {
|
|
1601
|
+
writer.uint32(8).int64(message.id);
|
|
1602
|
+
}
|
|
1603
|
+
if (message.isMine !== false) {
|
|
1604
|
+
writer.uint32(16).bool(message.isMine);
|
|
1605
|
+
}
|
|
1606
|
+
if (message.nickname !== "") {
|
|
1607
|
+
writer.uint32(26).string(message.nickname);
|
|
1608
|
+
}
|
|
1609
|
+
if (message.profileImageUrl !== undefined) {
|
|
1610
|
+
writer.uint32(34).string(message.profileImageUrl);
|
|
1611
|
+
}
|
|
1612
|
+
if (message.openChannel !== undefined) {
|
|
1613
|
+
OpenChannelMemberExtra.encode(message.openChannel, writer.uint32(42).fork()).join();
|
|
1614
|
+
}
|
|
1615
|
+
return writer;
|
|
1616
|
+
},
|
|
1617
|
+
decode(input, length) {
|
|
1618
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
1619
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
1620
|
+
if (previousRecursionDepth >= 100) {
|
|
1621
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
1622
|
+
}
|
|
1623
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
1624
|
+
try {
|
|
1625
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
1626
|
+
const message = createBaseMember();
|
|
1627
|
+
while (reader.pos < end) {
|
|
1628
|
+
const tag = reader.uint32();
|
|
1629
|
+
switch (tag >>> 3) {
|
|
1630
|
+
case 1: {
|
|
1631
|
+
if (tag !== 8) {
|
|
1632
|
+
break;
|
|
1633
|
+
}
|
|
1634
|
+
message.id = reader.int64().toString();
|
|
1635
|
+
continue;
|
|
1636
|
+
}
|
|
1637
|
+
case 2: {
|
|
1638
|
+
if (tag !== 16) {
|
|
1639
|
+
break;
|
|
1640
|
+
}
|
|
1641
|
+
message.isMine = reader.bool();
|
|
1642
|
+
continue;
|
|
1643
|
+
}
|
|
1644
|
+
case 3: {
|
|
1645
|
+
if (tag !== 26) {
|
|
1646
|
+
break;
|
|
1647
|
+
}
|
|
1648
|
+
message.nickname = reader.string();
|
|
1649
|
+
continue;
|
|
1650
|
+
}
|
|
1651
|
+
case 4: {
|
|
1652
|
+
if (tag !== 34) {
|
|
1653
|
+
break;
|
|
1654
|
+
}
|
|
1655
|
+
message.profileImageUrl = reader.string();
|
|
1656
|
+
continue;
|
|
1657
|
+
}
|
|
1658
|
+
case 5: {
|
|
1659
|
+
if (tag !== 42) {
|
|
1660
|
+
break;
|
|
1661
|
+
}
|
|
1662
|
+
message.openChannel = OpenChannelMemberExtra.decode(reader, reader.uint32());
|
|
1663
|
+
continue;
|
|
1664
|
+
}
|
|
1665
|
+
}
|
|
1666
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
1667
|
+
break;
|
|
1668
|
+
}
|
|
1669
|
+
reader.skip(tag & 7);
|
|
1670
|
+
}
|
|
1671
|
+
return message;
|
|
1672
|
+
}
|
|
1673
|
+
finally {
|
|
1674
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
1675
|
+
}
|
|
1676
|
+
},
|
|
1677
|
+
create(base) {
|
|
1678
|
+
return Member.fromPartial(base ?? {});
|
|
1679
|
+
},
|
|
1680
|
+
fromPartial(object) {
|
|
1681
|
+
const message = createBaseMember();
|
|
1682
|
+
message.id = object.id ?? "0";
|
|
1683
|
+
message.isMine = object.isMine ?? false;
|
|
1684
|
+
message.nickname = object.nickname ?? "";
|
|
1685
|
+
message.profileImageUrl = object.profileImageUrl ?? undefined;
|
|
1686
|
+
message.openChannel = (object.openChannel !== undefined && object.openChannel !== null)
|
|
1687
|
+
? OpenChannelMemberExtra.fromPartial(object.openChannel)
|
|
1688
|
+
: undefined;
|
|
1689
|
+
return message;
|
|
1690
|
+
},
|
|
1691
|
+
};
|
|
1692
|
+
function createBaseOpenChannelMemberExtra() {
|
|
1693
|
+
return { profileType: 0, linkMemberType: 0, profileLinkId: "0" };
|
|
1694
|
+
}
|
|
1695
|
+
export const OpenChannelMemberExtra = {
|
|
1696
|
+
encode(message, writer = new BinaryWriter()) {
|
|
1697
|
+
if (message.profileType !== 0) {
|
|
1698
|
+
writer.uint32(8).int32(message.profileType);
|
|
1699
|
+
}
|
|
1700
|
+
if (message.linkMemberType !== 0) {
|
|
1701
|
+
writer.uint32(16).int32(message.linkMemberType);
|
|
1702
|
+
}
|
|
1703
|
+
if (message.profileLinkId !== "0") {
|
|
1704
|
+
writer.uint32(24).int64(message.profileLinkId);
|
|
1705
|
+
}
|
|
1706
|
+
return writer;
|
|
1707
|
+
},
|
|
1708
|
+
decode(input, length) {
|
|
1709
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
1710
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
1711
|
+
if (previousRecursionDepth >= 100) {
|
|
1712
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
1713
|
+
}
|
|
1714
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
1715
|
+
try {
|
|
1716
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
1717
|
+
const message = createBaseOpenChannelMemberExtra();
|
|
1718
|
+
while (reader.pos < end) {
|
|
1719
|
+
const tag = reader.uint32();
|
|
1720
|
+
switch (tag >>> 3) {
|
|
1721
|
+
case 1: {
|
|
1722
|
+
if (tag !== 8) {
|
|
1723
|
+
break;
|
|
1724
|
+
}
|
|
1725
|
+
message.profileType = reader.int32();
|
|
1726
|
+
continue;
|
|
1727
|
+
}
|
|
1728
|
+
case 2: {
|
|
1729
|
+
if (tag !== 16) {
|
|
1730
|
+
break;
|
|
1731
|
+
}
|
|
1732
|
+
message.linkMemberType = reader.int32();
|
|
1733
|
+
continue;
|
|
1734
|
+
}
|
|
1735
|
+
case 3: {
|
|
1736
|
+
if (tag !== 24) {
|
|
1737
|
+
break;
|
|
1738
|
+
}
|
|
1739
|
+
message.profileLinkId = reader.int64().toString();
|
|
1740
|
+
continue;
|
|
1741
|
+
}
|
|
1742
|
+
}
|
|
1743
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
1744
|
+
break;
|
|
1745
|
+
}
|
|
1746
|
+
reader.skip(tag & 7);
|
|
1747
|
+
}
|
|
1748
|
+
return message;
|
|
1749
|
+
}
|
|
1750
|
+
finally {
|
|
1751
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
1752
|
+
}
|
|
1753
|
+
},
|
|
1754
|
+
create(base) {
|
|
1755
|
+
return OpenChannelMemberExtra.fromPartial(base ?? {});
|
|
1756
|
+
},
|
|
1757
|
+
fromPartial(object) {
|
|
1758
|
+
const message = createBaseOpenChannelMemberExtra();
|
|
1759
|
+
message.profileType = object.profileType ?? 0;
|
|
1760
|
+
message.linkMemberType = object.linkMemberType ?? 0;
|
|
1761
|
+
message.profileLinkId = object.profileLinkId ?? "0";
|
|
1762
|
+
return message;
|
|
1763
|
+
},
|
|
1764
|
+
};
|
|
1765
|
+
function createBaseMessageRevision() {
|
|
1766
|
+
return { revision: "0", message: "" };
|
|
1767
|
+
}
|
|
1768
|
+
export const MessageRevision = {
|
|
1769
|
+
encode(message, writer = new BinaryWriter()) {
|
|
1770
|
+
if (message.revision !== "0") {
|
|
1771
|
+
writer.uint32(8).int64(message.revision);
|
|
1772
|
+
}
|
|
1773
|
+
if (message.message !== "") {
|
|
1774
|
+
writer.uint32(18).string(message.message);
|
|
1775
|
+
}
|
|
1776
|
+
return writer;
|
|
1777
|
+
},
|
|
1778
|
+
decode(input, length) {
|
|
1779
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
1780
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
1781
|
+
if (previousRecursionDepth >= 100) {
|
|
1782
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
1783
|
+
}
|
|
1784
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
1785
|
+
try {
|
|
1786
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
1787
|
+
const message = createBaseMessageRevision();
|
|
1788
|
+
while (reader.pos < end) {
|
|
1789
|
+
const tag = reader.uint32();
|
|
1790
|
+
switch (tag >>> 3) {
|
|
1791
|
+
case 1: {
|
|
1792
|
+
if (tag !== 8) {
|
|
1793
|
+
break;
|
|
1794
|
+
}
|
|
1795
|
+
message.revision = reader.int64().toString();
|
|
1796
|
+
continue;
|
|
1797
|
+
}
|
|
1798
|
+
case 2: {
|
|
1799
|
+
if (tag !== 18) {
|
|
1800
|
+
break;
|
|
1801
|
+
}
|
|
1802
|
+
message.message = reader.string();
|
|
1803
|
+
continue;
|
|
1804
|
+
}
|
|
1805
|
+
}
|
|
1806
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
1807
|
+
break;
|
|
1808
|
+
}
|
|
1809
|
+
reader.skip(tag & 7);
|
|
1810
|
+
}
|
|
1811
|
+
return message;
|
|
1812
|
+
}
|
|
1813
|
+
finally {
|
|
1814
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
1815
|
+
}
|
|
1816
|
+
},
|
|
1817
|
+
create(base) {
|
|
1818
|
+
return MessageRevision.fromPartial(base ?? {});
|
|
1819
|
+
},
|
|
1820
|
+
fromPartial(object) {
|
|
1821
|
+
const message = createBaseMessageRevision();
|
|
1822
|
+
message.revision = object.revision ?? "0";
|
|
1823
|
+
message.message = object.message ?? "";
|
|
1824
|
+
return message;
|
|
1825
|
+
},
|
|
1826
|
+
};
|
|
1827
|
+
function createBaseMessageEvent() {
|
|
1828
|
+
return {
|
|
1829
|
+
messageId: "0",
|
|
1830
|
+
threadId: undefined,
|
|
1831
|
+
scope: 0,
|
|
1832
|
+
messageType: 0,
|
|
1833
|
+
channel: undefined,
|
|
1834
|
+
author: undefined,
|
|
1835
|
+
message: "",
|
|
1836
|
+
attachmentJson: "",
|
|
1837
|
+
modifyLog: [],
|
|
1838
|
+
};
|
|
1839
|
+
}
|
|
1840
|
+
export const MessageEvent = {
|
|
1841
|
+
encode(message, writer = new BinaryWriter()) {
|
|
1842
|
+
if (message.messageId !== "0") {
|
|
1843
|
+
writer.uint32(8).int64(message.messageId);
|
|
1844
|
+
}
|
|
1845
|
+
if (message.threadId !== undefined) {
|
|
1846
|
+
writer.uint32(16).int64(message.threadId);
|
|
1847
|
+
}
|
|
1848
|
+
if (message.scope !== 0) {
|
|
1849
|
+
writer.uint32(24).int32(message.scope);
|
|
1850
|
+
}
|
|
1851
|
+
if (message.messageType !== 0) {
|
|
1852
|
+
writer.uint32(32).int32(message.messageType);
|
|
1853
|
+
}
|
|
1854
|
+
if (message.channel !== undefined) {
|
|
1855
|
+
Channel.encode(message.channel, writer.uint32(42).fork()).join();
|
|
1856
|
+
}
|
|
1857
|
+
if (message.author !== undefined) {
|
|
1858
|
+
Member.encode(message.author, writer.uint32(50).fork()).join();
|
|
1859
|
+
}
|
|
1860
|
+
if (message.message !== "") {
|
|
1861
|
+
writer.uint32(58).string(message.message);
|
|
1862
|
+
}
|
|
1863
|
+
if (message.attachmentJson !== "") {
|
|
1864
|
+
writer.uint32(66).string(message.attachmentJson);
|
|
1865
|
+
}
|
|
1866
|
+
for (const v of message.modifyLog) {
|
|
1867
|
+
MessageRevision.encode(v, writer.uint32(74).fork()).join();
|
|
1868
|
+
}
|
|
1869
|
+
return writer;
|
|
1870
|
+
},
|
|
1871
|
+
decode(input, length) {
|
|
1872
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
1873
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
1874
|
+
if (previousRecursionDepth >= 100) {
|
|
1875
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
1876
|
+
}
|
|
1877
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
1878
|
+
try {
|
|
1879
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
1880
|
+
const message = createBaseMessageEvent();
|
|
1881
|
+
while (reader.pos < end) {
|
|
1882
|
+
const tag = reader.uint32();
|
|
1883
|
+
switch (tag >>> 3) {
|
|
1884
|
+
case 1: {
|
|
1885
|
+
if (tag !== 8) {
|
|
1886
|
+
break;
|
|
1887
|
+
}
|
|
1888
|
+
message.messageId = reader.int64().toString();
|
|
1889
|
+
continue;
|
|
1890
|
+
}
|
|
1891
|
+
case 2: {
|
|
1892
|
+
if (tag !== 16) {
|
|
1893
|
+
break;
|
|
1894
|
+
}
|
|
1895
|
+
message.threadId = reader.int64().toString();
|
|
1896
|
+
continue;
|
|
1897
|
+
}
|
|
1898
|
+
case 3: {
|
|
1899
|
+
if (tag !== 24) {
|
|
1900
|
+
break;
|
|
1901
|
+
}
|
|
1902
|
+
message.scope = reader.int32();
|
|
1903
|
+
continue;
|
|
1904
|
+
}
|
|
1905
|
+
case 4: {
|
|
1906
|
+
if (tag !== 32) {
|
|
1907
|
+
break;
|
|
1908
|
+
}
|
|
1909
|
+
message.messageType = reader.int32();
|
|
1910
|
+
continue;
|
|
1911
|
+
}
|
|
1912
|
+
case 5: {
|
|
1913
|
+
if (tag !== 42) {
|
|
1914
|
+
break;
|
|
1915
|
+
}
|
|
1916
|
+
message.channel = Channel.decode(reader, reader.uint32());
|
|
1917
|
+
continue;
|
|
1918
|
+
}
|
|
1919
|
+
case 6: {
|
|
1920
|
+
if (tag !== 50) {
|
|
1921
|
+
break;
|
|
1922
|
+
}
|
|
1923
|
+
message.author = Member.decode(reader, reader.uint32());
|
|
1924
|
+
continue;
|
|
1925
|
+
}
|
|
1926
|
+
case 7: {
|
|
1927
|
+
if (tag !== 58) {
|
|
1928
|
+
break;
|
|
1929
|
+
}
|
|
1930
|
+
message.message = reader.string();
|
|
1931
|
+
continue;
|
|
1932
|
+
}
|
|
1933
|
+
case 8: {
|
|
1934
|
+
if (tag !== 66) {
|
|
1935
|
+
break;
|
|
1936
|
+
}
|
|
1937
|
+
message.attachmentJson = reader.string();
|
|
1938
|
+
continue;
|
|
1939
|
+
}
|
|
1940
|
+
case 9: {
|
|
1941
|
+
if (tag !== 74) {
|
|
1942
|
+
break;
|
|
1943
|
+
}
|
|
1944
|
+
message.modifyLog.push(MessageRevision.decode(reader, reader.uint32()));
|
|
1945
|
+
continue;
|
|
1946
|
+
}
|
|
1947
|
+
}
|
|
1948
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
1949
|
+
break;
|
|
1950
|
+
}
|
|
1951
|
+
reader.skip(tag & 7);
|
|
1952
|
+
}
|
|
1953
|
+
return message;
|
|
1954
|
+
}
|
|
1955
|
+
finally {
|
|
1956
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
1957
|
+
}
|
|
1958
|
+
},
|
|
1959
|
+
create(base) {
|
|
1960
|
+
return MessageEvent.fromPartial(base ?? {});
|
|
1961
|
+
},
|
|
1962
|
+
fromPartial(object) {
|
|
1963
|
+
const message = createBaseMessageEvent();
|
|
1964
|
+
message.messageId = object.messageId ?? "0";
|
|
1965
|
+
message.threadId = object.threadId ?? undefined;
|
|
1966
|
+
message.scope = object.scope ?? 0;
|
|
1967
|
+
message.messageType = object.messageType ?? 0;
|
|
1968
|
+
message.channel = (object.channel !== undefined && object.channel !== null)
|
|
1969
|
+
? Channel.fromPartial(object.channel)
|
|
1970
|
+
: undefined;
|
|
1971
|
+
message.author = (object.author !== undefined && object.author !== null)
|
|
1972
|
+
? Member.fromPartial(object.author)
|
|
1973
|
+
: undefined;
|
|
1974
|
+
message.message = object.message ?? "";
|
|
1975
|
+
message.attachmentJson = object.attachmentJson ?? "";
|
|
1976
|
+
message.modifyLog = object.modifyLog?.map((e) => MessageRevision.fromPartial(e)) || [];
|
|
1977
|
+
return message;
|
|
1978
|
+
},
|
|
1979
|
+
};
|
|
1980
|
+
function createBaseFeedUser() {
|
|
1981
|
+
return { id: "0", nickname: "" };
|
|
1982
|
+
}
|
|
1983
|
+
export const FeedUser = {
|
|
1984
|
+
encode(message, writer = new BinaryWriter()) {
|
|
1985
|
+
if (message.id !== "0") {
|
|
1986
|
+
writer.uint32(8).int64(message.id);
|
|
1987
|
+
}
|
|
1988
|
+
if (message.nickname !== "") {
|
|
1989
|
+
writer.uint32(18).string(message.nickname);
|
|
1990
|
+
}
|
|
1991
|
+
return writer;
|
|
1992
|
+
},
|
|
1993
|
+
decode(input, length) {
|
|
1994
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
1995
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
1996
|
+
if (previousRecursionDepth >= 100) {
|
|
1997
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
1998
|
+
}
|
|
1999
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
2000
|
+
try {
|
|
2001
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
2002
|
+
const message = createBaseFeedUser();
|
|
2003
|
+
while (reader.pos < end) {
|
|
2004
|
+
const tag = reader.uint32();
|
|
2005
|
+
switch (tag >>> 3) {
|
|
2006
|
+
case 1: {
|
|
2007
|
+
if (tag !== 8) {
|
|
2008
|
+
break;
|
|
2009
|
+
}
|
|
2010
|
+
message.id = reader.int64().toString();
|
|
2011
|
+
continue;
|
|
2012
|
+
}
|
|
2013
|
+
case 2: {
|
|
2014
|
+
if (tag !== 18) {
|
|
2015
|
+
break;
|
|
2016
|
+
}
|
|
2017
|
+
message.nickname = reader.string();
|
|
2018
|
+
continue;
|
|
2019
|
+
}
|
|
2020
|
+
}
|
|
2021
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
2022
|
+
break;
|
|
2023
|
+
}
|
|
2024
|
+
reader.skip(tag & 7);
|
|
2025
|
+
}
|
|
2026
|
+
return message;
|
|
2027
|
+
}
|
|
2028
|
+
finally {
|
|
2029
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
2030
|
+
}
|
|
2031
|
+
},
|
|
2032
|
+
create(base) {
|
|
2033
|
+
return FeedUser.fromPartial(base ?? {});
|
|
2034
|
+
},
|
|
2035
|
+
fromPartial(object) {
|
|
2036
|
+
const message = createBaseFeedUser();
|
|
2037
|
+
message.id = object.id ?? "0";
|
|
2038
|
+
message.nickname = object.nickname ?? "";
|
|
2039
|
+
return message;
|
|
2040
|
+
},
|
|
2041
|
+
};
|
|
2042
|
+
function createBaseFeedUserJoined() {
|
|
2043
|
+
return { joinedUsers: [] };
|
|
2044
|
+
}
|
|
2045
|
+
export const FeedUserJoined = {
|
|
2046
|
+
encode(message, writer = new BinaryWriter()) {
|
|
2047
|
+
for (const v of message.joinedUsers) {
|
|
2048
|
+
FeedUser.encode(v, writer.uint32(10).fork()).join();
|
|
2049
|
+
}
|
|
2050
|
+
return writer;
|
|
2051
|
+
},
|
|
2052
|
+
decode(input, length) {
|
|
2053
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
2054
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
2055
|
+
if (previousRecursionDepth >= 100) {
|
|
2056
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
2057
|
+
}
|
|
2058
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
2059
|
+
try {
|
|
2060
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
2061
|
+
const message = createBaseFeedUserJoined();
|
|
2062
|
+
while (reader.pos < end) {
|
|
2063
|
+
const tag = reader.uint32();
|
|
2064
|
+
switch (tag >>> 3) {
|
|
2065
|
+
case 1: {
|
|
2066
|
+
if (tag !== 10) {
|
|
2067
|
+
break;
|
|
2068
|
+
}
|
|
2069
|
+
message.joinedUsers.push(FeedUser.decode(reader, reader.uint32()));
|
|
2070
|
+
continue;
|
|
2071
|
+
}
|
|
2072
|
+
}
|
|
2073
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
2074
|
+
break;
|
|
2075
|
+
}
|
|
2076
|
+
reader.skip(tag & 7);
|
|
2077
|
+
}
|
|
2078
|
+
return message;
|
|
2079
|
+
}
|
|
2080
|
+
finally {
|
|
2081
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
2082
|
+
}
|
|
2083
|
+
},
|
|
2084
|
+
create(base) {
|
|
2085
|
+
return FeedUserJoined.fromPartial(base ?? {});
|
|
2086
|
+
},
|
|
2087
|
+
fromPartial(object) {
|
|
2088
|
+
const message = createBaseFeedUserJoined();
|
|
2089
|
+
message.joinedUsers = object.joinedUsers?.map((e) => FeedUser.fromPartial(e)) || [];
|
|
2090
|
+
return message;
|
|
2091
|
+
},
|
|
2092
|
+
};
|
|
2093
|
+
function createBaseFeedUserLeft() {
|
|
2094
|
+
return { leftMember: undefined };
|
|
2095
|
+
}
|
|
2096
|
+
export const FeedUserLeft = {
|
|
2097
|
+
encode(message, writer = new BinaryWriter()) {
|
|
2098
|
+
if (message.leftMember !== undefined) {
|
|
2099
|
+
FeedUser.encode(message.leftMember, writer.uint32(10).fork()).join();
|
|
2100
|
+
}
|
|
2101
|
+
return writer;
|
|
2102
|
+
},
|
|
2103
|
+
decode(input, length) {
|
|
2104
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
2105
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
2106
|
+
if (previousRecursionDepth >= 100) {
|
|
2107
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
2108
|
+
}
|
|
2109
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
2110
|
+
try {
|
|
2111
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
2112
|
+
const message = createBaseFeedUserLeft();
|
|
2113
|
+
while (reader.pos < end) {
|
|
2114
|
+
const tag = reader.uint32();
|
|
2115
|
+
switch (tag >>> 3) {
|
|
2116
|
+
case 1: {
|
|
2117
|
+
if (tag !== 10) {
|
|
2118
|
+
break;
|
|
2119
|
+
}
|
|
2120
|
+
message.leftMember = FeedUser.decode(reader, reader.uint32());
|
|
2121
|
+
continue;
|
|
2122
|
+
}
|
|
2123
|
+
}
|
|
2124
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
2125
|
+
break;
|
|
2126
|
+
}
|
|
2127
|
+
reader.skip(tag & 7);
|
|
2128
|
+
}
|
|
2129
|
+
return message;
|
|
2130
|
+
}
|
|
2131
|
+
finally {
|
|
2132
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
2133
|
+
}
|
|
2134
|
+
},
|
|
2135
|
+
create(base) {
|
|
2136
|
+
return FeedUserLeft.fromPartial(base ?? {});
|
|
2137
|
+
},
|
|
2138
|
+
fromPartial(object) {
|
|
2139
|
+
const message = createBaseFeedUserLeft();
|
|
2140
|
+
message.leftMember = (object.leftMember !== undefined && object.leftMember !== null)
|
|
2141
|
+
? FeedUser.fromPartial(object.leftMember)
|
|
2142
|
+
: undefined;
|
|
2143
|
+
return message;
|
|
2144
|
+
},
|
|
2145
|
+
};
|
|
2146
|
+
function createBaseFeedUserKicked() {
|
|
2147
|
+
return { kickedUser: undefined, kickedBy: undefined };
|
|
2148
|
+
}
|
|
2149
|
+
export const FeedUserKicked = {
|
|
2150
|
+
encode(message, writer = new BinaryWriter()) {
|
|
2151
|
+
if (message.kickedUser !== undefined) {
|
|
2152
|
+
FeedUser.encode(message.kickedUser, writer.uint32(10).fork()).join();
|
|
2153
|
+
}
|
|
2154
|
+
if (message.kickedBy !== undefined) {
|
|
2155
|
+
Member.encode(message.kickedBy, writer.uint32(18).fork()).join();
|
|
2156
|
+
}
|
|
2157
|
+
return writer;
|
|
2158
|
+
},
|
|
2159
|
+
decode(input, length) {
|
|
2160
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
2161
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
2162
|
+
if (previousRecursionDepth >= 100) {
|
|
2163
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
2164
|
+
}
|
|
2165
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
2166
|
+
try {
|
|
2167
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
2168
|
+
const message = createBaseFeedUserKicked();
|
|
2169
|
+
while (reader.pos < end) {
|
|
2170
|
+
const tag = reader.uint32();
|
|
2171
|
+
switch (tag >>> 3) {
|
|
2172
|
+
case 1: {
|
|
2173
|
+
if (tag !== 10) {
|
|
2174
|
+
break;
|
|
2175
|
+
}
|
|
2176
|
+
message.kickedUser = FeedUser.decode(reader, reader.uint32());
|
|
2177
|
+
continue;
|
|
2178
|
+
}
|
|
2179
|
+
case 2: {
|
|
2180
|
+
if (tag !== 18) {
|
|
2181
|
+
break;
|
|
2182
|
+
}
|
|
2183
|
+
message.kickedBy = Member.decode(reader, reader.uint32());
|
|
2184
|
+
continue;
|
|
2185
|
+
}
|
|
2186
|
+
}
|
|
2187
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
2188
|
+
break;
|
|
2189
|
+
}
|
|
2190
|
+
reader.skip(tag & 7);
|
|
2191
|
+
}
|
|
2192
|
+
return message;
|
|
2193
|
+
}
|
|
2194
|
+
finally {
|
|
2195
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
2196
|
+
}
|
|
2197
|
+
},
|
|
2198
|
+
create(base) {
|
|
2199
|
+
return FeedUserKicked.fromPartial(base ?? {});
|
|
2200
|
+
},
|
|
2201
|
+
fromPartial(object) {
|
|
2202
|
+
const message = createBaseFeedUserKicked();
|
|
2203
|
+
message.kickedUser = (object.kickedUser !== undefined && object.kickedUser !== null)
|
|
2204
|
+
? FeedUser.fromPartial(object.kickedUser)
|
|
2205
|
+
: undefined;
|
|
2206
|
+
message.kickedBy = (object.kickedBy !== undefined && object.kickedBy !== null)
|
|
2207
|
+
? Member.fromPartial(object.kickedBy)
|
|
2208
|
+
: undefined;
|
|
2209
|
+
return message;
|
|
2210
|
+
},
|
|
2211
|
+
};
|
|
2212
|
+
function createBaseFeedMessageDeleted() {
|
|
2213
|
+
return { messageId: "0", previousMessage: undefined };
|
|
2214
|
+
}
|
|
2215
|
+
export const FeedMessageDeleted = {
|
|
2216
|
+
encode(message, writer = new BinaryWriter()) {
|
|
2217
|
+
if (message.messageId !== "0") {
|
|
2218
|
+
writer.uint32(8).int64(message.messageId);
|
|
2219
|
+
}
|
|
2220
|
+
if (message.previousMessage !== undefined) {
|
|
2221
|
+
MessageEvent.encode(message.previousMessage, writer.uint32(18).fork()).join();
|
|
2222
|
+
}
|
|
2223
|
+
return writer;
|
|
2224
|
+
},
|
|
2225
|
+
decode(input, length) {
|
|
2226
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
2227
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
2228
|
+
if (previousRecursionDepth >= 100) {
|
|
2229
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
2230
|
+
}
|
|
2231
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
2232
|
+
try {
|
|
2233
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
2234
|
+
const message = createBaseFeedMessageDeleted();
|
|
2235
|
+
while (reader.pos < end) {
|
|
2236
|
+
const tag = reader.uint32();
|
|
2237
|
+
switch (tag >>> 3) {
|
|
2238
|
+
case 1: {
|
|
2239
|
+
if (tag !== 8) {
|
|
2240
|
+
break;
|
|
2241
|
+
}
|
|
2242
|
+
message.messageId = reader.int64().toString();
|
|
2243
|
+
continue;
|
|
2244
|
+
}
|
|
2245
|
+
case 2: {
|
|
2246
|
+
if (tag !== 18) {
|
|
2247
|
+
break;
|
|
2248
|
+
}
|
|
2249
|
+
message.previousMessage = MessageEvent.decode(reader, reader.uint32());
|
|
2250
|
+
continue;
|
|
2251
|
+
}
|
|
2252
|
+
}
|
|
2253
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
2254
|
+
break;
|
|
2255
|
+
}
|
|
2256
|
+
reader.skip(tag & 7);
|
|
2257
|
+
}
|
|
2258
|
+
return message;
|
|
2259
|
+
}
|
|
2260
|
+
finally {
|
|
2261
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
2262
|
+
}
|
|
2263
|
+
},
|
|
2264
|
+
create(base) {
|
|
2265
|
+
return FeedMessageDeleted.fromPartial(base ?? {});
|
|
2266
|
+
},
|
|
2267
|
+
fromPartial(object) {
|
|
2268
|
+
const message = createBaseFeedMessageDeleted();
|
|
2269
|
+
message.messageId = object.messageId ?? "0";
|
|
2270
|
+
message.previousMessage = (object.previousMessage !== undefined && object.previousMessage !== null)
|
|
2271
|
+
? MessageEvent.fromPartial(object.previousMessage)
|
|
2272
|
+
: undefined;
|
|
2273
|
+
return message;
|
|
2274
|
+
},
|
|
2275
|
+
};
|
|
2276
|
+
function createBaseFeedMessageChanged() {
|
|
2277
|
+
return { messageId: "0", targetRevision: "0", message: undefined };
|
|
2278
|
+
}
|
|
2279
|
+
export const FeedMessageChanged = {
|
|
2280
|
+
encode(message, writer = new BinaryWriter()) {
|
|
2281
|
+
if (message.messageId !== "0") {
|
|
2282
|
+
writer.uint32(8).int64(message.messageId);
|
|
2283
|
+
}
|
|
2284
|
+
if (message.targetRevision !== "0") {
|
|
2285
|
+
writer.uint32(16).int64(message.targetRevision);
|
|
2286
|
+
}
|
|
2287
|
+
if (message.message !== undefined) {
|
|
2288
|
+
MessageEvent.encode(message.message, writer.uint32(26).fork()).join();
|
|
2289
|
+
}
|
|
2290
|
+
return writer;
|
|
2291
|
+
},
|
|
2292
|
+
decode(input, length) {
|
|
2293
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
2294
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
2295
|
+
if (previousRecursionDepth >= 100) {
|
|
2296
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
2297
|
+
}
|
|
2298
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
2299
|
+
try {
|
|
2300
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
2301
|
+
const message = createBaseFeedMessageChanged();
|
|
2302
|
+
while (reader.pos < end) {
|
|
2303
|
+
const tag = reader.uint32();
|
|
2304
|
+
switch (tag >>> 3) {
|
|
2305
|
+
case 1: {
|
|
2306
|
+
if (tag !== 8) {
|
|
2307
|
+
break;
|
|
2308
|
+
}
|
|
2309
|
+
message.messageId = reader.int64().toString();
|
|
2310
|
+
continue;
|
|
2311
|
+
}
|
|
2312
|
+
case 2: {
|
|
2313
|
+
if (tag !== 16) {
|
|
2314
|
+
break;
|
|
2315
|
+
}
|
|
2316
|
+
message.targetRevision = reader.int64().toString();
|
|
2317
|
+
continue;
|
|
2318
|
+
}
|
|
2319
|
+
case 3: {
|
|
2320
|
+
if (tag !== 26) {
|
|
2321
|
+
break;
|
|
2322
|
+
}
|
|
2323
|
+
message.message = MessageEvent.decode(reader, reader.uint32());
|
|
2324
|
+
continue;
|
|
2325
|
+
}
|
|
2326
|
+
}
|
|
2327
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
2328
|
+
break;
|
|
2329
|
+
}
|
|
2330
|
+
reader.skip(tag & 7);
|
|
2331
|
+
}
|
|
2332
|
+
return message;
|
|
2333
|
+
}
|
|
2334
|
+
finally {
|
|
2335
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
2336
|
+
}
|
|
2337
|
+
},
|
|
2338
|
+
create(base) {
|
|
2339
|
+
return FeedMessageChanged.fromPartial(base ?? {});
|
|
2340
|
+
},
|
|
2341
|
+
fromPartial(object) {
|
|
2342
|
+
const message = createBaseFeedMessageChanged();
|
|
2343
|
+
message.messageId = object.messageId ?? "0";
|
|
2344
|
+
message.targetRevision = object.targetRevision ?? "0";
|
|
2345
|
+
message.message = (object.message !== undefined && object.message !== null)
|
|
2346
|
+
? MessageEvent.fromPartial(object.message)
|
|
2347
|
+
: undefined;
|
|
2348
|
+
return message;
|
|
2349
|
+
},
|
|
2350
|
+
};
|
|
2351
|
+
function createBaseFeedMessageHidden() {
|
|
2352
|
+
return { messageIds: [], previousMessages: [] };
|
|
2353
|
+
}
|
|
2354
|
+
export const FeedMessageHidden = {
|
|
2355
|
+
encode(message, writer = new BinaryWriter()) {
|
|
2356
|
+
writer.uint32(10).fork();
|
|
2357
|
+
for (const v of message.messageIds) {
|
|
2358
|
+
writer.int64(v);
|
|
2359
|
+
}
|
|
2360
|
+
writer.join();
|
|
2361
|
+
for (const v of message.previousMessages) {
|
|
2362
|
+
MessageEvent.encode(v, writer.uint32(18).fork()).join();
|
|
2363
|
+
}
|
|
2364
|
+
return writer;
|
|
2365
|
+
},
|
|
2366
|
+
decode(input, length) {
|
|
2367
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
2368
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
2369
|
+
if (previousRecursionDepth >= 100) {
|
|
2370
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
2371
|
+
}
|
|
2372
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
2373
|
+
try {
|
|
2374
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
2375
|
+
const message = createBaseFeedMessageHidden();
|
|
2376
|
+
while (reader.pos < end) {
|
|
2377
|
+
const tag = reader.uint32();
|
|
2378
|
+
switch (tag >>> 3) {
|
|
2379
|
+
case 1: {
|
|
2380
|
+
if (tag === 8) {
|
|
2381
|
+
message.messageIds.push(reader.int64().toString());
|
|
2382
|
+
continue;
|
|
2383
|
+
}
|
|
2384
|
+
if (tag === 10) {
|
|
2385
|
+
const end2 = reader.uint32() + reader.pos;
|
|
2386
|
+
while (reader.pos < end2) {
|
|
2387
|
+
message.messageIds.push(reader.int64().toString());
|
|
2388
|
+
}
|
|
2389
|
+
continue;
|
|
2390
|
+
}
|
|
2391
|
+
break;
|
|
2392
|
+
}
|
|
2393
|
+
case 2: {
|
|
2394
|
+
if (tag !== 18) {
|
|
2395
|
+
break;
|
|
2396
|
+
}
|
|
2397
|
+
message.previousMessages.push(MessageEvent.decode(reader, reader.uint32()));
|
|
2398
|
+
continue;
|
|
2399
|
+
}
|
|
2400
|
+
}
|
|
2401
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
2402
|
+
break;
|
|
2403
|
+
}
|
|
2404
|
+
reader.skip(tag & 7);
|
|
2405
|
+
}
|
|
2406
|
+
return message;
|
|
2407
|
+
}
|
|
2408
|
+
finally {
|
|
2409
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
2410
|
+
}
|
|
2411
|
+
},
|
|
2412
|
+
create(base) {
|
|
2413
|
+
return FeedMessageHidden.fromPartial(base ?? {});
|
|
2414
|
+
},
|
|
2415
|
+
fromPartial(object) {
|
|
2416
|
+
const message = createBaseFeedMessageHidden();
|
|
2417
|
+
message.messageIds = object.messageIds?.map((e) => e) || [];
|
|
2418
|
+
message.previousMessages = object.previousMessages?.map((e) => MessageEvent.fromPartial(e)) || [];
|
|
2419
|
+
return message;
|
|
2420
|
+
},
|
|
2421
|
+
};
|
|
2422
|
+
function createBaseFeedHostChanged() {
|
|
2423
|
+
return { previousHost: undefined, newHost: undefined };
|
|
2424
|
+
}
|
|
2425
|
+
export const FeedHostChanged = {
|
|
2426
|
+
encode(message, writer = new BinaryWriter()) {
|
|
2427
|
+
if (message.previousHost !== undefined) {
|
|
2428
|
+
FeedUser.encode(message.previousHost, writer.uint32(10).fork()).join();
|
|
2429
|
+
}
|
|
2430
|
+
if (message.newHost !== undefined) {
|
|
2431
|
+
FeedUser.encode(message.newHost, writer.uint32(18).fork()).join();
|
|
2432
|
+
}
|
|
2433
|
+
return writer;
|
|
2434
|
+
},
|
|
2435
|
+
decode(input, length) {
|
|
2436
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
2437
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
2438
|
+
if (previousRecursionDepth >= 100) {
|
|
2439
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
2440
|
+
}
|
|
2441
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
2442
|
+
try {
|
|
2443
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
2444
|
+
const message = createBaseFeedHostChanged();
|
|
2445
|
+
while (reader.pos < end) {
|
|
2446
|
+
const tag = reader.uint32();
|
|
2447
|
+
switch (tag >>> 3) {
|
|
2448
|
+
case 1: {
|
|
2449
|
+
if (tag !== 10) {
|
|
2450
|
+
break;
|
|
2451
|
+
}
|
|
2452
|
+
message.previousHost = FeedUser.decode(reader, reader.uint32());
|
|
2453
|
+
continue;
|
|
2454
|
+
}
|
|
2455
|
+
case 2: {
|
|
2456
|
+
if (tag !== 18) {
|
|
2457
|
+
break;
|
|
2458
|
+
}
|
|
2459
|
+
message.newHost = FeedUser.decode(reader, reader.uint32());
|
|
2460
|
+
continue;
|
|
2461
|
+
}
|
|
2462
|
+
}
|
|
2463
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
2464
|
+
break;
|
|
2465
|
+
}
|
|
2466
|
+
reader.skip(tag & 7);
|
|
2467
|
+
}
|
|
2468
|
+
return message;
|
|
2469
|
+
}
|
|
2470
|
+
finally {
|
|
2471
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
2472
|
+
}
|
|
2473
|
+
},
|
|
2474
|
+
create(base) {
|
|
2475
|
+
return FeedHostChanged.fromPartial(base ?? {});
|
|
2476
|
+
},
|
|
2477
|
+
fromPartial(object) {
|
|
2478
|
+
const message = createBaseFeedHostChanged();
|
|
2479
|
+
message.previousHost = (object.previousHost !== undefined && object.previousHost !== null)
|
|
2480
|
+
? FeedUser.fromPartial(object.previousHost)
|
|
2481
|
+
: undefined;
|
|
2482
|
+
message.newHost = (object.newHost !== undefined && object.newHost !== null)
|
|
2483
|
+
? FeedUser.fromPartial(object.newHost)
|
|
2484
|
+
: undefined;
|
|
2485
|
+
return message;
|
|
2486
|
+
},
|
|
2487
|
+
};
|
|
2488
|
+
function createBaseFeedModeratorAdded() {
|
|
2489
|
+
return { member: undefined };
|
|
2490
|
+
}
|
|
2491
|
+
export const FeedModeratorAdded = {
|
|
2492
|
+
encode(message, writer = new BinaryWriter()) {
|
|
2493
|
+
if (message.member !== undefined) {
|
|
2494
|
+
FeedUser.encode(message.member, writer.uint32(10).fork()).join();
|
|
2495
|
+
}
|
|
2496
|
+
return writer;
|
|
2497
|
+
},
|
|
2498
|
+
decode(input, length) {
|
|
2499
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
2500
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
2501
|
+
if (previousRecursionDepth >= 100) {
|
|
2502
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
2503
|
+
}
|
|
2504
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
2505
|
+
try {
|
|
2506
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
2507
|
+
const message = createBaseFeedModeratorAdded();
|
|
2508
|
+
while (reader.pos < end) {
|
|
2509
|
+
const tag = reader.uint32();
|
|
2510
|
+
switch (tag >>> 3) {
|
|
2511
|
+
case 1: {
|
|
2512
|
+
if (tag !== 10) {
|
|
2513
|
+
break;
|
|
2514
|
+
}
|
|
2515
|
+
message.member = FeedUser.decode(reader, reader.uint32());
|
|
2516
|
+
continue;
|
|
2517
|
+
}
|
|
2518
|
+
}
|
|
2519
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
2520
|
+
break;
|
|
2521
|
+
}
|
|
2522
|
+
reader.skip(tag & 7);
|
|
2523
|
+
}
|
|
2524
|
+
return message;
|
|
2525
|
+
}
|
|
2526
|
+
finally {
|
|
2527
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
2528
|
+
}
|
|
2529
|
+
},
|
|
2530
|
+
create(base) {
|
|
2531
|
+
return FeedModeratorAdded.fromPartial(base ?? {});
|
|
2532
|
+
},
|
|
2533
|
+
fromPartial(object) {
|
|
2534
|
+
const message = createBaseFeedModeratorAdded();
|
|
2535
|
+
message.member = (object.member !== undefined && object.member !== null)
|
|
2536
|
+
? FeedUser.fromPartial(object.member)
|
|
2537
|
+
: undefined;
|
|
2538
|
+
return message;
|
|
2539
|
+
},
|
|
2540
|
+
};
|
|
2541
|
+
function createBaseFeedModeratorRemoved() {
|
|
2542
|
+
return { member: undefined };
|
|
2543
|
+
}
|
|
2544
|
+
export const FeedModeratorRemoved = {
|
|
2545
|
+
encode(message, writer = new BinaryWriter()) {
|
|
2546
|
+
if (message.member !== undefined) {
|
|
2547
|
+
FeedUser.encode(message.member, writer.uint32(10).fork()).join();
|
|
2548
|
+
}
|
|
2549
|
+
return writer;
|
|
2550
|
+
},
|
|
2551
|
+
decode(input, length) {
|
|
2552
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
2553
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
2554
|
+
if (previousRecursionDepth >= 100) {
|
|
2555
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
2556
|
+
}
|
|
2557
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
2558
|
+
try {
|
|
2559
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
2560
|
+
const message = createBaseFeedModeratorRemoved();
|
|
2561
|
+
while (reader.pos < end) {
|
|
2562
|
+
const tag = reader.uint32();
|
|
2563
|
+
switch (tag >>> 3) {
|
|
2564
|
+
case 1: {
|
|
2565
|
+
if (tag !== 10) {
|
|
2566
|
+
break;
|
|
2567
|
+
}
|
|
2568
|
+
message.member = FeedUser.decode(reader, reader.uint32());
|
|
2569
|
+
continue;
|
|
2570
|
+
}
|
|
2571
|
+
}
|
|
2572
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
2573
|
+
break;
|
|
2574
|
+
}
|
|
2575
|
+
reader.skip(tag & 7);
|
|
2576
|
+
}
|
|
2577
|
+
return message;
|
|
2578
|
+
}
|
|
2579
|
+
finally {
|
|
2580
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
2581
|
+
}
|
|
2582
|
+
},
|
|
2583
|
+
create(base) {
|
|
2584
|
+
return FeedModeratorRemoved.fromPartial(base ?? {});
|
|
2585
|
+
},
|
|
2586
|
+
fromPartial(object) {
|
|
2587
|
+
const message = createBaseFeedModeratorRemoved();
|
|
2588
|
+
message.member = (object.member !== undefined && object.member !== null)
|
|
2589
|
+
? FeedUser.fromPartial(object.member)
|
|
2590
|
+
: undefined;
|
|
2591
|
+
return message;
|
|
2592
|
+
},
|
|
2593
|
+
};
|
|
2594
|
+
function createBaseFeedManagerSpeakerMode() {
|
|
2595
|
+
return { enabled: false };
|
|
2596
|
+
}
|
|
2597
|
+
export const FeedManagerSpeakerMode = {
|
|
2598
|
+
encode(message, writer = new BinaryWriter()) {
|
|
2599
|
+
if (message.enabled !== false) {
|
|
2600
|
+
writer.uint32(8).bool(message.enabled);
|
|
2601
|
+
}
|
|
2602
|
+
return writer;
|
|
2603
|
+
},
|
|
2604
|
+
decode(input, length) {
|
|
2605
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
2606
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
2607
|
+
if (previousRecursionDepth >= 100) {
|
|
2608
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
2609
|
+
}
|
|
2610
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
2611
|
+
try {
|
|
2612
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
2613
|
+
const message = createBaseFeedManagerSpeakerMode();
|
|
2614
|
+
while (reader.pos < end) {
|
|
2615
|
+
const tag = reader.uint32();
|
|
2616
|
+
switch (tag >>> 3) {
|
|
2617
|
+
case 1: {
|
|
2618
|
+
if (tag !== 8) {
|
|
2619
|
+
break;
|
|
2620
|
+
}
|
|
2621
|
+
message.enabled = reader.bool();
|
|
2622
|
+
continue;
|
|
2623
|
+
}
|
|
2624
|
+
}
|
|
2625
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
2626
|
+
break;
|
|
2627
|
+
}
|
|
2628
|
+
reader.skip(tag & 7);
|
|
2629
|
+
}
|
|
2630
|
+
return message;
|
|
2631
|
+
}
|
|
2632
|
+
finally {
|
|
2633
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
2634
|
+
}
|
|
2635
|
+
},
|
|
2636
|
+
create(base) {
|
|
2637
|
+
return FeedManagerSpeakerMode.fromPartial(base ?? {});
|
|
2638
|
+
},
|
|
2639
|
+
fromPartial(object) {
|
|
2640
|
+
const message = createBaseFeedManagerSpeakerMode();
|
|
2641
|
+
message.enabled = object.enabled ?? false;
|
|
2642
|
+
return message;
|
|
2643
|
+
},
|
|
2644
|
+
};
|
|
2645
|
+
function createBaseFeedOpenLinkDeleted() {
|
|
2646
|
+
return {};
|
|
2647
|
+
}
|
|
2648
|
+
export const FeedOpenLinkDeleted = {
|
|
2649
|
+
encode(_, writer = new BinaryWriter()) {
|
|
2650
|
+
return writer;
|
|
2651
|
+
},
|
|
2652
|
+
decode(input, length) {
|
|
2653
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
2654
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
2655
|
+
if (previousRecursionDepth >= 100) {
|
|
2656
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
2657
|
+
}
|
|
2658
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
2659
|
+
try {
|
|
2660
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
2661
|
+
const message = createBaseFeedOpenLinkDeleted();
|
|
2662
|
+
while (reader.pos < end) {
|
|
2663
|
+
const tag = reader.uint32();
|
|
2664
|
+
switch (tag >>> 3) {
|
|
2665
|
+
}
|
|
2666
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
2667
|
+
break;
|
|
2668
|
+
}
|
|
2669
|
+
reader.skip(tag & 7);
|
|
2670
|
+
}
|
|
2671
|
+
return message;
|
|
2672
|
+
}
|
|
2673
|
+
finally {
|
|
2674
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
2675
|
+
}
|
|
2676
|
+
},
|
|
2677
|
+
create(base) {
|
|
2678
|
+
return FeedOpenLinkDeleted.fromPartial(base ?? {});
|
|
2679
|
+
},
|
|
2680
|
+
fromPartial(_) {
|
|
2681
|
+
const message = createBaseFeedOpenLinkDeleted();
|
|
2682
|
+
return message;
|
|
2683
|
+
},
|
|
2684
|
+
};
|
|
2685
|
+
function createBaseFeedUnknown() {
|
|
2686
|
+
return { rawJson: "" };
|
|
2687
|
+
}
|
|
2688
|
+
export const FeedUnknown = {
|
|
2689
|
+
encode(message, writer = new BinaryWriter()) {
|
|
2690
|
+
if (message.rawJson !== "") {
|
|
2691
|
+
writer.uint32(10).string(message.rawJson);
|
|
2692
|
+
}
|
|
2693
|
+
return writer;
|
|
2694
|
+
},
|
|
2695
|
+
decode(input, length) {
|
|
2696
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
2697
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
2698
|
+
if (previousRecursionDepth >= 100) {
|
|
2699
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
2700
|
+
}
|
|
2701
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
2702
|
+
try {
|
|
2703
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
2704
|
+
const message = createBaseFeedUnknown();
|
|
2705
|
+
while (reader.pos < end) {
|
|
2706
|
+
const tag = reader.uint32();
|
|
2707
|
+
switch (tag >>> 3) {
|
|
2708
|
+
case 1: {
|
|
2709
|
+
if (tag !== 10) {
|
|
2710
|
+
break;
|
|
2711
|
+
}
|
|
2712
|
+
message.rawJson = reader.string();
|
|
2713
|
+
continue;
|
|
2714
|
+
}
|
|
2715
|
+
}
|
|
2716
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
2717
|
+
break;
|
|
2718
|
+
}
|
|
2719
|
+
reader.skip(tag & 7);
|
|
2720
|
+
}
|
|
2721
|
+
return message;
|
|
2722
|
+
}
|
|
2723
|
+
finally {
|
|
2724
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
2725
|
+
}
|
|
2726
|
+
},
|
|
2727
|
+
create(base) {
|
|
2728
|
+
return FeedUnknown.fromPartial(base ?? {});
|
|
2729
|
+
},
|
|
2730
|
+
fromPartial(object) {
|
|
2731
|
+
const message = createBaseFeedUnknown();
|
|
2732
|
+
message.rawJson = object.rawJson ?? "";
|
|
2733
|
+
return message;
|
|
2734
|
+
},
|
|
2735
|
+
};
|
|
2736
|
+
function createBaseFeedPayload() {
|
|
2737
|
+
return { value: undefined };
|
|
2738
|
+
}
|
|
2739
|
+
export const FeedPayload = {
|
|
2740
|
+
encode(message, writer = new BinaryWriter()) {
|
|
2741
|
+
switch (message.value?.$case) {
|
|
2742
|
+
case "userJoined":
|
|
2743
|
+
FeedUserJoined.encode(message.value.userJoined, writer.uint32(10).fork()).join();
|
|
2744
|
+
break;
|
|
2745
|
+
case "userLeft":
|
|
2746
|
+
FeedUserLeft.encode(message.value.userLeft, writer.uint32(18).fork()).join();
|
|
2747
|
+
break;
|
|
2748
|
+
case "userKicked":
|
|
2749
|
+
FeedUserKicked.encode(message.value.userKicked, writer.uint32(26).fork()).join();
|
|
2750
|
+
break;
|
|
2751
|
+
case "messageDeleted":
|
|
2752
|
+
FeedMessageDeleted.encode(message.value.messageDeleted, writer.uint32(34).fork()).join();
|
|
2753
|
+
break;
|
|
2754
|
+
case "messageChanged":
|
|
2755
|
+
FeedMessageChanged.encode(message.value.messageChanged, writer.uint32(42).fork()).join();
|
|
2756
|
+
break;
|
|
2757
|
+
case "messageHidden":
|
|
2758
|
+
FeedMessageHidden.encode(message.value.messageHidden, writer.uint32(50).fork()).join();
|
|
2759
|
+
break;
|
|
2760
|
+
case "hostChanged":
|
|
2761
|
+
FeedHostChanged.encode(message.value.hostChanged, writer.uint32(58).fork()).join();
|
|
2762
|
+
break;
|
|
2763
|
+
case "moderatorAdded":
|
|
2764
|
+
FeedModeratorAdded.encode(message.value.moderatorAdded, writer.uint32(66).fork()).join();
|
|
2765
|
+
break;
|
|
2766
|
+
case "moderatorRemoved":
|
|
2767
|
+
FeedModeratorRemoved.encode(message.value.moderatorRemoved, writer.uint32(74).fork()).join();
|
|
2768
|
+
break;
|
|
2769
|
+
case "managerSpeakerMode":
|
|
2770
|
+
FeedManagerSpeakerMode.encode(message.value.managerSpeakerMode, writer.uint32(82).fork()).join();
|
|
2771
|
+
break;
|
|
2772
|
+
case "openLinkDeleted":
|
|
2773
|
+
FeedOpenLinkDeleted.encode(message.value.openLinkDeleted, writer.uint32(90).fork()).join();
|
|
2774
|
+
break;
|
|
2775
|
+
case "unknown":
|
|
2776
|
+
FeedUnknown.encode(message.value.unknown, writer.uint32(98).fork()).join();
|
|
2777
|
+
break;
|
|
2778
|
+
}
|
|
2779
|
+
return writer;
|
|
2780
|
+
},
|
|
2781
|
+
decode(input, length) {
|
|
2782
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
2783
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
2784
|
+
if (previousRecursionDepth >= 100) {
|
|
2785
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
2786
|
+
}
|
|
2787
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
2788
|
+
try {
|
|
2789
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
2790
|
+
const message = createBaseFeedPayload();
|
|
2791
|
+
while (reader.pos < end) {
|
|
2792
|
+
const tag = reader.uint32();
|
|
2793
|
+
switch (tag >>> 3) {
|
|
2794
|
+
case 1: {
|
|
2795
|
+
if (tag !== 10) {
|
|
2796
|
+
break;
|
|
2797
|
+
}
|
|
2798
|
+
message.value = { $case: "userJoined", userJoined: FeedUserJoined.decode(reader, reader.uint32()) };
|
|
2799
|
+
continue;
|
|
2800
|
+
}
|
|
2801
|
+
case 2: {
|
|
2802
|
+
if (tag !== 18) {
|
|
2803
|
+
break;
|
|
2804
|
+
}
|
|
2805
|
+
message.value = { $case: "userLeft", userLeft: FeedUserLeft.decode(reader, reader.uint32()) };
|
|
2806
|
+
continue;
|
|
2807
|
+
}
|
|
2808
|
+
case 3: {
|
|
2809
|
+
if (tag !== 26) {
|
|
2810
|
+
break;
|
|
2811
|
+
}
|
|
2812
|
+
message.value = { $case: "userKicked", userKicked: FeedUserKicked.decode(reader, reader.uint32()) };
|
|
2813
|
+
continue;
|
|
2814
|
+
}
|
|
2815
|
+
case 4: {
|
|
2816
|
+
if (tag !== 34) {
|
|
2817
|
+
break;
|
|
2818
|
+
}
|
|
2819
|
+
message.value = {
|
|
2820
|
+
$case: "messageDeleted",
|
|
2821
|
+
messageDeleted: FeedMessageDeleted.decode(reader, reader.uint32()),
|
|
2822
|
+
};
|
|
2823
|
+
continue;
|
|
2824
|
+
}
|
|
2825
|
+
case 5: {
|
|
2826
|
+
if (tag !== 42) {
|
|
2827
|
+
break;
|
|
2828
|
+
}
|
|
2829
|
+
message.value = {
|
|
2830
|
+
$case: "messageChanged",
|
|
2831
|
+
messageChanged: FeedMessageChanged.decode(reader, reader.uint32()),
|
|
2832
|
+
};
|
|
2833
|
+
continue;
|
|
2834
|
+
}
|
|
2835
|
+
case 6: {
|
|
2836
|
+
if (tag !== 50) {
|
|
2837
|
+
break;
|
|
2838
|
+
}
|
|
2839
|
+
message.value = {
|
|
2840
|
+
$case: "messageHidden",
|
|
2841
|
+
messageHidden: FeedMessageHidden.decode(reader, reader.uint32()),
|
|
2842
|
+
};
|
|
2843
|
+
continue;
|
|
2844
|
+
}
|
|
2845
|
+
case 7: {
|
|
2846
|
+
if (tag !== 58) {
|
|
2847
|
+
break;
|
|
2848
|
+
}
|
|
2849
|
+
message.value = { $case: "hostChanged", hostChanged: FeedHostChanged.decode(reader, reader.uint32()) };
|
|
2850
|
+
continue;
|
|
2851
|
+
}
|
|
2852
|
+
case 8: {
|
|
2853
|
+
if (tag !== 66) {
|
|
2854
|
+
break;
|
|
2855
|
+
}
|
|
2856
|
+
message.value = {
|
|
2857
|
+
$case: "moderatorAdded",
|
|
2858
|
+
moderatorAdded: FeedModeratorAdded.decode(reader, reader.uint32()),
|
|
2859
|
+
};
|
|
2860
|
+
continue;
|
|
2861
|
+
}
|
|
2862
|
+
case 9: {
|
|
2863
|
+
if (tag !== 74) {
|
|
2864
|
+
break;
|
|
2865
|
+
}
|
|
2866
|
+
message.value = {
|
|
2867
|
+
$case: "moderatorRemoved",
|
|
2868
|
+
moderatorRemoved: FeedModeratorRemoved.decode(reader, reader.uint32()),
|
|
2869
|
+
};
|
|
2870
|
+
continue;
|
|
2871
|
+
}
|
|
2872
|
+
case 10: {
|
|
2873
|
+
if (tag !== 82) {
|
|
2874
|
+
break;
|
|
2875
|
+
}
|
|
2876
|
+
message.value = {
|
|
2877
|
+
$case: "managerSpeakerMode",
|
|
2878
|
+
managerSpeakerMode: FeedManagerSpeakerMode.decode(reader, reader.uint32()),
|
|
2879
|
+
};
|
|
2880
|
+
continue;
|
|
2881
|
+
}
|
|
2882
|
+
case 11: {
|
|
2883
|
+
if (tag !== 90) {
|
|
2884
|
+
break;
|
|
2885
|
+
}
|
|
2886
|
+
message.value = {
|
|
2887
|
+
$case: "openLinkDeleted",
|
|
2888
|
+
openLinkDeleted: FeedOpenLinkDeleted.decode(reader, reader.uint32()),
|
|
2889
|
+
};
|
|
2890
|
+
continue;
|
|
2891
|
+
}
|
|
2892
|
+
case 12: {
|
|
2893
|
+
if (tag !== 98) {
|
|
2894
|
+
break;
|
|
2895
|
+
}
|
|
2896
|
+
message.value = { $case: "unknown", unknown: FeedUnknown.decode(reader, reader.uint32()) };
|
|
2897
|
+
continue;
|
|
2898
|
+
}
|
|
2899
|
+
}
|
|
2900
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
2901
|
+
break;
|
|
2902
|
+
}
|
|
2903
|
+
reader.skip(tag & 7);
|
|
2904
|
+
}
|
|
2905
|
+
return message;
|
|
2906
|
+
}
|
|
2907
|
+
finally {
|
|
2908
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
2909
|
+
}
|
|
2910
|
+
},
|
|
2911
|
+
create(base) {
|
|
2912
|
+
return FeedPayload.fromPartial(base ?? {});
|
|
2913
|
+
},
|
|
2914
|
+
fromPartial(object) {
|
|
2915
|
+
const message = createBaseFeedPayload();
|
|
2916
|
+
switch (object.value?.$case) {
|
|
2917
|
+
case "userJoined": {
|
|
2918
|
+
if (object.value?.userJoined !== undefined && object.value?.userJoined !== null) {
|
|
2919
|
+
message.value = { $case: "userJoined", userJoined: FeedUserJoined.fromPartial(object.value.userJoined) };
|
|
2920
|
+
}
|
|
2921
|
+
break;
|
|
2922
|
+
}
|
|
2923
|
+
case "userLeft": {
|
|
2924
|
+
if (object.value?.userLeft !== undefined && object.value?.userLeft !== null) {
|
|
2925
|
+
message.value = { $case: "userLeft", userLeft: FeedUserLeft.fromPartial(object.value.userLeft) };
|
|
2926
|
+
}
|
|
2927
|
+
break;
|
|
2928
|
+
}
|
|
2929
|
+
case "userKicked": {
|
|
2930
|
+
if (object.value?.userKicked !== undefined && object.value?.userKicked !== null) {
|
|
2931
|
+
message.value = { $case: "userKicked", userKicked: FeedUserKicked.fromPartial(object.value.userKicked) };
|
|
2932
|
+
}
|
|
2933
|
+
break;
|
|
2934
|
+
}
|
|
2935
|
+
case "messageDeleted": {
|
|
2936
|
+
if (object.value?.messageDeleted !== undefined && object.value?.messageDeleted !== null) {
|
|
2937
|
+
message.value = {
|
|
2938
|
+
$case: "messageDeleted",
|
|
2939
|
+
messageDeleted: FeedMessageDeleted.fromPartial(object.value.messageDeleted),
|
|
2940
|
+
};
|
|
2941
|
+
}
|
|
2942
|
+
break;
|
|
2943
|
+
}
|
|
2944
|
+
case "messageChanged": {
|
|
2945
|
+
if (object.value?.messageChanged !== undefined && object.value?.messageChanged !== null) {
|
|
2946
|
+
message.value = {
|
|
2947
|
+
$case: "messageChanged",
|
|
2948
|
+
messageChanged: FeedMessageChanged.fromPartial(object.value.messageChanged),
|
|
2949
|
+
};
|
|
2950
|
+
}
|
|
2951
|
+
break;
|
|
2952
|
+
}
|
|
2953
|
+
case "messageHidden": {
|
|
2954
|
+
if (object.value?.messageHidden !== undefined && object.value?.messageHidden !== null) {
|
|
2955
|
+
message.value = {
|
|
2956
|
+
$case: "messageHidden",
|
|
2957
|
+
messageHidden: FeedMessageHidden.fromPartial(object.value.messageHidden),
|
|
2958
|
+
};
|
|
2959
|
+
}
|
|
2960
|
+
break;
|
|
2961
|
+
}
|
|
2962
|
+
case "hostChanged": {
|
|
2963
|
+
if (object.value?.hostChanged !== undefined && object.value?.hostChanged !== null) {
|
|
2964
|
+
message.value = { $case: "hostChanged", hostChanged: FeedHostChanged.fromPartial(object.value.hostChanged) };
|
|
2965
|
+
}
|
|
2966
|
+
break;
|
|
2967
|
+
}
|
|
2968
|
+
case "moderatorAdded": {
|
|
2969
|
+
if (object.value?.moderatorAdded !== undefined && object.value?.moderatorAdded !== null) {
|
|
2970
|
+
message.value = {
|
|
2971
|
+
$case: "moderatorAdded",
|
|
2972
|
+
moderatorAdded: FeedModeratorAdded.fromPartial(object.value.moderatorAdded),
|
|
2973
|
+
};
|
|
2974
|
+
}
|
|
2975
|
+
break;
|
|
2976
|
+
}
|
|
2977
|
+
case "moderatorRemoved": {
|
|
2978
|
+
if (object.value?.moderatorRemoved !== undefined && object.value?.moderatorRemoved !== null) {
|
|
2979
|
+
message.value = {
|
|
2980
|
+
$case: "moderatorRemoved",
|
|
2981
|
+
moderatorRemoved: FeedModeratorRemoved.fromPartial(object.value.moderatorRemoved),
|
|
2982
|
+
};
|
|
2983
|
+
}
|
|
2984
|
+
break;
|
|
2985
|
+
}
|
|
2986
|
+
case "managerSpeakerMode": {
|
|
2987
|
+
if (object.value?.managerSpeakerMode !== undefined && object.value?.managerSpeakerMode !== null) {
|
|
2988
|
+
message.value = {
|
|
2989
|
+
$case: "managerSpeakerMode",
|
|
2990
|
+
managerSpeakerMode: FeedManagerSpeakerMode.fromPartial(object.value.managerSpeakerMode),
|
|
2991
|
+
};
|
|
2992
|
+
}
|
|
2993
|
+
break;
|
|
2994
|
+
}
|
|
2995
|
+
case "openLinkDeleted": {
|
|
2996
|
+
if (object.value?.openLinkDeleted !== undefined && object.value?.openLinkDeleted !== null) {
|
|
2997
|
+
message.value = {
|
|
2998
|
+
$case: "openLinkDeleted",
|
|
2999
|
+
openLinkDeleted: FeedOpenLinkDeleted.fromPartial(object.value.openLinkDeleted),
|
|
3000
|
+
};
|
|
3001
|
+
}
|
|
3002
|
+
break;
|
|
3003
|
+
}
|
|
3004
|
+
case "unknown": {
|
|
3005
|
+
if (object.value?.unknown !== undefined && object.value?.unknown !== null) {
|
|
3006
|
+
message.value = { $case: "unknown", unknown: FeedUnknown.fromPartial(object.value.unknown) };
|
|
3007
|
+
}
|
|
3008
|
+
break;
|
|
3009
|
+
}
|
|
3010
|
+
}
|
|
3011
|
+
return message;
|
|
3012
|
+
},
|
|
3013
|
+
};
|
|
3014
|
+
function createBaseFeedEvent() {
|
|
3015
|
+
return { channel: undefined, feed: undefined, author: undefined };
|
|
3016
|
+
}
|
|
3017
|
+
export const FeedEvent = {
|
|
3018
|
+
encode(message, writer = new BinaryWriter()) {
|
|
3019
|
+
if (message.channel !== undefined) {
|
|
3020
|
+
Channel.encode(message.channel, writer.uint32(10).fork()).join();
|
|
3021
|
+
}
|
|
3022
|
+
if (message.feed !== undefined) {
|
|
3023
|
+
FeedPayload.encode(message.feed, writer.uint32(18).fork()).join();
|
|
3024
|
+
}
|
|
3025
|
+
if (message.author !== undefined) {
|
|
3026
|
+
Member.encode(message.author, writer.uint32(26).fork()).join();
|
|
3027
|
+
}
|
|
3028
|
+
return writer;
|
|
3029
|
+
},
|
|
3030
|
+
decode(input, length) {
|
|
3031
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
3032
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
3033
|
+
if (previousRecursionDepth >= 100) {
|
|
3034
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
3035
|
+
}
|
|
3036
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
3037
|
+
try {
|
|
3038
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
3039
|
+
const message = createBaseFeedEvent();
|
|
3040
|
+
while (reader.pos < end) {
|
|
3041
|
+
const tag = reader.uint32();
|
|
3042
|
+
switch (tag >>> 3) {
|
|
3043
|
+
case 1: {
|
|
3044
|
+
if (tag !== 10) {
|
|
3045
|
+
break;
|
|
3046
|
+
}
|
|
3047
|
+
message.channel = Channel.decode(reader, reader.uint32());
|
|
3048
|
+
continue;
|
|
3049
|
+
}
|
|
3050
|
+
case 2: {
|
|
3051
|
+
if (tag !== 18) {
|
|
3052
|
+
break;
|
|
3053
|
+
}
|
|
3054
|
+
message.feed = FeedPayload.decode(reader, reader.uint32());
|
|
3055
|
+
continue;
|
|
3056
|
+
}
|
|
3057
|
+
case 3: {
|
|
3058
|
+
if (tag !== 26) {
|
|
3059
|
+
break;
|
|
3060
|
+
}
|
|
3061
|
+
message.author = Member.decode(reader, reader.uint32());
|
|
3062
|
+
continue;
|
|
3063
|
+
}
|
|
3064
|
+
}
|
|
3065
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
3066
|
+
break;
|
|
3067
|
+
}
|
|
3068
|
+
reader.skip(tag & 7);
|
|
3069
|
+
}
|
|
3070
|
+
return message;
|
|
3071
|
+
}
|
|
3072
|
+
finally {
|
|
3073
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
3074
|
+
}
|
|
3075
|
+
},
|
|
3076
|
+
create(base) {
|
|
3077
|
+
return FeedEvent.fromPartial(base ?? {});
|
|
3078
|
+
},
|
|
3079
|
+
fromPartial(object) {
|
|
3080
|
+
const message = createBaseFeedEvent();
|
|
3081
|
+
message.channel = (object.channel !== undefined && object.channel !== null)
|
|
3082
|
+
? Channel.fromPartial(object.channel)
|
|
3083
|
+
: undefined;
|
|
3084
|
+
message.feed = (object.feed !== undefined && object.feed !== null)
|
|
3085
|
+
? FeedPayload.fromPartial(object.feed)
|
|
3086
|
+
: undefined;
|
|
3087
|
+
message.author = (object.author !== undefined && object.author !== null)
|
|
3088
|
+
? Member.fromPartial(object.author)
|
|
3089
|
+
: undefined;
|
|
3090
|
+
return message;
|
|
3091
|
+
},
|
|
3092
|
+
};
|
|
3093
|
+
function createBaseEvent() {
|
|
3094
|
+
return { value: undefined };
|
|
3095
|
+
}
|
|
3096
|
+
export const Event = {
|
|
3097
|
+
encode(message, writer = new BinaryWriter()) {
|
|
3098
|
+
switch (message.value?.$case) {
|
|
3099
|
+
case "message":
|
|
3100
|
+
MessageEvent.encode(message.value.message, writer.uint32(10).fork()).join();
|
|
3101
|
+
break;
|
|
3102
|
+
case "feed":
|
|
3103
|
+
FeedEvent.encode(message.value.feed, writer.uint32(18).fork()).join();
|
|
3104
|
+
break;
|
|
3105
|
+
}
|
|
3106
|
+
return writer;
|
|
3107
|
+
},
|
|
3108
|
+
decode(input, length) {
|
|
3109
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
3110
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
3111
|
+
if (previousRecursionDepth >= 100) {
|
|
3112
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
3113
|
+
}
|
|
3114
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
3115
|
+
try {
|
|
3116
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
3117
|
+
const message = createBaseEvent();
|
|
3118
|
+
while (reader.pos < end) {
|
|
3119
|
+
const tag = reader.uint32();
|
|
3120
|
+
switch (tag >>> 3) {
|
|
3121
|
+
case 1: {
|
|
3122
|
+
if (tag !== 10) {
|
|
3123
|
+
break;
|
|
3124
|
+
}
|
|
3125
|
+
message.value = { $case: "message", message: MessageEvent.decode(reader, reader.uint32()) };
|
|
3126
|
+
continue;
|
|
3127
|
+
}
|
|
3128
|
+
case 2: {
|
|
3129
|
+
if (tag !== 18) {
|
|
3130
|
+
break;
|
|
3131
|
+
}
|
|
3132
|
+
message.value = { $case: "feed", feed: FeedEvent.decode(reader, reader.uint32()) };
|
|
3133
|
+
continue;
|
|
3134
|
+
}
|
|
3135
|
+
}
|
|
3136
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
3137
|
+
break;
|
|
3138
|
+
}
|
|
3139
|
+
reader.skip(tag & 7);
|
|
3140
|
+
}
|
|
3141
|
+
return message;
|
|
3142
|
+
}
|
|
3143
|
+
finally {
|
|
3144
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
3145
|
+
}
|
|
3146
|
+
},
|
|
3147
|
+
create(base) {
|
|
3148
|
+
return Event.fromPartial(base ?? {});
|
|
3149
|
+
},
|
|
3150
|
+
fromPartial(object) {
|
|
3151
|
+
const message = createBaseEvent();
|
|
3152
|
+
switch (object.value?.$case) {
|
|
3153
|
+
case "message": {
|
|
3154
|
+
if (object.value?.message !== undefined && object.value?.message !== null) {
|
|
3155
|
+
message.value = { $case: "message", message: MessageEvent.fromPartial(object.value.message) };
|
|
3156
|
+
}
|
|
3157
|
+
break;
|
|
3158
|
+
}
|
|
3159
|
+
case "feed": {
|
|
3160
|
+
if (object.value?.feed !== undefined && object.value?.feed !== null) {
|
|
3161
|
+
message.value = { $case: "feed", feed: FeedEvent.fromPartial(object.value.feed) };
|
|
3162
|
+
}
|
|
3163
|
+
break;
|
|
3164
|
+
}
|
|
3165
|
+
}
|
|
3166
|
+
return message;
|
|
3167
|
+
},
|
|
3168
|
+
};
|
|
3169
|
+
export const ArisaService = {
|
|
3170
|
+
healthCheck: {
|
|
3171
|
+
path: "/arisa.v1.Arisa/HealthCheck",
|
|
3172
|
+
requestStream: false,
|
|
3173
|
+
responseStream: false,
|
|
3174
|
+
requestSerialize: (value) => Buffer.from(Empty.encode(value).finish()),
|
|
3175
|
+
requestDeserialize: (value) => Empty.decode(value),
|
|
3176
|
+
responseSerialize: (value) => Buffer.from(Empty.encode(value).finish()),
|
|
3177
|
+
responseDeserialize: (value) => Empty.decode(value),
|
|
3178
|
+
},
|
|
3179
|
+
subscribeEvents: {
|
|
3180
|
+
path: "/arisa.v1.Arisa/SubscribeEvents",
|
|
3181
|
+
requestStream: false,
|
|
3182
|
+
responseStream: true,
|
|
3183
|
+
requestSerialize: (value) => Buffer.from(SubscribeEventsRequest.encode(value).finish()),
|
|
3184
|
+
requestDeserialize: (value) => SubscribeEventsRequest.decode(value),
|
|
3185
|
+
responseSerialize: (value) => Buffer.from(Event.encode(value).finish()),
|
|
3186
|
+
responseDeserialize: (value) => Event.decode(value),
|
|
3187
|
+
},
|
|
3188
|
+
reply: {
|
|
3189
|
+
path: "/arisa.v1.Arisa/Reply",
|
|
3190
|
+
requestStream: false,
|
|
3191
|
+
responseStream: false,
|
|
3192
|
+
requestSerialize: (value) => Buffer.from(ReplyRequest.encode(value).finish()),
|
|
3193
|
+
requestDeserialize: (value) => ReplyRequest.decode(value),
|
|
3194
|
+
responseSerialize: (value) => Buffer.from(Empty.encode(value).finish()),
|
|
3195
|
+
responseDeserialize: (value) => Empty.decode(value),
|
|
3196
|
+
},
|
|
3197
|
+
markRead: {
|
|
3198
|
+
path: "/arisa.v1.Arisa/MarkRead",
|
|
3199
|
+
requestStream: false,
|
|
3200
|
+
responseStream: false,
|
|
3201
|
+
requestSerialize: (value) => Buffer.from(MarkReadRequest.encode(value).finish()),
|
|
3202
|
+
requestDeserialize: (value) => MarkReadRequest.decode(value),
|
|
3203
|
+
responseSerialize: (value) => Buffer.from(Empty.encode(value).finish()),
|
|
3204
|
+
responseDeserialize: (value) => Empty.decode(value),
|
|
3205
|
+
},
|
|
3206
|
+
enterChannel: {
|
|
3207
|
+
path: "/arisa.v1.Arisa/EnterChannel",
|
|
3208
|
+
requestStream: false,
|
|
3209
|
+
responseStream: false,
|
|
3210
|
+
requestSerialize: (value) => Buffer.from(EnterChannelRequest.encode(value).finish()),
|
|
3211
|
+
requestDeserialize: (value) => EnterChannelRequest.decode(value),
|
|
3212
|
+
responseSerialize: (value) => Buffer.from(Empty.encode(value).finish()),
|
|
3213
|
+
responseDeserialize: (value) => Empty.decode(value),
|
|
3214
|
+
},
|
|
3215
|
+
sendMedia: {
|
|
3216
|
+
path: "/arisa.v1.Arisa/SendMedia",
|
|
3217
|
+
requestStream: false,
|
|
3218
|
+
responseStream: false,
|
|
3219
|
+
requestSerialize: (value) => Buffer.from(SendMediaRequest.encode(value).finish()),
|
|
3220
|
+
requestDeserialize: (value) => SendMediaRequest.decode(value),
|
|
3221
|
+
responseSerialize: (value) => Buffer.from(Empty.encode(value).finish()),
|
|
3222
|
+
responseDeserialize: (value) => Empty.decode(value),
|
|
3223
|
+
},
|
|
3224
|
+
sendMediaByChunk: {
|
|
3225
|
+
path: "/arisa.v1.Arisa/SendMediaByChunk",
|
|
3226
|
+
requestStream: true,
|
|
3227
|
+
responseStream: false,
|
|
3228
|
+
requestSerialize: (value) => Buffer.from(SendMediaByChunkRequest.encode(value).finish()),
|
|
3229
|
+
requestDeserialize: (value) => SendMediaByChunkRequest.decode(value),
|
|
3230
|
+
responseSerialize: (value) => Buffer.from(Empty.encode(value).finish()),
|
|
3231
|
+
responseDeserialize: (value) => Empty.decode(value),
|
|
3232
|
+
},
|
|
3233
|
+
getUser: {
|
|
3234
|
+
path: "/arisa.v1.Arisa/GetUser",
|
|
3235
|
+
requestStream: false,
|
|
3236
|
+
responseStream: false,
|
|
3237
|
+
requestSerialize: (value) => Buffer.from(GetUserRequest.encode(value).finish()),
|
|
3238
|
+
requestDeserialize: (value) => GetUserRequest.decode(value),
|
|
3239
|
+
responseSerialize: (value) => Buffer.from(Member.encode(value).finish()),
|
|
3240
|
+
responseDeserialize: (value) => Member.decode(value),
|
|
3241
|
+
},
|
|
3242
|
+
getUsers: {
|
|
3243
|
+
path: "/arisa.v1.Arisa/GetUsers",
|
|
3244
|
+
requestStream: false,
|
|
3245
|
+
responseStream: false,
|
|
3246
|
+
requestSerialize: (value) => Buffer.from(GetUsersRequest.encode(value).finish()),
|
|
3247
|
+
requestDeserialize: (value) => GetUsersRequest.decode(value),
|
|
3248
|
+
responseSerialize: (value) => Buffer.from(GetUsersResponse.encode(value).finish()),
|
|
3249
|
+
responseDeserialize: (value) => GetUsersResponse.decode(value),
|
|
3250
|
+
},
|
|
3251
|
+
getChannel: {
|
|
3252
|
+
path: "/arisa.v1.Arisa/GetChannel",
|
|
3253
|
+
requestStream: false,
|
|
3254
|
+
responseStream: false,
|
|
3255
|
+
requestSerialize: (value) => Buffer.from(GetChannelRequest.encode(value).finish()),
|
|
3256
|
+
requestDeserialize: (value) => GetChannelRequest.decode(value),
|
|
3257
|
+
responseSerialize: (value) => Buffer.from(Channel.encode(value).finish()),
|
|
3258
|
+
responseDeserialize: (value) => Channel.decode(value),
|
|
3259
|
+
},
|
|
3260
|
+
getMessage: {
|
|
3261
|
+
path: "/arisa.v1.Arisa/GetMessage",
|
|
3262
|
+
requestStream: false,
|
|
3263
|
+
responseStream: false,
|
|
3264
|
+
requestSerialize: (value) => Buffer.from(GetMessageRequest.encode(value).finish()),
|
|
3265
|
+
requestDeserialize: (value) => GetMessageRequest.decode(value),
|
|
3266
|
+
responseSerialize: (value) => Buffer.from(Event.encode(value).finish()),
|
|
3267
|
+
responseDeserialize: (value) => Event.decode(value),
|
|
3268
|
+
},
|
|
3269
|
+
getMessages: {
|
|
3270
|
+
path: "/arisa.v1.Arisa/GetMessages",
|
|
3271
|
+
requestStream: false,
|
|
3272
|
+
responseStream: false,
|
|
3273
|
+
requestSerialize: (value) => Buffer.from(GetMessagesRequest.encode(value).finish()),
|
|
3274
|
+
requestDeserialize: (value) => GetMessagesRequest.decode(value),
|
|
3275
|
+
responseSerialize: (value) => Buffer.from(GetMessagesResponse.encode(value).finish()),
|
|
3276
|
+
responseDeserialize: (value) => GetMessagesResponse.decode(value),
|
|
3277
|
+
},
|
|
3278
|
+
getChannelMembers: {
|
|
3279
|
+
path: "/arisa.v1.Arisa/GetChannelMembers",
|
|
3280
|
+
requestStream: false,
|
|
3281
|
+
responseStream: false,
|
|
3282
|
+
requestSerialize: (value) => Buffer.from(GetChannelMembersRequest.encode(value).finish()),
|
|
3283
|
+
requestDeserialize: (value) => GetChannelMembersRequest.decode(value),
|
|
3284
|
+
responseSerialize: (value) => Buffer.from(ChannelMembers.encode(value).finish()),
|
|
3285
|
+
responseDeserialize: (value) => ChannelMembers.decode(value),
|
|
3286
|
+
},
|
|
3287
|
+
rawQuery: {
|
|
3288
|
+
path: "/arisa.v1.Arisa/RawQuery",
|
|
3289
|
+
requestStream: false,
|
|
3290
|
+
responseStream: false,
|
|
3291
|
+
requestSerialize: (value) => Buffer.from(RawQueryRequest.encode(value).finish()),
|
|
3292
|
+
requestDeserialize: (value) => RawQueryRequest.decode(value),
|
|
3293
|
+
responseSerialize: (value) => Buffer.from(RawQueryResponse.encode(value).finish()),
|
|
3294
|
+
responseDeserialize: (value) => RawQueryResponse.decode(value),
|
|
3295
|
+
},
|
|
3296
|
+
decrypt: {
|
|
3297
|
+
path: "/arisa.v1.Arisa/Decrypt",
|
|
3298
|
+
requestStream: false,
|
|
3299
|
+
responseStream: false,
|
|
3300
|
+
requestSerialize: (value) => Buffer.from(DecryptRequest.encode(value).finish()),
|
|
3301
|
+
requestDeserialize: (value) => DecryptRequest.decode(value),
|
|
3302
|
+
responseSerialize: (value) => Buffer.from(DecryptResponse.encode(value).finish()),
|
|
3303
|
+
responseDeserialize: (value) => DecryptResponse.decode(value),
|
|
3304
|
+
},
|
|
3305
|
+
getCredential: {
|
|
3306
|
+
path: "/arisa.v1.Arisa/GetCredential",
|
|
3307
|
+
requestStream: false,
|
|
3308
|
+
responseStream: false,
|
|
3309
|
+
requestSerialize: (value) => Buffer.from(Empty.encode(value).finish()),
|
|
3310
|
+
requestDeserialize: (value) => Empty.decode(value),
|
|
3311
|
+
responseSerialize: (value) => Buffer.from(Credential.encode(value).finish()),
|
|
3312
|
+
responseDeserialize: (value) => Credential.decode(value),
|
|
3313
|
+
},
|
|
3314
|
+
};
|
|
3315
|
+
//# sourceMappingURL=arisa.pb.js.map
|