@inline-chat/protocol 0.0.1

package/dist/server.js

@@ -0,0 +1,1287 @@
+import { WireType } from "@protobuf-ts/runtime";
+import { UnknownFieldHandler } from "@protobuf-ts/runtime";
+import { reflectionMergePartial } from "@protobuf-ts/runtime";
+import { MessageType } from "@protobuf-ts/runtime";
+import { Space } from "./core.js";
+import { Peer } from "./core.js";
+import { User } from "./core.js";
+import { Member } from "./core.js";
+// @generated message type with reflection information, may provide speed optimized methods
+class ServerUpdate$Type extends MessageType {
+    constructor() {
+        super("server.ServerUpdate", [
+            { no: 1, name: "date", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 2, name: "seq", kind: "scalar", T: 5 /*ScalarType.INT32*/ },
+            { no: 4, name: "new_message", kind: "message", oneof: "update", T: () => ServerChatUpdateNewMessage },
+            { no: 5, name: "edit_message", kind: "message", oneof: "update", T: () => ServerChatUpdateEditMessage },
+            { no: 6, name: "delete_messages", kind: "message", oneof: "update", T: () => ServerChatUpdateDeleteMessages },
+            { no: 7, name: "delete_chat", kind: "message", oneof: "update", T: () => ServerChatUpdateDeleteChat },
+            { no: 8, name: "participant_delete", kind: "message", oneof: "update", T: () => ServerChatUpdateParticipantDelete },
+            { no: 18, name: "new_chat", kind: "message", oneof: "update", T: () => ServerChatUpdateNewChat },
+            { no: 13, name: "chat_visibility", kind: "message", oneof: "update", T: () => ServerChatUpdateVisibility },
+            { no: 15, name: "chat_info", kind: "message", oneof: "update", T: () => ServerChatUpdateInfo },
+            { no: 16, name: "pinned_messages", kind: "message", oneof: "update", T: () => ServerChatUpdatePinnedMessages },
+            { no: 21, name: "chat_moved", kind: "message", oneof: "update", T: () => ServerChatUpdateMoved },
+            { no: 9, name: "space_remove_member", kind: "message", oneof: "update", T: () => ServerSpaceUpdateRemoveMember },
+            { no: 12, name: "space_member_update", kind: "message", oneof: "update", T: () => ServerSpaceUpdateMemberUpdate },
+            { no: 19, name: "space_member_add", kind: "message", oneof: "update", T: () => ServerSpaceUpdateMemberAdd },
+            { no: 10, name: "user_space_member_delete", kind: "message", oneof: "update", T: () => ServerUserUpdateSpaceMemberDelete },
+            { no: 11, name: "user_chat_participant_delete", kind: "message", oneof: "update", T: () => ServerUserUpdateChatParticipantDelete },
+            { no: 14, name: "user_dialog_archived", kind: "message", oneof: "update", T: () => ServerUserUpdateDialogArchived },
+            { no: 17, name: "user_join_space", kind: "message", oneof: "update", T: () => ServerUserUpdateJoinSpace },
+            { no: 20, name: "user_read_max_id", kind: "message", oneof: "update", T: () => ServerUserUpdateReadMaxId },
+            { no: 22, name: "user_mark_as_unread", kind: "message", oneof: "update", T: () => ServerUserUpdateMarkAsUnread }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.date = 0n;
+        message.seq = 0;
+        message.update = { oneofKind: undefined };
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* int64 date */ 1:
+                    message.date = reader.int64().toBigInt();
+                    break;
+                case /* int32 seq */ 2:
+                    message.seq = reader.int32();
+                    break;
+                case /* server.ServerChatUpdateNewMessage new_message */ 4:
+                    message.update = {
+                        oneofKind: "newMessage",
+                        newMessage: ServerChatUpdateNewMessage.internalBinaryRead(reader, reader.uint32(), options, message.update.newMessage)
+                    };
+                    break;
+                case /* server.ServerChatUpdateEditMessage edit_message */ 5:
+                    message.update = {
+                        oneofKind: "editMessage",
+                        editMessage: ServerChatUpdateEditMessage.internalBinaryRead(reader, reader.uint32(), options, message.update.editMessage)
+                    };
+                    break;
+                case /* server.ServerChatUpdateDeleteMessages delete_messages */ 6:
+                    message.update = {
+                        oneofKind: "deleteMessages",
+                        deleteMessages: ServerChatUpdateDeleteMessages.internalBinaryRead(reader, reader.uint32(), options, message.update.deleteMessages)
+                    };
+                    break;
+                case /* server.ServerChatUpdateDeleteChat delete_chat */ 7:
+                    message.update = {
+                        oneofKind: "deleteChat",
+                        deleteChat: ServerChatUpdateDeleteChat.internalBinaryRead(reader, reader.uint32(), options, message.update.deleteChat)
+                    };
+                    break;
+                case /* server.ServerChatUpdateParticipantDelete participant_delete */ 8:
+                    message.update = {
+                        oneofKind: "participantDelete",
+                        participantDelete: ServerChatUpdateParticipantDelete.internalBinaryRead(reader, reader.uint32(), options, message.update.participantDelete)
+                    };
+                    break;
+                case /* server.ServerChatUpdateNewChat new_chat */ 18:
+                    message.update = {
+                        oneofKind: "newChat",
+                        newChat: ServerChatUpdateNewChat.internalBinaryRead(reader, reader.uint32(), options, message.update.newChat)
+                    };
+                    break;
+                case /* server.ServerChatUpdateVisibility chat_visibility */ 13:
+                    message.update = {
+                        oneofKind: "chatVisibility",
+                        chatVisibility: ServerChatUpdateVisibility.internalBinaryRead(reader, reader.uint32(), options, message.update.chatVisibility)
+                    };
+                    break;
+                case /* server.ServerChatUpdateInfo chat_info */ 15:
+                    message.update = {
+                        oneofKind: "chatInfo",
+                        chatInfo: ServerChatUpdateInfo.internalBinaryRead(reader, reader.uint32(), options, message.update.chatInfo)
+                    };
+                    break;
+                case /* server.ServerChatUpdatePinnedMessages pinned_messages */ 16:
+                    message.update = {
+                        oneofKind: "pinnedMessages",
+                        pinnedMessages: ServerChatUpdatePinnedMessages.internalBinaryRead(reader, reader.uint32(), options, message.update.pinnedMessages)
+                    };
+                    break;
+                case /* server.ServerChatUpdateMoved chat_moved */ 21:
+                    message.update = {
+                        oneofKind: "chatMoved",
+                        chatMoved: ServerChatUpdateMoved.internalBinaryRead(reader, reader.uint32(), options, message.update.chatMoved)
+                    };
+                    break;
+                case /* server.ServerSpaceUpdateRemoveMember space_remove_member */ 9:
+                    message.update = {
+                        oneofKind: "spaceRemoveMember",
+                        spaceRemoveMember: ServerSpaceUpdateRemoveMember.internalBinaryRead(reader, reader.uint32(), options, message.update.spaceRemoveMember)
+                    };
+                    break;
+                case /* server.ServerSpaceUpdateMemberUpdate space_member_update */ 12:
+                    message.update = {
+                        oneofKind: "spaceMemberUpdate",
+                        spaceMemberUpdate: ServerSpaceUpdateMemberUpdate.internalBinaryRead(reader, reader.uint32(), options, message.update.spaceMemberUpdate)
+                    };
+                    break;
+                case /* server.ServerSpaceUpdateMemberAdd space_member_add */ 19:
+                    message.update = {
+                        oneofKind: "spaceMemberAdd",
+                        spaceMemberAdd: ServerSpaceUpdateMemberAdd.internalBinaryRead(reader, reader.uint32(), options, message.update.spaceMemberAdd)
+                    };
+                    break;
+                case /* server.ServerUserUpdateSpaceMemberDelete user_space_member_delete */ 10:
+                    message.update = {
+                        oneofKind: "userSpaceMemberDelete",
+                        userSpaceMemberDelete: ServerUserUpdateSpaceMemberDelete.internalBinaryRead(reader, reader.uint32(), options, message.update.userSpaceMemberDelete)
+                    };
+                    break;
+                case /* server.ServerUserUpdateChatParticipantDelete user_chat_participant_delete */ 11:
+                    message.update = {
+                        oneofKind: "userChatParticipantDelete",
+                        userChatParticipantDelete: ServerUserUpdateChatParticipantDelete.internalBinaryRead(reader, reader.uint32(), options, message.update.userChatParticipantDelete)
+                    };
+                    break;
+                case /* server.ServerUserUpdateDialogArchived user_dialog_archived */ 14:
+                    message.update = {
+                        oneofKind: "userDialogArchived",
+                        userDialogArchived: ServerUserUpdateDialogArchived.internalBinaryRead(reader, reader.uint32(), options, message.update.userDialogArchived)
+                    };
+                    break;
+                case /* server.ServerUserUpdateJoinSpace user_join_space */ 17:
+                    message.update = {
+                        oneofKind: "userJoinSpace",
+                        userJoinSpace: ServerUserUpdateJoinSpace.internalBinaryRead(reader, reader.uint32(), options, message.update.userJoinSpace)
+                    };
+                    break;
+                case /* server.ServerUserUpdateReadMaxId user_read_max_id */ 20:
+                    message.update = {
+                        oneofKind: "userReadMaxId",
+                        userReadMaxId: ServerUserUpdateReadMaxId.internalBinaryRead(reader, reader.uint32(), options, message.update.userReadMaxId)
+                    };
+                    break;
+                case /* server.ServerUserUpdateMarkAsUnread user_mark_as_unread */ 22:
+                    message.update = {
+                        oneofKind: "userMarkAsUnread",
+                        userMarkAsUnread: ServerUserUpdateMarkAsUnread.internalBinaryRead(reader, reader.uint32(), options, message.update.userMarkAsUnread)
+                    };
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* int64 date = 1; */
+        if (message.date !== 0n)
+            writer.tag(1, WireType.Varint).int64(message.date);
+        /* int32 seq = 2; */
+        if (message.seq !== 0)
+            writer.tag(2, WireType.Varint).int32(message.seq);
+        /* server.ServerChatUpdateNewMessage new_message = 4; */
+        if (message.update.oneofKind === "newMessage")
+            ServerChatUpdateNewMessage.internalBinaryWrite(message.update.newMessage, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
+        /* server.ServerChatUpdateEditMessage edit_message = 5; */
+        if (message.update.oneofKind === "editMessage")
+            ServerChatUpdateEditMessage.internalBinaryWrite(message.update.editMessage, writer.tag(5, WireType.LengthDelimited).fork(), options).join();
+        /* server.ServerChatUpdateDeleteMessages delete_messages = 6; */
+        if (message.update.oneofKind === "deleteMessages")
+            ServerChatUpdateDeleteMessages.internalBinaryWrite(message.update.deleteMessages, writer.tag(6, WireType.LengthDelimited).fork(), options).join();
+        /* server.ServerChatUpdateDeleteChat delete_chat = 7; */
+        if (message.update.oneofKind === "deleteChat")
+            ServerChatUpdateDeleteChat.internalBinaryWrite(message.update.deleteChat, writer.tag(7, WireType.LengthDelimited).fork(), options).join();
+        /* server.ServerChatUpdateParticipantDelete participant_delete = 8; */
+        if (message.update.oneofKind === "participantDelete")
+            ServerChatUpdateParticipantDelete.internalBinaryWrite(message.update.participantDelete, writer.tag(8, WireType.LengthDelimited).fork(), options).join();
+        /* server.ServerChatUpdateNewChat new_chat = 18; */
+        if (message.update.oneofKind === "newChat")
+            ServerChatUpdateNewChat.internalBinaryWrite(message.update.newChat, writer.tag(18, WireType.LengthDelimited).fork(), options).join();
+        /* server.ServerChatUpdateVisibility chat_visibility = 13; */
+        if (message.update.oneofKind === "chatVisibility")
+            ServerChatUpdateVisibility.internalBinaryWrite(message.update.chatVisibility, writer.tag(13, WireType.LengthDelimited).fork(), options).join();
+        /* server.ServerChatUpdateInfo chat_info = 15; */
+        if (message.update.oneofKind === "chatInfo")
+            ServerChatUpdateInfo.internalBinaryWrite(message.update.chatInfo, writer.tag(15, WireType.LengthDelimited).fork(), options).join();
+        /* server.ServerChatUpdatePinnedMessages pinned_messages = 16; */
+        if (message.update.oneofKind === "pinnedMessages")
+            ServerChatUpdatePinnedMessages.internalBinaryWrite(message.update.pinnedMessages, writer.tag(16, WireType.LengthDelimited).fork(), options).join();
+        /* server.ServerChatUpdateMoved chat_moved = 21; */
+        if (message.update.oneofKind === "chatMoved")
+            ServerChatUpdateMoved.internalBinaryWrite(message.update.chatMoved, writer.tag(21, WireType.LengthDelimited).fork(), options).join();
+        /* server.ServerSpaceUpdateRemoveMember space_remove_member = 9; */
+        if (message.update.oneofKind === "spaceRemoveMember")
+            ServerSpaceUpdateRemoveMember.internalBinaryWrite(message.update.spaceRemoveMember, writer.tag(9, WireType.LengthDelimited).fork(), options).join();
+        /* server.ServerSpaceUpdateMemberUpdate space_member_update = 12; */
+        if (message.update.oneofKind === "spaceMemberUpdate")
+            ServerSpaceUpdateMemberUpdate.internalBinaryWrite(message.update.spaceMemberUpdate, writer.tag(12, WireType.LengthDelimited).fork(), options).join();
+        /* server.ServerSpaceUpdateMemberAdd space_member_add = 19; */
+        if (message.update.oneofKind === "spaceMemberAdd")
+            ServerSpaceUpdateMemberAdd.internalBinaryWrite(message.update.spaceMemberAdd, writer.tag(19, WireType.LengthDelimited).fork(), options).join();
+        /* server.ServerUserUpdateSpaceMemberDelete user_space_member_delete = 10; */
+        if (message.update.oneofKind === "userSpaceMemberDelete")
+            ServerUserUpdateSpaceMemberDelete.internalBinaryWrite(message.update.userSpaceMemberDelete, writer.tag(10, WireType.LengthDelimited).fork(), options).join();
+        /* server.ServerUserUpdateChatParticipantDelete user_chat_participant_delete = 11; */
+        if (message.update.oneofKind === "userChatParticipantDelete")
+            ServerUserUpdateChatParticipantDelete.internalBinaryWrite(message.update.userChatParticipantDelete, writer.tag(11, WireType.LengthDelimited).fork(), options).join();
+        /* server.ServerUserUpdateDialogArchived user_dialog_archived = 14; */
+        if (message.update.oneofKind === "userDialogArchived")
+            ServerUserUpdateDialogArchived.internalBinaryWrite(message.update.userDialogArchived, writer.tag(14, WireType.LengthDelimited).fork(), options).join();
+        /* server.ServerUserUpdateJoinSpace user_join_space = 17; */
+        if (message.update.oneofKind === "userJoinSpace")
+            ServerUserUpdateJoinSpace.internalBinaryWrite(message.update.userJoinSpace, writer.tag(17, WireType.LengthDelimited).fork(), options).join();
+        /* server.ServerUserUpdateReadMaxId user_read_max_id = 20; */
+        if (message.update.oneofKind === "userReadMaxId")
+            ServerUserUpdateReadMaxId.internalBinaryWrite(message.update.userReadMaxId, writer.tag(20, WireType.LengthDelimited).fork(), options).join();
+        /* server.ServerUserUpdateMarkAsUnread user_mark_as_unread = 22; */
+        if (message.update.oneofKind === "userMarkAsUnread")
+            ServerUserUpdateMarkAsUnread.internalBinaryWrite(message.update.userMarkAsUnread, writer.tag(22, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message server.ServerUpdate
+ */
+export const ServerUpdate = new ServerUpdate$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ServerChatUpdateNewMessage$Type extends MessageType {
+    constructor() {
+        super("server.ServerChatUpdateNewMessage", [
+            { no: 1, name: "chat_id", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 2, name: "msg_id", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.chatId = 0n;
+        message.msgId = 0n;
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* int64 chat_id */ 1:
+                    message.chatId = reader.int64().toBigInt();
+                    break;
+                case /* int64 msg_id */ 2:
+                    message.msgId = reader.int64().toBigInt();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* int64 chat_id = 1; */
+        if (message.chatId !== 0n)
+            writer.tag(1, WireType.Varint).int64(message.chatId);
+        /* int64 msg_id = 2; */
+        if (message.msgId !== 0n)
+            writer.tag(2, WireType.Varint).int64(message.msgId);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message server.ServerChatUpdateNewMessage
+ */
+export const ServerChatUpdateNewMessage = new ServerChatUpdateNewMessage$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ServerChatUpdateEditMessage$Type extends MessageType {
+    constructor() {
+        super("server.ServerChatUpdateEditMessage", [
+            { no: 1, name: "chat_id", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 2, name: "msg_id", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.chatId = 0n;
+        message.msgId = 0n;
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* int64 chat_id */ 1:
+                    message.chatId = reader.int64().toBigInt();
+                    break;
+                case /* int64 msg_id */ 2:
+                    message.msgId = reader.int64().toBigInt();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* int64 chat_id = 1; */
+        if (message.chatId !== 0n)
+            writer.tag(1, WireType.Varint).int64(message.chatId);
+        /* int64 msg_id = 2; */
+        if (message.msgId !== 0n)
+            writer.tag(2, WireType.Varint).int64(message.msgId);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message server.ServerChatUpdateEditMessage
+ */
+export const ServerChatUpdateEditMessage = new ServerChatUpdateEditMessage$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ServerChatUpdateDeleteMessages$Type extends MessageType {
+    constructor() {
+        super("server.ServerChatUpdateDeleteMessages", [
+            { no: 1, name: "chat_id", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 2, name: "msg_ids", kind: "scalar", repeat: 1 /*RepeatType.PACKED*/, T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.chatId = 0n;
+        message.msgIds = [];
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* int64 chat_id */ 1:
+                    message.chatId = reader.int64().toBigInt();
+                    break;
+                case /* repeated int64 msg_ids */ 2:
+                    if (wireType === WireType.LengthDelimited)
+                        for (let e = reader.int32() + reader.pos; reader.pos < e;)
+                            message.msgIds.push(reader.int64().toBigInt());
+                    else
+                        message.msgIds.push(reader.int64().toBigInt());
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* int64 chat_id = 1; */
+        if (message.chatId !== 0n)
+            writer.tag(1, WireType.Varint).int64(message.chatId);
+        /* repeated int64 msg_ids = 2; */
+        if (message.msgIds.length) {
+            writer.tag(2, WireType.LengthDelimited).fork();
+            for (let i = 0; i < message.msgIds.length; i++)
+                writer.int64(message.msgIds[i]);
+            writer.join();
+        }
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message server.ServerChatUpdateDeleteMessages
+ */
+export const ServerChatUpdateDeleteMessages = new ServerChatUpdateDeleteMessages$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ServerChatUpdateDeleteChat$Type extends MessageType {
+    constructor() {
+        super("server.ServerChatUpdateDeleteChat", [
+            { no: 1, name: "chat_id", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.chatId = 0n;
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* int64 chat_id */ 1:
+                    message.chatId = reader.int64().toBigInt();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* int64 chat_id = 1; */
+        if (message.chatId !== 0n)
+            writer.tag(1, WireType.Varint).int64(message.chatId);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message server.ServerChatUpdateDeleteChat
+ */
+export const ServerChatUpdateDeleteChat = new ServerChatUpdateDeleteChat$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ServerChatUpdateNewChat$Type extends MessageType {
+    constructor() {
+        super("server.ServerChatUpdateNewChat", [
+            { no: 1, name: "chat_id", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.chatId = 0n;
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* int64 chat_id */ 1:
+                    message.chatId = reader.int64().toBigInt();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* int64 chat_id = 1; */
+        if (message.chatId !== 0n)
+            writer.tag(1, WireType.Varint).int64(message.chatId);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message server.ServerChatUpdateNewChat
+ */
+export const ServerChatUpdateNewChat = new ServerChatUpdateNewChat$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ServerChatUpdateParticipantDelete$Type extends MessageType {
+    constructor() {
+        super("server.ServerChatUpdateParticipantDelete", [
+            { no: 1, name: "chat_id", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 2, name: "user_id", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.chatId = 0n;
+        message.userId = 0n;
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* int64 chat_id */ 1:
+                    message.chatId = reader.int64().toBigInt();
+                    break;
+                case /* int64 user_id */ 2:
+                    message.userId = reader.int64().toBigInt();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* int64 chat_id = 1; */
+        if (message.chatId !== 0n)
+            writer.tag(1, WireType.Varint).int64(message.chatId);
+        /* int64 user_id = 2; */
+        if (message.userId !== 0n)
+            writer.tag(2, WireType.Varint).int64(message.userId);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message server.ServerChatUpdateParticipantDelete
+ */
+export const ServerChatUpdateParticipantDelete = new ServerChatUpdateParticipantDelete$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ServerChatUpdateVisibility$Type extends MessageType {
+    constructor() {
+        super("server.ServerChatUpdateVisibility", [
+            { no: 1, name: "chat_id", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 2, name: "is_public", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.chatId = 0n;
+        message.isPublic = false;
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* int64 chat_id */ 1:
+                    message.chatId = reader.int64().toBigInt();
+                    break;
+                case /* bool is_public */ 2:
+                    message.isPublic = reader.bool();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* int64 chat_id = 1; */
+        if (message.chatId !== 0n)
+            writer.tag(1, WireType.Varint).int64(message.chatId);
+        /* bool is_public = 2; */
+        if (message.isPublic !== false)
+            writer.tag(2, WireType.Varint).bool(message.isPublic);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message server.ServerChatUpdateVisibility
+ */
+export const ServerChatUpdateVisibility = new ServerChatUpdateVisibility$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ServerChatUpdatePinnedMessages$Type extends MessageType {
+    constructor() {
+        super("server.ServerChatUpdatePinnedMessages", [
+            { no: 1, name: "chat_id", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 2, name: "message_ids", kind: "scalar", repeat: 1 /*RepeatType.PACKED*/, T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.chatId = 0n;
+        message.messageIds = [];
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* int64 chat_id */ 1:
+                    message.chatId = reader.int64().toBigInt();
+                    break;
+                case /* repeated int64 message_ids */ 2:
+                    if (wireType === WireType.LengthDelimited)
+                        for (let e = reader.int32() + reader.pos; reader.pos < e;)
+                            message.messageIds.push(reader.int64().toBigInt());
+                    else
+                        message.messageIds.push(reader.int64().toBigInt());
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* int64 chat_id = 1; */
+        if (message.chatId !== 0n)
+            writer.tag(1, WireType.Varint).int64(message.chatId);
+        /* repeated int64 message_ids = 2; */
+        if (message.messageIds.length) {
+            writer.tag(2, WireType.LengthDelimited).fork();
+            for (let i = 0; i < message.messageIds.length; i++)
+                writer.int64(message.messageIds[i]);
+            writer.join();
+        }
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message server.ServerChatUpdatePinnedMessages
+ */
+export const ServerChatUpdatePinnedMessages = new ServerChatUpdatePinnedMessages$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ServerChatUpdateInfo$Type extends MessageType {
+    constructor() {
+        super("server.ServerChatUpdateInfo", [
+            { no: 1, name: "chat_id", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 2, name: "title", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "emoji", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.chatId = 0n;
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* int64 chat_id */ 1:
+                    message.chatId = reader.int64().toBigInt();
+                    break;
+                case /* optional string title */ 2:
+                    message.title = reader.string();
+                    break;
+                case /* optional string emoji */ 3:
+                    message.emoji = reader.string();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* int64 chat_id = 1; */
+        if (message.chatId !== 0n)
+            writer.tag(1, WireType.Varint).int64(message.chatId);
+        /* optional string title = 2; */
+        if (message.title !== undefined)
+            writer.tag(2, WireType.LengthDelimited).string(message.title);
+        /* optional string emoji = 3; */
+        if (message.emoji !== undefined)
+            writer.tag(3, WireType.LengthDelimited).string(message.emoji);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message server.ServerChatUpdateInfo
+ */
+export const ServerChatUpdateInfo = new ServerChatUpdateInfo$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ServerChatUpdateMoved$Type extends MessageType {
+    constructor() {
+        super("server.ServerChatUpdateMoved", [
+            { no: 1, name: "chat_id", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 2, name: "old_space_id", kind: "scalar", opt: true, T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 3, name: "new_space_id", kind: "scalar", opt: true, T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.chatId = 0n;
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* int64 chat_id */ 1:
+                    message.chatId = reader.int64().toBigInt();
+                    break;
+                case /* optional int64 old_space_id */ 2:
+                    message.oldSpaceId = reader.int64().toBigInt();
+                    break;
+                case /* optional int64 new_space_id */ 3:
+                    message.newSpaceId = reader.int64().toBigInt();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* int64 chat_id = 1; */
+        if (message.chatId !== 0n)
+            writer.tag(1, WireType.Varint).int64(message.chatId);
+        /* optional int64 old_space_id = 2; */
+        if (message.oldSpaceId !== undefined)
+            writer.tag(2, WireType.Varint).int64(message.oldSpaceId);
+        /* optional int64 new_space_id = 3; */
+        if (message.newSpaceId !== undefined)
+            writer.tag(3, WireType.Varint).int64(message.newSpaceId);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message server.ServerChatUpdateMoved
+ */
+export const ServerChatUpdateMoved = new ServerChatUpdateMoved$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ServerSpaceUpdateRemoveMember$Type extends MessageType {
+    constructor() {
+        super("server.ServerSpaceUpdateRemoveMember", [
+            { no: 1, name: "space_id", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 2, name: "user_id", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.spaceId = 0n;
+        message.userId = 0n;
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* int64 space_id */ 1:
+                    message.spaceId = reader.int64().toBigInt();
+                    break;
+                case /* int64 user_id */ 2:
+                    message.userId = reader.int64().toBigInt();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* int64 space_id = 1; */
+        if (message.spaceId !== 0n)
+            writer.tag(1, WireType.Varint).int64(message.spaceId);
+        /* int64 user_id = 2; */
+        if (message.userId !== 0n)
+            writer.tag(2, WireType.Varint).int64(message.userId);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message server.ServerSpaceUpdateRemoveMember
+ */
+export const ServerSpaceUpdateRemoveMember = new ServerSpaceUpdateRemoveMember$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ServerSpaceUpdateMemberUpdate$Type extends MessageType {
+    constructor() {
+        super("server.ServerSpaceUpdateMemberUpdate", [
+            { no: 1, name: "member", kind: "message", T: () => Member }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* Member member */ 1:
+                    message.member = Member.internalBinaryRead(reader, reader.uint32(), options, message.member);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* Member member = 1; */
+        if (message.member)
+            Member.internalBinaryWrite(message.member, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message server.ServerSpaceUpdateMemberUpdate
+ */
+export const ServerSpaceUpdateMemberUpdate = new ServerSpaceUpdateMemberUpdate$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ServerSpaceUpdateMemberAdd$Type extends MessageType {
+    constructor() {
+        super("server.ServerSpaceUpdateMemberAdd", [
+            { no: 1, name: "member", kind: "message", T: () => Member },
+            { no: 2, name: "user", kind: "message", T: () => User }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* Member member */ 1:
+                    message.member = Member.internalBinaryRead(reader, reader.uint32(), options, message.member);
+                    break;
+                case /* User user */ 2:
+                    message.user = User.internalBinaryRead(reader, reader.uint32(), options, message.user);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* Member member = 1; */
+        if (message.member)
+            Member.internalBinaryWrite(message.member, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* User user = 2; */
+        if (message.user)
+            User.internalBinaryWrite(message.user, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message server.ServerSpaceUpdateMemberAdd
+ */
+export const ServerSpaceUpdateMemberAdd = new ServerSpaceUpdateMemberAdd$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ServerUserUpdateSpaceMemberDelete$Type extends MessageType {
+    constructor() {
+        super("server.ServerUserUpdateSpaceMemberDelete", [
+            { no: 1, name: "space_id", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.spaceId = 0n;
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* int64 space_id */ 1:
+                    message.spaceId = reader.int64().toBigInt();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* int64 space_id = 1; */
+        if (message.spaceId !== 0n)
+            writer.tag(1, WireType.Varint).int64(message.spaceId);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message server.ServerUserUpdateSpaceMemberDelete
+ */
+export const ServerUserUpdateSpaceMemberDelete = new ServerUserUpdateSpaceMemberDelete$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ServerUserUpdateChatParticipantDelete$Type extends MessageType {
+    constructor() {
+        super("server.ServerUserUpdateChatParticipantDelete", [
+            { no: 1, name: "chat_id", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.chatId = 0n;
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* int64 chat_id */ 1:
+                    message.chatId = reader.int64().toBigInt();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* int64 chat_id = 1; */
+        if (message.chatId !== 0n)
+            writer.tag(1, WireType.Varint).int64(message.chatId);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message server.ServerUserUpdateChatParticipantDelete
+ */
+export const ServerUserUpdateChatParticipantDelete = new ServerUserUpdateChatParticipantDelete$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ServerUserUpdateDialogArchived$Type extends MessageType {
+    constructor() {
+        super("server.ServerUserUpdateDialogArchived", [
+            { no: 1, name: "peer_id", kind: "message", T: () => Peer },
+            { no: 2, name: "archived", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.archived = false;
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* Peer peer_id */ 1:
+                    message.peerId = Peer.internalBinaryRead(reader, reader.uint32(), options, message.peerId);
+                    break;
+                case /* bool archived */ 2:
+                    message.archived = reader.bool();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* Peer peer_id = 1; */
+        if (message.peerId)
+            Peer.internalBinaryWrite(message.peerId, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* bool archived = 2; */
+        if (message.archived !== false)
+            writer.tag(2, WireType.Varint).bool(message.archived);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message server.ServerUserUpdateDialogArchived
+ */
+export const ServerUserUpdateDialogArchived = new ServerUserUpdateDialogArchived$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ServerUserUpdateJoinSpace$Type extends MessageType {
+    constructor() {
+        super("server.ServerUserUpdateJoinSpace", [
+            { no: 1, name: "space", kind: "message", T: () => Space },
+            { no: 2, name: "member", kind: "message", T: () => Member }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* Space space */ 1:
+                    message.space = Space.internalBinaryRead(reader, reader.uint32(), options, message.space);
+                    break;
+                case /* Member member */ 2:
+                    message.member = Member.internalBinaryRead(reader, reader.uint32(), options, message.member);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* Space space = 1; */
+        if (message.space)
+            Space.internalBinaryWrite(message.space, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* Member member = 2; */
+        if (message.member)
+            Member.internalBinaryWrite(message.member, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message server.ServerUserUpdateJoinSpace
+ */
+export const ServerUserUpdateJoinSpace = new ServerUserUpdateJoinSpace$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ServerUserUpdateReadMaxId$Type extends MessageType {
+    constructor() {
+        super("server.ServerUserUpdateReadMaxId", [
+            { no: 1, name: "peer_id", kind: "message", T: () => Peer },
+            { no: 2, name: "read_max_id", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 3, name: "unread_count", kind: "scalar", T: 5 /*ScalarType.INT32*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.readMaxId = 0n;
+        message.unreadCount = 0;
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* Peer peer_id */ 1:
+                    message.peerId = Peer.internalBinaryRead(reader, reader.uint32(), options, message.peerId);
+                    break;
+                case /* int64 read_max_id */ 2:
+                    message.readMaxId = reader.int64().toBigInt();
+                    break;
+                case /* int32 unread_count */ 3:
+                    message.unreadCount = reader.int32();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* Peer peer_id = 1; */
+        if (message.peerId)
+            Peer.internalBinaryWrite(message.peerId, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* int64 read_max_id = 2; */
+        if (message.readMaxId !== 0n)
+            writer.tag(2, WireType.Varint).int64(message.readMaxId);
+        /* int32 unread_count = 3; */
+        if (message.unreadCount !== 0)
+            writer.tag(3, WireType.Varint).int32(message.unreadCount);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message server.ServerUserUpdateReadMaxId
+ */
+export const ServerUserUpdateReadMaxId = new ServerUserUpdateReadMaxId$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ServerUserUpdateMarkAsUnread$Type extends MessageType {
+    constructor() {
+        super("server.ServerUserUpdateMarkAsUnread", [
+            { no: 1, name: "peer_id", kind: "message", T: () => Peer },
+            { no: 2, name: "unread_mark", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.unreadMark = false;
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* Peer peer_id */ 1:
+                    message.peerId = Peer.internalBinaryRead(reader, reader.uint32(), options, message.peerId);
+                    break;
+                case /* bool unread_mark */ 2:
+                    message.unreadMark = reader.bool();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* Peer peer_id = 1; */
+        if (message.peerId)
+            Peer.internalBinaryWrite(message.peerId, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* bool unread_mark = 2; */
+        if (message.unreadMark !== false)
+            writer.tag(2, WireType.Varint).bool(message.unreadMark);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message server.ServerUserUpdateMarkAsUnread
+ */
+export const ServerUserUpdateMarkAsUnread = new ServerUserUpdateMarkAsUnread$Type();