moth11.net
protobuf definitions for hyper-real-time chat
compile lrc 1.0 for ts
+10
.gitignore
+10
.gitignore
+56
README.md
+56
README.md
···
1
+
# @rachel-mp4/lrcproto
2
+
3
+
This repository defines the LRC protocol message schema using Protocol Buffers and provides generated code for both **TypeScript** and **Go**.
4
+
5
+
## Installation
6
+
7
+
### TypeScript
8
+
9
+
```bash
10
+
npm install @rachel-mp4/lrcproto
11
+
```
12
+
13
+
### Go
14
+
15
+
```go
16
+
import "github.com/rachel.mp4/lrcproto/gen/go"
17
+
```
18
+
19
+
## Schema
20
+
21
+
When implemented in a websocket, LRC communication occurs by sending **Events**, which in LRC 1.0 can be of 14 types. Their semantics may differ slightly if they are sent from client -> server or server -> client
22
+
23
+
```
24
+
Ping #Requests a Pong
25
+
26
+
Pong #Response to a Ping
27
+
28
+
Init #Initializes my message (client -> server)
29
+
#or declares that a message was initialized (server -> client)
30
+
Pub #Publishes my message (client -> server)
31
+
#or declares that a message was published (server -> client)
32
+
Insert #Inserts a string at a given byte offset
33
+
34
+
Delete #Deletes the bytes between two offsets
35
+
36
+
Mute #Requests the server stop relaying events from a user
37
+
38
+
Unmute #Requests the server start relaying events from a user
39
+
40
+
Set #Sets my metadata
41
+
42
+
Get #Requests the included fields from the server (client -> server)
43
+
#or provides it to the client (server -> client)
44
+
Kick #Requests to kick a user
45
+
46
+
Hug #Hugs a user
47
+
48
+
Ban #Requests to ban a user
49
+
50
+
Unban #Requests to unban a user
51
+
```
52
+
53
+
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.
54
+
55
+
## License
56
+
MIT
+1278
gen/ts/lrc.ts
+1278
gen/ts/lrc.ts
···
1
+
// @generated by protobuf-ts 2.10.0
2
+
// @generated from protobuf file "lrc.proto" (syntax proto3)
3
+
// tslint:disable
4
+
import type { BinaryWriteOptions } from "@protobuf-ts/runtime";
5
+
import type { IBinaryWriter } from "@protobuf-ts/runtime";
6
+
import { WireType } from "@protobuf-ts/runtime";
7
+
import type { BinaryReadOptions } from "@protobuf-ts/runtime";
8
+
import type { IBinaryReader } from "@protobuf-ts/runtime";
9
+
import { UnknownFieldHandler } from "@protobuf-ts/runtime";
10
+
import type { PartialMessage } from "@protobuf-ts/runtime";
11
+
import { reflectionMergePartial } from "@protobuf-ts/runtime";
12
+
import { MessageType } from "@protobuf-ts/runtime";
13
+
/**
14
+
* @generated from protobuf message Event
15
+
*/
16
+
export interface Event {
17
+
/**
18
+
* @generated from protobuf oneof: msg
19
+
*/
20
+
msg: {
21
+
oneofKind: "ping";
22
+
/**
23
+
* @generated from protobuf field: Ping ping = 1;
24
+
*/
25
+
ping: Ping;
26
+
} | {
27
+
oneofKind: "pong";
28
+
/**
29
+
* @generated from protobuf field: Pong pong = 2;
30
+
*/
31
+
pong: Pong;
32
+
} | {
33
+
oneofKind: "init";
34
+
/**
35
+
* @generated from protobuf field: Init init = 3;
36
+
*/
37
+
init: Init;
38
+
} | {
39
+
oneofKind: "pub";
40
+
/**
41
+
* @generated from protobuf field: Pub pub = 4;
42
+
*/
43
+
pub: Pub;
44
+
} | {
45
+
oneofKind: "insert";
46
+
/**
47
+
* @generated from protobuf field: Insert insert = 5;
48
+
*/
49
+
insert: Insert;
50
+
} | {
51
+
oneofKind: "delete";
52
+
/**
53
+
* @generated from protobuf field: Delete delete = 6;
54
+
*/
55
+
delete: Delete;
56
+
} | {
57
+
oneofKind: "mute";
58
+
/**
59
+
* @generated from protobuf field: Mute mute = 7;
60
+
*/
61
+
mute: Mute;
62
+
} | {
63
+
oneofKind: "unmute";
64
+
/**
65
+
* @generated from protobuf field: Unmute unmute = 8;
66
+
*/
67
+
unmute: Unmute;
68
+
} | {
69
+
oneofKind: "set";
70
+
/**
71
+
* @generated from protobuf field: Set set = 9;
72
+
*/
73
+
set: Set;
74
+
} | {
75
+
oneofKind: "get";
76
+
/**
77
+
* @generated from protobuf field: Get get = 10;
78
+
*/
79
+
get: Get;
80
+
} | {
81
+
oneofKind: "kick";
82
+
/**
83
+
* @generated from protobuf field: Kick kick = 11;
84
+
*/
85
+
kick: Kick;
86
+
} | {
87
+
oneofKind: "hug";
88
+
/**
89
+
* @generated from protobuf field: Hug hug = 12;
90
+
*/
91
+
hug: Hug;
92
+
} | {
93
+
oneofKind: "ban";
94
+
/**
95
+
* @generated from protobuf field: Ban ban = 13;
96
+
*/
97
+
ban: Ban;
98
+
} | {
99
+
oneofKind: "unban";
100
+
/**
101
+
* @generated from protobuf field: Unban unban = 14;
102
+
*/
103
+
unban: Unban;
104
+
} | {
105
+
oneofKind: undefined;
106
+
};
107
+
}
108
+
/**
109
+
* @generated from protobuf message Ping
110
+
*/
111
+
export interface Ping {
112
+
}
113
+
/**
114
+
* @generated from protobuf message Pong
115
+
*/
116
+
export interface Pong {
117
+
}
118
+
/**
119
+
* @generated from protobuf message Init
120
+
*/
121
+
export interface Init {
122
+
/**
123
+
* @generated from protobuf field: uint32 id = 1;
124
+
*/
125
+
id: number;
126
+
/**
127
+
* @generated from protobuf field: string nick = 2;
128
+
*/
129
+
nick: string;
130
+
/**
131
+
* @generated from protobuf field: string externalID = 3;
132
+
*/
133
+
externalID: string;
134
+
/**
135
+
* @generated from protobuf field: uint32 color = 4;
136
+
*/
137
+
color: number;
138
+
/**
139
+
* @generated from protobuf field: bool echoed = 5;
140
+
*/
141
+
echoed: boolean;
142
+
}
143
+
/**
144
+
* @generated from protobuf message Pub
145
+
*/
146
+
export interface Pub {
147
+
/**
148
+
* @generated from protobuf field: uint32 id = 1;
149
+
*/
150
+
id: number;
151
+
}
152
+
/**
153
+
* @generated from protobuf message Insert
154
+
*/
155
+
export interface Insert {
156
+
/**
157
+
* @generated from protobuf field: uint32 id = 1;
158
+
*/
159
+
id: number;
160
+
/**
161
+
* @generated from protobuf field: string body = 2;
162
+
*/
163
+
body: string;
164
+
/**
165
+
* @generated from protobuf field: uint32 byteIndex = 3;
166
+
*/
167
+
byteIndex: number;
168
+
}
169
+
/**
170
+
* @generated from protobuf message Delete
171
+
*/
172
+
export interface Delete {
173
+
/**
174
+
* @generated from protobuf field: uint32 id = 1;
175
+
*/
176
+
id: number;
177
+
/**
178
+
* @generated from protobuf field: uint32 byteStart = 2;
179
+
*/
180
+
byteStart: number;
181
+
/**
182
+
* @generated from protobuf field: uint32 byteEnd = 3;
183
+
*/
184
+
byteEnd: number;
185
+
}
186
+
/**
187
+
* @generated from protobuf message Mute
188
+
*/
189
+
export interface Mute {
190
+
/**
191
+
* @generated from protobuf field: uint32 id = 1;
192
+
*/
193
+
id: number;
194
+
}
195
+
/**
196
+
* @generated from protobuf message Unmute
197
+
*/
198
+
export interface Unmute {
199
+
/**
200
+
* @generated from protobuf field: uint32 id = 1;
201
+
*/
202
+
id: number;
203
+
}
204
+
/**
205
+
* @generated from protobuf message Set
206
+
*/
207
+
export interface Set {
208
+
/**
209
+
* @generated from protobuf field: string nick = 1;
210
+
*/
211
+
nick: string;
212
+
/**
213
+
* @generated from protobuf field: string externalID = 2;
214
+
*/
215
+
externalID: string;
216
+
/**
217
+
* @generated from protobuf field: uint32 color = 3;
218
+
*/
219
+
color: number;
220
+
}
221
+
/**
222
+
* @generated from protobuf message Get
223
+
*/
224
+
export interface Get {
225
+
/**
226
+
* @generated from protobuf field: string topic = 1;
227
+
*/
228
+
topic: string;
229
+
/**
230
+
* @generated from protobuf field: uint32 connected = 2;
231
+
*/
232
+
connected: number;
233
+
}
234
+
/**
235
+
* @generated from protobuf message Sudo
236
+
*/
237
+
export interface Sudo {
238
+
/**
239
+
* @generated from protobuf field: string externalID = 1;
240
+
*/
241
+
externalID: string;
242
+
/**
243
+
* @generated from protobuf field: string secret = 2;
244
+
*/
245
+
secret: string;
246
+
}
247
+
/**
248
+
* @generated from protobuf message Kick
249
+
*/
250
+
export interface Kick {
251
+
/**
252
+
* @generated from protobuf field: Sudo privileges = 1;
253
+
*/
254
+
privileges?: Sudo;
255
+
/**
256
+
* @generated from protobuf field: uint32 id = 2;
257
+
*/
258
+
id: number;
259
+
}
260
+
/**
261
+
* @generated from protobuf message Hug
262
+
*/
263
+
export interface Hug {
264
+
/**
265
+
* @generated from protobuf field: uint32 id = 1;
266
+
*/
267
+
id: number;
268
+
}
269
+
/**
270
+
* @generated from protobuf message Ban
271
+
*/
272
+
export interface Ban {
273
+
/**
274
+
* @generated from protobuf field: Sudo privileges = 1;
275
+
*/
276
+
privileges?: Sudo;
277
+
/**
278
+
* @generated from protobuf field: uint32 id = 2;
279
+
*/
280
+
id: number;
281
+
}
282
+
/**
283
+
* @generated from protobuf message Unban
284
+
*/
285
+
export interface Unban {
286
+
/**
287
+
* @generated from protobuf field: Sudo privileges = 1;
288
+
*/
289
+
privileges?: Sudo;
290
+
/**
291
+
* @generated from protobuf field: uint32 id = 2;
292
+
*/
293
+
id: number;
294
+
}
295
+
// @generated message type with reflection information, may provide speed optimized methods
296
+
class Event$Type extends MessageType<Event> {
297
+
constructor() {
298
+
super("Event", [
299
+
{ no: 1, name: "ping", kind: "message", oneof: "msg", T: () => Ping },
300
+
{ no: 2, name: "pong", kind: "message", oneof: "msg", T: () => Pong },
301
+
{ no: 3, name: "init", kind: "message", oneof: "msg", T: () => Init },
302
+
{ no: 4, name: "pub", kind: "message", oneof: "msg", T: () => Pub },
303
+
{ no: 5, name: "insert", kind: "message", oneof: "msg", T: () => Insert },
304
+
{ no: 6, name: "delete", kind: "message", oneof: "msg", T: () => Delete },
305
+
{ no: 7, name: "mute", kind: "message", oneof: "msg", T: () => Mute },
306
+
{ no: 8, name: "unmute", kind: "message", oneof: "msg", T: () => Unmute },
307
+
{ no: 9, name: "set", kind: "message", oneof: "msg", T: () => Set },
308
+
{ no: 10, name: "get", kind: "message", oneof: "msg", T: () => Get },
309
+
{ no: 11, name: "kick", kind: "message", oneof: "msg", T: () => Kick },
310
+
{ no: 12, name: "hug", kind: "message", oneof: "msg", T: () => Hug },
311
+
{ no: 13, name: "ban", kind: "message", oneof: "msg", T: () => Ban },
312
+
{ no: 14, name: "unban", kind: "message", oneof: "msg", T: () => Unban }
313
+
]);
314
+
}
315
+
create(value?: PartialMessage<Event>): Event {
316
+
const message = globalThis.Object.create((this.messagePrototype!));
317
+
message.msg = { oneofKind: undefined };
318
+
if (value !== undefined)
319
+
reflectionMergePartial<Event>(this, message, value);
320
+
return message;
321
+
}
322
+
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Event): Event {
323
+
let message = target ?? this.create(), end = reader.pos + length;
324
+
while (reader.pos < end) {
325
+
let [fieldNo, wireType] = reader.tag();
326
+
switch (fieldNo) {
327
+
case /* Ping ping */ 1:
328
+
message.msg = {
329
+
oneofKind: "ping",
330
+
ping: Ping.internalBinaryRead(reader, reader.uint32(), options, (message.msg as any).ping)
331
+
};
332
+
break;
333
+
case /* Pong pong */ 2:
334
+
message.msg = {
335
+
oneofKind: "pong",
336
+
pong: Pong.internalBinaryRead(reader, reader.uint32(), options, (message.msg as any).pong)
337
+
};
338
+
break;
339
+
case /* Init init */ 3:
340
+
message.msg = {
341
+
oneofKind: "init",
342
+
init: Init.internalBinaryRead(reader, reader.uint32(), options, (message.msg as any).init)
343
+
};
344
+
break;
345
+
case /* Pub pub */ 4:
346
+
message.msg = {
347
+
oneofKind: "pub",
348
+
pub: Pub.internalBinaryRead(reader, reader.uint32(), options, (message.msg as any).pub)
349
+
};
350
+
break;
351
+
case /* Insert insert */ 5:
352
+
message.msg = {
353
+
oneofKind: "insert",
354
+
insert: Insert.internalBinaryRead(reader, reader.uint32(), options, (message.msg as any).insert)
355
+
};
356
+
break;
357
+
case /* Delete delete */ 6:
358
+
message.msg = {
359
+
oneofKind: "delete",
360
+
delete: Delete.internalBinaryRead(reader, reader.uint32(), options, (message.msg as any).delete)
361
+
};
362
+
break;
363
+
case /* Mute mute */ 7:
364
+
message.msg = {
365
+
oneofKind: "mute",
366
+
mute: Mute.internalBinaryRead(reader, reader.uint32(), options, (message.msg as any).mute)
367
+
};
368
+
break;
369
+
case /* Unmute unmute */ 8:
370
+
message.msg = {
371
+
oneofKind: "unmute",
372
+
unmute: Unmute.internalBinaryRead(reader, reader.uint32(), options, (message.msg as any).unmute)
373
+
};
374
+
break;
375
+
case /* Set set */ 9:
376
+
message.msg = {
377
+
oneofKind: "set",
378
+
set: Set.internalBinaryRead(reader, reader.uint32(), options, (message.msg as any).set)
379
+
};
380
+
break;
381
+
case /* Get get */ 10:
382
+
message.msg = {
383
+
oneofKind: "get",
384
+
get: Get.internalBinaryRead(reader, reader.uint32(), options, (message.msg as any).get)
385
+
};
386
+
break;
387
+
case /* Kick kick */ 11:
388
+
message.msg = {
389
+
oneofKind: "kick",
390
+
kick: Kick.internalBinaryRead(reader, reader.uint32(), options, (message.msg as any).kick)
391
+
};
392
+
break;
393
+
case /* Hug hug */ 12:
394
+
message.msg = {
395
+
oneofKind: "hug",
396
+
hug: Hug.internalBinaryRead(reader, reader.uint32(), options, (message.msg as any).hug)
397
+
};
398
+
break;
399
+
case /* Ban ban */ 13:
400
+
message.msg = {
401
+
oneofKind: "ban",
402
+
ban: Ban.internalBinaryRead(reader, reader.uint32(), options, (message.msg as any).ban)
403
+
};
404
+
break;
405
+
case /* Unban unban */ 14:
406
+
message.msg = {
407
+
oneofKind: "unban",
408
+
unban: Unban.internalBinaryRead(reader, reader.uint32(), options, (message.msg as any).unban)
409
+
};
410
+
break;
411
+
default:
412
+
let u = options.readUnknownField;
413
+
if (u === "throw")
414
+
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
415
+
let d = reader.skip(wireType);
416
+
if (u !== false)
417
+
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
418
+
}
419
+
}
420
+
return message;
421
+
}
422
+
internalBinaryWrite(message: Event, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
423
+
/* Ping ping = 1; */
424
+
if (message.msg.oneofKind === "ping")
425
+
Ping.internalBinaryWrite(message.msg.ping, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
426
+
/* Pong pong = 2; */
427
+
if (message.msg.oneofKind === "pong")
428
+
Pong.internalBinaryWrite(message.msg.pong, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
429
+
/* Init init = 3; */
430
+
if (message.msg.oneofKind === "init")
431
+
Init.internalBinaryWrite(message.msg.init, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
432
+
/* Pub pub = 4; */
433
+
if (message.msg.oneofKind === "pub")
434
+
Pub.internalBinaryWrite(message.msg.pub, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
435
+
/* Insert insert = 5; */
436
+
if (message.msg.oneofKind === "insert")
437
+
Insert.internalBinaryWrite(message.msg.insert, writer.tag(5, WireType.LengthDelimited).fork(), options).join();
438
+
/* Delete delete = 6; */
439
+
if (message.msg.oneofKind === "delete")
440
+
Delete.internalBinaryWrite(message.msg.delete, writer.tag(6, WireType.LengthDelimited).fork(), options).join();
441
+
/* Mute mute = 7; */
442
+
if (message.msg.oneofKind === "mute")
443
+
Mute.internalBinaryWrite(message.msg.mute, writer.tag(7, WireType.LengthDelimited).fork(), options).join();
444
+
/* Unmute unmute = 8; */
445
+
if (message.msg.oneofKind === "unmute")
446
+
Unmute.internalBinaryWrite(message.msg.unmute, writer.tag(8, WireType.LengthDelimited).fork(), options).join();
447
+
/* Set set = 9; */
448
+
if (message.msg.oneofKind === "set")
449
+
Set.internalBinaryWrite(message.msg.set, writer.tag(9, WireType.LengthDelimited).fork(), options).join();
450
+
/* Get get = 10; */
451
+
if (message.msg.oneofKind === "get")
452
+
Get.internalBinaryWrite(message.msg.get, writer.tag(10, WireType.LengthDelimited).fork(), options).join();
453
+
/* Kick kick = 11; */
454
+
if (message.msg.oneofKind === "kick")
455
+
Kick.internalBinaryWrite(message.msg.kick, writer.tag(11, WireType.LengthDelimited).fork(), options).join();
456
+
/* Hug hug = 12; */
457
+
if (message.msg.oneofKind === "hug")
458
+
Hug.internalBinaryWrite(message.msg.hug, writer.tag(12, WireType.LengthDelimited).fork(), options).join();
459
+
/* Ban ban = 13; */
460
+
if (message.msg.oneofKind === "ban")
461
+
Ban.internalBinaryWrite(message.msg.ban, writer.tag(13, WireType.LengthDelimited).fork(), options).join();
462
+
/* Unban unban = 14; */
463
+
if (message.msg.oneofKind === "unban")
464
+
Unban.internalBinaryWrite(message.msg.unban, writer.tag(14, WireType.LengthDelimited).fork(), options).join();
465
+
let u = options.writeUnknownFields;
466
+
if (u !== false)
467
+
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
468
+
return writer;
469
+
}
470
+
}
471
+
/**
472
+
* @generated MessageType for protobuf message Event
473
+
*/
474
+
export const Event = new Event$Type();
475
+
// @generated message type with reflection information, may provide speed optimized methods
476
+
class Ping$Type extends MessageType<Ping> {
477
+
constructor() {
478
+
super("Ping", []);
479
+
}
480
+
create(value?: PartialMessage<Ping>): Ping {
481
+
const message = globalThis.Object.create((this.messagePrototype!));
482
+
if (value !== undefined)
483
+
reflectionMergePartial<Ping>(this, message, value);
484
+
return message;
485
+
}
486
+
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Ping): Ping {
487
+
let message = target ?? this.create(), end = reader.pos + length;
488
+
while (reader.pos < end) {
489
+
let [fieldNo, wireType] = reader.tag();
490
+
switch (fieldNo) {
491
+
default:
492
+
let u = options.readUnknownField;
493
+
if (u === "throw")
494
+
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
495
+
let d = reader.skip(wireType);
496
+
if (u !== false)
497
+
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
498
+
}
499
+
}
500
+
return message;
501
+
}
502
+
internalBinaryWrite(message: Ping, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
503
+
let u = options.writeUnknownFields;
504
+
if (u !== false)
505
+
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
506
+
return writer;
507
+
}
508
+
}
509
+
/**
510
+
* @generated MessageType for protobuf message Ping
511
+
*/
512
+
export const Ping = new Ping$Type();
513
+
// @generated message type with reflection information, may provide speed optimized methods
514
+
class Pong$Type extends MessageType<Pong> {
515
+
constructor() {
516
+
super("Pong", []);
517
+
}
518
+
create(value?: PartialMessage<Pong>): Pong {
519
+
const message = globalThis.Object.create((this.messagePrototype!));
520
+
if (value !== undefined)
521
+
reflectionMergePartial<Pong>(this, message, value);
522
+
return message;
523
+
}
524
+
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Pong): Pong {
525
+
let message = target ?? this.create(), end = reader.pos + length;
526
+
while (reader.pos < end) {
527
+
let [fieldNo, wireType] = reader.tag();
528
+
switch (fieldNo) {
529
+
default:
530
+
let u = options.readUnknownField;
531
+
if (u === "throw")
532
+
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
533
+
let d = reader.skip(wireType);
534
+
if (u !== false)
535
+
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
536
+
}
537
+
}
538
+
return message;
539
+
}
540
+
internalBinaryWrite(message: Pong, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
541
+
let u = options.writeUnknownFields;
542
+
if (u !== false)
543
+
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
544
+
return writer;
545
+
}
546
+
}
547
+
/**
548
+
* @generated MessageType for protobuf message Pong
549
+
*/
550
+
export const Pong = new Pong$Type();
551
+
// @generated message type with reflection information, may provide speed optimized methods
552
+
class Init$Type extends MessageType<Init> {
553
+
constructor() {
554
+
super("Init", [
555
+
{ no: 1, name: "id", kind: "scalar", T: 13 /*ScalarType.UINT32*/ },
556
+
{ no: 2, name: "nick", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
557
+
{ no: 3, name: "externalID", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
558
+
{ no: 4, name: "color", kind: "scalar", T: 13 /*ScalarType.UINT32*/ },
559
+
{ no: 5, name: "echoed", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }
560
+
]);
561
+
}
562
+
create(value?: PartialMessage<Init>): Init {
563
+
const message = globalThis.Object.create((this.messagePrototype!));
564
+
message.id = 0;
565
+
message.nick = "";
566
+
message.externalID = "";
567
+
message.color = 0;
568
+
message.echoed = false;
569
+
if (value !== undefined)
570
+
reflectionMergePartial<Init>(this, message, value);
571
+
return message;
572
+
}
573
+
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Init): Init {
574
+
let message = target ?? this.create(), end = reader.pos + length;
575
+
while (reader.pos < end) {
576
+
let [fieldNo, wireType] = reader.tag();
577
+
switch (fieldNo) {
578
+
case /* uint32 id */ 1:
579
+
message.id = reader.uint32();
580
+
break;
581
+
case /* string nick */ 2:
582
+
message.nick = reader.string();
583
+
break;
584
+
case /* string externalID */ 3:
585
+
message.externalID = reader.string();
586
+
break;
587
+
case /* uint32 color */ 4:
588
+
message.color = reader.uint32();
589
+
break;
590
+
case /* bool echoed */ 5:
591
+
message.echoed = reader.bool();
592
+
break;
593
+
default:
594
+
let u = options.readUnknownField;
595
+
if (u === "throw")
596
+
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
597
+
let d = reader.skip(wireType);
598
+
if (u !== false)
599
+
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
600
+
}
601
+
}
602
+
return message;
603
+
}
604
+
internalBinaryWrite(message: Init, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
605
+
/* uint32 id = 1; */
606
+
if (message.id !== 0)
607
+
writer.tag(1, WireType.Varint).uint32(message.id);
608
+
/* string nick = 2; */
609
+
if (message.nick !== "")
610
+
writer.tag(2, WireType.LengthDelimited).string(message.nick);
611
+
/* string externalID = 3; */
612
+
if (message.externalID !== "")
613
+
writer.tag(3, WireType.LengthDelimited).string(message.externalID);
614
+
/* uint32 color = 4; */
615
+
if (message.color !== 0)
616
+
writer.tag(4, WireType.Varint).uint32(message.color);
617
+
/* bool echoed = 5; */
618
+
if (message.echoed !== false)
619
+
writer.tag(5, WireType.Varint).bool(message.echoed);
620
+
let u = options.writeUnknownFields;
621
+
if (u !== false)
622
+
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
623
+
return writer;
624
+
}
625
+
}
626
+
/**
627
+
* @generated MessageType for protobuf message Init
628
+
*/
629
+
export const Init = new Init$Type();
630
+
// @generated message type with reflection information, may provide speed optimized methods
631
+
class Pub$Type extends MessageType<Pub> {
632
+
constructor() {
633
+
super("Pub", [
634
+
{ no: 1, name: "id", kind: "scalar", T: 13 /*ScalarType.UINT32*/ }
635
+
]);
636
+
}
637
+
create(value?: PartialMessage<Pub>): Pub {
638
+
const message = globalThis.Object.create((this.messagePrototype!));
639
+
message.id = 0;
640
+
if (value !== undefined)
641
+
reflectionMergePartial<Pub>(this, message, value);
642
+
return message;
643
+
}
644
+
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Pub): Pub {
645
+
let message = target ?? this.create(), end = reader.pos + length;
646
+
while (reader.pos < end) {
647
+
let [fieldNo, wireType] = reader.tag();
648
+
switch (fieldNo) {
649
+
case /* uint32 id */ 1:
650
+
message.id = reader.uint32();
651
+
break;
652
+
default:
653
+
let u = options.readUnknownField;
654
+
if (u === "throw")
655
+
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
656
+
let d = reader.skip(wireType);
657
+
if (u !== false)
658
+
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
659
+
}
660
+
}
661
+
return message;
662
+
}
663
+
internalBinaryWrite(message: Pub, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
664
+
/* uint32 id = 1; */
665
+
if (message.id !== 0)
666
+
writer.tag(1, WireType.Varint).uint32(message.id);
667
+
let u = options.writeUnknownFields;
668
+
if (u !== false)
669
+
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
670
+
return writer;
671
+
}
672
+
}
673
+
/**
674
+
* @generated MessageType for protobuf message Pub
675
+
*/
676
+
export const Pub = new Pub$Type();
677
+
// @generated message type with reflection information, may provide speed optimized methods
678
+
class Insert$Type extends MessageType<Insert> {
679
+
constructor() {
680
+
super("Insert", [
681
+
{ no: 1, name: "id", kind: "scalar", T: 13 /*ScalarType.UINT32*/ },
682
+
{ no: 2, name: "body", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
683
+
{ no: 3, name: "byteIndex", kind: "scalar", T: 13 /*ScalarType.UINT32*/ }
684
+
]);
685
+
}
686
+
create(value?: PartialMessage<Insert>): Insert {
687
+
const message = globalThis.Object.create((this.messagePrototype!));
688
+
message.id = 0;
689
+
message.body = "";
690
+
message.byteIndex = 0;
691
+
if (value !== undefined)
692
+
reflectionMergePartial<Insert>(this, message, value);
693
+
return message;
694
+
}
695
+
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Insert): Insert {
696
+
let message = target ?? this.create(), end = reader.pos + length;
697
+
while (reader.pos < end) {
698
+
let [fieldNo, wireType] = reader.tag();
699
+
switch (fieldNo) {
700
+
case /* uint32 id */ 1:
701
+
message.id = reader.uint32();
702
+
break;
703
+
case /* string body */ 2:
704
+
message.body = reader.string();
705
+
break;
706
+
case /* uint32 byteIndex */ 3:
707
+
message.byteIndex = reader.uint32();
708
+
break;
709
+
default:
710
+
let u = options.readUnknownField;
711
+
if (u === "throw")
712
+
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
713
+
let d = reader.skip(wireType);
714
+
if (u !== false)
715
+
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
716
+
}
717
+
}
718
+
return message;
719
+
}
720
+
internalBinaryWrite(message: Insert, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
721
+
/* uint32 id = 1; */
722
+
if (message.id !== 0)
723
+
writer.tag(1, WireType.Varint).uint32(message.id);
724
+
/* string body = 2; */
725
+
if (message.body !== "")
726
+
writer.tag(2, WireType.LengthDelimited).string(message.body);
727
+
/* uint32 byteIndex = 3; */
728
+
if (message.byteIndex !== 0)
729
+
writer.tag(3, WireType.Varint).uint32(message.byteIndex);
730
+
let u = options.writeUnknownFields;
731
+
if (u !== false)
732
+
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
733
+
return writer;
734
+
}
735
+
}
736
+
/**
737
+
* @generated MessageType for protobuf message Insert
738
+
*/
739
+
export const Insert = new Insert$Type();
740
+
// @generated message type with reflection information, may provide speed optimized methods
741
+
class Delete$Type extends MessageType<Delete> {
742
+
constructor() {
743
+
super("Delete", [
744
+
{ no: 1, name: "id", kind: "scalar", T: 13 /*ScalarType.UINT32*/ },
745
+
{ no: 2, name: "byteStart", kind: "scalar", T: 13 /*ScalarType.UINT32*/ },
746
+
{ no: 3, name: "byteEnd", kind: "scalar", T: 13 /*ScalarType.UINT32*/ }
747
+
]);
748
+
}
749
+
create(value?: PartialMessage<Delete>): Delete {
750
+
const message = globalThis.Object.create((this.messagePrototype!));
751
+
message.id = 0;
752
+
message.byteStart = 0;
753
+
message.byteEnd = 0;
754
+
if (value !== undefined)
755
+
reflectionMergePartial<Delete>(this, message, value);
756
+
return message;
757
+
}
758
+
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Delete): Delete {
759
+
let message = target ?? this.create(), end = reader.pos + length;
760
+
while (reader.pos < end) {
761
+
let [fieldNo, wireType] = reader.tag();
762
+
switch (fieldNo) {
763
+
case /* uint32 id */ 1:
764
+
message.id = reader.uint32();
765
+
break;
766
+
case /* uint32 byteStart */ 2:
767
+
message.byteStart = reader.uint32();
768
+
break;
769
+
case /* uint32 byteEnd */ 3:
770
+
message.byteEnd = reader.uint32();
771
+
break;
772
+
default:
773
+
let u = options.readUnknownField;
774
+
if (u === "throw")
775
+
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
776
+
let d = reader.skip(wireType);
777
+
if (u !== false)
778
+
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
779
+
}
780
+
}
781
+
return message;
782
+
}
783
+
internalBinaryWrite(message: Delete, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
784
+
/* uint32 id = 1; */
785
+
if (message.id !== 0)
786
+
writer.tag(1, WireType.Varint).uint32(message.id);
787
+
/* uint32 byteStart = 2; */
788
+
if (message.byteStart !== 0)
789
+
writer.tag(2, WireType.Varint).uint32(message.byteStart);
790
+
/* uint32 byteEnd = 3; */
791
+
if (message.byteEnd !== 0)
792
+
writer.tag(3, WireType.Varint).uint32(message.byteEnd);
793
+
let u = options.writeUnknownFields;
794
+
if (u !== false)
795
+
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
796
+
return writer;
797
+
}
798
+
}
799
+
/**
800
+
* @generated MessageType for protobuf message Delete
801
+
*/
802
+
export const Delete = new Delete$Type();
803
+
// @generated message type with reflection information, may provide speed optimized methods
804
+
class Mute$Type extends MessageType<Mute> {
805
+
constructor() {
806
+
super("Mute", [
807
+
{ no: 1, name: "id", kind: "scalar", T: 13 /*ScalarType.UINT32*/ }
808
+
]);
809
+
}
810
+
create(value?: PartialMessage<Mute>): Mute {
811
+
const message = globalThis.Object.create((this.messagePrototype!));
812
+
message.id = 0;
813
+
if (value !== undefined)
814
+
reflectionMergePartial<Mute>(this, message, value);
815
+
return message;
816
+
}
817
+
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Mute): Mute {
818
+
let message = target ?? this.create(), end = reader.pos + length;
819
+
while (reader.pos < end) {
820
+
let [fieldNo, wireType] = reader.tag();
821
+
switch (fieldNo) {
822
+
case /* uint32 id */ 1:
823
+
message.id = reader.uint32();
824
+
break;
825
+
default:
826
+
let u = options.readUnknownField;
827
+
if (u === "throw")
828
+
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
829
+
let d = reader.skip(wireType);
830
+
if (u !== false)
831
+
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
832
+
}
833
+
}
834
+
return message;
835
+
}
836
+
internalBinaryWrite(message: Mute, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
837
+
/* uint32 id = 1; */
838
+
if (message.id !== 0)
839
+
writer.tag(1, WireType.Varint).uint32(message.id);
840
+
let u = options.writeUnknownFields;
841
+
if (u !== false)
842
+
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
843
+
return writer;
844
+
}
845
+
}
846
+
/**
847
+
* @generated MessageType for protobuf message Mute
848
+
*/
849
+
export const Mute = new Mute$Type();
850
+
// @generated message type with reflection information, may provide speed optimized methods
851
+
class Unmute$Type extends MessageType<Unmute> {
852
+
constructor() {
853
+
super("Unmute", [
854
+
{ no: 1, name: "id", kind: "scalar", T: 13 /*ScalarType.UINT32*/ }
855
+
]);
856
+
}
857
+
create(value?: PartialMessage<Unmute>): Unmute {
858
+
const message = globalThis.Object.create((this.messagePrototype!));
859
+
message.id = 0;
860
+
if (value !== undefined)
861
+
reflectionMergePartial<Unmute>(this, message, value);
862
+
return message;
863
+
}
864
+
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Unmute): Unmute {
865
+
let message = target ?? this.create(), end = reader.pos + length;
866
+
while (reader.pos < end) {
867
+
let [fieldNo, wireType] = reader.tag();
868
+
switch (fieldNo) {
869
+
case /* uint32 id */ 1:
870
+
message.id = reader.uint32();
871
+
break;
872
+
default:
873
+
let u = options.readUnknownField;
874
+
if (u === "throw")
875
+
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
876
+
let d = reader.skip(wireType);
877
+
if (u !== false)
878
+
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
879
+
}
880
+
}
881
+
return message;
882
+
}
883
+
internalBinaryWrite(message: Unmute, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
884
+
/* uint32 id = 1; */
885
+
if (message.id !== 0)
886
+
writer.tag(1, WireType.Varint).uint32(message.id);
887
+
let u = options.writeUnknownFields;
888
+
if (u !== false)
889
+
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
890
+
return writer;
891
+
}
892
+
}
893
+
/**
894
+
* @generated MessageType for protobuf message Unmute
895
+
*/
896
+
export const Unmute = new Unmute$Type();
897
+
// @generated message type with reflection information, may provide speed optimized methods
898
+
class Set$Type extends MessageType<Set> {
899
+
constructor() {
900
+
super("Set", [
901
+
{ no: 1, name: "nick", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
902
+
{ no: 2, name: "externalID", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
903
+
{ no: 3, name: "color", kind: "scalar", T: 13 /*ScalarType.UINT32*/ }
904
+
]);
905
+
}
906
+
create(value?: PartialMessage<Set>): Set {
907
+
const message = globalThis.Object.create((this.messagePrototype!));
908
+
message.nick = "";
909
+
message.externalID = "";
910
+
message.color = 0;
911
+
if (value !== undefined)
912
+
reflectionMergePartial<Set>(this, message, value);
913
+
return message;
914
+
}
915
+
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Set): Set {
916
+
let message = target ?? this.create(), end = reader.pos + length;
917
+
while (reader.pos < end) {
918
+
let [fieldNo, wireType] = reader.tag();
919
+
switch (fieldNo) {
920
+
case /* string nick */ 1:
921
+
message.nick = reader.string();
922
+
break;
923
+
case /* string externalID */ 2:
924
+
message.externalID = reader.string();
925
+
break;
926
+
case /* uint32 color */ 3:
927
+
message.color = reader.uint32();
928
+
break;
929
+
default:
930
+
let u = options.readUnknownField;
931
+
if (u === "throw")
932
+
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
933
+
let d = reader.skip(wireType);
934
+
if (u !== false)
935
+
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
936
+
}
937
+
}
938
+
return message;
939
+
}
940
+
internalBinaryWrite(message: Set, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
941
+
/* string nick = 1; */
942
+
if (message.nick !== "")
943
+
writer.tag(1, WireType.LengthDelimited).string(message.nick);
944
+
/* string externalID = 2; */
945
+
if (message.externalID !== "")
946
+
writer.tag(2, WireType.LengthDelimited).string(message.externalID);
947
+
/* uint32 color = 3; */
948
+
if (message.color !== 0)
949
+
writer.tag(3, WireType.Varint).uint32(message.color);
950
+
let u = options.writeUnknownFields;
951
+
if (u !== false)
952
+
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
953
+
return writer;
954
+
}
955
+
}
956
+
/**
957
+
* @generated MessageType for protobuf message Set
958
+
*/
959
+
export const Set = new Set$Type();
960
+
// @generated message type with reflection information, may provide speed optimized methods
961
+
class Get$Type extends MessageType<Get> {
962
+
constructor() {
963
+
super("Get", [
964
+
{ no: 1, name: "topic", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
965
+
{ no: 2, name: "connected", kind: "scalar", T: 13 /*ScalarType.UINT32*/ }
966
+
]);
967
+
}
968
+
create(value?: PartialMessage<Get>): Get {
969
+
const message = globalThis.Object.create((this.messagePrototype!));
970
+
message.topic = "";
971
+
message.connected = 0;
972
+
if (value !== undefined)
973
+
reflectionMergePartial<Get>(this, message, value);
974
+
return message;
975
+
}
976
+
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Get): Get {
977
+
let message = target ?? this.create(), end = reader.pos + length;
978
+
while (reader.pos < end) {
979
+
let [fieldNo, wireType] = reader.tag();
980
+
switch (fieldNo) {
981
+
case /* string topic */ 1:
982
+
message.topic = reader.string();
983
+
break;
984
+
case /* uint32 connected */ 2:
985
+
message.connected = reader.uint32();
986
+
break;
987
+
default:
988
+
let u = options.readUnknownField;
989
+
if (u === "throw")
990
+
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
991
+
let d = reader.skip(wireType);
992
+
if (u !== false)
993
+
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
994
+
}
995
+
}
996
+
return message;
997
+
}
998
+
internalBinaryWrite(message: Get, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
999
+
/* string topic = 1; */
1000
+
if (message.topic !== "")
1001
+
writer.tag(1, WireType.LengthDelimited).string(message.topic);
1002
+
/* uint32 connected = 2; */
1003
+
if (message.connected !== 0)
1004
+
writer.tag(2, WireType.Varint).uint32(message.connected);
1005
+
let u = options.writeUnknownFields;
1006
+
if (u !== false)
1007
+
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
1008
+
return writer;
1009
+
}
1010
+
}
1011
+
/**
1012
+
* @generated MessageType for protobuf message Get
1013
+
*/
1014
+
export const Get = new Get$Type();
1015
+
// @generated message type with reflection information, may provide speed optimized methods
1016
+
class Sudo$Type extends MessageType<Sudo> {
1017
+
constructor() {
1018
+
super("Sudo", [
1019
+
{ no: 1, name: "externalID", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
1020
+
{ no: 2, name: "secret", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
1021
+
]);
1022
+
}
1023
+
create(value?: PartialMessage<Sudo>): Sudo {
1024
+
const message = globalThis.Object.create((this.messagePrototype!));
1025
+
message.externalID = "";
1026
+
message.secret = "";
1027
+
if (value !== undefined)
1028
+
reflectionMergePartial<Sudo>(this, message, value);
1029
+
return message;
1030
+
}
1031
+
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Sudo): Sudo {
1032
+
let message = target ?? this.create(), end = reader.pos + length;
1033
+
while (reader.pos < end) {
1034
+
let [fieldNo, wireType] = reader.tag();
1035
+
switch (fieldNo) {
1036
+
case /* string externalID */ 1:
1037
+
message.externalID = reader.string();
1038
+
break;
1039
+
case /* string secret */ 2:
1040
+
message.secret = reader.string();
1041
+
break;
1042
+
default:
1043
+
let u = options.readUnknownField;
1044
+
if (u === "throw")
1045
+
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
1046
+
let d = reader.skip(wireType);
1047
+
if (u !== false)
1048
+
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
1049
+
}
1050
+
}
1051
+
return message;
1052
+
}
1053
+
internalBinaryWrite(message: Sudo, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
1054
+
/* string externalID = 1; */
1055
+
if (message.externalID !== "")
1056
+
writer.tag(1, WireType.LengthDelimited).string(message.externalID);
1057
+
/* string secret = 2; */
1058
+
if (message.secret !== "")
1059
+
writer.tag(2, WireType.LengthDelimited).string(message.secret);
1060
+
let u = options.writeUnknownFields;
1061
+
if (u !== false)
1062
+
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
1063
+
return writer;
1064
+
}
1065
+
}
1066
+
/**
1067
+
* @generated MessageType for protobuf message Sudo
1068
+
*/
1069
+
export const Sudo = new Sudo$Type();
1070
+
// @generated message type with reflection information, may provide speed optimized methods
1071
+
class Kick$Type extends MessageType<Kick> {
1072
+
constructor() {
1073
+
super("Kick", [
1074
+
{ no: 1, name: "privileges", kind: "message", T: () => Sudo },
1075
+
{ no: 2, name: "id", kind: "scalar", T: 13 /*ScalarType.UINT32*/ }
1076
+
]);
1077
+
}
1078
+
create(value?: PartialMessage<Kick>): Kick {
1079
+
const message = globalThis.Object.create((this.messagePrototype!));
1080
+
message.id = 0;
1081
+
if (value !== undefined)
1082
+
reflectionMergePartial<Kick>(this, message, value);
1083
+
return message;
1084
+
}
1085
+
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Kick): Kick {
1086
+
let message = target ?? this.create(), end = reader.pos + length;
1087
+
while (reader.pos < end) {
1088
+
let [fieldNo, wireType] = reader.tag();
1089
+
switch (fieldNo) {
1090
+
case /* Sudo privileges */ 1:
1091
+
message.privileges = Sudo.internalBinaryRead(reader, reader.uint32(), options, message.privileges);
1092
+
break;
1093
+
case /* uint32 id */ 2:
1094
+
message.id = reader.uint32();
1095
+
break;
1096
+
default:
1097
+
let u = options.readUnknownField;
1098
+
if (u === "throw")
1099
+
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
1100
+
let d = reader.skip(wireType);
1101
+
if (u !== false)
1102
+
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
1103
+
}
1104
+
}
1105
+
return message;
1106
+
}
1107
+
internalBinaryWrite(message: Kick, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
1108
+
/* Sudo privileges = 1; */
1109
+
if (message.privileges)
1110
+
Sudo.internalBinaryWrite(message.privileges, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
1111
+
/* uint32 id = 2; */
1112
+
if (message.id !== 0)
1113
+
writer.tag(2, WireType.Varint).uint32(message.id);
1114
+
let u = options.writeUnknownFields;
1115
+
if (u !== false)
1116
+
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
1117
+
return writer;
1118
+
}
1119
+
}
1120
+
/**
1121
+
* @generated MessageType for protobuf message Kick
1122
+
*/
1123
+
export const Kick = new Kick$Type();
1124
+
// @generated message type with reflection information, may provide speed optimized methods
1125
+
class Hug$Type extends MessageType<Hug> {
1126
+
constructor() {
1127
+
super("Hug", [
1128
+
{ no: 1, name: "id", kind: "scalar", T: 13 /*ScalarType.UINT32*/ }
1129
+
]);
1130
+
}
1131
+
create(value?: PartialMessage<Hug>): Hug {
1132
+
const message = globalThis.Object.create((this.messagePrototype!));
1133
+
message.id = 0;
1134
+
if (value !== undefined)
1135
+
reflectionMergePartial<Hug>(this, message, value);
1136
+
return message;
1137
+
}
1138
+
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Hug): Hug {
1139
+
let message = target ?? this.create(), end = reader.pos + length;
1140
+
while (reader.pos < end) {
1141
+
let [fieldNo, wireType] = reader.tag();
1142
+
switch (fieldNo) {
1143
+
case /* uint32 id */ 1:
1144
+
message.id = reader.uint32();
1145
+
break;
1146
+
default:
1147
+
let u = options.readUnknownField;
1148
+
if (u === "throw")
1149
+
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
1150
+
let d = reader.skip(wireType);
1151
+
if (u !== false)
1152
+
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
1153
+
}
1154
+
}
1155
+
return message;
1156
+
}
1157
+
internalBinaryWrite(message: Hug, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
1158
+
/* uint32 id = 1; */
1159
+
if (message.id !== 0)
1160
+
writer.tag(1, WireType.Varint).uint32(message.id);
1161
+
let u = options.writeUnknownFields;
1162
+
if (u !== false)
1163
+
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
1164
+
return writer;
1165
+
}
1166
+
}
1167
+
/**
1168
+
* @generated MessageType for protobuf message Hug
1169
+
*/
1170
+
export const Hug = new Hug$Type();
1171
+
// @generated message type with reflection information, may provide speed optimized methods
1172
+
class Ban$Type extends MessageType<Ban> {
1173
+
constructor() {
1174
+
super("Ban", [
1175
+
{ no: 1, name: "privileges", kind: "message", T: () => Sudo },
1176
+
{ no: 2, name: "id", kind: "scalar", T: 13 /*ScalarType.UINT32*/ }
1177
+
]);
1178
+
}
1179
+
create(value?: PartialMessage<Ban>): Ban {
1180
+
const message = globalThis.Object.create((this.messagePrototype!));
1181
+
message.id = 0;
1182
+
if (value !== undefined)
1183
+
reflectionMergePartial<Ban>(this, message, value);
1184
+
return message;
1185
+
}
1186
+
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Ban): Ban {
1187
+
let message = target ?? this.create(), end = reader.pos + length;
1188
+
while (reader.pos < end) {
1189
+
let [fieldNo, wireType] = reader.tag();
1190
+
switch (fieldNo) {
1191
+
case /* Sudo privileges */ 1:
1192
+
message.privileges = Sudo.internalBinaryRead(reader, reader.uint32(), options, message.privileges);
1193
+
break;
1194
+
case /* uint32 id */ 2:
1195
+
message.id = reader.uint32();
1196
+
break;
1197
+
default:
1198
+
let u = options.readUnknownField;
1199
+
if (u === "throw")
1200
+
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
1201
+
let d = reader.skip(wireType);
1202
+
if (u !== false)
1203
+
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
1204
+
}
1205
+
}
1206
+
return message;
1207
+
}
1208
+
internalBinaryWrite(message: Ban, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
1209
+
/* Sudo privileges = 1; */
1210
+
if (message.privileges)
1211
+
Sudo.internalBinaryWrite(message.privileges, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
1212
+
/* uint32 id = 2; */
1213
+
if (message.id !== 0)
1214
+
writer.tag(2, WireType.Varint).uint32(message.id);
1215
+
let u = options.writeUnknownFields;
1216
+
if (u !== false)
1217
+
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
1218
+
return writer;
1219
+
}
1220
+
}
1221
+
/**
1222
+
* @generated MessageType for protobuf message Ban
1223
+
*/
1224
+
export const Ban = new Ban$Type();
1225
+
// @generated message type with reflection information, may provide speed optimized methods
1226
+
class Unban$Type extends MessageType<Unban> {
1227
+
constructor() {
1228
+
super("Unban", [
1229
+
{ no: 1, name: "privileges", kind: "message", T: () => Sudo },
1230
+
{ no: 2, name: "id", kind: "scalar", T: 13 /*ScalarType.UINT32*/ }
1231
+
]);
1232
+
}
1233
+
create(value?: PartialMessage<Unban>): Unban {
1234
+
const message = globalThis.Object.create((this.messagePrototype!));
1235
+
message.id = 0;
1236
+
if (value !== undefined)
1237
+
reflectionMergePartial<Unban>(this, message, value);
1238
+
return message;
1239
+
}
1240
+
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Unban): Unban {
1241
+
let message = target ?? this.create(), end = reader.pos + length;
1242
+
while (reader.pos < end) {
1243
+
let [fieldNo, wireType] = reader.tag();
1244
+
switch (fieldNo) {
1245
+
case /* Sudo privileges */ 1:
1246
+
message.privileges = Sudo.internalBinaryRead(reader, reader.uint32(), options, message.privileges);
1247
+
break;
1248
+
case /* uint32 id */ 2:
1249
+
message.id = reader.uint32();
1250
+
break;
1251
+
default:
1252
+
let u = options.readUnknownField;
1253
+
if (u === "throw")
1254
+
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
1255
+
let d = reader.skip(wireType);
1256
+
if (u !== false)
1257
+
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
1258
+
}
1259
+
}
1260
+
return message;
1261
+
}
1262
+
internalBinaryWrite(message: Unban, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
1263
+
/* Sudo privileges = 1; */
1264
+
if (message.privileges)
1265
+
Sudo.internalBinaryWrite(message.privileges, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
1266
+
/* uint32 id = 2; */
1267
+
if (message.id !== 0)
1268
+
writer.tag(2, WireType.Varint).uint32(message.id);
1269
+
let u = options.writeUnknownFields;
1270
+
if (u !== false)
1271
+
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
1272
+
return writer;
1273
+
}
1274
+
}
1275
+
/**
1276
+
* @generated MessageType for protobuf message Unban
1277
+
*/
1278
+
export const Unban = new Unban$Type();
+88
package-lock.json
+88
package-lock.json
···
1
+
{
2
+
"name": "@rachel-mp4/lrcproto",
3
+
"version": "1.0.0",
4
+
"lockfileVersion": 3,
5
+
"requires": true,
6
+
"packages": {
7
+
"": {
8
+
"name": "@rachel-mp4/lrcproto",
9
+
"version": "1.0.0",
10
+
"license": "MIT",
11
+
"dependencies": {
12
+
"typescript": "^3.9.10"
13
+
},
14
+
"devDependencies": {
15
+
"@protobuf-ts/plugin": "^2.10.0"
16
+
}
17
+
},
18
+
"node_modules/@protobuf-ts/plugin": {
19
+
"version": "2.10.0",
20
+
"resolved": "https://registry.npmjs.org/@protobuf-ts/plugin/-/plugin-2.10.0.tgz",
21
+
"integrity": "sha512-iMX4C4TVfMNRLn2msK0cVg5jmizjtu5FYiy8EK5Lg6EgyR9TVHeK2rzmufWKYM2Pcg1jSwC0cFcXHQnCoeFxUg==",
22
+
"dev": true,
23
+
"license": "Apache-2.0",
24
+
"dependencies": {
25
+
"@protobuf-ts/plugin-framework": "^2.10.0",
26
+
"@protobuf-ts/protoc": "^2.10.0",
27
+
"@protobuf-ts/runtime": "^2.10.0",
28
+
"@protobuf-ts/runtime-rpc": "^2.10.0",
29
+
"typescript": "^3.9"
30
+
},
31
+
"bin": {
32
+
"protoc-gen-dump": "bin/protoc-gen-dump",
33
+
"protoc-gen-ts": "bin/protoc-gen-ts"
34
+
}
35
+
},
36
+
"node_modules/@protobuf-ts/plugin-framework": {
37
+
"version": "2.10.0",
38
+
"resolved": "https://registry.npmjs.org/@protobuf-ts/plugin-framework/-/plugin-framework-2.10.0.tgz",
39
+
"integrity": "sha512-EuW9irbt+w7Ml1CaAxK6xyl7pSuWVbNy0rsChxJEthMrAVTN5EPdJ3whNWvsRBa+HwRImEl8KHNnRoq/vGOHbg==",
40
+
"dev": true,
41
+
"license": "(Apache-2.0 AND BSD-3-Clause)",
42
+
"dependencies": {
43
+
"@protobuf-ts/runtime": "^2.10.0",
44
+
"typescript": "^3.9"
45
+
}
46
+
},
47
+
"node_modules/@protobuf-ts/protoc": {
48
+
"version": "2.10.0",
49
+
"resolved": "https://registry.npmjs.org/@protobuf-ts/protoc/-/protoc-2.10.0.tgz",
50
+
"integrity": "sha512-S4BtGBh22+uL5E6qLVxV0QNY6tiLVB8QL7RIkvo+KYknipZfSNwubdKy5CPkrwVXzJn4s3cx7bKx1w6BxkBIPg==",
51
+
"dev": true,
52
+
"license": "Apache-2.0",
53
+
"bin": {
54
+
"protoc": "protoc.js"
55
+
}
56
+
},
57
+
"node_modules/@protobuf-ts/runtime": {
58
+
"version": "2.10.0",
59
+
"resolved": "https://registry.npmjs.org/@protobuf-ts/runtime/-/runtime-2.10.0.tgz",
60
+
"integrity": "sha512-ypYwGg9Pn3W/2lZ7/HW60hONGuSdzphvOY8Dq7LeNttymDe0y3LaTUUMRpuGqOT6FfrWEMnfQbyqU8AAreo8wA==",
61
+
"dev": true,
62
+
"license": "(Apache-2.0 AND BSD-3-Clause)"
63
+
},
64
+
"node_modules/@protobuf-ts/runtime-rpc": {
65
+
"version": "2.10.0",
66
+
"resolved": "https://registry.npmjs.org/@protobuf-ts/runtime-rpc/-/runtime-rpc-2.10.0.tgz",
67
+
"integrity": "sha512-8CS/XPv3+pMK4v8UKhtCdvbS4h9l7aqlteKdRt0/UbIKZ8n0qHj6hX8cBhz2ngvohxCOS0N08zPr9aCLBNhW3Q==",
68
+
"dev": true,
69
+
"license": "Apache-2.0",
70
+
"dependencies": {
71
+
"@protobuf-ts/runtime": "^2.10.0"
72
+
}
73
+
},
74
+
"node_modules/typescript": {
75
+
"version": "3.9.10",
76
+
"resolved": "https://registry.npmjs.org/typescript/-/typescript-3.9.10.tgz",
77
+
"integrity": "sha512-w6fIxVE/H1PkLKcCPsFqKE7Kv7QUwhU8qQY2MueZXWx5cPZdwFupLgKK3vntcK98BtNHZtAF4LA/yl2a7k8R6Q==",
78
+
"license": "Apache-2.0",
79
+
"bin": {
80
+
"tsc": "bin/tsc",
81
+
"tsserver": "bin/tsserver"
82
+
},
83
+
"engines": {
84
+
"node": ">=4.2.0"
85
+
}
86
+
}
87
+
}
88
+
}
+18
package.json
+18
package.json
···
1
+
{
2
+
"name": "@rachel-mp4/lrcproto",
3
+
"version": "1.0.1",
4
+
"description": "protobuf definitions for LRC",
5
+
"main": "gen/ts/lrc.ts",
6
+
"dependencies": {
7
+
"typescript": "^3.9.10"
8
+
},
9
+
"devDependencies": {"@protobuf-ts/plugin": "^2.10.0"},
10
+
"keywords": [
11
+
"lrc"
12
+
],
13
+
"author": "rachel-mp4",
14
+
"license": "MIT",
15
+
"publishConfig": {
16
+
"access": "public"
17
+
}
18
+
}