maybe add batch event

README.md

···
 
 This repository defines the LRC protocol message schema using Protocol Buffers and provides generated code for both **TypeScript** and **Go**.
 
+
+## Generation
+these may work idrk
+
+### Typescript
+```
+npx protoc \
+  --ts_out gen/ts \
+  --proto_path . \
+  lrc.proto
+```
+
+### Go
+```
+protoc --go_out=gen/go --go_opt=paths=source_relative lrc.proto
+```
+
 ## Installation
 
 ### TypeScript
···
 The LRC protocol does not inherently determine how Mute, Unmute, Kick, Ban and Unban should be implemented. ExternalID and Secret fields allow for some form of verification of identity, which can occur outside of the protocol.
 
 ## License
-MIT
+MIT

gen/go/lrc.pb.go

···
 	return 0
 }
 
+type BatchEvent struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	Events        []*Event               `protobuf:"bytes,1,rep,name=events,proto3" json:"events,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *BatchEvent) Reset() {
+	*x = BatchEvent{}
+	mi := &file_lrc_proto_msgTypes[16]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *BatchEvent) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*BatchEvent) ProtoMessage() {}
+
+func (x *BatchEvent) ProtoReflect() protoreflect.Message {
+	mi := &file_lrc_proto_msgTypes[16]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use BatchEvent.ProtoReflect.Descriptor instead.
+func (*BatchEvent) Descriptor() ([]byte, []int) {
+	return file_lrc_proto_rawDescGZIP(), []int{16}
+}
+
+func (x *BatchEvent) GetEvents() []*Event {
+	if x != nil {
+		return x.Events
+	}
+	return nil
+}
+
 var File_lrc_proto protoreflect.FileDescriptor
 
 const file_lrc_proto_rawDesc = "" +
···
 	"\n" +
 	"privileges\x18\x01 \x01(\v2\f.lrc.v1.SudoR\n" +
 	"privileges\x12\x0e\n" +
-	"\x02id\x18\x02 \x01(\rR\x02idB3Z1github.com/rachel-mp4/lrcproto/gen/go/lrcpb;lrcpbb\x06proto3"
+	"\x02id\x18\x02 \x01(\rR\x02id\"3\n" +
+	"\n" +
+	"BatchEvent\x12%\n" +
+	"\x06events\x18\x01 \x03(\v2\r.lrc.v1.EventR\x06eventsB3Z1github.com/rachel-mp4/lrcproto/gen/go/lrcpb;lrcpbb\x06proto3"
 
 var (
 	file_lrc_proto_rawDescOnce sync.Once
···
 	return file_lrc_proto_rawDescData
 }
 
-var file_lrc_proto_msgTypes = make([]protoimpl.MessageInfo, 16)
+var file_lrc_proto_msgTypes = make([]protoimpl.MessageInfo, 17)
 var file_lrc_proto_goTypes = []any{
-	(*Event)(nil),  // 0: lrc.v1.Event
-	(*Ping)(nil),   // 1: lrc.v1.Ping
-	(*Pong)(nil),   // 2: lrc.v1.Pong
-	(*Init)(nil),   // 3: lrc.v1.Init
-	(*Pub)(nil),    // 4: lrc.v1.Pub
-	(*Insert)(nil), // 5: lrc.v1.Insert
-	(*Delete)(nil), // 6: lrc.v1.Delete
-	(*Mute)(nil),   // 7: lrc.v1.Mute
-	(*Unmute)(nil), // 8: lrc.v1.Unmute
-	(*Set)(nil),    // 9: lrc.v1.Set
-	(*Get)(nil),    // 10: lrc.v1.Get
-	(*Sudo)(nil),   // 11: lrc.v1.Sudo
-	(*Kick)(nil),   // 12: lrc.v1.Kick
-	(*Hug)(nil),    // 13: lrc.v1.Hug
-	(*Ban)(nil),    // 14: lrc.v1.Ban
-	(*Unban)(nil),  // 15: lrc.v1.Unban
+	(*Event)(nil),      // 0: lrc.v1.Event
+	(*Ping)(nil),       // 1: lrc.v1.Ping
+	(*Pong)(nil),       // 2: lrc.v1.Pong
+	(*Init)(nil),       // 3: lrc.v1.Init
+	(*Pub)(nil),        // 4: lrc.v1.Pub
+	(*Insert)(nil),     // 5: lrc.v1.Insert
+	(*Delete)(nil),     // 6: lrc.v1.Delete
+	(*Mute)(nil),       // 7: lrc.v1.Mute
+	(*Unmute)(nil),     // 8: lrc.v1.Unmute
+	(*Set)(nil),        // 9: lrc.v1.Set
+	(*Get)(nil),        // 10: lrc.v1.Get
+	(*Sudo)(nil),       // 11: lrc.v1.Sudo
+	(*Kick)(nil),       // 12: lrc.v1.Kick
+	(*Hug)(nil),        // 13: lrc.v1.Hug
+	(*Ban)(nil),        // 14: lrc.v1.Ban
+	(*Unban)(nil),      // 15: lrc.v1.Unban
+	(*BatchEvent)(nil), // 16: lrc.v1.BatchEvent
 }
 var file_lrc_proto_depIdxs = []int32{
 	1,  // 0: lrc.v1.Event.ping:type_name -> lrc.v1.Ping
···
 	11, // 14: lrc.v1.Kick.privileges:type_name -> lrc.v1.Sudo
 	11, // 15: lrc.v1.Ban.privileges:type_name -> lrc.v1.Sudo
 	11, // 16: lrc.v1.Unban.privileges:type_name -> lrc.v1.Sudo
-	17, // [17:17] is the sub-list for method output_type
-	17, // [17:17] is the sub-list for method input_type
-	17, // [17:17] is the sub-list for extension type_name
-	17, // [17:17] is the sub-list for extension extendee
-	0,  // [0:17] is the sub-list for field type_name
+	0,  // 17: lrc.v1.BatchEvent.events:type_name -> lrc.v1.Event
+	18, // [18:18] is the sub-list for method output_type
+	18, // [18:18] is the sub-list for method input_type
+	18, // [18:18] is the sub-list for extension type_name
+	18, // [18:18] is the sub-list for extension extendee
+	0,  // [0:18] is the sub-list for field type_name
 }
 
 func init() { file_lrc_proto_init() }
···
 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
 			RawDescriptor: unsafe.Slice(unsafe.StringData(file_lrc_proto_rawDesc), len(file_lrc_proto_rawDesc)),
 			NumEnums:      0,
-			NumMessages:   16,
+			NumMessages:   17,
 			NumExtensions: 0,
 			NumServices:   0,
 		},

gen/ts/lrc.ts

···
-// @generated by protobuf-ts 2.10.0 with parameter long_type_string,optimize_code_size
+// @generated by protobuf-ts 2.10.0
 // @generated from protobuf file "lrc.proto" (package "lrc.v1", syntax proto3)
 // tslint:disable
+import type { BinaryWriteOptions } from "@protobuf-ts/runtime";
+import type { IBinaryWriter } from "@protobuf-ts/runtime";
+import { WireType } from "@protobuf-ts/runtime";
+import type { BinaryReadOptions } from "@protobuf-ts/runtime";
+import type { IBinaryReader } from "@protobuf-ts/runtime";
+import { UnknownFieldHandler } from "@protobuf-ts/runtime";
+import type { PartialMessage } from "@protobuf-ts/runtime";
+import { reflectionMergePartial } from "@protobuf-ts/runtime";
 import { MessageType } from "@protobuf-ts/runtime";
 /**
  * @generated from protobuf message lrc.v1.Event
···
      */
     id: number;
 }
+/**
+ * @generated from protobuf message lrc.v1.BatchEvent
+ */
+export interface BatchEvent {
+    /**
+     * @generated from protobuf field: repeated lrc.v1.Event events = 1;
+     */
+    events: Event[];
+}
 // @generated message type with reflection information, may provide speed optimized methods
 class Event$Type extends MessageType<Event> {
     constructor() {
···
             { no: 14, name: "unban", kind: "message", oneof: "msg", T: () => Unban }
         ]);
     }
+    create(value?: PartialMessage<Event>): Event {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.msg = { oneofKind: undefined };
+        if (value !== undefined)
+            reflectionMergePartial<Event>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Event): Event {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* lrc.v1.Ping ping */ 1:
+                    message.msg = {
+                        oneofKind: "ping",
+                        ping: Ping.internalBinaryRead(reader, reader.uint32(), options, (message.msg as any).ping)
+                    };
+                    break;
+                case /* lrc.v1.Pong pong */ 2:
+                    message.msg = {
+                        oneofKind: "pong",
+                        pong: Pong.internalBinaryRead(reader, reader.uint32(), options, (message.msg as any).pong)
+                    };
+                    break;
+                case /* lrc.v1.Init init */ 3:
+                    message.msg = {
+                        oneofKind: "init",
+                        init: Init.internalBinaryRead(reader, reader.uint32(), options, (message.msg as any).init)
+                    };
+                    break;
+                case /* lrc.v1.Pub pub */ 4:
+                    message.msg = {
+                        oneofKind: "pub",
+                        pub: Pub.internalBinaryRead(reader, reader.uint32(), options, (message.msg as any).pub)
+                    };
+                    break;
+                case /* lrc.v1.Insert insert */ 5:
+                    message.msg = {
+                        oneofKind: "insert",
+                        insert: Insert.internalBinaryRead(reader, reader.uint32(), options, (message.msg as any).insert)
+                    };
+                    break;
+                case /* lrc.v1.Delete delete */ 6:
+                    message.msg = {
+                        oneofKind: "delete",
+                        delete: Delete.internalBinaryRead(reader, reader.uint32(), options, (message.msg as any).delete)
+                    };
+                    break;
+                case /* lrc.v1.Mute mute */ 7:
+                    message.msg = {
+                        oneofKind: "mute",
+                        mute: Mute.internalBinaryRead(reader, reader.uint32(), options, (message.msg as any).mute)
+                    };
+                    break;
+                case /* lrc.v1.Unmute unmute */ 8:
+                    message.msg = {
+                        oneofKind: "unmute",
+                        unmute: Unmute.internalBinaryRead(reader, reader.uint32(), options, (message.msg as any).unmute)
+                    };
+                    break;
+                case /* lrc.v1.Set set */ 9:
+                    message.msg = {
+                        oneofKind: "set",
+                        set: Set.internalBinaryRead(reader, reader.uint32(), options, (message.msg as any).set)
+                    };
+                    break;
+                case /* lrc.v1.Get get */ 10:
+                    message.msg = {
+                        oneofKind: "get",
+                        get: Get.internalBinaryRead(reader, reader.uint32(), options, (message.msg as any).get)
+                    };
+                    break;
+                case /* lrc.v1.Kick kick */ 11:
+                    message.msg = {
+                        oneofKind: "kick",
+                        kick: Kick.internalBinaryRead(reader, reader.uint32(), options, (message.msg as any).kick)
+                    };
+                    break;
+                case /* lrc.v1.Hug hug */ 12:
+                    message.msg = {
+                        oneofKind: "hug",
+                        hug: Hug.internalBinaryRead(reader, reader.uint32(), options, (message.msg as any).hug)
+                    };
+                    break;
+                case /* lrc.v1.Ban ban */ 13:
+                    message.msg = {
+                        oneofKind: "ban",
+                        ban: Ban.internalBinaryRead(reader, reader.uint32(), options, (message.msg as any).ban)
+                    };
+                    break;
+                case /* lrc.v1.Unban unban */ 14:
+                    message.msg = {
+                        oneofKind: "unban",
+                        unban: Unban.internalBinaryRead(reader, reader.uint32(), options, (message.msg as any).unban)
+                    };
+                    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: Event, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* lrc.v1.Ping ping = 1; */
+        if (message.msg.oneofKind === "ping")
+            Ping.internalBinaryWrite(message.msg.ping, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* lrc.v1.Pong pong = 2; */
+        if (message.msg.oneofKind === "pong")
+            Pong.internalBinaryWrite(message.msg.pong, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        /* lrc.v1.Init init = 3; */
+        if (message.msg.oneofKind === "init")
+            Init.internalBinaryWrite(message.msg.init, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        /* lrc.v1.Pub pub = 4; */
+        if (message.msg.oneofKind === "pub")
+            Pub.internalBinaryWrite(message.msg.pub, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
+        /* lrc.v1.Insert insert = 5; */
+        if (message.msg.oneofKind === "insert")
+            Insert.internalBinaryWrite(message.msg.insert, writer.tag(5, WireType.LengthDelimited).fork(), options).join();
+        /* lrc.v1.Delete delete = 6; */
+        if (message.msg.oneofKind === "delete")
+            Delete.internalBinaryWrite(message.msg.delete, writer.tag(6, WireType.LengthDelimited).fork(), options).join();
+        /* lrc.v1.Mute mute = 7; */
+        if (message.msg.oneofKind === "mute")
+            Mute.internalBinaryWrite(message.msg.mute, writer.tag(7, WireType.LengthDelimited).fork(), options).join();
+        /* lrc.v1.Unmute unmute = 8; */
+        if (message.msg.oneofKind === "unmute")
+            Unmute.internalBinaryWrite(message.msg.unmute, writer.tag(8, WireType.LengthDelimited).fork(), options).join();
+        /* lrc.v1.Set set = 9; */
+        if (message.msg.oneofKind === "set")
+            Set.internalBinaryWrite(message.msg.set, writer.tag(9, WireType.LengthDelimited).fork(), options).join();
+        /* lrc.v1.Get get = 10; */
+        if (message.msg.oneofKind === "get")
+            Get.internalBinaryWrite(message.msg.get, writer.tag(10, WireType.LengthDelimited).fork(), options).join();
+        /* lrc.v1.Kick kick = 11; */
+        if (message.msg.oneofKind === "kick")
+            Kick.internalBinaryWrite(message.msg.kick, writer.tag(11, WireType.LengthDelimited).fork(), options).join();
+        /* lrc.v1.Hug hug = 12; */
+        if (message.msg.oneofKind === "hug")
+            Hug.internalBinaryWrite(message.msg.hug, writer.tag(12, WireType.LengthDelimited).fork(), options).join();
+        /* lrc.v1.Ban ban = 13; */
+        if (message.msg.oneofKind === "ban")
+            Ban.internalBinaryWrite(message.msg.ban, writer.tag(13, WireType.LengthDelimited).fork(), options).join();
+        /* lrc.v1.Unban unban = 14; */
+        if (message.msg.oneofKind === "unban")
+            Unban.internalBinaryWrite(message.msg.unban, writer.tag(14, 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 lrc.v1.Event
···
     constructor() {
         super("lrc.v1.Ping", []);
     }
+    create(value?: PartialMessage<Ping>): Ping {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        if (value !== undefined)
+            reflectionMergePartial<Ping>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Ping): Ping {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                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: Ping, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
 }
 /**
  * @generated MessageType for protobuf message lrc.v1.Ping
···
     constructor() {
         super("lrc.v1.Pong", []);
     }
+    create(value?: PartialMessage<Pong>): Pong {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        if (value !== undefined)
+            reflectionMergePartial<Pong>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Pong): Pong {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                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: Pong, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
 }
 /**
  * @generated MessageType for protobuf message lrc.v1.Pong
···
             { no: 6, name: "nonce", kind: "scalar", opt: true, T: 12 /*ScalarType.BYTES*/ }
         ]);
     }
+    create(value?: PartialMessage<Init>): Init {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        if (value !== undefined)
+            reflectionMergePartial<Init>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Init): Init {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* optional uint32 id */ 1:
+                    message.id = reader.uint32();
+                    break;
+                case /* optional string nick */ 2:
+                    message.nick = reader.string();
+                    break;
+                case /* optional string externalID */ 3:
+                    message.externalID = reader.string();
+                    break;
+                case /* optional uint32 color */ 4:
+                    message.color = reader.uint32();
+                    break;
+                case /* optional bool echoed */ 5:
+                    message.echoed = reader.bool();
+                    break;
+                case /* optional bytes nonce */ 6:
+                    message.nonce = reader.bytes();
+                    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: Init, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* optional uint32 id = 1; */
+        if (message.id !== undefined)
+            writer.tag(1, WireType.Varint).uint32(message.id);
+        /* optional string nick = 2; */
+        if (message.nick !== undefined)
+            writer.tag(2, WireType.LengthDelimited).string(message.nick);
+        /* optional string externalID = 3; */
+        if (message.externalID !== undefined)
+            writer.tag(3, WireType.LengthDelimited).string(message.externalID);
+        /* optional uint32 color = 4; */
+        if (message.color !== undefined)
+            writer.tag(4, WireType.Varint).uint32(message.color);
+        /* optional bool echoed = 5; */
+        if (message.echoed !== undefined)
+            writer.tag(5, WireType.Varint).bool(message.echoed);
+        /* optional bytes nonce = 6; */
+        if (message.nonce !== undefined)
+            writer.tag(6, WireType.LengthDelimited).bytes(message.nonce);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
 }
 /**
  * @generated MessageType for protobuf message lrc.v1.Init
···
             { no: 1, name: "id", kind: "scalar", opt: true, T: 13 /*ScalarType.UINT32*/ }
         ]);
     }
+    create(value?: PartialMessage<Pub>): Pub {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        if (value !== undefined)
+            reflectionMergePartial<Pub>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Pub): Pub {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* optional uint32 id */ 1:
+                    message.id = reader.uint32();
+                    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: Pub, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* optional uint32 id = 1; */
+        if (message.id !== undefined)
+            writer.tag(1, WireType.Varint).uint32(message.id);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
 }
 /**
  * @generated MessageType for protobuf message lrc.v1.Pub
···
             { no: 3, name: "utf16Index", kind: "scalar", T: 13 /*ScalarType.UINT32*/ }
         ]);
     }
+    create(value?: PartialMessage<Insert>): Insert {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.body = "";
+        message.utf16Index = 0;
+        if (value !== undefined)
+            reflectionMergePartial<Insert>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Insert): Insert {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* optional uint32 id */ 1:
+                    message.id = reader.uint32();
+                    break;
+                case /* string body */ 2:
+                    message.body = reader.string();
+                    break;
+                case /* uint32 utf16Index */ 3:
+                    message.utf16Index = reader.uint32();
+                    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: Insert, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* optional uint32 id = 1; */
+        if (message.id !== undefined)
+            writer.tag(1, WireType.Varint).uint32(message.id);
+        /* string body = 2; */
+        if (message.body !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.body);
+        /* uint32 utf16Index = 3; */
+        if (message.utf16Index !== 0)
+            writer.tag(3, WireType.Varint).uint32(message.utf16Index);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
 }
 /**
  * @generated MessageType for protobuf message lrc.v1.Insert
···
             { no: 3, name: "utf16End", kind: "scalar", T: 13 /*ScalarType.UINT32*/ }
         ]);
     }
+    create(value?: PartialMessage<Delete>): Delete {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.utf16Start = 0;
+        message.utf16End = 0;
+        if (value !== undefined)
+            reflectionMergePartial<Delete>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Delete): Delete {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* optional uint32 id */ 1:
+                    message.id = reader.uint32();
+                    break;
+                case /* uint32 utf16Start */ 2:
+                    message.utf16Start = reader.uint32();
+                    break;
+                case /* uint32 utf16End */ 3:
+                    message.utf16End = reader.uint32();
+                    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: Delete, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* optional uint32 id = 1; */
+        if (message.id !== undefined)
+            writer.tag(1, WireType.Varint).uint32(message.id);
+        /* uint32 utf16Start = 2; */
+        if (message.utf16Start !== 0)
+            writer.tag(2, WireType.Varint).uint32(message.utf16Start);
+        /* uint32 utf16End = 3; */
+        if (message.utf16End !== 0)
+            writer.tag(3, WireType.Varint).uint32(message.utf16End);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
 }
 /**
  * @generated MessageType for protobuf message lrc.v1.Delete
···
             { no: 1, name: "id", kind: "scalar", T: 13 /*ScalarType.UINT32*/ }
         ]);
     }
+    create(value?: PartialMessage<Mute>): Mute {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.id = 0;
+        if (value !== undefined)
+            reflectionMergePartial<Mute>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Mute): Mute {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* uint32 id */ 1:
+                    message.id = reader.uint32();
+                    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: Mute, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* uint32 id = 1; */
+        if (message.id !== 0)
+            writer.tag(1, WireType.Varint).uint32(message.id);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
 }
 /**
  * @generated MessageType for protobuf message lrc.v1.Mute
···
             { no: 1, name: "id", kind: "scalar", T: 13 /*ScalarType.UINT32*/ }
         ]);
     }
+    create(value?: PartialMessage<Unmute>): Unmute {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.id = 0;
+        if (value !== undefined)
+            reflectionMergePartial<Unmute>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Unmute): Unmute {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* uint32 id */ 1:
+                    message.id = reader.uint32();
+                    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: Unmute, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* uint32 id = 1; */
+        if (message.id !== 0)
+            writer.tag(1, WireType.Varint).uint32(message.id);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
 }
 /**
  * @generated MessageType for protobuf message lrc.v1.Unmute
···
             { no: 3, name: "color", kind: "scalar", opt: true, T: 13 /*ScalarType.UINT32*/ }
         ]);
     }
+    create(value?: PartialMessage<Set>): Set {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        if (value !== undefined)
+            reflectionMergePartial<Set>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Set): Set {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* optional string nick */ 1:
+                    message.nick = reader.string();
+                    break;
+                case /* optional string externalID */ 2:
+                    message.externalID = reader.string();
+                    break;
+                case /* optional uint32 color */ 3:
+                    message.color = reader.uint32();
+                    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: Set, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* optional string nick = 1; */
+        if (message.nick !== undefined)
+            writer.tag(1, WireType.LengthDelimited).string(message.nick);
+        /* optional string externalID = 2; */
+        if (message.externalID !== undefined)
+            writer.tag(2, WireType.LengthDelimited).string(message.externalID);
+        /* optional uint32 color = 3; */
+        if (message.color !== undefined)
+            writer.tag(3, WireType.Varint).uint32(message.color);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
 }
 /**
  * @generated MessageType for protobuf message lrc.v1.Set
···
             { no: 2, name: "connected", kind: "scalar", opt: true, T: 13 /*ScalarType.UINT32*/ }
         ]);
     }
+    create(value?: PartialMessage<Get>): Get {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        if (value !== undefined)
+            reflectionMergePartial<Get>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Get): Get {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* optional string topic */ 1:
+                    message.topic = reader.string();
+                    break;
+                case /* optional uint32 connected */ 2:
+                    message.connected = reader.uint32();
+                    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: Get, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* optional string topic = 1; */
+        if (message.topic !== undefined)
+            writer.tag(1, WireType.LengthDelimited).string(message.topic);
+        /* optional uint32 connected = 2; */
+        if (message.connected !== undefined)
+            writer.tag(2, WireType.Varint).uint32(message.connected);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
 }
 /**
  * @generated MessageType for protobuf message lrc.v1.Get
···
             { no: 2, name: "secret", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
         ]);
     }
+    create(value?: PartialMessage<Sudo>): Sudo {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.externalID = "";
+        message.secret = "";
+        if (value !== undefined)
+            reflectionMergePartial<Sudo>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Sudo): Sudo {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string externalID */ 1:
+                    message.externalID = reader.string();
+                    break;
+                case /* string secret */ 2:
+                    message.secret = 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: Sudo, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string externalID = 1; */
+        if (message.externalID !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.externalID);
+        /* string secret = 2; */
+        if (message.secret !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.secret);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
 }
 /**
  * @generated MessageType for protobuf message lrc.v1.Sudo
···
             { no: 2, name: "id", kind: "scalar", T: 13 /*ScalarType.UINT32*/ }
         ]);
     }
+    create(value?: PartialMessage<Kick>): Kick {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.id = 0;
+        if (value !== undefined)
+            reflectionMergePartial<Kick>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Kick): Kick {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* lrc.v1.Sudo privileges */ 1:
+                    message.privileges = Sudo.internalBinaryRead(reader, reader.uint32(), options, message.privileges);
+                    break;
+                case /* uint32 id */ 2:
+                    message.id = reader.uint32();
+                    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: Kick, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* lrc.v1.Sudo privileges = 1; */
+        if (message.privileges)
+            Sudo.internalBinaryWrite(message.privileges, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* uint32 id = 2; */
+        if (message.id !== 0)
+            writer.tag(2, WireType.Varint).uint32(message.id);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
 }
 /**
  * @generated MessageType for protobuf message lrc.v1.Kick
···
             { no: 1, name: "id", kind: "scalar", T: 13 /*ScalarType.UINT32*/ }
         ]);
     }
+    create(value?: PartialMessage<Hug>): Hug {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.id = 0;
+        if (value !== undefined)
+            reflectionMergePartial<Hug>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Hug): Hug {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* uint32 id */ 1:
+                    message.id = reader.uint32();
+                    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: Hug, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* uint32 id = 1; */
+        if (message.id !== 0)
+            writer.tag(1, WireType.Varint).uint32(message.id);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
 }
 /**
  * @generated MessageType for protobuf message lrc.v1.Hug
···
             { no: 2, name: "id", kind: "scalar", T: 13 /*ScalarType.UINT32*/ }
         ]);
     }
+    create(value?: PartialMessage<Ban>): Ban {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.id = 0;
+        if (value !== undefined)
+            reflectionMergePartial<Ban>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Ban): Ban {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* lrc.v1.Sudo privileges */ 1:
+                    message.privileges = Sudo.internalBinaryRead(reader, reader.uint32(), options, message.privileges);
+                    break;
+                case /* uint32 id */ 2:
+                    message.id = reader.uint32();
+                    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: Ban, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* lrc.v1.Sudo privileges = 1; */
+        if (message.privileges)
+            Sudo.internalBinaryWrite(message.privileges, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* uint32 id = 2; */
+        if (message.id !== 0)
+            writer.tag(2, WireType.Varint).uint32(message.id);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
 }
 /**
  * @generated MessageType for protobuf message lrc.v1.Ban
···
             { no: 2, name: "id", kind: "scalar", T: 13 /*ScalarType.UINT32*/ }
         ]);
     }
+    create(value?: PartialMessage<Unban>): Unban {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.id = 0;
+        if (value !== undefined)
+            reflectionMergePartial<Unban>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Unban): Unban {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* lrc.v1.Sudo privileges */ 1:
+                    message.privileges = Sudo.internalBinaryRead(reader, reader.uint32(), options, message.privileges);
+                    break;
+                case /* uint32 id */ 2:
+                    message.id = reader.uint32();
+                    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: Unban, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* lrc.v1.Sudo privileges = 1; */
+        if (message.privileges)
+            Sudo.internalBinaryWrite(message.privileges, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* uint32 id = 2; */
+        if (message.id !== 0)
+            writer.tag(2, WireType.Varint).uint32(message.id);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
 }
 /**
  * @generated MessageType for protobuf message lrc.v1.Unban
  */
 export const Unban = new Unban$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class BatchEvent$Type extends MessageType<BatchEvent> {
+    constructor() {
+        super("lrc.v1.BatchEvent", [
+            { no: 1, name: "events", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => Event }
+        ]);
+    }
+    create(value?: PartialMessage<BatchEvent>): BatchEvent {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.events = [];
+        if (value !== undefined)
+            reflectionMergePartial<BatchEvent>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: BatchEvent): BatchEvent {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* repeated lrc.v1.Event events */ 1:
+                    message.events.push(Event.internalBinaryRead(reader, reader.uint32(), options));
+                    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: BatchEvent, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* repeated lrc.v1.Event events = 1; */
+        for (let i = 0; i < message.events.length; i++)
+            Event.internalBinaryWrite(message.events[i], 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 lrc.v1.BatchEvent
+ */
+export const BatchEvent = new BatchEvent$Type();

lrc.proto

···
   Sudo privileges = 1;
   uint32 id = 2;
 }
+
+message BatchEvent { repeated Event events = 1; }