@stream-io/video-client 1.6.4 → 1.7.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -1,5 +1,5 @@
1
1
  import 'webrtc-adapter';
2
- import { MessageType, isJsonObject, typeofJsonValue, reflectionMergePartial, UnknownFieldHandler, WireType, PbLong } from '@protobuf-ts/runtime';
2
+ import { MessageType, isJsonObject, typeofJsonValue, PbLong } from '@protobuf-ts/runtime';
3
3
  import { ServiceType, stackIntercept, RpcError } from '@protobuf-ts/runtime-rpc';
4
4
  import axios, { AxiosHeaders } from 'axios';
5
5
  export { AxiosError } from 'axios';
@@ -221,66 +221,6 @@ class Struct$Type extends MessageType {
221
221
  }
222
222
  return target;
223
223
  }
224
- create(value) {
225
- const message = globalThis.Object.create(this.messagePrototype);
226
- message.fields = {};
227
- if (value !== undefined)
228
- reflectionMergePartial(this, message, value);
229
- return message;
230
- }
231
- internalBinaryRead(reader, length, options, target) {
232
- let message = target ?? this.create(), end = reader.pos + length;
233
- while (reader.pos < end) {
234
- let [fieldNo, wireType] = reader.tag();
235
- switch (fieldNo) {
236
- case /* map<string, google.protobuf.Value> fields */ 1:
237
- this.binaryReadMap1(message.fields, reader, options);
238
- break;
239
- default:
240
- let u = options.readUnknownField;
241
- if (u === 'throw')
242
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
243
- let d = reader.skip(wireType);
244
- if (u !== false)
245
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
246
- }
247
- }
248
- return message;
249
- }
250
- binaryReadMap1(map, reader, options) {
251
- let len = reader.uint32(), end = reader.pos + len, key, val;
252
- while (reader.pos < end) {
253
- let [fieldNo, wireType] = reader.tag();
254
- switch (fieldNo) {
255
- case 1:
256
- key = reader.string();
257
- break;
258
- case 2:
259
- val = Value.internalBinaryRead(reader, reader.uint32(), options);
260
- break;
261
- default:
262
- throw new globalThis.Error('unknown map entry field for field google.protobuf.Struct.fields');
263
- }
264
- }
265
- map[key ?? ''] = val ?? Value.create();
266
- }
267
- internalBinaryWrite(message, writer, options) {
268
- /* map<string, google.protobuf.Value> fields = 1; */
269
- for (let k of globalThis.Object.keys(message.fields)) {
270
- writer
271
- .tag(1, WireType.LengthDelimited)
272
- .fork()
273
- .tag(1, WireType.LengthDelimited)
274
- .string(k);
275
- writer.tag(2, WireType.LengthDelimited).fork();
276
- Value.internalBinaryWrite(message.fields[k], writer, options);
277
- writer.join().join();
278
- }
279
- let u = options.writeUnknownFields;
280
- if (u !== false)
281
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
282
- return writer;
283
- }
284
224
  }
285
225
  /**
286
226
  * @generated MessageType for protobuf message google.protobuf.Struct
@@ -410,89 +350,6 @@ class Value$Type extends MessageType {
410
350
  }
411
351
  return target;
412
352
  }
413
- create(value) {
414
- const message = globalThis.Object.create(this.messagePrototype);
415
- message.kind = { oneofKind: undefined };
416
- if (value !== undefined)
417
- reflectionMergePartial(this, message, value);
418
- return message;
419
- }
420
- internalBinaryRead(reader, length, options, target) {
421
- let message = target ?? this.create(), end = reader.pos + length;
422
- while (reader.pos < end) {
423
- let [fieldNo, wireType] = reader.tag();
424
- switch (fieldNo) {
425
- case /* google.protobuf.NullValue null_value */ 1:
426
- message.kind = {
427
- oneofKind: 'nullValue',
428
- nullValue: reader.int32(),
429
- };
430
- break;
431
- case /* double number_value */ 2:
432
- message.kind = {
433
- oneofKind: 'numberValue',
434
- numberValue: reader.double(),
435
- };
436
- break;
437
- case /* string string_value */ 3:
438
- message.kind = {
439
- oneofKind: 'stringValue',
440
- stringValue: reader.string(),
441
- };
442
- break;
443
- case /* bool bool_value */ 4:
444
- message.kind = {
445
- oneofKind: 'boolValue',
446
- boolValue: reader.bool(),
447
- };
448
- break;
449
- case /* google.protobuf.Struct struct_value */ 5:
450
- message.kind = {
451
- oneofKind: 'structValue',
452
- structValue: Struct.internalBinaryRead(reader, reader.uint32(), options, message.kind.structValue),
453
- };
454
- break;
455
- case /* google.protobuf.ListValue list_value */ 6:
456
- message.kind = {
457
- oneofKind: 'listValue',
458
- listValue: ListValue.internalBinaryRead(reader, reader.uint32(), options, message.kind.listValue),
459
- };
460
- break;
461
- default:
462
- let u = options.readUnknownField;
463
- if (u === 'throw')
464
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
465
- let d = reader.skip(wireType);
466
- if (u !== false)
467
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
468
- }
469
- }
470
- return message;
471
- }
472
- internalBinaryWrite(message, writer, options) {
473
- /* google.protobuf.NullValue null_value = 1; */
474
- if (message.kind.oneofKind === 'nullValue')
475
- writer.tag(1, WireType.Varint).int32(message.kind.nullValue);
476
- /* double number_value = 2; */
477
- if (message.kind.oneofKind === 'numberValue')
478
- writer.tag(2, WireType.Bit64).double(message.kind.numberValue);
479
- /* string string_value = 3; */
480
- if (message.kind.oneofKind === 'stringValue')
481
- writer.tag(3, WireType.LengthDelimited).string(message.kind.stringValue);
482
- /* bool bool_value = 4; */
483
- if (message.kind.oneofKind === 'boolValue')
484
- writer.tag(4, WireType.Varint).bool(message.kind.boolValue);
485
- /* google.protobuf.Struct struct_value = 5; */
486
- if (message.kind.oneofKind === 'structValue')
487
- Struct.internalBinaryWrite(message.kind.structValue, writer.tag(5, WireType.LengthDelimited).fork(), options).join();
488
- /* google.protobuf.ListValue list_value = 6; */
489
- if (message.kind.oneofKind === 'listValue')
490
- ListValue.internalBinaryWrite(message.kind.listValue, writer.tag(6, WireType.LengthDelimited).fork(), options).join();
491
- let u = options.writeUnknownFields;
492
- if (u !== false)
493
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
494
- return writer;
495
- }
496
353
  }
497
354
  /**
498
355
  * @generated MessageType for protobuf message google.protobuf.Value
@@ -532,41 +389,6 @@ class ListValue$Type extends MessageType {
532
389
  target.values.push(...values);
533
390
  return target;
534
391
  }
535
- create(value) {
536
- const message = globalThis.Object.create(this.messagePrototype);
537
- message.values = [];
538
- if (value !== undefined)
539
- reflectionMergePartial(this, message, value);
540
- return message;
541
- }
542
- internalBinaryRead(reader, length, options, target) {
543
- let message = target ?? this.create(), end = reader.pos + length;
544
- while (reader.pos < end) {
545
- let [fieldNo, wireType] = reader.tag();
546
- switch (fieldNo) {
547
- case /* repeated google.protobuf.Value values */ 1:
548
- message.values.push(Value.internalBinaryRead(reader, reader.uint32(), options));
549
- break;
550
- default:
551
- let u = options.readUnknownField;
552
- if (u === 'throw')
553
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
554
- let d = reader.skip(wireType);
555
- if (u !== false)
556
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
557
- }
558
- }
559
- return message;
560
- }
561
- internalBinaryWrite(message, writer, options) {
562
- /* repeated google.protobuf.Value values = 1; */
563
- for (let i = 0; i < message.values.length; i++)
564
- Value.internalBinaryWrite(message.values[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join();
565
- let u = options.writeUnknownFields;
566
- if (u !== false)
567
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
568
- return writer;
569
- }
570
392
  }
571
393
  /**
572
394
  * @generated MessageType for protobuf message google.protobuf.ListValue
@@ -668,54 +490,16 @@ class Timestamp$Type extends MessageType {
668
490
  1000000000;
669
491
  return target;
670
492
  }
671
- create(value) {
672
- const message = globalThis.Object.create(this.messagePrototype);
673
- message.seconds = '0';
674
- message.nanos = 0;
675
- if (value !== undefined)
676
- reflectionMergePartial(this, message, value);
677
- return message;
678
- }
679
- internalBinaryRead(reader, length, options, target) {
680
- let message = target ?? this.create(), end = reader.pos + length;
681
- while (reader.pos < end) {
682
- let [fieldNo, wireType] = reader.tag();
683
- switch (fieldNo) {
684
- case /* int64 seconds */ 1:
685
- message.seconds = reader.int64().toString();
686
- break;
687
- case /* int32 nanos */ 2:
688
- message.nanos = reader.int32();
689
- break;
690
- default:
691
- let u = options.readUnknownField;
692
- if (u === 'throw')
693
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
694
- let d = reader.skip(wireType);
695
- if (u !== false)
696
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
697
- }
698
- }
699
- return message;
700
- }
701
- internalBinaryWrite(message, writer, options) {
702
- /* int64 seconds = 1; */
703
- if (message.seconds !== '0')
704
- writer.tag(1, WireType.Varint).int64(message.seconds);
705
- /* int32 nanos = 2; */
706
- if (message.nanos !== 0)
707
- writer.tag(2, WireType.Varint).int32(message.nanos);
708
- let u = options.writeUnknownFields;
709
- if (u !== false)
710
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
711
- return writer;
712
- }
713
493
  }
714
494
  /**
715
495
  * @generated MessageType for protobuf message google.protobuf.Timestamp
716
496
  */
717
497
  const Timestamp = new Timestamp$Type();
718
498
 
499
+ /* eslint-disable */
500
+ // @generated by protobuf-ts 2.9.4 with parameter long_type_string,client_generic,server_none,eslint_disable,optimize_code_size
501
+ // @generated from protobuf file "video/sfu/models/models.proto" (package "stream.video.sfu.models", syntax proto3)
502
+ // tslint:disable
719
503
  /**
720
504
  * @generated from protobuf enum stream.video.sfu.models.PeerType
721
505
  */
@@ -1084,60 +868,6 @@ class CallState$Type extends MessageType {
1084
868
  },
1085
869
  ]);
1086
870
  }
1087
- create(value) {
1088
- const message = globalThis.Object.create(this.messagePrototype);
1089
- message.participants = [];
1090
- message.pins = [];
1091
- if (value !== undefined)
1092
- reflectionMergePartial(this, message, value);
1093
- return message;
1094
- }
1095
- internalBinaryRead(reader, length, options, target) {
1096
- let message = target ?? this.create(), end = reader.pos + length;
1097
- while (reader.pos < end) {
1098
- let [fieldNo, wireType] = reader.tag();
1099
- switch (fieldNo) {
1100
- case /* repeated stream.video.sfu.models.Participant participants */ 1:
1101
- message.participants.push(Participant.internalBinaryRead(reader, reader.uint32(), options));
1102
- break;
1103
- case /* google.protobuf.Timestamp started_at */ 2:
1104
- message.startedAt = Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.startedAt);
1105
- break;
1106
- case /* stream.video.sfu.models.ParticipantCount participant_count */ 3:
1107
- message.participantCount = ParticipantCount.internalBinaryRead(reader, reader.uint32(), options, message.participantCount);
1108
- break;
1109
- case /* repeated stream.video.sfu.models.Pin pins */ 4:
1110
- message.pins.push(Pin.internalBinaryRead(reader, reader.uint32(), options));
1111
- break;
1112
- default:
1113
- let u = options.readUnknownField;
1114
- if (u === 'throw')
1115
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
1116
- let d = reader.skip(wireType);
1117
- if (u !== false)
1118
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
1119
- }
1120
- }
1121
- return message;
1122
- }
1123
- internalBinaryWrite(message, writer, options) {
1124
- /* repeated stream.video.sfu.models.Participant participants = 1; */
1125
- for (let i = 0; i < message.participants.length; i++)
1126
- Participant.internalBinaryWrite(message.participants[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join();
1127
- /* google.protobuf.Timestamp started_at = 2; */
1128
- if (message.startedAt)
1129
- Timestamp.internalBinaryWrite(message.startedAt, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
1130
- /* stream.video.sfu.models.ParticipantCount participant_count = 3; */
1131
- if (message.participantCount)
1132
- ParticipantCount.internalBinaryWrite(message.participantCount, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
1133
- /* repeated stream.video.sfu.models.Pin pins = 4; */
1134
- for (let i = 0; i < message.pins.length; i++)
1135
- Pin.internalBinaryWrite(message.pins[i], writer.tag(4, WireType.LengthDelimited).fork(), options).join();
1136
- let u = options.writeUnknownFields;
1137
- if (u !== false)
1138
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
1139
- return writer;
1140
- }
1141
871
  }
1142
872
  /**
1143
873
  * @generated MessageType for protobuf message stream.video.sfu.models.CallState
@@ -1151,48 +881,6 @@ class ParticipantCount$Type extends MessageType {
1151
881
  { no: 2, name: 'anonymous', kind: 'scalar', T: 13 /*ScalarType.UINT32*/ },
1152
882
  ]);
1153
883
  }
1154
- create(value) {
1155
- const message = globalThis.Object.create(this.messagePrototype);
1156
- message.total = 0;
1157
- message.anonymous = 0;
1158
- if (value !== undefined)
1159
- reflectionMergePartial(this, message, value);
1160
- return message;
1161
- }
1162
- internalBinaryRead(reader, length, options, target) {
1163
- let message = target ?? this.create(), end = reader.pos + length;
1164
- while (reader.pos < end) {
1165
- let [fieldNo, wireType] = reader.tag();
1166
- switch (fieldNo) {
1167
- case /* uint32 total */ 1:
1168
- message.total = reader.uint32();
1169
- break;
1170
- case /* uint32 anonymous */ 2:
1171
- message.anonymous = reader.uint32();
1172
- break;
1173
- default:
1174
- let u = options.readUnknownField;
1175
- if (u === 'throw')
1176
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
1177
- let d = reader.skip(wireType);
1178
- if (u !== false)
1179
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
1180
- }
1181
- }
1182
- return message;
1183
- }
1184
- internalBinaryWrite(message, writer, options) {
1185
- /* uint32 total = 1; */
1186
- if (message.total !== 0)
1187
- writer.tag(1, WireType.Varint).uint32(message.total);
1188
- /* uint32 anonymous = 2; */
1189
- if (message.anonymous !== 0)
1190
- writer.tag(2, WireType.Varint).uint32(message.anonymous);
1191
- let u = options.writeUnknownFields;
1192
- if (u !== false)
1193
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
1194
- return writer;
1195
- }
1196
884
  }
1197
885
  /**
1198
886
  * @generated MessageType for protobuf message stream.video.sfu.models.ParticipantCount
@@ -1206,48 +894,6 @@ class Pin$Type extends MessageType {
1206
894
  { no: 2, name: 'session_id', kind: 'scalar', T: 9 /*ScalarType.STRING*/ },
1207
895
  ]);
1208
896
  }
1209
- create(value) {
1210
- const message = globalThis.Object.create(this.messagePrototype);
1211
- message.userId = '';
1212
- message.sessionId = '';
1213
- if (value !== undefined)
1214
- reflectionMergePartial(this, message, value);
1215
- return message;
1216
- }
1217
- internalBinaryRead(reader, length, options, target) {
1218
- let message = target ?? this.create(), end = reader.pos + length;
1219
- while (reader.pos < end) {
1220
- let [fieldNo, wireType] = reader.tag();
1221
- switch (fieldNo) {
1222
- case /* string user_id */ 1:
1223
- message.userId = reader.string();
1224
- break;
1225
- case /* string session_id */ 2:
1226
- message.sessionId = reader.string();
1227
- break;
1228
- default:
1229
- let u = options.readUnknownField;
1230
- if (u === 'throw')
1231
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
1232
- let d = reader.skip(wireType);
1233
- if (u !== false)
1234
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
1235
- }
1236
- }
1237
- return message;
1238
- }
1239
- internalBinaryWrite(message, writer, options) {
1240
- /* string user_id = 1; */
1241
- if (message.userId !== '')
1242
- writer.tag(1, WireType.LengthDelimited).string(message.userId);
1243
- /* string session_id = 2; */
1244
- if (message.sessionId !== '')
1245
- writer.tag(2, WireType.LengthDelimited).string(message.sessionId);
1246
- let u = options.writeUnknownFields;
1247
- if (u !== false)
1248
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
1249
- return writer;
1250
- }
1251
897
  }
1252
898
  /**
1253
899
  * @generated MessageType for protobuf message stream.video.sfu.models.Pin
@@ -1307,131 +953,6 @@ class Participant$Type extends MessageType {
1307
953
  },
1308
954
  ]);
1309
955
  }
1310
- create(value) {
1311
- const message = globalThis.Object.create(this.messagePrototype);
1312
- message.userId = '';
1313
- message.sessionId = '';
1314
- message.publishedTracks = [];
1315
- message.trackLookupPrefix = '';
1316
- message.connectionQuality = 0;
1317
- message.isSpeaking = false;
1318
- message.isDominantSpeaker = false;
1319
- message.audioLevel = 0;
1320
- message.name = '';
1321
- message.image = '';
1322
- message.roles = [];
1323
- if (value !== undefined)
1324
- reflectionMergePartial(this, message, value);
1325
- return message;
1326
- }
1327
- internalBinaryRead(reader, length, options, target) {
1328
- let message = target ?? this.create(), end = reader.pos + length;
1329
- while (reader.pos < end) {
1330
- let [fieldNo, wireType] = reader.tag();
1331
- switch (fieldNo) {
1332
- case /* string user_id */ 1:
1333
- message.userId = reader.string();
1334
- break;
1335
- case /* string session_id */ 2:
1336
- message.sessionId = reader.string();
1337
- break;
1338
- case /* repeated stream.video.sfu.models.TrackType published_tracks */ 3:
1339
- if (wireType === WireType.LengthDelimited)
1340
- for (let e = reader.int32() + reader.pos; reader.pos < e;)
1341
- message.publishedTracks.push(reader.int32());
1342
- else
1343
- message.publishedTracks.push(reader.int32());
1344
- break;
1345
- case /* google.protobuf.Timestamp joined_at */ 4:
1346
- message.joinedAt = Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.joinedAt);
1347
- break;
1348
- case /* string track_lookup_prefix */ 5:
1349
- message.trackLookupPrefix = reader.string();
1350
- break;
1351
- case /* stream.video.sfu.models.ConnectionQuality connection_quality */ 6:
1352
- message.connectionQuality = reader.int32();
1353
- break;
1354
- case /* bool is_speaking */ 7:
1355
- message.isSpeaking = reader.bool();
1356
- break;
1357
- case /* bool is_dominant_speaker */ 8:
1358
- message.isDominantSpeaker = reader.bool();
1359
- break;
1360
- case /* float audio_level */ 9:
1361
- message.audioLevel = reader.float();
1362
- break;
1363
- case /* string name */ 10:
1364
- message.name = reader.string();
1365
- break;
1366
- case /* string image */ 11:
1367
- message.image = reader.string();
1368
- break;
1369
- case /* google.protobuf.Struct custom */ 12:
1370
- message.custom = Struct.internalBinaryRead(reader, reader.uint32(), options, message.custom);
1371
- break;
1372
- case /* repeated string roles */ 13:
1373
- message.roles.push(reader.string());
1374
- break;
1375
- default:
1376
- let u = options.readUnknownField;
1377
- if (u === 'throw')
1378
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
1379
- let d = reader.skip(wireType);
1380
- if (u !== false)
1381
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
1382
- }
1383
- }
1384
- return message;
1385
- }
1386
- internalBinaryWrite(message, writer, options) {
1387
- /* string user_id = 1; */
1388
- if (message.userId !== '')
1389
- writer.tag(1, WireType.LengthDelimited).string(message.userId);
1390
- /* string session_id = 2; */
1391
- if (message.sessionId !== '')
1392
- writer.tag(2, WireType.LengthDelimited).string(message.sessionId);
1393
- /* repeated stream.video.sfu.models.TrackType published_tracks = 3; */
1394
- if (message.publishedTracks.length) {
1395
- writer.tag(3, WireType.LengthDelimited).fork();
1396
- for (let i = 0; i < message.publishedTracks.length; i++)
1397
- writer.int32(message.publishedTracks[i]);
1398
- writer.join();
1399
- }
1400
- /* google.protobuf.Timestamp joined_at = 4; */
1401
- if (message.joinedAt)
1402
- Timestamp.internalBinaryWrite(message.joinedAt, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
1403
- /* string track_lookup_prefix = 5; */
1404
- if (message.trackLookupPrefix !== '')
1405
- writer.tag(5, WireType.LengthDelimited).string(message.trackLookupPrefix);
1406
- /* stream.video.sfu.models.ConnectionQuality connection_quality = 6; */
1407
- if (message.connectionQuality !== 0)
1408
- writer.tag(6, WireType.Varint).int32(message.connectionQuality);
1409
- /* bool is_speaking = 7; */
1410
- if (message.isSpeaking !== false)
1411
- writer.tag(7, WireType.Varint).bool(message.isSpeaking);
1412
- /* bool is_dominant_speaker = 8; */
1413
- if (message.isDominantSpeaker !== false)
1414
- writer.tag(8, WireType.Varint).bool(message.isDominantSpeaker);
1415
- /* float audio_level = 9; */
1416
- if (message.audioLevel !== 0)
1417
- writer.tag(9, WireType.Bit32).float(message.audioLevel);
1418
- /* string name = 10; */
1419
- if (message.name !== '')
1420
- writer.tag(10, WireType.LengthDelimited).string(message.name);
1421
- /* string image = 11; */
1422
- if (message.image !== '')
1423
- writer.tag(11, WireType.LengthDelimited).string(message.image);
1424
- /* google.protobuf.Struct custom = 12; */
1425
- if (message.custom)
1426
- Struct.internalBinaryWrite(message.custom, writer.tag(12, WireType.LengthDelimited).fork(), options).join();
1427
- /* repeated string roles = 13; */
1428
- for (let i = 0; i < message.roles.length; i++)
1429
- writer.tag(13, WireType.LengthDelimited).string(message.roles[i]);
1430
- let u = options.writeUnknownFields;
1431
- if (u !== false)
1432
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
1433
- return writer;
1434
- }
1435
956
  }
1436
957
  /**
1437
958
  * @generated MessageType for protobuf message stream.video.sfu.models.Participant
@@ -1454,48 +975,6 @@ class StreamQuality$Type extends MessageType {
1454
975
  { no: 2, name: 'user_id', kind: 'scalar', T: 9 /*ScalarType.STRING*/ },
1455
976
  ]);
1456
977
  }
1457
- create(value) {
1458
- const message = globalThis.Object.create(this.messagePrototype);
1459
- message.videoQuality = 0;
1460
- message.userId = '';
1461
- if (value !== undefined)
1462
- reflectionMergePartial(this, message, value);
1463
- return message;
1464
- }
1465
- internalBinaryRead(reader, length, options, target) {
1466
- let message = target ?? this.create(), end = reader.pos + length;
1467
- while (reader.pos < end) {
1468
- let [fieldNo, wireType] = reader.tag();
1469
- switch (fieldNo) {
1470
- case /* stream.video.sfu.models.VideoQuality video_quality */ 1:
1471
- message.videoQuality = reader.int32();
1472
- break;
1473
- case /* string user_id */ 2:
1474
- message.userId = reader.string();
1475
- break;
1476
- default:
1477
- let u = options.readUnknownField;
1478
- if (u === 'throw')
1479
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
1480
- let d = reader.skip(wireType);
1481
- if (u !== false)
1482
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
1483
- }
1484
- }
1485
- return message;
1486
- }
1487
- internalBinaryWrite(message, writer, options) {
1488
- /* stream.video.sfu.models.VideoQuality video_quality = 1; */
1489
- if (message.videoQuality !== 0)
1490
- writer.tag(1, WireType.Varint).int32(message.videoQuality);
1491
- /* string user_id = 2; */
1492
- if (message.userId !== '')
1493
- writer.tag(2, WireType.LengthDelimited).string(message.userId);
1494
- let u = options.writeUnknownFields;
1495
- if (u !== false)
1496
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
1497
- return writer;
1498
- }
1499
978
  }
1500
979
  /**
1501
980
  * @generated MessageType for protobuf message stream.video.sfu.models.StreamQuality
@@ -1509,48 +988,6 @@ class VideoDimension$Type extends MessageType {
1509
988
  { no: 2, name: 'height', kind: 'scalar', T: 13 /*ScalarType.UINT32*/ },
1510
989
  ]);
1511
990
  }
1512
- create(value) {
1513
- const message = globalThis.Object.create(this.messagePrototype);
1514
- message.width = 0;
1515
- message.height = 0;
1516
- if (value !== undefined)
1517
- reflectionMergePartial(this, message, value);
1518
- return message;
1519
- }
1520
- internalBinaryRead(reader, length, options, target) {
1521
- let message = target ?? this.create(), end = reader.pos + length;
1522
- while (reader.pos < end) {
1523
- let [fieldNo, wireType] = reader.tag();
1524
- switch (fieldNo) {
1525
- case /* uint32 width */ 1:
1526
- message.width = reader.uint32();
1527
- break;
1528
- case /* uint32 height */ 2:
1529
- message.height = reader.uint32();
1530
- break;
1531
- default:
1532
- let u = options.readUnknownField;
1533
- if (u === 'throw')
1534
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
1535
- let d = reader.skip(wireType);
1536
- if (u !== false)
1537
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
1538
- }
1539
- }
1540
- return message;
1541
- }
1542
- internalBinaryWrite(message, writer, options) {
1543
- /* uint32 width = 1; */
1544
- if (message.width !== 0)
1545
- writer.tag(1, WireType.Varint).uint32(message.width);
1546
- /* uint32 height = 2; */
1547
- if (message.height !== 0)
1548
- writer.tag(2, WireType.Varint).uint32(message.height);
1549
- let u = options.writeUnknownFields;
1550
- if (u !== false)
1551
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
1552
- return writer;
1553
- }
1554
991
  }
1555
992
  /**
1556
993
  * @generated MessageType for protobuf message stream.video.sfu.models.VideoDimension
@@ -1581,68 +1018,6 @@ class VideoLayer$Type extends MessageType {
1581
1018
  },
1582
1019
  ]);
1583
1020
  }
1584
- create(value) {
1585
- const message = globalThis.Object.create(this.messagePrototype);
1586
- message.rid = '';
1587
- message.bitrate = 0;
1588
- message.fps = 0;
1589
- message.quality = 0;
1590
- if (value !== undefined)
1591
- reflectionMergePartial(this, message, value);
1592
- return message;
1593
- }
1594
- internalBinaryRead(reader, length, options, target) {
1595
- let message = target ?? this.create(), end = reader.pos + length;
1596
- while (reader.pos < end) {
1597
- let [fieldNo, wireType] = reader.tag();
1598
- switch (fieldNo) {
1599
- case /* string rid */ 1:
1600
- message.rid = reader.string();
1601
- break;
1602
- case /* stream.video.sfu.models.VideoDimension video_dimension */ 2:
1603
- message.videoDimension = VideoDimension.internalBinaryRead(reader, reader.uint32(), options, message.videoDimension);
1604
- break;
1605
- case /* uint32 bitrate */ 4:
1606
- message.bitrate = reader.uint32();
1607
- break;
1608
- case /* uint32 fps */ 5:
1609
- message.fps = reader.uint32();
1610
- break;
1611
- case /* stream.video.sfu.models.VideoQuality quality */ 6:
1612
- message.quality = reader.int32();
1613
- break;
1614
- default:
1615
- let u = options.readUnknownField;
1616
- if (u === 'throw')
1617
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
1618
- let d = reader.skip(wireType);
1619
- if (u !== false)
1620
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
1621
- }
1622
- }
1623
- return message;
1624
- }
1625
- internalBinaryWrite(message, writer, options) {
1626
- /* string rid = 1; */
1627
- if (message.rid !== '')
1628
- writer.tag(1, WireType.LengthDelimited).string(message.rid);
1629
- /* stream.video.sfu.models.VideoDimension video_dimension = 2; */
1630
- if (message.videoDimension)
1631
- VideoDimension.internalBinaryWrite(message.videoDimension, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
1632
- /* uint32 bitrate = 4; */
1633
- if (message.bitrate !== 0)
1634
- writer.tag(4, WireType.Varint).uint32(message.bitrate);
1635
- /* uint32 fps = 5; */
1636
- if (message.fps !== 0)
1637
- writer.tag(5, WireType.Varint).uint32(message.fps);
1638
- /* stream.video.sfu.models.VideoQuality quality = 6; */
1639
- if (message.quality !== 0)
1640
- writer.tag(6, WireType.Varint).int32(message.quality);
1641
- let u = options.writeUnknownFields;
1642
- if (u !== false)
1643
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
1644
- return writer;
1645
- }
1646
1021
  }
1647
1022
  /**
1648
1023
  * @generated MessageType for protobuf message stream.video.sfu.models.VideoLayer
@@ -1681,78 +1056,6 @@ class Codec$Type extends MessageType {
1681
1056
  },
1682
1057
  ]);
1683
1058
  }
1684
- create(value) {
1685
- const message = globalThis.Object.create(this.messagePrototype);
1686
- message.payloadType = 0;
1687
- message.name = '';
1688
- message.fmtpLine = '';
1689
- message.clockRate = 0;
1690
- message.encodingParameters = '';
1691
- message.feedbacks = [];
1692
- if (value !== undefined)
1693
- reflectionMergePartial(this, message, value);
1694
- return message;
1695
- }
1696
- internalBinaryRead(reader, length, options, target) {
1697
- let message = target ?? this.create(), end = reader.pos + length;
1698
- while (reader.pos < end) {
1699
- let [fieldNo, wireType] = reader.tag();
1700
- switch (fieldNo) {
1701
- case /* uint32 payload_type */ 1:
1702
- message.payloadType = reader.uint32();
1703
- break;
1704
- case /* string name */ 2:
1705
- message.name = reader.string();
1706
- break;
1707
- case /* string fmtp_line */ 3:
1708
- message.fmtpLine = reader.string();
1709
- break;
1710
- case /* uint32 clock_rate */ 4:
1711
- message.clockRate = reader.uint32();
1712
- break;
1713
- case /* string encoding_parameters */ 5:
1714
- message.encodingParameters = reader.string();
1715
- break;
1716
- case /* repeated string feedbacks */ 6:
1717
- message.feedbacks.push(reader.string());
1718
- break;
1719
- default:
1720
- let u = options.readUnknownField;
1721
- if (u === 'throw')
1722
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
1723
- let d = reader.skip(wireType);
1724
- if (u !== false)
1725
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
1726
- }
1727
- }
1728
- return message;
1729
- }
1730
- internalBinaryWrite(message, writer, options) {
1731
- /* uint32 payload_type = 1; */
1732
- if (message.payloadType !== 0)
1733
- writer.tag(1, WireType.Varint).uint32(message.payloadType);
1734
- /* string name = 2; */
1735
- if (message.name !== '')
1736
- writer.tag(2, WireType.LengthDelimited).string(message.name);
1737
- /* string fmtp_line = 3; */
1738
- if (message.fmtpLine !== '')
1739
- writer.tag(3, WireType.LengthDelimited).string(message.fmtpLine);
1740
- /* uint32 clock_rate = 4; */
1741
- if (message.clockRate !== 0)
1742
- writer.tag(4, WireType.Varint).uint32(message.clockRate);
1743
- /* string encoding_parameters = 5; */
1744
- if (message.encodingParameters !== '')
1745
- writer
1746
- .tag(5, WireType.LengthDelimited)
1747
- .string(message.encodingParameters);
1748
- /* repeated string feedbacks = 6; */
1749
- for (let i = 0; i < message.feedbacks.length; i++)
1750
- writer.tag(6, WireType.LengthDelimited).string(message.feedbacks[i]);
1751
- let u = options.writeUnknownFields;
1752
- if (u !== false)
1753
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
1754
- return writer;
1755
- }
1756
1059
  }
1757
1060
  /**
1758
1061
  * @generated MessageType for protobuf message stream.video.sfu.models.Codec
@@ -1777,55 +1080,6 @@ let ICETrickle$Type$1 = class ICETrickle$Type extends MessageType {
1777
1080
  { no: 3, name: 'session_id', kind: 'scalar', T: 9 /*ScalarType.STRING*/ },
1778
1081
  ]);
1779
1082
  }
1780
- create(value) {
1781
- const message = globalThis.Object.create(this.messagePrototype);
1782
- message.peerType = 0;
1783
- message.iceCandidate = '';
1784
- message.sessionId = '';
1785
- if (value !== undefined)
1786
- reflectionMergePartial(this, message, value);
1787
- return message;
1788
- }
1789
- internalBinaryRead(reader, length, options, target) {
1790
- let message = target ?? this.create(), end = reader.pos + length;
1791
- while (reader.pos < end) {
1792
- let [fieldNo, wireType] = reader.tag();
1793
- switch (fieldNo) {
1794
- case /* stream.video.sfu.models.PeerType peer_type */ 1:
1795
- message.peerType = reader.int32();
1796
- break;
1797
- case /* string ice_candidate */ 2:
1798
- message.iceCandidate = reader.string();
1799
- break;
1800
- case /* string session_id */ 3:
1801
- message.sessionId = reader.string();
1802
- break;
1803
- default:
1804
- let u = options.readUnknownField;
1805
- if (u === 'throw')
1806
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
1807
- let d = reader.skip(wireType);
1808
- if (u !== false)
1809
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
1810
- }
1811
- }
1812
- return message;
1813
- }
1814
- internalBinaryWrite(message, writer, options) {
1815
- /* stream.video.sfu.models.PeerType peer_type = 1; */
1816
- if (message.peerType !== 0)
1817
- writer.tag(1, WireType.Varint).int32(message.peerType);
1818
- /* string ice_candidate = 2; */
1819
- if (message.iceCandidate !== '')
1820
- writer.tag(2, WireType.LengthDelimited).string(message.iceCandidate);
1821
- /* string session_id = 3; */
1822
- if (message.sessionId !== '')
1823
- writer.tag(3, WireType.LengthDelimited).string(message.sessionId);
1824
- let u = options.writeUnknownFields;
1825
- if (u !== false)
1826
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
1827
- return writer;
1828
- }
1829
1083
  };
1830
1084
  /**
1831
1085
  * @generated MessageType for protobuf message stream.video.sfu.models.ICETrickle
@@ -1860,90 +1114,6 @@ class TrackInfo$Type extends MessageType {
1860
1114
  { no: 10, name: 'muted', kind: 'scalar', T: 8 /*ScalarType.BOOL*/ },
1861
1115
  ]);
1862
1116
  }
1863
- create(value) {
1864
- const message = globalThis.Object.create(this.messagePrototype);
1865
- message.trackId = '';
1866
- message.trackType = 0;
1867
- message.layers = [];
1868
- message.mid = '';
1869
- message.dtx = false;
1870
- message.stereo = false;
1871
- message.red = false;
1872
- message.muted = false;
1873
- if (value !== undefined)
1874
- reflectionMergePartial(this, message, value);
1875
- return message;
1876
- }
1877
- internalBinaryRead(reader, length, options, target) {
1878
- let message = target ?? this.create(), end = reader.pos + length;
1879
- while (reader.pos < end) {
1880
- let [fieldNo, wireType] = reader.tag();
1881
- switch (fieldNo) {
1882
- case /* string track_id */ 1:
1883
- message.trackId = reader.string();
1884
- break;
1885
- case /* stream.video.sfu.models.TrackType track_type */ 2:
1886
- message.trackType = reader.int32();
1887
- break;
1888
- case /* repeated stream.video.sfu.models.VideoLayer layers */ 5:
1889
- message.layers.push(VideoLayer.internalBinaryRead(reader, reader.uint32(), options));
1890
- break;
1891
- case /* string mid */ 6:
1892
- message.mid = reader.string();
1893
- break;
1894
- case /* bool dtx */ 7:
1895
- message.dtx = reader.bool();
1896
- break;
1897
- case /* bool stereo */ 8:
1898
- message.stereo = reader.bool();
1899
- break;
1900
- case /* bool red */ 9:
1901
- message.red = reader.bool();
1902
- break;
1903
- case /* bool muted */ 10:
1904
- message.muted = reader.bool();
1905
- break;
1906
- default:
1907
- let u = options.readUnknownField;
1908
- if (u === 'throw')
1909
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
1910
- let d = reader.skip(wireType);
1911
- if (u !== false)
1912
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
1913
- }
1914
- }
1915
- return message;
1916
- }
1917
- internalBinaryWrite(message, writer, options) {
1918
- /* string track_id = 1; */
1919
- if (message.trackId !== '')
1920
- writer.tag(1, WireType.LengthDelimited).string(message.trackId);
1921
- /* stream.video.sfu.models.TrackType track_type = 2; */
1922
- if (message.trackType !== 0)
1923
- writer.tag(2, WireType.Varint).int32(message.trackType);
1924
- /* repeated stream.video.sfu.models.VideoLayer layers = 5; */
1925
- for (let i = 0; i < message.layers.length; i++)
1926
- VideoLayer.internalBinaryWrite(message.layers[i], writer.tag(5, WireType.LengthDelimited).fork(), options).join();
1927
- /* string mid = 6; */
1928
- if (message.mid !== '')
1929
- writer.tag(6, WireType.LengthDelimited).string(message.mid);
1930
- /* bool dtx = 7; */
1931
- if (message.dtx !== false)
1932
- writer.tag(7, WireType.Varint).bool(message.dtx);
1933
- /* bool stereo = 8; */
1934
- if (message.stereo !== false)
1935
- writer.tag(8, WireType.Varint).bool(message.stereo);
1936
- /* bool red = 9; */
1937
- if (message.red !== false)
1938
- writer.tag(9, WireType.Varint).bool(message.red);
1939
- /* bool muted = 10; */
1940
- if (message.muted !== false)
1941
- writer.tag(10, WireType.Varint).bool(message.muted);
1942
- let u = options.writeUnknownFields;
1943
- if (u !== false)
1944
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
1945
- return writer;
1946
- }
1947
1117
  }
1948
1118
  /**
1949
1119
  * @generated MessageType for protobuf message stream.video.sfu.models.TrackInfo
@@ -1967,55 +1137,6 @@ let Error$Type$1 = class Error$Type extends MessageType {
1967
1137
  { no: 3, name: 'should_retry', kind: 'scalar', T: 8 /*ScalarType.BOOL*/ },
1968
1138
  ]);
1969
1139
  }
1970
- create(value) {
1971
- const message = globalThis.Object.create(this.messagePrototype);
1972
- message.code = 0;
1973
- message.message = '';
1974
- message.shouldRetry = false;
1975
- if (value !== undefined)
1976
- reflectionMergePartial(this, message, value);
1977
- return message;
1978
- }
1979
- internalBinaryRead(reader, length, options, target) {
1980
- let message = target ?? this.create(), end = reader.pos + length;
1981
- while (reader.pos < end) {
1982
- let [fieldNo, wireType] = reader.tag();
1983
- switch (fieldNo) {
1984
- case /* stream.video.sfu.models.ErrorCode code */ 1:
1985
- message.code = reader.int32();
1986
- break;
1987
- case /* string message */ 2:
1988
- message.message = reader.string();
1989
- break;
1990
- case /* bool should_retry */ 3:
1991
- message.shouldRetry = reader.bool();
1992
- break;
1993
- default:
1994
- let u = options.readUnknownField;
1995
- if (u === 'throw')
1996
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
1997
- let d = reader.skip(wireType);
1998
- if (u !== false)
1999
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
2000
- }
2001
- }
2002
- return message;
2003
- }
2004
- internalBinaryWrite(message, writer, options) {
2005
- /* stream.video.sfu.models.ErrorCode code = 1; */
2006
- if (message.code !== 0)
2007
- writer.tag(1, WireType.Varint).int32(message.code);
2008
- /* string message = 2; */
2009
- if (message.message !== '')
2010
- writer.tag(2, WireType.LengthDelimited).string(message.message);
2011
- /* bool should_retry = 3; */
2012
- if (message.shouldRetry !== false)
2013
- writer.tag(3, WireType.Varint).bool(message.shouldRetry);
2014
- let u = options.writeUnknownFields;
2015
- if (u !== false)
2016
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
2017
- return writer;
2018
- }
2019
1140
  };
2020
1141
  /**
2021
1142
  * @generated MessageType for protobuf message stream.video.sfu.models.Error
@@ -2031,58 +1152,6 @@ class ClientDetails$Type extends MessageType {
2031
1152
  { no: 4, name: 'device', kind: 'message', T: () => Device },
2032
1153
  ]);
2033
1154
  }
2034
- create(value) {
2035
- const message = globalThis.Object.create(this.messagePrototype);
2036
- if (value !== undefined)
2037
- reflectionMergePartial(this, message, value);
2038
- return message;
2039
- }
2040
- internalBinaryRead(reader, length, options, target) {
2041
- let message = target ?? this.create(), end = reader.pos + length;
2042
- while (reader.pos < end) {
2043
- let [fieldNo, wireType] = reader.tag();
2044
- switch (fieldNo) {
2045
- case /* stream.video.sfu.models.Sdk sdk */ 1:
2046
- message.sdk = Sdk.internalBinaryRead(reader, reader.uint32(), options, message.sdk);
2047
- break;
2048
- case /* stream.video.sfu.models.OS os */ 2:
2049
- message.os = OS.internalBinaryRead(reader, reader.uint32(), options, message.os);
2050
- break;
2051
- case /* stream.video.sfu.models.Browser browser */ 3:
2052
- message.browser = Browser.internalBinaryRead(reader, reader.uint32(), options, message.browser);
2053
- break;
2054
- case /* stream.video.sfu.models.Device device */ 4:
2055
- message.device = Device.internalBinaryRead(reader, reader.uint32(), options, message.device);
2056
- break;
2057
- default:
2058
- let u = options.readUnknownField;
2059
- if (u === 'throw')
2060
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
2061
- let d = reader.skip(wireType);
2062
- if (u !== false)
2063
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
2064
- }
2065
- }
2066
- return message;
2067
- }
2068
- internalBinaryWrite(message, writer, options) {
2069
- /* stream.video.sfu.models.Sdk sdk = 1; */
2070
- if (message.sdk)
2071
- Sdk.internalBinaryWrite(message.sdk, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
2072
- /* stream.video.sfu.models.OS os = 2; */
2073
- if (message.os)
2074
- OS.internalBinaryWrite(message.os, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
2075
- /* stream.video.sfu.models.Browser browser = 3; */
2076
- if (message.browser)
2077
- Browser.internalBinaryWrite(message.browser, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
2078
- /* stream.video.sfu.models.Device device = 4; */
2079
- if (message.device)
2080
- Device.internalBinaryWrite(message.device, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
2081
- let u = options.writeUnknownFields;
2082
- if (u !== false)
2083
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
2084
- return writer;
2085
- }
2086
1155
  }
2087
1156
  /**
2088
1157
  * @generated MessageType for protobuf message stream.video.sfu.models.ClientDetails
@@ -2103,62 +1172,6 @@ class Sdk$Type extends MessageType {
2103
1172
  { no: 4, name: 'patch', kind: 'scalar', T: 9 /*ScalarType.STRING*/ },
2104
1173
  ]);
2105
1174
  }
2106
- create(value) {
2107
- const message = globalThis.Object.create(this.messagePrototype);
2108
- message.type = 0;
2109
- message.major = '';
2110
- message.minor = '';
2111
- message.patch = '';
2112
- if (value !== undefined)
2113
- reflectionMergePartial(this, message, value);
2114
- return message;
2115
- }
2116
- internalBinaryRead(reader, length, options, target) {
2117
- let message = target ?? this.create(), end = reader.pos + length;
2118
- while (reader.pos < end) {
2119
- let [fieldNo, wireType] = reader.tag();
2120
- switch (fieldNo) {
2121
- case /* stream.video.sfu.models.SdkType type */ 1:
2122
- message.type = reader.int32();
2123
- break;
2124
- case /* string major */ 2:
2125
- message.major = reader.string();
2126
- break;
2127
- case /* string minor */ 3:
2128
- message.minor = reader.string();
2129
- break;
2130
- case /* string patch */ 4:
2131
- message.patch = reader.string();
2132
- break;
2133
- default:
2134
- let u = options.readUnknownField;
2135
- if (u === 'throw')
2136
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
2137
- let d = reader.skip(wireType);
2138
- if (u !== false)
2139
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
2140
- }
2141
- }
2142
- return message;
2143
- }
2144
- internalBinaryWrite(message, writer, options) {
2145
- /* stream.video.sfu.models.SdkType type = 1; */
2146
- if (message.type !== 0)
2147
- writer.tag(1, WireType.Varint).int32(message.type);
2148
- /* string major = 2; */
2149
- if (message.major !== '')
2150
- writer.tag(2, WireType.LengthDelimited).string(message.major);
2151
- /* string minor = 3; */
2152
- if (message.minor !== '')
2153
- writer.tag(3, WireType.LengthDelimited).string(message.minor);
2154
- /* string patch = 4; */
2155
- if (message.patch !== '')
2156
- writer.tag(4, WireType.LengthDelimited).string(message.patch);
2157
- let u = options.writeUnknownFields;
2158
- if (u !== false)
2159
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
2160
- return writer;
2161
- }
2162
1175
  }
2163
1176
  /**
2164
1177
  * @generated MessageType for protobuf message stream.video.sfu.models.Sdk
@@ -2178,55 +1191,6 @@ class OS$Type extends MessageType {
2178
1191
  },
2179
1192
  ]);
2180
1193
  }
2181
- create(value) {
2182
- const message = globalThis.Object.create(this.messagePrototype);
2183
- message.name = '';
2184
- message.version = '';
2185
- message.architecture = '';
2186
- if (value !== undefined)
2187
- reflectionMergePartial(this, message, value);
2188
- return message;
2189
- }
2190
- internalBinaryRead(reader, length, options, target) {
2191
- let message = target ?? this.create(), end = reader.pos + length;
2192
- while (reader.pos < end) {
2193
- let [fieldNo, wireType] = reader.tag();
2194
- switch (fieldNo) {
2195
- case /* string name */ 1:
2196
- message.name = reader.string();
2197
- break;
2198
- case /* string version */ 2:
2199
- message.version = reader.string();
2200
- break;
2201
- case /* string architecture */ 3:
2202
- message.architecture = reader.string();
2203
- break;
2204
- default:
2205
- let u = options.readUnknownField;
2206
- if (u === 'throw')
2207
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
2208
- let d = reader.skip(wireType);
2209
- if (u !== false)
2210
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
2211
- }
2212
- }
2213
- return message;
2214
- }
2215
- internalBinaryWrite(message, writer, options) {
2216
- /* string name = 1; */
2217
- if (message.name !== '')
2218
- writer.tag(1, WireType.LengthDelimited).string(message.name);
2219
- /* string version = 2; */
2220
- if (message.version !== '')
2221
- writer.tag(2, WireType.LengthDelimited).string(message.version);
2222
- /* string architecture = 3; */
2223
- if (message.architecture !== '')
2224
- writer.tag(3, WireType.LengthDelimited).string(message.architecture);
2225
- let u = options.writeUnknownFields;
2226
- if (u !== false)
2227
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
2228
- return writer;
2229
- }
2230
1194
  }
2231
1195
  /**
2232
1196
  * @generated MessageType for protobuf message stream.video.sfu.models.OS
@@ -2240,48 +1204,6 @@ class Browser$Type extends MessageType {
2240
1204
  { no: 2, name: 'version', kind: 'scalar', T: 9 /*ScalarType.STRING*/ },
2241
1205
  ]);
2242
1206
  }
2243
- create(value) {
2244
- const message = globalThis.Object.create(this.messagePrototype);
2245
- message.name = '';
2246
- message.version = '';
2247
- if (value !== undefined)
2248
- reflectionMergePartial(this, message, value);
2249
- return message;
2250
- }
2251
- internalBinaryRead(reader, length, options, target) {
2252
- let message = target ?? this.create(), end = reader.pos + length;
2253
- while (reader.pos < end) {
2254
- let [fieldNo, wireType] = reader.tag();
2255
- switch (fieldNo) {
2256
- case /* string name */ 1:
2257
- message.name = reader.string();
2258
- break;
2259
- case /* string version */ 2:
2260
- message.version = reader.string();
2261
- break;
2262
- default:
2263
- let u = options.readUnknownField;
2264
- if (u === 'throw')
2265
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
2266
- let d = reader.skip(wireType);
2267
- if (u !== false)
2268
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
2269
- }
2270
- }
2271
- return message;
2272
- }
2273
- internalBinaryWrite(message, writer, options) {
2274
- /* string name = 1; */
2275
- if (message.name !== '')
2276
- writer.tag(1, WireType.LengthDelimited).string(message.name);
2277
- /* string version = 2; */
2278
- if (message.version !== '')
2279
- writer.tag(2, WireType.LengthDelimited).string(message.version);
2280
- let u = options.writeUnknownFields;
2281
- if (u !== false)
2282
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
2283
- return writer;
2284
- }
2285
1207
  }
2286
1208
  /**
2287
1209
  * @generated MessageType for protobuf message stream.video.sfu.models.Browser
@@ -2295,48 +1217,6 @@ class Device$Type extends MessageType {
2295
1217
  { no: 2, name: 'version', kind: 'scalar', T: 9 /*ScalarType.STRING*/ },
2296
1218
  ]);
2297
1219
  }
2298
- create(value) {
2299
- const message = globalThis.Object.create(this.messagePrototype);
2300
- message.name = '';
2301
- message.version = '';
2302
- if (value !== undefined)
2303
- reflectionMergePartial(this, message, value);
2304
- return message;
2305
- }
2306
- internalBinaryRead(reader, length, options, target) {
2307
- let message = target ?? this.create(), end = reader.pos + length;
2308
- while (reader.pos < end) {
2309
- let [fieldNo, wireType] = reader.tag();
2310
- switch (fieldNo) {
2311
- case /* string name */ 1:
2312
- message.name = reader.string();
2313
- break;
2314
- case /* string version */ 2:
2315
- message.version = reader.string();
2316
- break;
2317
- default:
2318
- let u = options.readUnknownField;
2319
- if (u === 'throw')
2320
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
2321
- let d = reader.skip(wireType);
2322
- if (u !== false)
2323
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
2324
- }
2325
- }
2326
- return message;
2327
- }
2328
- internalBinaryWrite(message, writer, options) {
2329
- /* string name = 1; */
2330
- if (message.name !== '')
2331
- writer.tag(1, WireType.LengthDelimited).string(message.name);
2332
- /* string version = 2; */
2333
- if (message.version !== '')
2334
- writer.tag(2, WireType.LengthDelimited).string(message.version);
2335
- let u = options.writeUnknownFields;
2336
- if (u !== false)
2337
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
2338
- return writer;
2339
- }
2340
1220
  }
2341
1221
  /**
2342
1222
  * @generated MessageType for protobuf message stream.video.sfu.models.Device
@@ -2365,80 +1245,6 @@ class Call$Type extends MessageType {
2365
1245
  { no: 7, name: 'updated_at', kind: 'message', T: () => Timestamp },
2366
1246
  ]);
2367
1247
  }
2368
- create(value) {
2369
- const message = globalThis.Object.create(this.messagePrototype);
2370
- message.type = '';
2371
- message.id = '';
2372
- message.createdByUserId = '';
2373
- message.hostUserId = '';
2374
- if (value !== undefined)
2375
- reflectionMergePartial(this, message, value);
2376
- return message;
2377
- }
2378
- internalBinaryRead(reader, length, options, target) {
2379
- let message = target ?? this.create(), end = reader.pos + length;
2380
- while (reader.pos < end) {
2381
- let [fieldNo, wireType] = reader.tag();
2382
- switch (fieldNo) {
2383
- case /* string type */ 1:
2384
- message.type = reader.string();
2385
- break;
2386
- case /* string id */ 2:
2387
- message.id = reader.string();
2388
- break;
2389
- case /* string created_by_user_id */ 3:
2390
- message.createdByUserId = reader.string();
2391
- break;
2392
- case /* string host_user_id */ 4:
2393
- message.hostUserId = reader.string();
2394
- break;
2395
- case /* google.protobuf.Struct custom */ 5:
2396
- message.custom = Struct.internalBinaryRead(reader, reader.uint32(), options, message.custom);
2397
- break;
2398
- case /* google.protobuf.Timestamp created_at */ 6:
2399
- message.createdAt = Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.createdAt);
2400
- break;
2401
- case /* google.protobuf.Timestamp updated_at */ 7:
2402
- message.updatedAt = Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.updatedAt);
2403
- break;
2404
- default:
2405
- let u = options.readUnknownField;
2406
- if (u === 'throw')
2407
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
2408
- let d = reader.skip(wireType);
2409
- if (u !== false)
2410
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
2411
- }
2412
- }
2413
- return message;
2414
- }
2415
- internalBinaryWrite(message, writer, options) {
2416
- /* string type = 1; */
2417
- if (message.type !== '')
2418
- writer.tag(1, WireType.LengthDelimited).string(message.type);
2419
- /* string id = 2; */
2420
- if (message.id !== '')
2421
- writer.tag(2, WireType.LengthDelimited).string(message.id);
2422
- /* string created_by_user_id = 3; */
2423
- if (message.createdByUserId !== '')
2424
- writer.tag(3, WireType.LengthDelimited).string(message.createdByUserId);
2425
- /* string host_user_id = 4; */
2426
- if (message.hostUserId !== '')
2427
- writer.tag(4, WireType.LengthDelimited).string(message.hostUserId);
2428
- /* google.protobuf.Struct custom = 5; */
2429
- if (message.custom)
2430
- Struct.internalBinaryWrite(message.custom, writer.tag(5, WireType.LengthDelimited).fork(), options).join();
2431
- /* google.protobuf.Timestamp created_at = 6; */
2432
- if (message.createdAt)
2433
- Timestamp.internalBinaryWrite(message.createdAt, writer.tag(6, WireType.LengthDelimited).fork(), options).join();
2434
- /* google.protobuf.Timestamp updated_at = 7; */
2435
- if (message.updatedAt)
2436
- Timestamp.internalBinaryWrite(message.updatedAt, writer.tag(7, WireType.LengthDelimited).fork(), options).join();
2437
- let u = options.writeUnknownFields;
2438
- if (u !== false)
2439
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
2440
- return writer;
2441
- }
2442
1248
  }
2443
1249
  /**
2444
1250
  * @generated MessageType for protobuf message stream.video.sfu.models.Call
@@ -2468,55 +1274,6 @@ class CallGrants$Type extends MessageType {
2468
1274
  },
2469
1275
  ]);
2470
1276
  }
2471
- create(value) {
2472
- const message = globalThis.Object.create(this.messagePrototype);
2473
- message.canPublishAudio = false;
2474
- message.canPublishVideo = false;
2475
- message.canScreenshare = false;
2476
- if (value !== undefined)
2477
- reflectionMergePartial(this, message, value);
2478
- return message;
2479
- }
2480
- internalBinaryRead(reader, length, options, target) {
2481
- let message = target ?? this.create(), end = reader.pos + length;
2482
- while (reader.pos < end) {
2483
- let [fieldNo, wireType] = reader.tag();
2484
- switch (fieldNo) {
2485
- case /* bool can_publish_audio */ 1:
2486
- message.canPublishAudio = reader.bool();
2487
- break;
2488
- case /* bool can_publish_video */ 2:
2489
- message.canPublishVideo = reader.bool();
2490
- break;
2491
- case /* bool can_screenshare */ 3:
2492
- message.canScreenshare = reader.bool();
2493
- break;
2494
- default:
2495
- let u = options.readUnknownField;
2496
- if (u === 'throw')
2497
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
2498
- let d = reader.skip(wireType);
2499
- if (u !== false)
2500
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
2501
- }
2502
- }
2503
- return message;
2504
- }
2505
- internalBinaryWrite(message, writer, options) {
2506
- /* bool can_publish_audio = 1; */
2507
- if (message.canPublishAudio !== false)
2508
- writer.tag(1, WireType.Varint).bool(message.canPublishAudio);
2509
- /* bool can_publish_video = 2; */
2510
- if (message.canPublishVideo !== false)
2511
- writer.tag(2, WireType.Varint).bool(message.canPublishVideo);
2512
- /* bool can_screenshare = 3; */
2513
- if (message.canScreenshare !== false)
2514
- writer.tag(3, WireType.Varint).bool(message.canScreenshare);
2515
- let u = options.writeUnknownFields;
2516
- if (u !== false)
2517
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
2518
- return writer;
2519
- }
2520
1277
  }
2521
1278
  /**
2522
1279
  * @generated MessageType for protobuf message stream.video.sfu.models.CallGrants
@@ -2556,7 +1313,7 @@ var models = /*#__PURE__*/Object.freeze({
2556
1313
  });
2557
1314
 
2558
1315
  /* eslint-disable */
2559
- // @generated by protobuf-ts 2.9.4 with parameter long_type_string,client_generic,server_none,eslint_disable
1316
+ // @generated by protobuf-ts 2.9.4 with parameter long_type_string,client_generic,server_none,eslint_disable,optimize_code_size
2560
1317
  // @generated from protobuf file "video/sfu/signal_rpc/signal.proto" (package "stream.video.sfu.signal", syntax proto3)
2561
1318
  // tslint:disable
2562
1319
  // @generated message type with reflection information, may provide speed optimized methods
@@ -2566,41 +1323,6 @@ class StartNoiseCancellationRequest$Type extends MessageType {
2566
1323
  { no: 1, name: 'session_id', kind: 'scalar', T: 9 /*ScalarType.STRING*/ },
2567
1324
  ]);
2568
1325
  }
2569
- create(value) {
2570
- const message = globalThis.Object.create(this.messagePrototype);
2571
- message.sessionId = '';
2572
- if (value !== undefined)
2573
- reflectionMergePartial(this, message, value);
2574
- return message;
2575
- }
2576
- internalBinaryRead(reader, length, options, target) {
2577
- let message = target ?? this.create(), end = reader.pos + length;
2578
- while (reader.pos < end) {
2579
- let [fieldNo, wireType] = reader.tag();
2580
- switch (fieldNo) {
2581
- case /* string session_id */ 1:
2582
- message.sessionId = reader.string();
2583
- break;
2584
- default:
2585
- let u = options.readUnknownField;
2586
- if (u === 'throw')
2587
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
2588
- let d = reader.skip(wireType);
2589
- if (u !== false)
2590
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
2591
- }
2592
- }
2593
- return message;
2594
- }
2595
- internalBinaryWrite(message, writer, options) {
2596
- /* string session_id = 1; */
2597
- if (message.sessionId !== '')
2598
- writer.tag(1, WireType.LengthDelimited).string(message.sessionId);
2599
- let u = options.writeUnknownFields;
2600
- if (u !== false)
2601
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
2602
- return writer;
2603
- }
2604
1326
  }
2605
1327
  /**
2606
1328
  * @generated MessageType for protobuf message stream.video.sfu.signal.StartNoiseCancellationRequest
@@ -2613,40 +1335,6 @@ class StartNoiseCancellationResponse$Type extends MessageType {
2613
1335
  { no: 1, name: 'error', kind: 'message', T: () => Error$2 },
2614
1336
  ]);
2615
1337
  }
2616
- create(value) {
2617
- const message = globalThis.Object.create(this.messagePrototype);
2618
- if (value !== undefined)
2619
- reflectionMergePartial(this, message, value);
2620
- return message;
2621
- }
2622
- internalBinaryRead(reader, length, options, target) {
2623
- let message = target ?? this.create(), end = reader.pos + length;
2624
- while (reader.pos < end) {
2625
- let [fieldNo, wireType] = reader.tag();
2626
- switch (fieldNo) {
2627
- case /* stream.video.sfu.models.Error error */ 1:
2628
- message.error = Error$2.internalBinaryRead(reader, reader.uint32(), options, message.error);
2629
- break;
2630
- default:
2631
- let u = options.readUnknownField;
2632
- if (u === 'throw')
2633
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
2634
- let d = reader.skip(wireType);
2635
- if (u !== false)
2636
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
2637
- }
2638
- }
2639
- return message;
2640
- }
2641
- internalBinaryWrite(message, writer, options) {
2642
- /* stream.video.sfu.models.Error error = 1; */
2643
- if (message.error)
2644
- Error$2.internalBinaryWrite(message.error, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
2645
- let u = options.writeUnknownFields;
2646
- if (u !== false)
2647
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
2648
- return writer;
2649
- }
2650
1338
  }
2651
1339
  /**
2652
1340
  * @generated MessageType for protobuf message stream.video.sfu.signal.StartNoiseCancellationResponse
@@ -2659,41 +1347,6 @@ class StopNoiseCancellationRequest$Type extends MessageType {
2659
1347
  { no: 1, name: 'session_id', kind: 'scalar', T: 9 /*ScalarType.STRING*/ },
2660
1348
  ]);
2661
1349
  }
2662
- create(value) {
2663
- const message = globalThis.Object.create(this.messagePrototype);
2664
- message.sessionId = '';
2665
- if (value !== undefined)
2666
- reflectionMergePartial(this, message, value);
2667
- return message;
2668
- }
2669
- internalBinaryRead(reader, length, options, target) {
2670
- let message = target ?? this.create(), end = reader.pos + length;
2671
- while (reader.pos < end) {
2672
- let [fieldNo, wireType] = reader.tag();
2673
- switch (fieldNo) {
2674
- case /* string session_id */ 1:
2675
- message.sessionId = reader.string();
2676
- break;
2677
- default:
2678
- let u = options.readUnknownField;
2679
- if (u === 'throw')
2680
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
2681
- let d = reader.skip(wireType);
2682
- if (u !== false)
2683
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
2684
- }
2685
- }
2686
- return message;
2687
- }
2688
- internalBinaryWrite(message, writer, options) {
2689
- /* string session_id = 1; */
2690
- if (message.sessionId !== '')
2691
- writer.tag(1, WireType.LengthDelimited).string(message.sessionId);
2692
- let u = options.writeUnknownFields;
2693
- if (u !== false)
2694
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
2695
- return writer;
2696
- }
2697
1350
  }
2698
1351
  /**
2699
1352
  * @generated MessageType for protobuf message stream.video.sfu.signal.StopNoiseCancellationRequest
@@ -2706,40 +1359,6 @@ class StopNoiseCancellationResponse$Type extends MessageType {
2706
1359
  { no: 1, name: 'error', kind: 'message', T: () => Error$2 },
2707
1360
  ]);
2708
1361
  }
2709
- create(value) {
2710
- const message = globalThis.Object.create(this.messagePrototype);
2711
- if (value !== undefined)
2712
- reflectionMergePartial(this, message, value);
2713
- return message;
2714
- }
2715
- internalBinaryRead(reader, length, options, target) {
2716
- let message = target ?? this.create(), end = reader.pos + length;
2717
- while (reader.pos < end) {
2718
- let [fieldNo, wireType] = reader.tag();
2719
- switch (fieldNo) {
2720
- case /* stream.video.sfu.models.Error error */ 1:
2721
- message.error = Error$2.internalBinaryRead(reader, reader.uint32(), options, message.error);
2722
- break;
2723
- default:
2724
- let u = options.readUnknownField;
2725
- if (u === 'throw')
2726
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
2727
- let d = reader.skip(wireType);
2728
- if (u !== false)
2729
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
2730
- }
2731
- }
2732
- return message;
2733
- }
2734
- internalBinaryWrite(message, writer, options) {
2735
- /* stream.video.sfu.models.Error error = 1; */
2736
- if (message.error)
2737
- Error$2.internalBinaryWrite(message.error, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
2738
- let u = options.writeUnknownFields;
2739
- if (u !== false)
2740
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
2741
- return writer;
2742
- }
2743
1362
  }
2744
1363
  /**
2745
1364
  * @generated MessageType for protobuf message stream.video.sfu.signal.StopNoiseCancellationResponse
@@ -2777,76 +1396,6 @@ class SendStatsRequest$Type extends MessageType {
2777
1396
  },
2778
1397
  ]);
2779
1398
  }
2780
- create(value) {
2781
- const message = globalThis.Object.create(this.messagePrototype);
2782
- message.sessionId = '';
2783
- message.subscriberStats = '';
2784
- message.publisherStats = '';
2785
- message.webrtcVersion = '';
2786
- message.sdk = '';
2787
- message.sdkVersion = '';
2788
- if (value !== undefined)
2789
- reflectionMergePartial(this, message, value);
2790
- return message;
2791
- }
2792
- internalBinaryRead(reader, length, options, target) {
2793
- let message = target ?? this.create(), end = reader.pos + length;
2794
- while (reader.pos < end) {
2795
- let [fieldNo, wireType] = reader.tag();
2796
- switch (fieldNo) {
2797
- case /* string session_id */ 1:
2798
- message.sessionId = reader.string();
2799
- break;
2800
- case /* string subscriber_stats */ 2:
2801
- message.subscriberStats = reader.string();
2802
- break;
2803
- case /* string publisher_stats */ 3:
2804
- message.publisherStats = reader.string();
2805
- break;
2806
- case /* string webrtc_version */ 4:
2807
- message.webrtcVersion = reader.string();
2808
- break;
2809
- case /* string sdk */ 5:
2810
- message.sdk = reader.string();
2811
- break;
2812
- case /* string sdk_version */ 6:
2813
- message.sdkVersion = reader.string();
2814
- break;
2815
- default:
2816
- let u = options.readUnknownField;
2817
- if (u === 'throw')
2818
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
2819
- let d = reader.skip(wireType);
2820
- if (u !== false)
2821
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
2822
- }
2823
- }
2824
- return message;
2825
- }
2826
- internalBinaryWrite(message, writer, options) {
2827
- /* string session_id = 1; */
2828
- if (message.sessionId !== '')
2829
- writer.tag(1, WireType.LengthDelimited).string(message.sessionId);
2830
- /* string subscriber_stats = 2; */
2831
- if (message.subscriberStats !== '')
2832
- writer.tag(2, WireType.LengthDelimited).string(message.subscriberStats);
2833
- /* string publisher_stats = 3; */
2834
- if (message.publisherStats !== '')
2835
- writer.tag(3, WireType.LengthDelimited).string(message.publisherStats);
2836
- /* string webrtc_version = 4; */
2837
- if (message.webrtcVersion !== '')
2838
- writer.tag(4, WireType.LengthDelimited).string(message.webrtcVersion);
2839
- /* string sdk = 5; */
2840
- if (message.sdk !== '')
2841
- writer.tag(5, WireType.LengthDelimited).string(message.sdk);
2842
- /* string sdk_version = 6; */
2843
- if (message.sdkVersion !== '')
2844
- writer.tag(6, WireType.LengthDelimited).string(message.sdkVersion);
2845
- let u = options.writeUnknownFields;
2846
- if (u !== false)
2847
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
2848
- return writer;
2849
- }
2850
1399
  }
2851
1400
  /**
2852
1401
  * @generated MessageType for protobuf message stream.video.sfu.signal.SendStatsRequest
@@ -2859,40 +1408,6 @@ class SendStatsResponse$Type extends MessageType {
2859
1408
  { no: 1, name: 'error', kind: 'message', T: () => Error$2 },
2860
1409
  ]);
2861
1410
  }
2862
- create(value) {
2863
- const message = globalThis.Object.create(this.messagePrototype);
2864
- if (value !== undefined)
2865
- reflectionMergePartial(this, message, value);
2866
- return message;
2867
- }
2868
- internalBinaryRead(reader, length, options, target) {
2869
- let message = target ?? this.create(), end = reader.pos + length;
2870
- while (reader.pos < end) {
2871
- let [fieldNo, wireType] = reader.tag();
2872
- switch (fieldNo) {
2873
- case /* stream.video.sfu.models.Error error */ 1:
2874
- message.error = Error$2.internalBinaryRead(reader, reader.uint32(), options, message.error);
2875
- break;
2876
- default:
2877
- let u = options.readUnknownField;
2878
- if (u === 'throw')
2879
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
2880
- let d = reader.skip(wireType);
2881
- if (u !== false)
2882
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
2883
- }
2884
- }
2885
- return message;
2886
- }
2887
- internalBinaryWrite(message, writer, options) {
2888
- /* stream.video.sfu.models.Error error = 1; */
2889
- if (message.error)
2890
- Error$2.internalBinaryWrite(message.error, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
2891
- let u = options.writeUnknownFields;
2892
- if (u !== false)
2893
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
2894
- return writer;
2895
- }
2896
1411
  }
2897
1412
  /**
2898
1413
  * @generated MessageType for protobuf message stream.video.sfu.signal.SendStatsResponse
@@ -2911,48 +1426,6 @@ class ICERestartRequest$Type extends MessageType {
2911
1426
  },
2912
1427
  ]);
2913
1428
  }
2914
- create(value) {
2915
- const message = globalThis.Object.create(this.messagePrototype);
2916
- message.sessionId = '';
2917
- message.peerType = 0;
2918
- if (value !== undefined)
2919
- reflectionMergePartial(this, message, value);
2920
- return message;
2921
- }
2922
- internalBinaryRead(reader, length, options, target) {
2923
- let message = target ?? this.create(), end = reader.pos + length;
2924
- while (reader.pos < end) {
2925
- let [fieldNo, wireType] = reader.tag();
2926
- switch (fieldNo) {
2927
- case /* string session_id */ 1:
2928
- message.sessionId = reader.string();
2929
- break;
2930
- case /* stream.video.sfu.models.PeerType peer_type */ 2:
2931
- message.peerType = reader.int32();
2932
- break;
2933
- default:
2934
- let u = options.readUnknownField;
2935
- if (u === 'throw')
2936
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
2937
- let d = reader.skip(wireType);
2938
- if (u !== false)
2939
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
2940
- }
2941
- }
2942
- return message;
2943
- }
2944
- internalBinaryWrite(message, writer, options) {
2945
- /* string session_id = 1; */
2946
- if (message.sessionId !== '')
2947
- writer.tag(1, WireType.LengthDelimited).string(message.sessionId);
2948
- /* stream.video.sfu.models.PeerType peer_type = 2; */
2949
- if (message.peerType !== 0)
2950
- writer.tag(2, WireType.Varint).int32(message.peerType);
2951
- let u = options.writeUnknownFields;
2952
- if (u !== false)
2953
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
2954
- return writer;
2955
- }
2956
1429
  }
2957
1430
  /**
2958
1431
  * @generated MessageType for protobuf message stream.video.sfu.signal.ICERestartRequest
@@ -2965,40 +1438,6 @@ class ICERestartResponse$Type extends MessageType {
2965
1438
  { no: 1, name: 'error', kind: 'message', T: () => Error$2 },
2966
1439
  ]);
2967
1440
  }
2968
- create(value) {
2969
- const message = globalThis.Object.create(this.messagePrototype);
2970
- if (value !== undefined)
2971
- reflectionMergePartial(this, message, value);
2972
- return message;
2973
- }
2974
- internalBinaryRead(reader, length, options, target) {
2975
- let message = target ?? this.create(), end = reader.pos + length;
2976
- while (reader.pos < end) {
2977
- let [fieldNo, wireType] = reader.tag();
2978
- switch (fieldNo) {
2979
- case /* stream.video.sfu.models.Error error */ 1:
2980
- message.error = Error$2.internalBinaryRead(reader, reader.uint32(), options, message.error);
2981
- break;
2982
- default:
2983
- let u = options.readUnknownField;
2984
- if (u === 'throw')
2985
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
2986
- let d = reader.skip(wireType);
2987
- if (u !== false)
2988
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
2989
- }
2990
- }
2991
- return message;
2992
- }
2993
- internalBinaryWrite(message, writer, options) {
2994
- /* stream.video.sfu.models.Error error = 1; */
2995
- if (message.error)
2996
- Error$2.internalBinaryWrite(message.error, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
2997
- let u = options.writeUnknownFields;
2998
- if (u !== false)
2999
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
3000
- return writer;
3001
- }
3002
1441
  }
3003
1442
  /**
3004
1443
  * @generated MessageType for protobuf message stream.video.sfu.signal.ICERestartResponse
@@ -3018,48 +1457,6 @@ class UpdateMuteStatesRequest$Type extends MessageType {
3018
1457
  },
3019
1458
  ]);
3020
1459
  }
3021
- create(value) {
3022
- const message = globalThis.Object.create(this.messagePrototype);
3023
- message.sessionId = '';
3024
- message.muteStates = [];
3025
- if (value !== undefined)
3026
- reflectionMergePartial(this, message, value);
3027
- return message;
3028
- }
3029
- internalBinaryRead(reader, length, options, target) {
3030
- let message = target ?? this.create(), end = reader.pos + length;
3031
- while (reader.pos < end) {
3032
- let [fieldNo, wireType] = reader.tag();
3033
- switch (fieldNo) {
3034
- case /* string session_id */ 1:
3035
- message.sessionId = reader.string();
3036
- break;
3037
- case /* repeated stream.video.sfu.signal.TrackMuteState mute_states */ 3:
3038
- message.muteStates.push(TrackMuteState.internalBinaryRead(reader, reader.uint32(), options));
3039
- break;
3040
- default:
3041
- let u = options.readUnknownField;
3042
- if (u === 'throw')
3043
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
3044
- let d = reader.skip(wireType);
3045
- if (u !== false)
3046
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
3047
- }
3048
- }
3049
- return message;
3050
- }
3051
- internalBinaryWrite(message, writer, options) {
3052
- /* string session_id = 1; */
3053
- if (message.sessionId !== '')
3054
- writer.tag(1, WireType.LengthDelimited).string(message.sessionId);
3055
- /* repeated stream.video.sfu.signal.TrackMuteState mute_states = 3; */
3056
- for (let i = 0; i < message.muteStates.length; i++)
3057
- TrackMuteState.internalBinaryWrite(message.muteStates[i], writer.tag(3, WireType.LengthDelimited).fork(), options).join();
3058
- let u = options.writeUnknownFields;
3059
- if (u !== false)
3060
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
3061
- return writer;
3062
- }
3063
1460
  }
3064
1461
  /**
3065
1462
  * @generated MessageType for protobuf message stream.video.sfu.signal.UpdateMuteStatesRequest
@@ -3072,40 +1469,6 @@ class UpdateMuteStatesResponse$Type extends MessageType {
3072
1469
  { no: 4, name: 'error', kind: 'message', T: () => Error$2 },
3073
1470
  ]);
3074
1471
  }
3075
- create(value) {
3076
- const message = globalThis.Object.create(this.messagePrototype);
3077
- if (value !== undefined)
3078
- reflectionMergePartial(this, message, value);
3079
- return message;
3080
- }
3081
- internalBinaryRead(reader, length, options, target) {
3082
- let message = target ?? this.create(), end = reader.pos + length;
3083
- while (reader.pos < end) {
3084
- let [fieldNo, wireType] = reader.tag();
3085
- switch (fieldNo) {
3086
- case /* stream.video.sfu.models.Error error */ 4:
3087
- message.error = Error$2.internalBinaryRead(reader, reader.uint32(), options, message.error);
3088
- break;
3089
- default:
3090
- let u = options.readUnknownField;
3091
- if (u === 'throw')
3092
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
3093
- let d = reader.skip(wireType);
3094
- if (u !== false)
3095
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
3096
- }
3097
- }
3098
- return message;
3099
- }
3100
- internalBinaryWrite(message, writer, options) {
3101
- /* stream.video.sfu.models.Error error = 4; */
3102
- if (message.error)
3103
- Error$2.internalBinaryWrite(message.error, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
3104
- let u = options.writeUnknownFields;
3105
- if (u !== false)
3106
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
3107
- return writer;
3108
- }
3109
1472
  }
3110
1473
  /**
3111
1474
  * @generated MessageType for protobuf message stream.video.sfu.signal.UpdateMuteStatesResponse
@@ -3128,48 +1491,6 @@ class TrackMuteState$Type extends MessageType {
3128
1491
  { no: 2, name: 'muted', kind: 'scalar', T: 8 /*ScalarType.BOOL*/ },
3129
1492
  ]);
3130
1493
  }
3131
- create(value) {
3132
- const message = globalThis.Object.create(this.messagePrototype);
3133
- message.trackType = 0;
3134
- message.muted = false;
3135
- if (value !== undefined)
3136
- reflectionMergePartial(this, message, value);
3137
- return message;
3138
- }
3139
- internalBinaryRead(reader, length, options, target) {
3140
- let message = target ?? this.create(), end = reader.pos + length;
3141
- while (reader.pos < end) {
3142
- let [fieldNo, wireType] = reader.tag();
3143
- switch (fieldNo) {
3144
- case /* stream.video.sfu.models.TrackType track_type */ 1:
3145
- message.trackType = reader.int32();
3146
- break;
3147
- case /* bool muted */ 2:
3148
- message.muted = reader.bool();
3149
- break;
3150
- default:
3151
- let u = options.readUnknownField;
3152
- if (u === 'throw')
3153
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
3154
- let d = reader.skip(wireType);
3155
- if (u !== false)
3156
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
3157
- }
3158
- }
3159
- return message;
3160
- }
3161
- internalBinaryWrite(message, writer, options) {
3162
- /* stream.video.sfu.models.TrackType track_type = 1; */
3163
- if (message.trackType !== 0)
3164
- writer.tag(1, WireType.Varint).int32(message.trackType);
3165
- /* bool muted = 2; */
3166
- if (message.muted !== false)
3167
- writer.tag(2, WireType.Varint).bool(message.muted);
3168
- let u = options.writeUnknownFields;
3169
- if (u !== false)
3170
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
3171
- return writer;
3172
- }
3173
1494
  }
3174
1495
  /**
3175
1496
  * @generated MessageType for protobuf message stream.video.sfu.signal.TrackMuteState
@@ -3182,41 +1503,6 @@ class AudioMuteChanged$Type extends MessageType {
3182
1503
  { no: 1, name: 'muted', kind: 'scalar', T: 8 /*ScalarType.BOOL*/ },
3183
1504
  ]);
3184
1505
  }
3185
- create(value) {
3186
- const message = globalThis.Object.create(this.messagePrototype);
3187
- message.muted = false;
3188
- if (value !== undefined)
3189
- reflectionMergePartial(this, message, value);
3190
- return message;
3191
- }
3192
- internalBinaryRead(reader, length, options, target) {
3193
- let message = target ?? this.create(), end = reader.pos + length;
3194
- while (reader.pos < end) {
3195
- let [fieldNo, wireType] = reader.tag();
3196
- switch (fieldNo) {
3197
- case /* bool muted */ 1:
3198
- message.muted = reader.bool();
3199
- break;
3200
- default:
3201
- let u = options.readUnknownField;
3202
- if (u === 'throw')
3203
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
3204
- let d = reader.skip(wireType);
3205
- if (u !== false)
3206
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
3207
- }
3208
- }
3209
- return message;
3210
- }
3211
- internalBinaryWrite(message, writer, options) {
3212
- /* bool muted = 1; */
3213
- if (message.muted !== false)
3214
- writer.tag(1, WireType.Varint).bool(message.muted);
3215
- let u = options.writeUnknownFields;
3216
- if (u !== false)
3217
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
3218
- return writer;
3219
- }
3220
1506
  }
3221
1507
  /**
3222
1508
  * @generated MessageType for protobuf message stream.video.sfu.signal.AudioMuteChanged
@@ -3229,41 +1515,6 @@ class VideoMuteChanged$Type extends MessageType {
3229
1515
  { no: 2, name: 'muted', kind: 'scalar', T: 8 /*ScalarType.BOOL*/ },
3230
1516
  ]);
3231
1517
  }
3232
- create(value) {
3233
- const message = globalThis.Object.create(this.messagePrototype);
3234
- message.muted = false;
3235
- if (value !== undefined)
3236
- reflectionMergePartial(this, message, value);
3237
- return message;
3238
- }
3239
- internalBinaryRead(reader, length, options, target) {
3240
- let message = target ?? this.create(), end = reader.pos + length;
3241
- while (reader.pos < end) {
3242
- let [fieldNo, wireType] = reader.tag();
3243
- switch (fieldNo) {
3244
- case /* bool muted */ 2:
3245
- message.muted = reader.bool();
3246
- break;
3247
- default:
3248
- let u = options.readUnknownField;
3249
- if (u === 'throw')
3250
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
3251
- let d = reader.skip(wireType);
3252
- if (u !== false)
3253
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
3254
- }
3255
- }
3256
- return message;
3257
- }
3258
- internalBinaryWrite(message, writer, options) {
3259
- /* bool muted = 2; */
3260
- if (message.muted !== false)
3261
- writer.tag(2, WireType.Varint).bool(message.muted);
3262
- let u = options.writeUnknownFields;
3263
- if (u !== false)
3264
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
3265
- return writer;
3266
- }
3267
1518
  }
3268
1519
  /**
3269
1520
  * @generated MessageType for protobuf message stream.video.sfu.signal.VideoMuteChanged
@@ -3283,48 +1534,6 @@ class UpdateSubscriptionsRequest$Type extends MessageType {
3283
1534
  },
3284
1535
  ]);
3285
1536
  }
3286
- create(value) {
3287
- const message = globalThis.Object.create(this.messagePrototype);
3288
- message.sessionId = '';
3289
- message.tracks = [];
3290
- if (value !== undefined)
3291
- reflectionMergePartial(this, message, value);
3292
- return message;
3293
- }
3294
- internalBinaryRead(reader, length, options, target) {
3295
- let message = target ?? this.create(), end = reader.pos + length;
3296
- while (reader.pos < end) {
3297
- let [fieldNo, wireType] = reader.tag();
3298
- switch (fieldNo) {
3299
- case /* string session_id */ 2:
3300
- message.sessionId = reader.string();
3301
- break;
3302
- case /* repeated stream.video.sfu.signal.TrackSubscriptionDetails tracks */ 3:
3303
- message.tracks.push(TrackSubscriptionDetails.internalBinaryRead(reader, reader.uint32(), options));
3304
- break;
3305
- default:
3306
- let u = options.readUnknownField;
3307
- if (u === 'throw')
3308
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
3309
- let d = reader.skip(wireType);
3310
- if (u !== false)
3311
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
3312
- }
3313
- }
3314
- return message;
3315
- }
3316
- internalBinaryWrite(message, writer, options) {
3317
- /* string session_id = 2; */
3318
- if (message.sessionId !== '')
3319
- writer.tag(2, WireType.LengthDelimited).string(message.sessionId);
3320
- /* repeated stream.video.sfu.signal.TrackSubscriptionDetails tracks = 3; */
3321
- for (let i = 0; i < message.tracks.length; i++)
3322
- TrackSubscriptionDetails.internalBinaryWrite(message.tracks[i], writer.tag(3, WireType.LengthDelimited).fork(), options).join();
3323
- let u = options.writeUnknownFields;
3324
- if (u !== false)
3325
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
3326
- return writer;
3327
- }
3328
1537
  }
3329
1538
  /**
3330
1539
  * @generated MessageType for protobuf message stream.video.sfu.signal.UpdateSubscriptionsRequest
@@ -3337,40 +1546,6 @@ class UpdateSubscriptionsResponse$Type extends MessageType {
3337
1546
  { no: 4, name: 'error', kind: 'message', T: () => Error$2 },
3338
1547
  ]);
3339
1548
  }
3340
- create(value) {
3341
- const message = globalThis.Object.create(this.messagePrototype);
3342
- if (value !== undefined)
3343
- reflectionMergePartial(this, message, value);
3344
- return message;
3345
- }
3346
- internalBinaryRead(reader, length, options, target) {
3347
- let message = target ?? this.create(), end = reader.pos + length;
3348
- while (reader.pos < end) {
3349
- let [fieldNo, wireType] = reader.tag();
3350
- switch (fieldNo) {
3351
- case /* stream.video.sfu.models.Error error */ 4:
3352
- message.error = Error$2.internalBinaryRead(reader, reader.uint32(), options, message.error);
3353
- break;
3354
- default:
3355
- let u = options.readUnknownField;
3356
- if (u === 'throw')
3357
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
3358
- let d = reader.skip(wireType);
3359
- if (u !== false)
3360
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
3361
- }
3362
- }
3363
- return message;
3364
- }
3365
- internalBinaryWrite(message, writer, options) {
3366
- /* stream.video.sfu.models.Error error = 4; */
3367
- if (message.error)
3368
- Error$2.internalBinaryWrite(message.error, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
3369
- let u = options.writeUnknownFields;
3370
- if (u !== false)
3371
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
3372
- return writer;
3373
- }
3374
1549
  }
3375
1550
  /**
3376
1551
  * @generated MessageType for protobuf message stream.video.sfu.signal.UpdateSubscriptionsResponse
@@ -3395,61 +1570,6 @@ class TrackSubscriptionDetails$Type extends MessageType {
3395
1570
  { no: 4, name: 'dimension', kind: 'message', T: () => VideoDimension },
3396
1571
  ]);
3397
1572
  }
3398
- create(value) {
3399
- const message = globalThis.Object.create(this.messagePrototype);
3400
- message.userId = '';
3401
- message.sessionId = '';
3402
- message.trackType = 0;
3403
- if (value !== undefined)
3404
- reflectionMergePartial(this, message, value);
3405
- return message;
3406
- }
3407
- internalBinaryRead(reader, length, options, target) {
3408
- let message = target ?? this.create(), end = reader.pos + length;
3409
- while (reader.pos < end) {
3410
- let [fieldNo, wireType] = reader.tag();
3411
- switch (fieldNo) {
3412
- case /* string user_id */ 1:
3413
- message.userId = reader.string();
3414
- break;
3415
- case /* string session_id */ 2:
3416
- message.sessionId = reader.string();
3417
- break;
3418
- case /* stream.video.sfu.models.TrackType track_type */ 3:
3419
- message.trackType = reader.int32();
3420
- break;
3421
- case /* stream.video.sfu.models.VideoDimension dimension */ 4:
3422
- message.dimension = VideoDimension.internalBinaryRead(reader, reader.uint32(), options, message.dimension);
3423
- break;
3424
- default:
3425
- let u = options.readUnknownField;
3426
- if (u === 'throw')
3427
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
3428
- let d = reader.skip(wireType);
3429
- if (u !== false)
3430
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
3431
- }
3432
- }
3433
- return message;
3434
- }
3435
- internalBinaryWrite(message, writer, options) {
3436
- /* string user_id = 1; */
3437
- if (message.userId !== '')
3438
- writer.tag(1, WireType.LengthDelimited).string(message.userId);
3439
- /* string session_id = 2; */
3440
- if (message.sessionId !== '')
3441
- writer.tag(2, WireType.LengthDelimited).string(message.sessionId);
3442
- /* stream.video.sfu.models.TrackType track_type = 3; */
3443
- if (message.trackType !== 0)
3444
- writer.tag(3, WireType.Varint).int32(message.trackType);
3445
- /* stream.video.sfu.models.VideoDimension dimension = 4; */
3446
- if (message.dimension)
3447
- VideoDimension.internalBinaryWrite(message.dimension, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
3448
- let u = options.writeUnknownFields;
3449
- if (u !== false)
3450
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
3451
- return writer;
3452
- }
3453
1573
  }
3454
1574
  /**
3455
1575
  * @generated MessageType for protobuf message stream.video.sfu.signal.TrackSubscriptionDetails
@@ -3469,55 +1589,6 @@ class SendAnswerRequest$Type extends MessageType {
3469
1589
  { no: 3, name: 'session_id', kind: 'scalar', T: 9 /*ScalarType.STRING*/ },
3470
1590
  ]);
3471
1591
  }
3472
- create(value) {
3473
- const message = globalThis.Object.create(this.messagePrototype);
3474
- message.peerType = 0;
3475
- message.sdp = '';
3476
- message.sessionId = '';
3477
- if (value !== undefined)
3478
- reflectionMergePartial(this, message, value);
3479
- return message;
3480
- }
3481
- internalBinaryRead(reader, length, options, target) {
3482
- let message = target ?? this.create(), end = reader.pos + length;
3483
- while (reader.pos < end) {
3484
- let [fieldNo, wireType] = reader.tag();
3485
- switch (fieldNo) {
3486
- case /* stream.video.sfu.models.PeerType peer_type */ 1:
3487
- message.peerType = reader.int32();
3488
- break;
3489
- case /* string sdp */ 2:
3490
- message.sdp = reader.string();
3491
- break;
3492
- case /* string session_id */ 3:
3493
- message.sessionId = reader.string();
3494
- break;
3495
- default:
3496
- let u = options.readUnknownField;
3497
- if (u === 'throw')
3498
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
3499
- let d = reader.skip(wireType);
3500
- if (u !== false)
3501
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
3502
- }
3503
- }
3504
- return message;
3505
- }
3506
- internalBinaryWrite(message, writer, options) {
3507
- /* stream.video.sfu.models.PeerType peer_type = 1; */
3508
- if (message.peerType !== 0)
3509
- writer.tag(1, WireType.Varint).int32(message.peerType);
3510
- /* string sdp = 2; */
3511
- if (message.sdp !== '')
3512
- writer.tag(2, WireType.LengthDelimited).string(message.sdp);
3513
- /* string session_id = 3; */
3514
- if (message.sessionId !== '')
3515
- writer.tag(3, WireType.LengthDelimited).string(message.sessionId);
3516
- let u = options.writeUnknownFields;
3517
- if (u !== false)
3518
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
3519
- return writer;
3520
- }
3521
1592
  }
3522
1593
  /**
3523
1594
  * @generated MessageType for protobuf message stream.video.sfu.signal.SendAnswerRequest
@@ -3530,40 +1601,6 @@ class SendAnswerResponse$Type extends MessageType {
3530
1601
  { no: 4, name: 'error', kind: 'message', T: () => Error$2 },
3531
1602
  ]);
3532
1603
  }
3533
- create(value) {
3534
- const message = globalThis.Object.create(this.messagePrototype);
3535
- if (value !== undefined)
3536
- reflectionMergePartial(this, message, value);
3537
- return message;
3538
- }
3539
- internalBinaryRead(reader, length, options, target) {
3540
- let message = target ?? this.create(), end = reader.pos + length;
3541
- while (reader.pos < end) {
3542
- let [fieldNo, wireType] = reader.tag();
3543
- switch (fieldNo) {
3544
- case /* stream.video.sfu.models.Error error */ 4:
3545
- message.error = Error$2.internalBinaryRead(reader, reader.uint32(), options, message.error);
3546
- break;
3547
- default:
3548
- let u = options.readUnknownField;
3549
- if (u === 'throw')
3550
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
3551
- let d = reader.skip(wireType);
3552
- if (u !== false)
3553
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
3554
- }
3555
- }
3556
- return message;
3557
- }
3558
- internalBinaryWrite(message, writer, options) {
3559
- /* stream.video.sfu.models.Error error = 4; */
3560
- if (message.error)
3561
- Error$2.internalBinaryWrite(message.error, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
3562
- let u = options.writeUnknownFields;
3563
- if (u !== false)
3564
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
3565
- return writer;
3566
- }
3567
1604
  }
3568
1605
  /**
3569
1606
  * @generated MessageType for protobuf message stream.video.sfu.signal.SendAnswerResponse
@@ -3576,40 +1613,6 @@ class ICETrickleResponse$Type extends MessageType {
3576
1613
  { no: 4, name: 'error', kind: 'message', T: () => Error$2 },
3577
1614
  ]);
3578
1615
  }
3579
- create(value) {
3580
- const message = globalThis.Object.create(this.messagePrototype);
3581
- if (value !== undefined)
3582
- reflectionMergePartial(this, message, value);
3583
- return message;
3584
- }
3585
- internalBinaryRead(reader, length, options, target) {
3586
- let message = target ?? this.create(), end = reader.pos + length;
3587
- while (reader.pos < end) {
3588
- let [fieldNo, wireType] = reader.tag();
3589
- switch (fieldNo) {
3590
- case /* stream.video.sfu.models.Error error */ 4:
3591
- message.error = Error$2.internalBinaryRead(reader, reader.uint32(), options, message.error);
3592
- break;
3593
- default:
3594
- let u = options.readUnknownField;
3595
- if (u === 'throw')
3596
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
3597
- let d = reader.skip(wireType);
3598
- if (u !== false)
3599
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
3600
- }
3601
- }
3602
- return message;
3603
- }
3604
- internalBinaryWrite(message, writer, options) {
3605
- /* stream.video.sfu.models.Error error = 4; */
3606
- if (message.error)
3607
- Error$2.internalBinaryWrite(message.error, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
3608
- let u = options.writeUnknownFields;
3609
- if (u !== false)
3610
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
3611
- return writer;
3612
- }
3613
1616
  }
3614
1617
  /**
3615
1618
  * @generated MessageType for protobuf message stream.video.sfu.signal.ICETrickleResponse
@@ -3630,55 +1633,6 @@ class SetPublisherRequest$Type extends MessageType {
3630
1633
  },
3631
1634
  ]);
3632
1635
  }
3633
- create(value) {
3634
- const message = globalThis.Object.create(this.messagePrototype);
3635
- message.sdp = '';
3636
- message.sessionId = '';
3637
- message.tracks = [];
3638
- if (value !== undefined)
3639
- reflectionMergePartial(this, message, value);
3640
- return message;
3641
- }
3642
- internalBinaryRead(reader, length, options, target) {
3643
- let message = target ?? this.create(), end = reader.pos + length;
3644
- while (reader.pos < end) {
3645
- let [fieldNo, wireType] = reader.tag();
3646
- switch (fieldNo) {
3647
- case /* string sdp */ 1:
3648
- message.sdp = reader.string();
3649
- break;
3650
- case /* string session_id */ 2:
3651
- message.sessionId = reader.string();
3652
- break;
3653
- case /* repeated stream.video.sfu.models.TrackInfo tracks */ 3:
3654
- message.tracks.push(TrackInfo.internalBinaryRead(reader, reader.uint32(), options));
3655
- break;
3656
- default:
3657
- let u = options.readUnknownField;
3658
- if (u === 'throw')
3659
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
3660
- let d = reader.skip(wireType);
3661
- if (u !== false)
3662
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
3663
- }
3664
- }
3665
- return message;
3666
- }
3667
- internalBinaryWrite(message, writer, options) {
3668
- /* string sdp = 1; */
3669
- if (message.sdp !== '')
3670
- writer.tag(1, WireType.LengthDelimited).string(message.sdp);
3671
- /* string session_id = 2; */
3672
- if (message.sessionId !== '')
3673
- writer.tag(2, WireType.LengthDelimited).string(message.sessionId);
3674
- /* repeated stream.video.sfu.models.TrackInfo tracks = 3; */
3675
- for (let i = 0; i < message.tracks.length; i++)
3676
- TrackInfo.internalBinaryWrite(message.tracks[i], writer.tag(3, WireType.LengthDelimited).fork(), options).join();
3677
- let u = options.writeUnknownFields;
3678
- if (u !== false)
3679
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
3680
- return writer;
3681
- }
3682
1636
  }
3683
1637
  /**
3684
1638
  * @generated MessageType for protobuf message stream.video.sfu.signal.SetPublisherRequest
@@ -3694,61 +1648,6 @@ class SetPublisherResponse$Type extends MessageType {
3694
1648
  { no: 4, name: 'error', kind: 'message', T: () => Error$2 },
3695
1649
  ]);
3696
1650
  }
3697
- create(value) {
3698
- const message = globalThis.Object.create(this.messagePrototype);
3699
- message.sdp = '';
3700
- message.sessionId = '';
3701
- message.iceRestart = false;
3702
- if (value !== undefined)
3703
- reflectionMergePartial(this, message, value);
3704
- return message;
3705
- }
3706
- internalBinaryRead(reader, length, options, target) {
3707
- let message = target ?? this.create(), end = reader.pos + length;
3708
- while (reader.pos < end) {
3709
- let [fieldNo, wireType] = reader.tag();
3710
- switch (fieldNo) {
3711
- case /* string sdp */ 1:
3712
- message.sdp = reader.string();
3713
- break;
3714
- case /* string session_id */ 2:
3715
- message.sessionId = reader.string();
3716
- break;
3717
- case /* bool ice_restart */ 3:
3718
- message.iceRestart = reader.bool();
3719
- break;
3720
- case /* stream.video.sfu.models.Error error */ 4:
3721
- message.error = Error$2.internalBinaryRead(reader, reader.uint32(), options, message.error);
3722
- break;
3723
- default:
3724
- let u = options.readUnknownField;
3725
- if (u === 'throw')
3726
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
3727
- let d = reader.skip(wireType);
3728
- if (u !== false)
3729
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
3730
- }
3731
- }
3732
- return message;
3733
- }
3734
- internalBinaryWrite(message, writer, options) {
3735
- /* string sdp = 1; */
3736
- if (message.sdp !== '')
3737
- writer.tag(1, WireType.LengthDelimited).string(message.sdp);
3738
- /* string session_id = 2; */
3739
- if (message.sessionId !== '')
3740
- writer.tag(2, WireType.LengthDelimited).string(message.sessionId);
3741
- /* bool ice_restart = 3; */
3742
- if (message.iceRestart !== false)
3743
- writer.tag(3, WireType.Varint).bool(message.iceRestart);
3744
- /* stream.video.sfu.models.Error error = 4; */
3745
- if (message.error)
3746
- Error$2.internalBinaryWrite(message.error, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
3747
- let u = options.writeUnknownFields;
3748
- if (u !== false)
3749
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
3750
- return writer;
3751
- }
3752
1651
  }
3753
1652
  /**
3754
1653
  * @generated MessageType for protobuf message stream.video.sfu.signal.SetPublisherResponse
@@ -3809,6 +1708,10 @@ const SignalServer = new ServiceType('stream.video.sfu.signal.SignalServer', [
3809
1708
  },
3810
1709
  ]);
3811
1710
 
1711
+ /* eslint-disable */
1712
+ // @generated by protobuf-ts 2.9.4 with parameter long_type_string,client_generic,server_none,eslint_disable,optimize_code_size
1713
+ // @generated from protobuf file "video/sfu/event/events.proto" (package "stream.video.sfu.event", syntax proto3)
1714
+ // tslint:disable
3812
1715
  /**
3813
1716
  * @generated from protobuf enum stream.video.sfu.event.VideoLayerSetting.Priority
3814
1717
  */
@@ -3984,224 +1887,6 @@ class SfuEvent$Type extends MessageType {
3984
1887
  },
3985
1888
  ]);
3986
1889
  }
3987
- create(value) {
3988
- const message = globalThis.Object.create(this.messagePrototype);
3989
- message.eventPayload = { oneofKind: undefined };
3990
- if (value !== undefined)
3991
- reflectionMergePartial(this, message, value);
3992
- return message;
3993
- }
3994
- internalBinaryRead(reader, length, options, target) {
3995
- let message = target ?? this.create(), end = reader.pos + length;
3996
- while (reader.pos < end) {
3997
- let [fieldNo, wireType] = reader.tag();
3998
- switch (fieldNo) {
3999
- case /* stream.video.sfu.event.SubscriberOffer subscriber_offer */ 1:
4000
- message.eventPayload = {
4001
- oneofKind: 'subscriberOffer',
4002
- subscriberOffer: SubscriberOffer.internalBinaryRead(reader, reader.uint32(), options, message.eventPayload.subscriberOffer),
4003
- };
4004
- break;
4005
- case /* stream.video.sfu.event.PublisherAnswer publisher_answer */ 2:
4006
- message.eventPayload = {
4007
- oneofKind: 'publisherAnswer',
4008
- publisherAnswer: PublisherAnswer.internalBinaryRead(reader, reader.uint32(), options, message.eventPayload.publisherAnswer),
4009
- };
4010
- break;
4011
- case /* stream.video.sfu.event.ConnectionQualityChanged connection_quality_changed */ 3:
4012
- message.eventPayload = {
4013
- oneofKind: 'connectionQualityChanged',
4014
- connectionQualityChanged: ConnectionQualityChanged.internalBinaryRead(reader, reader.uint32(), options, message.eventPayload.connectionQualityChanged),
4015
- };
4016
- break;
4017
- case /* stream.video.sfu.event.AudioLevelChanged audio_level_changed */ 4:
4018
- message.eventPayload = {
4019
- oneofKind: 'audioLevelChanged',
4020
- audioLevelChanged: AudioLevelChanged.internalBinaryRead(reader, reader.uint32(), options, message.eventPayload.audioLevelChanged),
4021
- };
4022
- break;
4023
- case /* stream.video.sfu.models.ICETrickle ice_trickle */ 5:
4024
- message.eventPayload = {
4025
- oneofKind: 'iceTrickle',
4026
- iceTrickle: ICETrickle$1.internalBinaryRead(reader, reader.uint32(), options, message.eventPayload.iceTrickle),
4027
- };
4028
- break;
4029
- case /* stream.video.sfu.event.ChangePublishQuality change_publish_quality */ 6:
4030
- message.eventPayload = {
4031
- oneofKind: 'changePublishQuality',
4032
- changePublishQuality: ChangePublishQuality.internalBinaryRead(reader, reader.uint32(), options, message.eventPayload.changePublishQuality),
4033
- };
4034
- break;
4035
- case /* stream.video.sfu.event.ParticipantJoined participant_joined */ 10:
4036
- message.eventPayload = {
4037
- oneofKind: 'participantJoined',
4038
- participantJoined: ParticipantJoined.internalBinaryRead(reader, reader.uint32(), options, message.eventPayload.participantJoined),
4039
- };
4040
- break;
4041
- case /* stream.video.sfu.event.ParticipantLeft participant_left */ 11:
4042
- message.eventPayload = {
4043
- oneofKind: 'participantLeft',
4044
- participantLeft: ParticipantLeft.internalBinaryRead(reader, reader.uint32(), options, message.eventPayload.participantLeft),
4045
- };
4046
- break;
4047
- case /* stream.video.sfu.event.DominantSpeakerChanged dominant_speaker_changed */ 12:
4048
- message.eventPayload = {
4049
- oneofKind: 'dominantSpeakerChanged',
4050
- dominantSpeakerChanged: DominantSpeakerChanged.internalBinaryRead(reader, reader.uint32(), options, message.eventPayload.dominantSpeakerChanged),
4051
- };
4052
- break;
4053
- case /* stream.video.sfu.event.JoinResponse join_response */ 13:
4054
- message.eventPayload = {
4055
- oneofKind: 'joinResponse',
4056
- joinResponse: JoinResponse.internalBinaryRead(reader, reader.uint32(), options, message.eventPayload.joinResponse),
4057
- };
4058
- break;
4059
- case /* stream.video.sfu.event.HealthCheckResponse health_check_response */ 14:
4060
- message.eventPayload = {
4061
- oneofKind: 'healthCheckResponse',
4062
- healthCheckResponse: HealthCheckResponse.internalBinaryRead(reader, reader.uint32(), options, message.eventPayload.healthCheckResponse),
4063
- };
4064
- break;
4065
- case /* stream.video.sfu.event.TrackPublished track_published */ 16:
4066
- message.eventPayload = {
4067
- oneofKind: 'trackPublished',
4068
- trackPublished: TrackPublished.internalBinaryRead(reader, reader.uint32(), options, message.eventPayload.trackPublished),
4069
- };
4070
- break;
4071
- case /* stream.video.sfu.event.TrackUnpublished track_unpublished */ 17:
4072
- message.eventPayload = {
4073
- oneofKind: 'trackUnpublished',
4074
- trackUnpublished: TrackUnpublished.internalBinaryRead(reader, reader.uint32(), options, message.eventPayload.trackUnpublished),
4075
- };
4076
- break;
4077
- case /* stream.video.sfu.event.Error error */ 18:
4078
- message.eventPayload = {
4079
- oneofKind: 'error',
4080
- error: Error$1.internalBinaryRead(reader, reader.uint32(), options, message.eventPayload.error),
4081
- };
4082
- break;
4083
- case /* stream.video.sfu.event.CallGrantsUpdated call_grants_updated */ 19:
4084
- message.eventPayload = {
4085
- oneofKind: 'callGrantsUpdated',
4086
- callGrantsUpdated: CallGrantsUpdated.internalBinaryRead(reader, reader.uint32(), options, message.eventPayload.callGrantsUpdated),
4087
- };
4088
- break;
4089
- case /* stream.video.sfu.event.GoAway go_away */ 20:
4090
- message.eventPayload = {
4091
- oneofKind: 'goAway',
4092
- goAway: GoAway.internalBinaryRead(reader, reader.uint32(), options, message.eventPayload.goAway),
4093
- };
4094
- break;
4095
- case /* stream.video.sfu.event.ICERestart ice_restart */ 21:
4096
- message.eventPayload = {
4097
- oneofKind: 'iceRestart',
4098
- iceRestart: ICERestart.internalBinaryRead(reader, reader.uint32(), options, message.eventPayload.iceRestart),
4099
- };
4100
- break;
4101
- case /* stream.video.sfu.event.PinsChanged pins_updated */ 22:
4102
- message.eventPayload = {
4103
- oneofKind: 'pinsUpdated',
4104
- pinsUpdated: PinsChanged.internalBinaryRead(reader, reader.uint32(), options, message.eventPayload.pinsUpdated),
4105
- };
4106
- break;
4107
- case /* stream.video.sfu.event.CallEnded call_ended */ 23:
4108
- message.eventPayload = {
4109
- oneofKind: 'callEnded',
4110
- callEnded: CallEnded.internalBinaryRead(reader, reader.uint32(), options, message.eventPayload.callEnded),
4111
- };
4112
- break;
4113
- case /* stream.video.sfu.event.ParticipantUpdated participant_updated */ 24:
4114
- message.eventPayload = {
4115
- oneofKind: 'participantUpdated',
4116
- participantUpdated: ParticipantUpdated.internalBinaryRead(reader, reader.uint32(), options, message.eventPayload.participantUpdated),
4117
- };
4118
- break;
4119
- case /* stream.video.sfu.event.ParticipantMigrationComplete participant_migration_complete */ 25:
4120
- message.eventPayload = {
4121
- oneofKind: 'participantMigrationComplete',
4122
- participantMigrationComplete: ParticipantMigrationComplete.internalBinaryRead(reader, reader.uint32(), options, message.eventPayload.participantMigrationComplete),
4123
- };
4124
- break;
4125
- default:
4126
- let u = options.readUnknownField;
4127
- if (u === 'throw')
4128
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
4129
- let d = reader.skip(wireType);
4130
- if (u !== false)
4131
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
4132
- }
4133
- }
4134
- return message;
4135
- }
4136
- internalBinaryWrite(message, writer, options) {
4137
- /* stream.video.sfu.event.SubscriberOffer subscriber_offer = 1; */
4138
- if (message.eventPayload.oneofKind === 'subscriberOffer')
4139
- SubscriberOffer.internalBinaryWrite(message.eventPayload.subscriberOffer, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
4140
- /* stream.video.sfu.event.PublisherAnswer publisher_answer = 2; */
4141
- if (message.eventPayload.oneofKind === 'publisherAnswer')
4142
- PublisherAnswer.internalBinaryWrite(message.eventPayload.publisherAnswer, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
4143
- /* stream.video.sfu.event.ConnectionQualityChanged connection_quality_changed = 3; */
4144
- if (message.eventPayload.oneofKind === 'connectionQualityChanged')
4145
- ConnectionQualityChanged.internalBinaryWrite(message.eventPayload.connectionQualityChanged, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
4146
- /* stream.video.sfu.event.AudioLevelChanged audio_level_changed = 4; */
4147
- if (message.eventPayload.oneofKind === 'audioLevelChanged')
4148
- AudioLevelChanged.internalBinaryWrite(message.eventPayload.audioLevelChanged, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
4149
- /* stream.video.sfu.models.ICETrickle ice_trickle = 5; */
4150
- if (message.eventPayload.oneofKind === 'iceTrickle')
4151
- ICETrickle$1.internalBinaryWrite(message.eventPayload.iceTrickle, writer.tag(5, WireType.LengthDelimited).fork(), options).join();
4152
- /* stream.video.sfu.event.ChangePublishQuality change_publish_quality = 6; */
4153
- if (message.eventPayload.oneofKind === 'changePublishQuality')
4154
- ChangePublishQuality.internalBinaryWrite(message.eventPayload.changePublishQuality, writer.tag(6, WireType.LengthDelimited).fork(), options).join();
4155
- /* stream.video.sfu.event.ParticipantJoined participant_joined = 10; */
4156
- if (message.eventPayload.oneofKind === 'participantJoined')
4157
- ParticipantJoined.internalBinaryWrite(message.eventPayload.participantJoined, writer.tag(10, WireType.LengthDelimited).fork(), options).join();
4158
- /* stream.video.sfu.event.ParticipantLeft participant_left = 11; */
4159
- if (message.eventPayload.oneofKind === 'participantLeft')
4160
- ParticipantLeft.internalBinaryWrite(message.eventPayload.participantLeft, writer.tag(11, WireType.LengthDelimited).fork(), options).join();
4161
- /* stream.video.sfu.event.DominantSpeakerChanged dominant_speaker_changed = 12; */
4162
- if (message.eventPayload.oneofKind === 'dominantSpeakerChanged')
4163
- DominantSpeakerChanged.internalBinaryWrite(message.eventPayload.dominantSpeakerChanged, writer.tag(12, WireType.LengthDelimited).fork(), options).join();
4164
- /* stream.video.sfu.event.JoinResponse join_response = 13; */
4165
- if (message.eventPayload.oneofKind === 'joinResponse')
4166
- JoinResponse.internalBinaryWrite(message.eventPayload.joinResponse, writer.tag(13, WireType.LengthDelimited).fork(), options).join();
4167
- /* stream.video.sfu.event.HealthCheckResponse health_check_response = 14; */
4168
- if (message.eventPayload.oneofKind === 'healthCheckResponse')
4169
- HealthCheckResponse.internalBinaryWrite(message.eventPayload.healthCheckResponse, writer.tag(14, WireType.LengthDelimited).fork(), options).join();
4170
- /* stream.video.sfu.event.TrackPublished track_published = 16; */
4171
- if (message.eventPayload.oneofKind === 'trackPublished')
4172
- TrackPublished.internalBinaryWrite(message.eventPayload.trackPublished, writer.tag(16, WireType.LengthDelimited).fork(), options).join();
4173
- /* stream.video.sfu.event.TrackUnpublished track_unpublished = 17; */
4174
- if (message.eventPayload.oneofKind === 'trackUnpublished')
4175
- TrackUnpublished.internalBinaryWrite(message.eventPayload.trackUnpublished, writer.tag(17, WireType.LengthDelimited).fork(), options).join();
4176
- /* stream.video.sfu.event.Error error = 18; */
4177
- if (message.eventPayload.oneofKind === 'error')
4178
- Error$1.internalBinaryWrite(message.eventPayload.error, writer.tag(18, WireType.LengthDelimited).fork(), options).join();
4179
- /* stream.video.sfu.event.CallGrantsUpdated call_grants_updated = 19; */
4180
- if (message.eventPayload.oneofKind === 'callGrantsUpdated')
4181
- CallGrantsUpdated.internalBinaryWrite(message.eventPayload.callGrantsUpdated, writer.tag(19, WireType.LengthDelimited).fork(), options).join();
4182
- /* stream.video.sfu.event.GoAway go_away = 20; */
4183
- if (message.eventPayload.oneofKind === 'goAway')
4184
- GoAway.internalBinaryWrite(message.eventPayload.goAway, writer.tag(20, WireType.LengthDelimited).fork(), options).join();
4185
- /* stream.video.sfu.event.ICERestart ice_restart = 21; */
4186
- if (message.eventPayload.oneofKind === 'iceRestart')
4187
- ICERestart.internalBinaryWrite(message.eventPayload.iceRestart, writer.tag(21, WireType.LengthDelimited).fork(), options).join();
4188
- /* stream.video.sfu.event.PinsChanged pins_updated = 22; */
4189
- if (message.eventPayload.oneofKind === 'pinsUpdated')
4190
- PinsChanged.internalBinaryWrite(message.eventPayload.pinsUpdated, writer.tag(22, WireType.LengthDelimited).fork(), options).join();
4191
- /* stream.video.sfu.event.CallEnded call_ended = 23; */
4192
- if (message.eventPayload.oneofKind === 'callEnded')
4193
- CallEnded.internalBinaryWrite(message.eventPayload.callEnded, writer.tag(23, WireType.LengthDelimited).fork(), options).join();
4194
- /* stream.video.sfu.event.ParticipantUpdated participant_updated = 24; */
4195
- if (message.eventPayload.oneofKind === 'participantUpdated')
4196
- ParticipantUpdated.internalBinaryWrite(message.eventPayload.participantUpdated, writer.tag(24, WireType.LengthDelimited).fork(), options).join();
4197
- /* stream.video.sfu.event.ParticipantMigrationComplete participant_migration_complete = 25; */
4198
- if (message.eventPayload.oneofKind === 'participantMigrationComplete')
4199
- ParticipantMigrationComplete.internalBinaryWrite(message.eventPayload.participantMigrationComplete, writer.tag(25, WireType.LengthDelimited).fork(), options).join();
4200
- let u = options.writeUnknownFields;
4201
- if (u !== false)
4202
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
4203
- return writer;
4204
- }
4205
1890
  }
4206
1891
  /**
4207
1892
  * @generated MessageType for protobuf message stream.video.sfu.event.SfuEvent
@@ -4212,21 +1897,6 @@ class ParticipantMigrationComplete$Type extends MessageType {
4212
1897
  constructor() {
4213
1898
  super('stream.video.sfu.event.ParticipantMigrationComplete', []);
4214
1899
  }
4215
- create(value) {
4216
- const message = globalThis.Object.create(this.messagePrototype);
4217
- if (value !== undefined)
4218
- reflectionMergePartial(this, message, value);
4219
- return message;
4220
- }
4221
- internalBinaryRead(reader, length, options, target) {
4222
- return target ?? this.create();
4223
- }
4224
- internalBinaryWrite(message, writer, options) {
4225
- let u = options.writeUnknownFields;
4226
- if (u !== false)
4227
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
4228
- return writer;
4229
- }
4230
1900
  }
4231
1901
  /**
4232
1902
  * @generated MessageType for protobuf message stream.video.sfu.event.ParticipantMigrationComplete
@@ -4245,41 +1915,6 @@ class PinsChanged$Type extends MessageType {
4245
1915
  },
4246
1916
  ]);
4247
1917
  }
4248
- create(value) {
4249
- const message = globalThis.Object.create(this.messagePrototype);
4250
- message.pins = [];
4251
- if (value !== undefined)
4252
- reflectionMergePartial(this, message, value);
4253
- return message;
4254
- }
4255
- internalBinaryRead(reader, length, options, target) {
4256
- let message = target ?? this.create(), end = reader.pos + length;
4257
- while (reader.pos < end) {
4258
- let [fieldNo, wireType] = reader.tag();
4259
- switch (fieldNo) {
4260
- case /* repeated stream.video.sfu.models.Pin pins */ 1:
4261
- message.pins.push(Pin.internalBinaryRead(reader, reader.uint32(), options));
4262
- break;
4263
- default:
4264
- let u = options.readUnknownField;
4265
- if (u === 'throw')
4266
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
4267
- let d = reader.skip(wireType);
4268
- if (u !== false)
4269
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
4270
- }
4271
- }
4272
- return message;
4273
- }
4274
- internalBinaryWrite(message, writer, options) {
4275
- /* repeated stream.video.sfu.models.Pin pins = 1; */
4276
- for (let i = 0; i < message.pins.length; i++)
4277
- Pin.internalBinaryWrite(message.pins[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join();
4278
- let u = options.writeUnknownFields;
4279
- if (u !== false)
4280
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
4281
- return writer;
4282
- }
4283
1918
  }
4284
1919
  /**
4285
1920
  * @generated MessageType for protobuf message stream.video.sfu.event.PinsChanged
@@ -4302,47 +1937,6 @@ class Error$Type extends MessageType {
4302
1937
  },
4303
1938
  ]);
4304
1939
  }
4305
- create(value) {
4306
- const message = globalThis.Object.create(this.messagePrototype);
4307
- message.reconnectStrategy = 0;
4308
- if (value !== undefined)
4309
- reflectionMergePartial(this, message, value);
4310
- return message;
4311
- }
4312
- internalBinaryRead(reader, length, options, target) {
4313
- let message = target ?? this.create(), end = reader.pos + length;
4314
- while (reader.pos < end) {
4315
- let [fieldNo, wireType] = reader.tag();
4316
- switch (fieldNo) {
4317
- case /* stream.video.sfu.models.Error error */ 4:
4318
- message.error = Error$2.internalBinaryRead(reader, reader.uint32(), options, message.error);
4319
- break;
4320
- case /* stream.video.sfu.models.WebsocketReconnectStrategy reconnect_strategy */ 5:
4321
- message.reconnectStrategy = reader.int32();
4322
- break;
4323
- default:
4324
- let u = options.readUnknownField;
4325
- if (u === 'throw')
4326
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
4327
- let d = reader.skip(wireType);
4328
- if (u !== false)
4329
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
4330
- }
4331
- }
4332
- return message;
4333
- }
4334
- internalBinaryWrite(message, writer, options) {
4335
- /* stream.video.sfu.models.Error error = 4; */
4336
- if (message.error)
4337
- Error$2.internalBinaryWrite(message.error, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
4338
- /* stream.video.sfu.models.WebsocketReconnectStrategy reconnect_strategy = 5; */
4339
- if (message.reconnectStrategy !== 0)
4340
- writer.tag(5, WireType.Varint).int32(message.reconnectStrategy);
4341
- let u = options.writeUnknownFields;
4342
- if (u !== false)
4343
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
4344
- return writer;
4345
- }
4346
1940
  }
4347
1941
  /**
4348
1942
  * @generated MessageType for protobuf message stream.video.sfu.event.Error
@@ -4366,48 +1960,6 @@ class ICETrickle$Type extends MessageType {
4366
1960
  },
4367
1961
  ]);
4368
1962
  }
4369
- create(value) {
4370
- const message = globalThis.Object.create(this.messagePrototype);
4371
- message.peerType = 0;
4372
- message.iceCandidate = '';
4373
- if (value !== undefined)
4374
- reflectionMergePartial(this, message, value);
4375
- return message;
4376
- }
4377
- internalBinaryRead(reader, length, options, target) {
4378
- let message = target ?? this.create(), end = reader.pos + length;
4379
- while (reader.pos < end) {
4380
- let [fieldNo, wireType] = reader.tag();
4381
- switch (fieldNo) {
4382
- case /* stream.video.sfu.models.PeerType peer_type */ 1:
4383
- message.peerType = reader.int32();
4384
- break;
4385
- case /* string ice_candidate */ 2:
4386
- message.iceCandidate = reader.string();
4387
- break;
4388
- default:
4389
- let u = options.readUnknownField;
4390
- if (u === 'throw')
4391
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
4392
- let d = reader.skip(wireType);
4393
- if (u !== false)
4394
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
4395
- }
4396
- }
4397
- return message;
4398
- }
4399
- internalBinaryWrite(message, writer, options) {
4400
- /* stream.video.sfu.models.PeerType peer_type = 1; */
4401
- if (message.peerType !== 0)
4402
- writer.tag(1, WireType.Varint).int32(message.peerType);
4403
- /* string ice_candidate = 2; */
4404
- if (message.iceCandidate !== '')
4405
- writer.tag(2, WireType.LengthDelimited).string(message.iceCandidate);
4406
- let u = options.writeUnknownFields;
4407
- if (u !== false)
4408
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
4409
- return writer;
4410
- }
4411
1963
  }
4412
1964
  /**
4413
1965
  * @generated MessageType for protobuf message stream.video.sfu.event.ICETrickle
@@ -4425,41 +1977,6 @@ class ICERestart$Type extends MessageType {
4425
1977
  },
4426
1978
  ]);
4427
1979
  }
4428
- create(value) {
4429
- const message = globalThis.Object.create(this.messagePrototype);
4430
- message.peerType = 0;
4431
- if (value !== undefined)
4432
- reflectionMergePartial(this, message, value);
4433
- return message;
4434
- }
4435
- internalBinaryRead(reader, length, options, target) {
4436
- let message = target ?? this.create(), end = reader.pos + length;
4437
- while (reader.pos < end) {
4438
- let [fieldNo, wireType] = reader.tag();
4439
- switch (fieldNo) {
4440
- case /* stream.video.sfu.models.PeerType peer_type */ 1:
4441
- message.peerType = reader.int32();
4442
- break;
4443
- default:
4444
- let u = options.readUnknownField;
4445
- if (u === 'throw')
4446
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
4447
- let d = reader.skip(wireType);
4448
- if (u !== false)
4449
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
4450
- }
4451
- }
4452
- return message;
4453
- }
4454
- internalBinaryWrite(message, writer, options) {
4455
- /* stream.video.sfu.models.PeerType peer_type = 1; */
4456
- if (message.peerType !== 0)
4457
- writer.tag(1, WireType.Varint).int32(message.peerType);
4458
- let u = options.writeUnknownFields;
4459
- if (u !== false)
4460
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
4461
- return writer;
4462
- }
4463
1980
  }
4464
1981
  /**
4465
1982
  * @generated MessageType for protobuf message stream.video.sfu.event.ICERestart
@@ -4492,62 +2009,6 @@ class SfuRequest$Type extends MessageType {
4492
2009
  },
4493
2010
  ]);
4494
2011
  }
4495
- create(value) {
4496
- const message = globalThis.Object.create(this.messagePrototype);
4497
- message.requestPayload = { oneofKind: undefined };
4498
- if (value !== undefined)
4499
- reflectionMergePartial(this, message, value);
4500
- return message;
4501
- }
4502
- internalBinaryRead(reader, length, options, target) {
4503
- let message = target ?? this.create(), end = reader.pos + length;
4504
- while (reader.pos < end) {
4505
- let [fieldNo, wireType] = reader.tag();
4506
- switch (fieldNo) {
4507
- case /* stream.video.sfu.event.JoinRequest join_request */ 1:
4508
- message.requestPayload = {
4509
- oneofKind: 'joinRequest',
4510
- joinRequest: JoinRequest.internalBinaryRead(reader, reader.uint32(), options, message.requestPayload.joinRequest),
4511
- };
4512
- break;
4513
- case /* stream.video.sfu.event.HealthCheckRequest health_check_request */ 2:
4514
- message.requestPayload = {
4515
- oneofKind: 'healthCheckRequest',
4516
- healthCheckRequest: HealthCheckRequest.internalBinaryRead(reader, reader.uint32(), options, message.requestPayload.healthCheckRequest),
4517
- };
4518
- break;
4519
- case /* stream.video.sfu.event.LeaveCallRequest leave_call_request */ 3:
4520
- message.requestPayload = {
4521
- oneofKind: 'leaveCallRequest',
4522
- leaveCallRequest: LeaveCallRequest.internalBinaryRead(reader, reader.uint32(), options, message.requestPayload.leaveCallRequest),
4523
- };
4524
- break;
4525
- default:
4526
- let u = options.readUnknownField;
4527
- if (u === 'throw')
4528
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
4529
- let d = reader.skip(wireType);
4530
- if (u !== false)
4531
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
4532
- }
4533
- }
4534
- return message;
4535
- }
4536
- internalBinaryWrite(message, writer, options) {
4537
- /* stream.video.sfu.event.JoinRequest join_request = 1; */
4538
- if (message.requestPayload.oneofKind === 'joinRequest')
4539
- JoinRequest.internalBinaryWrite(message.requestPayload.joinRequest, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
4540
- /* stream.video.sfu.event.HealthCheckRequest health_check_request = 2; */
4541
- if (message.requestPayload.oneofKind === 'healthCheckRequest')
4542
- HealthCheckRequest.internalBinaryWrite(message.requestPayload.healthCheckRequest, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
4543
- /* stream.video.sfu.event.LeaveCallRequest leave_call_request = 3; */
4544
- if (message.requestPayload.oneofKind === 'leaveCallRequest')
4545
- LeaveCallRequest.internalBinaryWrite(message.requestPayload.leaveCallRequest, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
4546
- let u = options.writeUnknownFields;
4547
- if (u !== false)
4548
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
4549
- return writer;
4550
- }
4551
2012
  }
4552
2013
  /**
4553
2014
  * @generated MessageType for protobuf message stream.video.sfu.event.SfuRequest
@@ -4561,48 +2022,6 @@ class LeaveCallRequest$Type extends MessageType {
4561
2022
  { no: 2, name: 'reason', kind: 'scalar', T: 9 /*ScalarType.STRING*/ },
4562
2023
  ]);
4563
2024
  }
4564
- create(value) {
4565
- const message = globalThis.Object.create(this.messagePrototype);
4566
- message.sessionId = '';
4567
- message.reason = '';
4568
- if (value !== undefined)
4569
- reflectionMergePartial(this, message, value);
4570
- return message;
4571
- }
4572
- internalBinaryRead(reader, length, options, target) {
4573
- let message = target ?? this.create(), end = reader.pos + length;
4574
- while (reader.pos < end) {
4575
- let [fieldNo, wireType] = reader.tag();
4576
- switch (fieldNo) {
4577
- case /* string session_id */ 1:
4578
- message.sessionId = reader.string();
4579
- break;
4580
- case /* string reason */ 2:
4581
- message.reason = reader.string();
4582
- break;
4583
- default:
4584
- let u = options.readUnknownField;
4585
- if (u === 'throw')
4586
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
4587
- let d = reader.skip(wireType);
4588
- if (u !== false)
4589
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
4590
- }
4591
- }
4592
- return message;
4593
- }
4594
- internalBinaryWrite(message, writer, options) {
4595
- /* string session_id = 1; */
4596
- if (message.sessionId !== '')
4597
- writer.tag(1, WireType.LengthDelimited).string(message.sessionId);
4598
- /* string reason = 2; */
4599
- if (message.reason !== '')
4600
- writer.tag(2, WireType.LengthDelimited).string(message.reason);
4601
- let u = options.writeUnknownFields;
4602
- if (u !== false)
4603
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
4604
- return writer;
4605
- }
4606
2025
  }
4607
2026
  /**
4608
2027
  * @generated MessageType for protobuf message stream.video.sfu.event.LeaveCallRequest
@@ -4613,21 +2032,6 @@ class HealthCheckRequest$Type extends MessageType {
4613
2032
  constructor() {
4614
2033
  super('stream.video.sfu.event.HealthCheckRequest', []);
4615
2034
  }
4616
- create(value) {
4617
- const message = globalThis.Object.create(this.messagePrototype);
4618
- if (value !== undefined)
4619
- reflectionMergePartial(this, message, value);
4620
- return message;
4621
- }
4622
- internalBinaryRead(reader, length, options, target) {
4623
- return target ?? this.create();
4624
- }
4625
- internalBinaryWrite(message, writer, options) {
4626
- let u = options.writeUnknownFields;
4627
- if (u !== false)
4628
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
4629
- return writer;
4630
- }
4631
2035
  }
4632
2036
  /**
4633
2037
  * @generated MessageType for protobuf message stream.video.sfu.event.HealthCheckRequest
@@ -4645,40 +2049,6 @@ class HealthCheckResponse$Type extends MessageType {
4645
2049
  },
4646
2050
  ]);
4647
2051
  }
4648
- create(value) {
4649
- const message = globalThis.Object.create(this.messagePrototype);
4650
- if (value !== undefined)
4651
- reflectionMergePartial(this, message, value);
4652
- return message;
4653
- }
4654
- internalBinaryRead(reader, length, options, target) {
4655
- let message = target ?? this.create(), end = reader.pos + length;
4656
- while (reader.pos < end) {
4657
- let [fieldNo, wireType] = reader.tag();
4658
- switch (fieldNo) {
4659
- case /* stream.video.sfu.models.ParticipantCount participant_count */ 1:
4660
- message.participantCount = ParticipantCount.internalBinaryRead(reader, reader.uint32(), options, message.participantCount);
4661
- break;
4662
- default:
4663
- let u = options.readUnknownField;
4664
- if (u === 'throw')
4665
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
4666
- let d = reader.skip(wireType);
4667
- if (u !== false)
4668
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
4669
- }
4670
- }
4671
- return message;
4672
- }
4673
- internalBinaryWrite(message, writer, options) {
4674
- /* stream.video.sfu.models.ParticipantCount participant_count = 1; */
4675
- if (message.participantCount)
4676
- ParticipantCount.internalBinaryWrite(message.participantCount, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
4677
- let u = options.writeUnknownFields;
4678
- if (u !== false)
4679
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
4680
- return writer;
4681
- }
4682
2052
  }
4683
2053
  /**
4684
2054
  * @generated MessageType for protobuf message stream.video.sfu.event.HealthCheckResponse
@@ -4703,61 +2073,6 @@ class TrackPublished$Type extends MessageType {
4703
2073
  { no: 4, name: 'participant', kind: 'message', T: () => Participant },
4704
2074
  ]);
4705
2075
  }
4706
- create(value) {
4707
- const message = globalThis.Object.create(this.messagePrototype);
4708
- message.userId = '';
4709
- message.sessionId = '';
4710
- message.type = 0;
4711
- if (value !== undefined)
4712
- reflectionMergePartial(this, message, value);
4713
- return message;
4714
- }
4715
- internalBinaryRead(reader, length, options, target) {
4716
- let message = target ?? this.create(), end = reader.pos + length;
4717
- while (reader.pos < end) {
4718
- let [fieldNo, wireType] = reader.tag();
4719
- switch (fieldNo) {
4720
- case /* string user_id */ 1:
4721
- message.userId = reader.string();
4722
- break;
4723
- case /* string session_id */ 2:
4724
- message.sessionId = reader.string();
4725
- break;
4726
- case /* stream.video.sfu.models.TrackType type */ 3:
4727
- message.type = reader.int32();
4728
- break;
4729
- case /* stream.video.sfu.models.Participant participant */ 4:
4730
- message.participant = Participant.internalBinaryRead(reader, reader.uint32(), options, message.participant);
4731
- break;
4732
- default:
4733
- let u = options.readUnknownField;
4734
- if (u === 'throw')
4735
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
4736
- let d = reader.skip(wireType);
4737
- if (u !== false)
4738
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
4739
- }
4740
- }
4741
- return message;
4742
- }
4743
- internalBinaryWrite(message, writer, options) {
4744
- /* string user_id = 1; */
4745
- if (message.userId !== '')
4746
- writer.tag(1, WireType.LengthDelimited).string(message.userId);
4747
- /* string session_id = 2; */
4748
- if (message.sessionId !== '')
4749
- writer.tag(2, WireType.LengthDelimited).string(message.sessionId);
4750
- /* stream.video.sfu.models.TrackType type = 3; */
4751
- if (message.type !== 0)
4752
- writer.tag(3, WireType.Varint).int32(message.type);
4753
- /* stream.video.sfu.models.Participant participant = 4; */
4754
- if (message.participant)
4755
- Participant.internalBinaryWrite(message.participant, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
4756
- let u = options.writeUnknownFields;
4757
- if (u !== false)
4758
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
4759
- return writer;
4760
- }
4761
2076
  }
4762
2077
  /**
4763
2078
  * @generated MessageType for protobuf message stream.video.sfu.event.TrackPublished
@@ -4792,68 +2107,6 @@ class TrackUnpublished$Type extends MessageType {
4792
2107
  { no: 5, name: 'participant', kind: 'message', T: () => Participant },
4793
2108
  ]);
4794
2109
  }
4795
- create(value) {
4796
- const message = globalThis.Object.create(this.messagePrototype);
4797
- message.userId = '';
4798
- message.sessionId = '';
4799
- message.type = 0;
4800
- message.cause = 0;
4801
- if (value !== undefined)
4802
- reflectionMergePartial(this, message, value);
4803
- return message;
4804
- }
4805
- internalBinaryRead(reader, length, options, target) {
4806
- let message = target ?? this.create(), end = reader.pos + length;
4807
- while (reader.pos < end) {
4808
- let [fieldNo, wireType] = reader.tag();
4809
- switch (fieldNo) {
4810
- case /* string user_id */ 1:
4811
- message.userId = reader.string();
4812
- break;
4813
- case /* string session_id */ 2:
4814
- message.sessionId = reader.string();
4815
- break;
4816
- case /* stream.video.sfu.models.TrackType type */ 3:
4817
- message.type = reader.int32();
4818
- break;
4819
- case /* stream.video.sfu.models.TrackUnpublishReason cause */ 4:
4820
- message.cause = reader.int32();
4821
- break;
4822
- case /* stream.video.sfu.models.Participant participant */ 5:
4823
- message.participant = Participant.internalBinaryRead(reader, reader.uint32(), options, message.participant);
4824
- break;
4825
- default:
4826
- let u = options.readUnknownField;
4827
- if (u === 'throw')
4828
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
4829
- let d = reader.skip(wireType);
4830
- if (u !== false)
4831
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
4832
- }
4833
- }
4834
- return message;
4835
- }
4836
- internalBinaryWrite(message, writer, options) {
4837
- /* string user_id = 1; */
4838
- if (message.userId !== '')
4839
- writer.tag(1, WireType.LengthDelimited).string(message.userId);
4840
- /* string session_id = 2; */
4841
- if (message.sessionId !== '')
4842
- writer.tag(2, WireType.LengthDelimited).string(message.sessionId);
4843
- /* stream.video.sfu.models.TrackType type = 3; */
4844
- if (message.type !== 0)
4845
- writer.tag(3, WireType.Varint).int32(message.type);
4846
- /* stream.video.sfu.models.TrackUnpublishReason cause = 4; */
4847
- if (message.cause !== 0)
4848
- writer.tag(4, WireType.Varint).int32(message.cause);
4849
- /* stream.video.sfu.models.Participant participant = 5; */
4850
- if (message.participant)
4851
- Participant.internalBinaryWrite(message.participant, writer.tag(5, WireType.LengthDelimited).fork(), options).join();
4852
- let u = options.writeUnknownFields;
4853
- if (u !== false)
4854
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
4855
- return writer;
4856
- }
4857
2110
  }
4858
2111
  /**
4859
2112
  * @generated MessageType for protobuf message stream.video.sfu.event.TrackUnpublished
@@ -4892,80 +2145,6 @@ class JoinRequest$Type extends MessageType {
4892
2145
  },
4893
2146
  ]);
4894
2147
  }
4895
- create(value) {
4896
- const message = globalThis.Object.create(this.messagePrototype);
4897
- message.token = '';
4898
- message.sessionId = '';
4899
- message.subscriberSdp = '';
4900
- message.fastReconnect = false;
4901
- if (value !== undefined)
4902
- reflectionMergePartial(this, message, value);
4903
- return message;
4904
- }
4905
- internalBinaryRead(reader, length, options, target) {
4906
- let message = target ?? this.create(), end = reader.pos + length;
4907
- while (reader.pos < end) {
4908
- let [fieldNo, wireType] = reader.tag();
4909
- switch (fieldNo) {
4910
- case /* string token */ 1:
4911
- message.token = reader.string();
4912
- break;
4913
- case /* string session_id */ 2:
4914
- message.sessionId = reader.string();
4915
- break;
4916
- case /* string subscriber_sdp */ 3:
4917
- message.subscriberSdp = reader.string();
4918
- break;
4919
- case /* stream.video.sfu.models.ClientDetails client_details */ 4:
4920
- message.clientDetails = ClientDetails.internalBinaryRead(reader, reader.uint32(), options, message.clientDetails);
4921
- break;
4922
- case /* stream.video.sfu.event.Migration migration = 5 [deprecated = true];*/ 5:
4923
- message.migration = Migration.internalBinaryRead(reader, reader.uint32(), options, message.migration);
4924
- break;
4925
- case /* bool fast_reconnect = 6 [deprecated = true];*/ 6:
4926
- message.fastReconnect = reader.bool();
4927
- break;
4928
- case /* stream.video.sfu.event.ReconnectDetails reconnect_details */ 7:
4929
- message.reconnectDetails = ReconnectDetails.internalBinaryRead(reader, reader.uint32(), options, message.reconnectDetails);
4930
- break;
4931
- default:
4932
- let u = options.readUnknownField;
4933
- if (u === 'throw')
4934
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
4935
- let d = reader.skip(wireType);
4936
- if (u !== false)
4937
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
4938
- }
4939
- }
4940
- return message;
4941
- }
4942
- internalBinaryWrite(message, writer, options) {
4943
- /* string token = 1; */
4944
- if (message.token !== '')
4945
- writer.tag(1, WireType.LengthDelimited).string(message.token);
4946
- /* string session_id = 2; */
4947
- if (message.sessionId !== '')
4948
- writer.tag(2, WireType.LengthDelimited).string(message.sessionId);
4949
- /* string subscriber_sdp = 3; */
4950
- if (message.subscriberSdp !== '')
4951
- writer.tag(3, WireType.LengthDelimited).string(message.subscriberSdp);
4952
- /* stream.video.sfu.models.ClientDetails client_details = 4; */
4953
- if (message.clientDetails)
4954
- ClientDetails.internalBinaryWrite(message.clientDetails, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
4955
- /* stream.video.sfu.event.Migration migration = 5 [deprecated = true]; */
4956
- if (message.migration)
4957
- Migration.internalBinaryWrite(message.migration, writer.tag(5, WireType.LengthDelimited).fork(), options).join();
4958
- /* bool fast_reconnect = 6 [deprecated = true]; */
4959
- if (message.fastReconnect !== false)
4960
- writer.tag(6, WireType.Varint).bool(message.fastReconnect);
4961
- /* stream.video.sfu.event.ReconnectDetails reconnect_details = 7; */
4962
- if (message.reconnectDetails)
4963
- ReconnectDetails.internalBinaryWrite(message.reconnectDetails, writer.tag(7, WireType.LengthDelimited).fork(), options).join();
4964
- let u = options.writeUnknownFields;
4965
- if (u !== false)
4966
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
4967
- return writer;
4968
- }
4969
2148
  }
4970
2149
  /**
4971
2150
  * @generated MessageType for protobuf message stream.video.sfu.event.JoinRequest
@@ -5019,76 +2198,6 @@ class ReconnectDetails$Type extends MessageType {
5019
2198
  },
5020
2199
  ]);
5021
2200
  }
5022
- create(value) {
5023
- const message = globalThis.Object.create(this.messagePrototype);
5024
- message.strategy = 0;
5025
- message.announcedTracks = [];
5026
- message.subscriptions = [];
5027
- message.reconnectAttempt = 0;
5028
- message.fromSfuId = '';
5029
- message.previousSessionId = '';
5030
- if (value !== undefined)
5031
- reflectionMergePartial(this, message, value);
5032
- return message;
5033
- }
5034
- internalBinaryRead(reader, length, options, target) {
5035
- let message = target ?? this.create(), end = reader.pos + length;
5036
- while (reader.pos < end) {
5037
- let [fieldNo, wireType] = reader.tag();
5038
- switch (fieldNo) {
5039
- case /* stream.video.sfu.models.WebsocketReconnectStrategy strategy */ 1:
5040
- message.strategy = reader.int32();
5041
- break;
5042
- case /* repeated stream.video.sfu.models.TrackInfo announced_tracks */ 3:
5043
- message.announcedTracks.push(TrackInfo.internalBinaryRead(reader, reader.uint32(), options));
5044
- break;
5045
- case /* repeated stream.video.sfu.signal.TrackSubscriptionDetails subscriptions */ 4:
5046
- message.subscriptions.push(TrackSubscriptionDetails.internalBinaryRead(reader, reader.uint32(), options));
5047
- break;
5048
- case /* uint32 reconnect_attempt */ 5:
5049
- message.reconnectAttempt = reader.uint32();
5050
- break;
5051
- case /* string from_sfu_id */ 6:
5052
- message.fromSfuId = reader.string();
5053
- break;
5054
- case /* string previous_session_id */ 7:
5055
- message.previousSessionId = reader.string();
5056
- break;
5057
- default:
5058
- let u = options.readUnknownField;
5059
- if (u === 'throw')
5060
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
5061
- let d = reader.skip(wireType);
5062
- if (u !== false)
5063
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
5064
- }
5065
- }
5066
- return message;
5067
- }
5068
- internalBinaryWrite(message, writer, options) {
5069
- /* stream.video.sfu.models.WebsocketReconnectStrategy strategy = 1; */
5070
- if (message.strategy !== 0)
5071
- writer.tag(1, WireType.Varint).int32(message.strategy);
5072
- /* repeated stream.video.sfu.models.TrackInfo announced_tracks = 3; */
5073
- for (let i = 0; i < message.announcedTracks.length; i++)
5074
- TrackInfo.internalBinaryWrite(message.announcedTracks[i], writer.tag(3, WireType.LengthDelimited).fork(), options).join();
5075
- /* repeated stream.video.sfu.signal.TrackSubscriptionDetails subscriptions = 4; */
5076
- for (let i = 0; i < message.subscriptions.length; i++)
5077
- TrackSubscriptionDetails.internalBinaryWrite(message.subscriptions[i], writer.tag(4, WireType.LengthDelimited).fork(), options).join();
5078
- /* uint32 reconnect_attempt = 5; */
5079
- if (message.reconnectAttempt !== 0)
5080
- writer.tag(5, WireType.Varint).uint32(message.reconnectAttempt);
5081
- /* string from_sfu_id = 6; */
5082
- if (message.fromSfuId !== '')
5083
- writer.tag(6, WireType.LengthDelimited).string(message.fromSfuId);
5084
- /* string previous_session_id = 7; */
5085
- if (message.previousSessionId !== '')
5086
- writer.tag(7, WireType.LengthDelimited).string(message.previousSessionId);
5087
- let u = options.writeUnknownFields;
5088
- if (u !== false)
5089
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
5090
- return writer;
5091
- }
5092
2201
  }
5093
2202
  /**
5094
2203
  * @generated MessageType for protobuf message stream.video.sfu.event.ReconnectDetails
@@ -5120,55 +2229,6 @@ class Migration$Type extends MessageType {
5120
2229
  },
5121
2230
  ]);
5122
2231
  }
5123
- create(value) {
5124
- const message = globalThis.Object.create(this.messagePrototype);
5125
- message.fromSfuId = '';
5126
- message.announcedTracks = [];
5127
- message.subscriptions = [];
5128
- if (value !== undefined)
5129
- reflectionMergePartial(this, message, value);
5130
- return message;
5131
- }
5132
- internalBinaryRead(reader, length, options, target) {
5133
- let message = target ?? this.create(), end = reader.pos + length;
5134
- while (reader.pos < end) {
5135
- let [fieldNo, wireType] = reader.tag();
5136
- switch (fieldNo) {
5137
- case /* string from_sfu_id */ 1:
5138
- message.fromSfuId = reader.string();
5139
- break;
5140
- case /* repeated stream.video.sfu.models.TrackInfo announced_tracks */ 2:
5141
- message.announcedTracks.push(TrackInfo.internalBinaryRead(reader, reader.uint32(), options));
5142
- break;
5143
- case /* repeated stream.video.sfu.signal.TrackSubscriptionDetails subscriptions */ 3:
5144
- message.subscriptions.push(TrackSubscriptionDetails.internalBinaryRead(reader, reader.uint32(), options));
5145
- break;
5146
- default:
5147
- let u = options.readUnknownField;
5148
- if (u === 'throw')
5149
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
5150
- let d = reader.skip(wireType);
5151
- if (u !== false)
5152
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
5153
- }
5154
- }
5155
- return message;
5156
- }
5157
- internalBinaryWrite(message, writer, options) {
5158
- /* string from_sfu_id = 1; */
5159
- if (message.fromSfuId !== '')
5160
- writer.tag(1, WireType.LengthDelimited).string(message.fromSfuId);
5161
- /* repeated stream.video.sfu.models.TrackInfo announced_tracks = 2; */
5162
- for (let i = 0; i < message.announcedTracks.length; i++)
5163
- TrackInfo.internalBinaryWrite(message.announcedTracks[i], writer.tag(2, WireType.LengthDelimited).fork(), options).join();
5164
- /* repeated stream.video.sfu.signal.TrackSubscriptionDetails subscriptions = 3; */
5165
- for (let i = 0; i < message.subscriptions.length; i++)
5166
- TrackSubscriptionDetails.internalBinaryWrite(message.subscriptions[i], writer.tag(3, WireType.LengthDelimited).fork(), options).join();
5167
- let u = options.writeUnknownFields;
5168
- if (u !== false)
5169
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
5170
- return writer;
5171
- }
5172
2232
  }
5173
2233
  /**
5174
2234
  * @generated MessageType for protobuf message stream.video.sfu.event.Migration
@@ -5188,56 +2248,6 @@ class JoinResponse$Type extends MessageType {
5188
2248
  },
5189
2249
  ]);
5190
2250
  }
5191
- create(value) {
5192
- const message = globalThis.Object.create(this.messagePrototype);
5193
- message.reconnected = false;
5194
- message.fastReconnectDeadlineSeconds = 0;
5195
- if (value !== undefined)
5196
- reflectionMergePartial(this, message, value);
5197
- return message;
5198
- }
5199
- internalBinaryRead(reader, length, options, target) {
5200
- let message = target ?? this.create(), end = reader.pos + length;
5201
- while (reader.pos < end) {
5202
- let [fieldNo, wireType] = reader.tag();
5203
- switch (fieldNo) {
5204
- case /* stream.video.sfu.models.CallState call_state */ 1:
5205
- message.callState = CallState$1.internalBinaryRead(reader, reader.uint32(), options, message.callState);
5206
- break;
5207
- case /* bool reconnected */ 2:
5208
- message.reconnected = reader.bool();
5209
- break;
5210
- case /* int32 fast_reconnect_deadline_seconds */ 3:
5211
- message.fastReconnectDeadlineSeconds = reader.int32();
5212
- break;
5213
- default:
5214
- let u = options.readUnknownField;
5215
- if (u === 'throw')
5216
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
5217
- let d = reader.skip(wireType);
5218
- if (u !== false)
5219
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
5220
- }
5221
- }
5222
- return message;
5223
- }
5224
- internalBinaryWrite(message, writer, options) {
5225
- /* stream.video.sfu.models.CallState call_state = 1; */
5226
- if (message.callState)
5227
- CallState$1.internalBinaryWrite(message.callState, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
5228
- /* bool reconnected = 2; */
5229
- if (message.reconnected !== false)
5230
- writer.tag(2, WireType.Varint).bool(message.reconnected);
5231
- /* int32 fast_reconnect_deadline_seconds = 3; */
5232
- if (message.fastReconnectDeadlineSeconds !== 0)
5233
- writer
5234
- .tag(3, WireType.Varint)
5235
- .int32(message.fastReconnectDeadlineSeconds);
5236
- let u = options.writeUnknownFields;
5237
- if (u !== false)
5238
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
5239
- return writer;
5240
- }
5241
2251
  }
5242
2252
  /**
5243
2253
  * @generated MessageType for protobuf message stream.video.sfu.event.JoinResponse
@@ -5251,47 +2261,6 @@ class ParticipantJoined$Type extends MessageType {
5251
2261
  { no: 2, name: 'participant', kind: 'message', T: () => Participant },
5252
2262
  ]);
5253
2263
  }
5254
- create(value) {
5255
- const message = globalThis.Object.create(this.messagePrototype);
5256
- message.callCid = '';
5257
- if (value !== undefined)
5258
- reflectionMergePartial(this, message, value);
5259
- return message;
5260
- }
5261
- internalBinaryRead(reader, length, options, target) {
5262
- let message = target ?? this.create(), end = reader.pos + length;
5263
- while (reader.pos < end) {
5264
- let [fieldNo, wireType] = reader.tag();
5265
- switch (fieldNo) {
5266
- case /* string call_cid */ 1:
5267
- message.callCid = reader.string();
5268
- break;
5269
- case /* stream.video.sfu.models.Participant participant */ 2:
5270
- message.participant = Participant.internalBinaryRead(reader, reader.uint32(), options, message.participant);
5271
- break;
5272
- default:
5273
- let u = options.readUnknownField;
5274
- if (u === 'throw')
5275
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
5276
- let d = reader.skip(wireType);
5277
- if (u !== false)
5278
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
5279
- }
5280
- }
5281
- return message;
5282
- }
5283
- internalBinaryWrite(message, writer, options) {
5284
- /* string call_cid = 1; */
5285
- if (message.callCid !== '')
5286
- writer.tag(1, WireType.LengthDelimited).string(message.callCid);
5287
- /* stream.video.sfu.models.Participant participant = 2; */
5288
- if (message.participant)
5289
- Participant.internalBinaryWrite(message.participant, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
5290
- let u = options.writeUnknownFields;
5291
- if (u !== false)
5292
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
5293
- return writer;
5294
- }
5295
2264
  }
5296
2265
  /**
5297
2266
  * @generated MessageType for protobuf message stream.video.sfu.event.ParticipantJoined
@@ -5305,47 +2274,6 @@ class ParticipantLeft$Type extends MessageType {
5305
2274
  { no: 2, name: 'participant', kind: 'message', T: () => Participant },
5306
2275
  ]);
5307
2276
  }
5308
- create(value) {
5309
- const message = globalThis.Object.create(this.messagePrototype);
5310
- message.callCid = '';
5311
- if (value !== undefined)
5312
- reflectionMergePartial(this, message, value);
5313
- return message;
5314
- }
5315
- internalBinaryRead(reader, length, options, target) {
5316
- let message = target ?? this.create(), end = reader.pos + length;
5317
- while (reader.pos < end) {
5318
- let [fieldNo, wireType] = reader.tag();
5319
- switch (fieldNo) {
5320
- case /* string call_cid */ 1:
5321
- message.callCid = reader.string();
5322
- break;
5323
- case /* stream.video.sfu.models.Participant participant */ 2:
5324
- message.participant = Participant.internalBinaryRead(reader, reader.uint32(), options, message.participant);
5325
- break;
5326
- default:
5327
- let u = options.readUnknownField;
5328
- if (u === 'throw')
5329
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
5330
- let d = reader.skip(wireType);
5331
- if (u !== false)
5332
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
5333
- }
5334
- }
5335
- return message;
5336
- }
5337
- internalBinaryWrite(message, writer, options) {
5338
- /* string call_cid = 1; */
5339
- if (message.callCid !== '')
5340
- writer.tag(1, WireType.LengthDelimited).string(message.callCid);
5341
- /* stream.video.sfu.models.Participant participant = 2; */
5342
- if (message.participant)
5343
- Participant.internalBinaryWrite(message.participant, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
5344
- let u = options.writeUnknownFields;
5345
- if (u !== false)
5346
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
5347
- return writer;
5348
- }
5349
2277
  }
5350
2278
  /**
5351
2279
  * @generated MessageType for protobuf message stream.video.sfu.event.ParticipantLeft
@@ -5359,47 +2287,6 @@ class ParticipantUpdated$Type extends MessageType {
5359
2287
  { no: 2, name: 'participant', kind: 'message', T: () => Participant },
5360
2288
  ]);
5361
2289
  }
5362
- create(value) {
5363
- const message = globalThis.Object.create(this.messagePrototype);
5364
- message.callCid = '';
5365
- if (value !== undefined)
5366
- reflectionMergePartial(this, message, value);
5367
- return message;
5368
- }
5369
- internalBinaryRead(reader, length, options, target) {
5370
- let message = target ?? this.create(), end = reader.pos + length;
5371
- while (reader.pos < end) {
5372
- let [fieldNo, wireType] = reader.tag();
5373
- switch (fieldNo) {
5374
- case /* string call_cid */ 1:
5375
- message.callCid = reader.string();
5376
- break;
5377
- case /* stream.video.sfu.models.Participant participant */ 2:
5378
- message.participant = Participant.internalBinaryRead(reader, reader.uint32(), options, message.participant);
5379
- break;
5380
- default:
5381
- let u = options.readUnknownField;
5382
- if (u === 'throw')
5383
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
5384
- let d = reader.skip(wireType);
5385
- if (u !== false)
5386
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
5387
- }
5388
- }
5389
- return message;
5390
- }
5391
- internalBinaryWrite(message, writer, options) {
5392
- /* string call_cid = 1; */
5393
- if (message.callCid !== '')
5394
- writer.tag(1, WireType.LengthDelimited).string(message.callCid);
5395
- /* stream.video.sfu.models.Participant participant = 2; */
5396
- if (message.participant)
5397
- Participant.internalBinaryWrite(message.participant, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
5398
- let u = options.writeUnknownFields;
5399
- if (u !== false)
5400
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
5401
- return writer;
5402
- }
5403
2290
  }
5404
2291
  /**
5405
2292
  * @generated MessageType for protobuf message stream.video.sfu.event.ParticipantUpdated
@@ -5413,48 +2300,6 @@ class SubscriberOffer$Type extends MessageType {
5413
2300
  { no: 2, name: 'sdp', kind: 'scalar', T: 9 /*ScalarType.STRING*/ },
5414
2301
  ]);
5415
2302
  }
5416
- create(value) {
5417
- const message = globalThis.Object.create(this.messagePrototype);
5418
- message.iceRestart = false;
5419
- message.sdp = '';
5420
- if (value !== undefined)
5421
- reflectionMergePartial(this, message, value);
5422
- return message;
5423
- }
5424
- internalBinaryRead(reader, length, options, target) {
5425
- let message = target ?? this.create(), end = reader.pos + length;
5426
- while (reader.pos < end) {
5427
- let [fieldNo, wireType] = reader.tag();
5428
- switch (fieldNo) {
5429
- case /* bool ice_restart */ 1:
5430
- message.iceRestart = reader.bool();
5431
- break;
5432
- case /* string sdp */ 2:
5433
- message.sdp = reader.string();
5434
- break;
5435
- default:
5436
- let u = options.readUnknownField;
5437
- if (u === 'throw')
5438
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
5439
- let d = reader.skip(wireType);
5440
- if (u !== false)
5441
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
5442
- }
5443
- }
5444
- return message;
5445
- }
5446
- internalBinaryWrite(message, writer, options) {
5447
- /* bool ice_restart = 1; */
5448
- if (message.iceRestart !== false)
5449
- writer.tag(1, WireType.Varint).bool(message.iceRestart);
5450
- /* string sdp = 2; */
5451
- if (message.sdp !== '')
5452
- writer.tag(2, WireType.LengthDelimited).string(message.sdp);
5453
- let u = options.writeUnknownFields;
5454
- if (u !== false)
5455
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
5456
- return writer;
5457
- }
5458
2303
  }
5459
2304
  /**
5460
2305
  * @generated MessageType for protobuf message stream.video.sfu.event.SubscriberOffer
@@ -5467,41 +2312,6 @@ class PublisherAnswer$Type extends MessageType {
5467
2312
  { no: 1, name: 'sdp', kind: 'scalar', T: 9 /*ScalarType.STRING*/ },
5468
2313
  ]);
5469
2314
  }
5470
- create(value) {
5471
- const message = globalThis.Object.create(this.messagePrototype);
5472
- message.sdp = '';
5473
- if (value !== undefined)
5474
- reflectionMergePartial(this, message, value);
5475
- return message;
5476
- }
5477
- internalBinaryRead(reader, length, options, target) {
5478
- let message = target ?? this.create(), end = reader.pos + length;
5479
- while (reader.pos < end) {
5480
- let [fieldNo, wireType] = reader.tag();
5481
- switch (fieldNo) {
5482
- case /* string sdp */ 1:
5483
- message.sdp = reader.string();
5484
- break;
5485
- default:
5486
- let u = options.readUnknownField;
5487
- if (u === 'throw')
5488
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
5489
- let d = reader.skip(wireType);
5490
- if (u !== false)
5491
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
5492
- }
5493
- }
5494
- return message;
5495
- }
5496
- internalBinaryWrite(message, writer, options) {
5497
- /* string sdp = 1; */
5498
- if (message.sdp !== '')
5499
- writer.tag(1, WireType.LengthDelimited).string(message.sdp);
5500
- let u = options.writeUnknownFields;
5501
- if (u !== false)
5502
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
5503
- return writer;
5504
- }
5505
2315
  }
5506
2316
  /**
5507
2317
  * @generated MessageType for protobuf message stream.video.sfu.event.PublisherAnswer
@@ -5520,41 +2330,6 @@ class ConnectionQualityChanged$Type extends MessageType {
5520
2330
  },
5521
2331
  ]);
5522
2332
  }
5523
- create(value) {
5524
- const message = globalThis.Object.create(this.messagePrototype);
5525
- message.connectionQualityUpdates = [];
5526
- if (value !== undefined)
5527
- reflectionMergePartial(this, message, value);
5528
- return message;
5529
- }
5530
- internalBinaryRead(reader, length, options, target) {
5531
- let message = target ?? this.create(), end = reader.pos + length;
5532
- while (reader.pos < end) {
5533
- let [fieldNo, wireType] = reader.tag();
5534
- switch (fieldNo) {
5535
- case /* repeated stream.video.sfu.event.ConnectionQualityInfo connection_quality_updates */ 1:
5536
- message.connectionQualityUpdates.push(ConnectionQualityInfo.internalBinaryRead(reader, reader.uint32(), options));
5537
- break;
5538
- default:
5539
- let u = options.readUnknownField;
5540
- if (u === 'throw')
5541
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
5542
- let d = reader.skip(wireType);
5543
- if (u !== false)
5544
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
5545
- }
5546
- }
5547
- return message;
5548
- }
5549
- internalBinaryWrite(message, writer, options) {
5550
- /* repeated stream.video.sfu.event.ConnectionQualityInfo connection_quality_updates = 1; */
5551
- for (let i = 0; i < message.connectionQualityUpdates.length; i++)
5552
- ConnectionQualityInfo.internalBinaryWrite(message.connectionQualityUpdates[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join();
5553
- let u = options.writeUnknownFields;
5554
- if (u !== false)
5555
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
5556
- return writer;
5557
- }
5558
2333
  }
5559
2334
  /**
5560
2335
  * @generated MessageType for protobuf message stream.video.sfu.event.ConnectionQualityChanged
@@ -5578,55 +2353,6 @@ class ConnectionQualityInfo$Type extends MessageType {
5578
2353
  },
5579
2354
  ]);
5580
2355
  }
5581
- create(value) {
5582
- const message = globalThis.Object.create(this.messagePrototype);
5583
- message.userId = '';
5584
- message.sessionId = '';
5585
- message.connectionQuality = 0;
5586
- if (value !== undefined)
5587
- reflectionMergePartial(this, message, value);
5588
- return message;
5589
- }
5590
- internalBinaryRead(reader, length, options, target) {
5591
- let message = target ?? this.create(), end = reader.pos + length;
5592
- while (reader.pos < end) {
5593
- let [fieldNo, wireType] = reader.tag();
5594
- switch (fieldNo) {
5595
- case /* string user_id */ 1:
5596
- message.userId = reader.string();
5597
- break;
5598
- case /* string session_id */ 2:
5599
- message.sessionId = reader.string();
5600
- break;
5601
- case /* stream.video.sfu.models.ConnectionQuality connection_quality */ 3:
5602
- message.connectionQuality = reader.int32();
5603
- break;
5604
- default:
5605
- let u = options.readUnknownField;
5606
- if (u === 'throw')
5607
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
5608
- let d = reader.skip(wireType);
5609
- if (u !== false)
5610
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
5611
- }
5612
- }
5613
- return message;
5614
- }
5615
- internalBinaryWrite(message, writer, options) {
5616
- /* string user_id = 1; */
5617
- if (message.userId !== '')
5618
- writer.tag(1, WireType.LengthDelimited).string(message.userId);
5619
- /* string session_id = 2; */
5620
- if (message.sessionId !== '')
5621
- writer.tag(2, WireType.LengthDelimited).string(message.sessionId);
5622
- /* stream.video.sfu.models.ConnectionQuality connection_quality = 3; */
5623
- if (message.connectionQuality !== 0)
5624
- writer.tag(3, WireType.Varint).int32(message.connectionQuality);
5625
- let u = options.writeUnknownFields;
5626
- if (u !== false)
5627
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
5628
- return writer;
5629
- }
5630
2356
  }
5631
2357
  /**
5632
2358
  * @generated MessageType for protobuf message stream.video.sfu.event.ConnectionQualityInfo
@@ -5640,48 +2366,6 @@ class DominantSpeakerChanged$Type extends MessageType {
5640
2366
  { no: 2, name: 'session_id', kind: 'scalar', T: 9 /*ScalarType.STRING*/ },
5641
2367
  ]);
5642
2368
  }
5643
- create(value) {
5644
- const message = globalThis.Object.create(this.messagePrototype);
5645
- message.userId = '';
5646
- message.sessionId = '';
5647
- if (value !== undefined)
5648
- reflectionMergePartial(this, message, value);
5649
- return message;
5650
- }
5651
- internalBinaryRead(reader, length, options, target) {
5652
- let message = target ?? this.create(), end = reader.pos + length;
5653
- while (reader.pos < end) {
5654
- let [fieldNo, wireType] = reader.tag();
5655
- switch (fieldNo) {
5656
- case /* string user_id */ 1:
5657
- message.userId = reader.string();
5658
- break;
5659
- case /* string session_id */ 2:
5660
- message.sessionId = reader.string();
5661
- break;
5662
- default:
5663
- let u = options.readUnknownField;
5664
- if (u === 'throw')
5665
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
5666
- let d = reader.skip(wireType);
5667
- if (u !== false)
5668
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
5669
- }
5670
- }
5671
- return message;
5672
- }
5673
- internalBinaryWrite(message, writer, options) {
5674
- /* string user_id = 1; */
5675
- if (message.userId !== '')
5676
- writer.tag(1, WireType.LengthDelimited).string(message.userId);
5677
- /* string session_id = 2; */
5678
- if (message.sessionId !== '')
5679
- writer.tag(2, WireType.LengthDelimited).string(message.sessionId);
5680
- let u = options.writeUnknownFields;
5681
- if (u !== false)
5682
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
5683
- return writer;
5684
- }
5685
2369
  }
5686
2370
  /**
5687
2371
  * @generated MessageType for protobuf message stream.video.sfu.event.DominantSpeakerChanged
@@ -5697,62 +2381,6 @@ class AudioLevel$Type extends MessageType {
5697
2381
  { no: 4, name: 'is_speaking', kind: 'scalar', T: 8 /*ScalarType.BOOL*/ },
5698
2382
  ]);
5699
2383
  }
5700
- create(value) {
5701
- const message = globalThis.Object.create(this.messagePrototype);
5702
- message.userId = '';
5703
- message.sessionId = '';
5704
- message.level = 0;
5705
- message.isSpeaking = false;
5706
- if (value !== undefined)
5707
- reflectionMergePartial(this, message, value);
5708
- return message;
5709
- }
5710
- internalBinaryRead(reader, length, options, target) {
5711
- let message = target ?? this.create(), end = reader.pos + length;
5712
- while (reader.pos < end) {
5713
- let [fieldNo, wireType] = reader.tag();
5714
- switch (fieldNo) {
5715
- case /* string user_id */ 1:
5716
- message.userId = reader.string();
5717
- break;
5718
- case /* string session_id */ 2:
5719
- message.sessionId = reader.string();
5720
- break;
5721
- case /* float level */ 3:
5722
- message.level = reader.float();
5723
- break;
5724
- case /* bool is_speaking */ 4:
5725
- message.isSpeaking = reader.bool();
5726
- break;
5727
- default:
5728
- let u = options.readUnknownField;
5729
- if (u === 'throw')
5730
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
5731
- let d = reader.skip(wireType);
5732
- if (u !== false)
5733
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
5734
- }
5735
- }
5736
- return message;
5737
- }
5738
- internalBinaryWrite(message, writer, options) {
5739
- /* string user_id = 1; */
5740
- if (message.userId !== '')
5741
- writer.tag(1, WireType.LengthDelimited).string(message.userId);
5742
- /* string session_id = 2; */
5743
- if (message.sessionId !== '')
5744
- writer.tag(2, WireType.LengthDelimited).string(message.sessionId);
5745
- /* float level = 3; */
5746
- if (message.level !== 0)
5747
- writer.tag(3, WireType.Bit32).float(message.level);
5748
- /* bool is_speaking = 4; */
5749
- if (message.isSpeaking !== false)
5750
- writer.tag(4, WireType.Varint).bool(message.isSpeaking);
5751
- let u = options.writeUnknownFields;
5752
- if (u !== false)
5753
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
5754
- return writer;
5755
- }
5756
2384
  }
5757
2385
  /**
5758
2386
  * @generated MessageType for protobuf message stream.video.sfu.event.AudioLevel
@@ -5771,41 +2399,6 @@ class AudioLevelChanged$Type extends MessageType {
5771
2399
  },
5772
2400
  ]);
5773
2401
  }
5774
- create(value) {
5775
- const message = globalThis.Object.create(this.messagePrototype);
5776
- message.audioLevels = [];
5777
- if (value !== undefined)
5778
- reflectionMergePartial(this, message, value);
5779
- return message;
5780
- }
5781
- internalBinaryRead(reader, length, options, target) {
5782
- let message = target ?? this.create(), end = reader.pos + length;
5783
- while (reader.pos < end) {
5784
- let [fieldNo, wireType] = reader.tag();
5785
- switch (fieldNo) {
5786
- case /* repeated stream.video.sfu.event.AudioLevel audio_levels */ 1:
5787
- message.audioLevels.push(AudioLevel.internalBinaryRead(reader, reader.uint32(), options));
5788
- break;
5789
- default:
5790
- let u = options.readUnknownField;
5791
- if (u === 'throw')
5792
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
5793
- let d = reader.skip(wireType);
5794
- if (u !== false)
5795
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
5796
- }
5797
- }
5798
- return message;
5799
- }
5800
- internalBinaryWrite(message, writer, options) {
5801
- /* repeated stream.video.sfu.event.AudioLevel audio_levels = 1; */
5802
- for (let i = 0; i < message.audioLevels.length; i++)
5803
- AudioLevel.internalBinaryWrite(message.audioLevels[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join();
5804
- let u = options.writeUnknownFields;
5805
- if (u !== false)
5806
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
5807
- return writer;
5808
- }
5809
2402
  }
5810
2403
  /**
5811
2404
  * @generated MessageType for protobuf message stream.video.sfu.event.AudioLevelChanged
@@ -5823,41 +2416,6 @@ class AudioMediaRequest$Type extends MessageType {
5823
2416
  },
5824
2417
  ]);
5825
2418
  }
5826
- create(value) {
5827
- const message = globalThis.Object.create(this.messagePrototype);
5828
- message.channelCount = 0;
5829
- if (value !== undefined)
5830
- reflectionMergePartial(this, message, value);
5831
- return message;
5832
- }
5833
- internalBinaryRead(reader, length, options, target) {
5834
- let message = target ?? this.create(), end = reader.pos + length;
5835
- while (reader.pos < end) {
5836
- let [fieldNo, wireType] = reader.tag();
5837
- switch (fieldNo) {
5838
- case /* int32 channel_count */ 1:
5839
- message.channelCount = reader.int32();
5840
- break;
5841
- default:
5842
- let u = options.readUnknownField;
5843
- if (u === 'throw')
5844
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
5845
- let d = reader.skip(wireType);
5846
- if (u !== false)
5847
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
5848
- }
5849
- }
5850
- return message;
5851
- }
5852
- internalBinaryWrite(message, writer, options) {
5853
- /* int32 channel_count = 1; */
5854
- if (message.channelCount !== 0)
5855
- writer.tag(1, WireType.Varint).int32(message.channelCount);
5856
- let u = options.writeUnknownFields;
5857
- if (u !== false)
5858
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
5859
- return writer;
5860
- }
5861
2419
  }
5862
2420
  /**
5863
2421
  * @generated MessageType for protobuf message stream.video.sfu.event.AudioMediaRequest
@@ -5876,46 +2434,6 @@ class AudioSender$Type extends MessageType {
5876
2434
  { no: 2, name: 'codec', kind: 'message', T: () => Codec },
5877
2435
  ]);
5878
2436
  }
5879
- create(value) {
5880
- const message = globalThis.Object.create(this.messagePrototype);
5881
- if (value !== undefined)
5882
- reflectionMergePartial(this, message, value);
5883
- return message;
5884
- }
5885
- internalBinaryRead(reader, length, options, target) {
5886
- let message = target ?? this.create(), end = reader.pos + length;
5887
- while (reader.pos < end) {
5888
- let [fieldNo, wireType] = reader.tag();
5889
- switch (fieldNo) {
5890
- case /* stream.video.sfu.event.AudioMediaRequest media_request */ 1:
5891
- message.mediaRequest = AudioMediaRequest.internalBinaryRead(reader, reader.uint32(), options, message.mediaRequest);
5892
- break;
5893
- case /* stream.video.sfu.models.Codec codec */ 2:
5894
- message.codec = Codec.internalBinaryRead(reader, reader.uint32(), options, message.codec);
5895
- break;
5896
- default:
5897
- let u = options.readUnknownField;
5898
- if (u === 'throw')
5899
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
5900
- let d = reader.skip(wireType);
5901
- if (u !== false)
5902
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
5903
- }
5904
- }
5905
- return message;
5906
- }
5907
- internalBinaryWrite(message, writer, options) {
5908
- /* stream.video.sfu.event.AudioMediaRequest media_request = 1; */
5909
- if (message.mediaRequest)
5910
- AudioMediaRequest.internalBinaryWrite(message.mediaRequest, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
5911
- /* stream.video.sfu.models.Codec codec = 2; */
5912
- if (message.codec)
5913
- Codec.internalBinaryWrite(message.codec, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
5914
- let u = options.writeUnknownFields;
5915
- if (u !== false)
5916
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
5917
- return writer;
5918
- }
5919
2437
  }
5920
2438
  /**
5921
2439
  * @generated MessageType for protobuf message stream.video.sfu.event.AudioSender
@@ -5940,55 +2458,6 @@ class VideoMediaRequest$Type extends MessageType {
5940
2458
  },
5941
2459
  ]);
5942
2460
  }
5943
- create(value) {
5944
- const message = globalThis.Object.create(this.messagePrototype);
5945
- message.idealHeight = 0;
5946
- message.idealWidth = 0;
5947
- message.idealFrameRate = 0;
5948
- if (value !== undefined)
5949
- reflectionMergePartial(this, message, value);
5950
- return message;
5951
- }
5952
- internalBinaryRead(reader, length, options, target) {
5953
- let message = target ?? this.create(), end = reader.pos + length;
5954
- while (reader.pos < end) {
5955
- let [fieldNo, wireType] = reader.tag();
5956
- switch (fieldNo) {
5957
- case /* int32 ideal_height */ 1:
5958
- message.idealHeight = reader.int32();
5959
- break;
5960
- case /* int32 ideal_width */ 2:
5961
- message.idealWidth = reader.int32();
5962
- break;
5963
- case /* int32 ideal_frame_rate */ 3:
5964
- message.idealFrameRate = reader.int32();
5965
- break;
5966
- default:
5967
- let u = options.readUnknownField;
5968
- if (u === 'throw')
5969
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
5970
- let d = reader.skip(wireType);
5971
- if (u !== false)
5972
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
5973
- }
5974
- }
5975
- return message;
5976
- }
5977
- internalBinaryWrite(message, writer, options) {
5978
- /* int32 ideal_height = 1; */
5979
- if (message.idealHeight !== 0)
5980
- writer.tag(1, WireType.Varint).int32(message.idealHeight);
5981
- /* int32 ideal_width = 2; */
5982
- if (message.idealWidth !== 0)
5983
- writer.tag(2, WireType.Varint).int32(message.idealWidth);
5984
- /* int32 ideal_frame_rate = 3; */
5985
- if (message.idealFrameRate !== 0)
5986
- writer.tag(3, WireType.Varint).int32(message.idealFrameRate);
5987
- let u = options.writeUnknownFields;
5988
- if (u !== false)
5989
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
5990
- return writer;
5991
- }
5992
2461
  }
5993
2462
  /**
5994
2463
  * @generated MessageType for protobuf message stream.video.sfu.event.VideoMediaRequest
@@ -6026,82 +2495,6 @@ class VideoLayerSetting$Type extends MessageType {
6026
2495
  },
6027
2496
  ]);
6028
2497
  }
6029
- create(value) {
6030
- const message = globalThis.Object.create(this.messagePrototype);
6031
- message.name = '';
6032
- message.active = false;
6033
- message.maxBitrate = 0;
6034
- message.scaleResolutionDownBy = 0;
6035
- message.priority = 0;
6036
- message.maxFramerate = 0;
6037
- if (value !== undefined)
6038
- reflectionMergePartial(this, message, value);
6039
- return message;
6040
- }
6041
- internalBinaryRead(reader, length, options, target) {
6042
- let message = target ?? this.create(), end = reader.pos + length;
6043
- while (reader.pos < end) {
6044
- let [fieldNo, wireType] = reader.tag();
6045
- switch (fieldNo) {
6046
- case /* string name */ 1:
6047
- message.name = reader.string();
6048
- break;
6049
- case /* bool active */ 2:
6050
- message.active = reader.bool();
6051
- break;
6052
- case /* int32 max_bitrate */ 3:
6053
- message.maxBitrate = reader.int32();
6054
- break;
6055
- case /* float scale_resolution_down_by */ 4:
6056
- message.scaleResolutionDownBy = reader.float();
6057
- break;
6058
- case /* stream.video.sfu.event.VideoLayerSetting.Priority priority */ 5:
6059
- message.priority = reader.int32();
6060
- break;
6061
- case /* stream.video.sfu.models.Codec codec */ 6:
6062
- message.codec = Codec.internalBinaryRead(reader, reader.uint32(), options, message.codec);
6063
- break;
6064
- case /* uint32 max_framerate */ 7:
6065
- message.maxFramerate = reader.uint32();
6066
- break;
6067
- default:
6068
- let u = options.readUnknownField;
6069
- if (u === 'throw')
6070
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
6071
- let d = reader.skip(wireType);
6072
- if (u !== false)
6073
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
6074
- }
6075
- }
6076
- return message;
6077
- }
6078
- internalBinaryWrite(message, writer, options) {
6079
- /* string name = 1; */
6080
- if (message.name !== '')
6081
- writer.tag(1, WireType.LengthDelimited).string(message.name);
6082
- /* bool active = 2; */
6083
- if (message.active !== false)
6084
- writer.tag(2, WireType.Varint).bool(message.active);
6085
- /* int32 max_bitrate = 3; */
6086
- if (message.maxBitrate !== 0)
6087
- writer.tag(3, WireType.Varint).int32(message.maxBitrate);
6088
- /* float scale_resolution_down_by = 4; */
6089
- if (message.scaleResolutionDownBy !== 0)
6090
- writer.tag(4, WireType.Bit32).float(message.scaleResolutionDownBy);
6091
- /* stream.video.sfu.event.VideoLayerSetting.Priority priority = 5; */
6092
- if (message.priority !== 0)
6093
- writer.tag(5, WireType.Varint).int32(message.priority);
6094
- /* stream.video.sfu.models.Codec codec = 6; */
6095
- if (message.codec)
6096
- Codec.internalBinaryWrite(message.codec, writer.tag(6, WireType.LengthDelimited).fork(), options).join();
6097
- /* uint32 max_framerate = 7; */
6098
- if (message.maxFramerate !== 0)
6099
- writer.tag(7, WireType.Varint).uint32(message.maxFramerate);
6100
- let u = options.writeUnknownFields;
6101
- if (u !== false)
6102
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
6103
- return writer;
6104
- }
6105
2498
  }
6106
2499
  /**
6107
2500
  * @generated MessageType for protobuf message stream.video.sfu.event.VideoLayerSetting
@@ -6127,53 +2520,6 @@ class VideoSender$Type extends MessageType {
6127
2520
  },
6128
2521
  ]);
6129
2522
  }
6130
- create(value) {
6131
- const message = globalThis.Object.create(this.messagePrototype);
6132
- message.layers = [];
6133
- if (value !== undefined)
6134
- reflectionMergePartial(this, message, value);
6135
- return message;
6136
- }
6137
- internalBinaryRead(reader, length, options, target) {
6138
- let message = target ?? this.create(), end = reader.pos + length;
6139
- while (reader.pos < end) {
6140
- let [fieldNo, wireType] = reader.tag();
6141
- switch (fieldNo) {
6142
- case /* stream.video.sfu.event.VideoMediaRequest media_request */ 1:
6143
- message.mediaRequest = VideoMediaRequest.internalBinaryRead(reader, reader.uint32(), options, message.mediaRequest);
6144
- break;
6145
- case /* stream.video.sfu.models.Codec codec */ 2:
6146
- message.codec = Codec.internalBinaryRead(reader, reader.uint32(), options, message.codec);
6147
- break;
6148
- case /* repeated stream.video.sfu.event.VideoLayerSetting layers */ 3:
6149
- message.layers.push(VideoLayerSetting.internalBinaryRead(reader, reader.uint32(), options));
6150
- break;
6151
- default:
6152
- let u = options.readUnknownField;
6153
- if (u === 'throw')
6154
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
6155
- let d = reader.skip(wireType);
6156
- if (u !== false)
6157
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
6158
- }
6159
- }
6160
- return message;
6161
- }
6162
- internalBinaryWrite(message, writer, options) {
6163
- /* stream.video.sfu.event.VideoMediaRequest media_request = 1; */
6164
- if (message.mediaRequest)
6165
- VideoMediaRequest.internalBinaryWrite(message.mediaRequest, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
6166
- /* stream.video.sfu.models.Codec codec = 2; */
6167
- if (message.codec)
6168
- Codec.internalBinaryWrite(message.codec, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
6169
- /* repeated stream.video.sfu.event.VideoLayerSetting layers = 3; */
6170
- for (let i = 0; i < message.layers.length; i++)
6171
- VideoLayerSetting.internalBinaryWrite(message.layers[i], writer.tag(3, WireType.LengthDelimited).fork(), options).join();
6172
- let u = options.writeUnknownFields;
6173
- if (u !== false)
6174
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
6175
- return writer;
6176
- }
6177
2523
  }
6178
2524
  /**
6179
2525
  * @generated MessageType for protobuf message stream.video.sfu.event.VideoSender
@@ -6199,48 +2545,6 @@ class ChangePublishQuality$Type extends MessageType {
6199
2545
  },
6200
2546
  ]);
6201
2547
  }
6202
- create(value) {
6203
- const message = globalThis.Object.create(this.messagePrototype);
6204
- message.audioSenders = [];
6205
- message.videoSenders = [];
6206
- if (value !== undefined)
6207
- reflectionMergePartial(this, message, value);
6208
- return message;
6209
- }
6210
- internalBinaryRead(reader, length, options, target) {
6211
- let message = target ?? this.create(), end = reader.pos + length;
6212
- while (reader.pos < end) {
6213
- let [fieldNo, wireType] = reader.tag();
6214
- switch (fieldNo) {
6215
- case /* repeated stream.video.sfu.event.AudioSender audio_senders */ 1:
6216
- message.audioSenders.push(AudioSender.internalBinaryRead(reader, reader.uint32(), options));
6217
- break;
6218
- case /* repeated stream.video.sfu.event.VideoSender video_senders */ 2:
6219
- message.videoSenders.push(VideoSender.internalBinaryRead(reader, reader.uint32(), options));
6220
- break;
6221
- default:
6222
- let u = options.readUnknownField;
6223
- if (u === 'throw')
6224
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
6225
- let d = reader.skip(wireType);
6226
- if (u !== false)
6227
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
6228
- }
6229
- }
6230
- return message;
6231
- }
6232
- internalBinaryWrite(message, writer, options) {
6233
- /* repeated stream.video.sfu.event.AudioSender audio_senders = 1; */
6234
- for (let i = 0; i < message.audioSenders.length; i++)
6235
- AudioSender.internalBinaryWrite(message.audioSenders[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join();
6236
- /* repeated stream.video.sfu.event.VideoSender video_senders = 2; */
6237
- for (let i = 0; i < message.videoSenders.length; i++)
6238
- VideoSender.internalBinaryWrite(message.videoSenders[i], writer.tag(2, WireType.LengthDelimited).fork(), options).join();
6239
- let u = options.writeUnknownFields;
6240
- if (u !== false)
6241
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
6242
- return writer;
6243
- }
6244
2548
  }
6245
2549
  /**
6246
2550
  * @generated MessageType for protobuf message stream.video.sfu.event.ChangePublishQuality
@@ -6254,47 +2558,6 @@ class CallGrantsUpdated$Type extends MessageType {
6254
2558
  { no: 2, name: 'message', kind: 'scalar', T: 9 /*ScalarType.STRING*/ },
6255
2559
  ]);
6256
2560
  }
6257
- create(value) {
6258
- const message = globalThis.Object.create(this.messagePrototype);
6259
- message.message = '';
6260
- if (value !== undefined)
6261
- reflectionMergePartial(this, message, value);
6262
- return message;
6263
- }
6264
- internalBinaryRead(reader, length, options, target) {
6265
- let message = target ?? this.create(), end = reader.pos + length;
6266
- while (reader.pos < end) {
6267
- let [fieldNo, wireType] = reader.tag();
6268
- switch (fieldNo) {
6269
- case /* stream.video.sfu.models.CallGrants current_grants */ 1:
6270
- message.currentGrants = CallGrants.internalBinaryRead(reader, reader.uint32(), options, message.currentGrants);
6271
- break;
6272
- case /* string message */ 2:
6273
- message.message = reader.string();
6274
- break;
6275
- default:
6276
- let u = options.readUnknownField;
6277
- if (u === 'throw')
6278
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
6279
- let d = reader.skip(wireType);
6280
- if (u !== false)
6281
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
6282
- }
6283
- }
6284
- return message;
6285
- }
6286
- internalBinaryWrite(message, writer, options) {
6287
- /* stream.video.sfu.models.CallGrants current_grants = 1; */
6288
- if (message.currentGrants)
6289
- CallGrants.internalBinaryWrite(message.currentGrants, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
6290
- /* string message = 2; */
6291
- if (message.message !== '')
6292
- writer.tag(2, WireType.LengthDelimited).string(message.message);
6293
- let u = options.writeUnknownFields;
6294
- if (u !== false)
6295
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
6296
- return writer;
6297
- }
6298
2561
  }
6299
2562
  /**
6300
2563
  * @generated MessageType for protobuf message stream.video.sfu.event.CallGrantsUpdated
@@ -6316,41 +2579,6 @@ class GoAway$Type extends MessageType {
6316
2579
  },
6317
2580
  ]);
6318
2581
  }
6319
- create(value) {
6320
- const message = globalThis.Object.create(this.messagePrototype);
6321
- message.reason = 0;
6322
- if (value !== undefined)
6323
- reflectionMergePartial(this, message, value);
6324
- return message;
6325
- }
6326
- internalBinaryRead(reader, length, options, target) {
6327
- let message = target ?? this.create(), end = reader.pos + length;
6328
- while (reader.pos < end) {
6329
- let [fieldNo, wireType] = reader.tag();
6330
- switch (fieldNo) {
6331
- case /* stream.video.sfu.models.GoAwayReason reason */ 1:
6332
- message.reason = reader.int32();
6333
- break;
6334
- default:
6335
- let u = options.readUnknownField;
6336
- if (u === 'throw')
6337
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
6338
- let d = reader.skip(wireType);
6339
- if (u !== false)
6340
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
6341
- }
6342
- }
6343
- return message;
6344
- }
6345
- internalBinaryWrite(message, writer, options) {
6346
- /* stream.video.sfu.models.GoAwayReason reason = 1; */
6347
- if (message.reason !== 0)
6348
- writer.tag(1, WireType.Varint).int32(message.reason);
6349
- let u = options.writeUnknownFields;
6350
- if (u !== false)
6351
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
6352
- return writer;
6353
- }
6354
2582
  }
6355
2583
  /**
6356
2584
  * @generated MessageType for protobuf message stream.video.sfu.event.GoAway
@@ -6372,41 +2600,6 @@ class CallEnded$Type extends MessageType {
6372
2600
  },
6373
2601
  ]);
6374
2602
  }
6375
- create(value) {
6376
- const message = globalThis.Object.create(this.messagePrototype);
6377
- message.reason = 0;
6378
- if (value !== undefined)
6379
- reflectionMergePartial(this, message, value);
6380
- return message;
6381
- }
6382
- internalBinaryRead(reader, length, options, target) {
6383
- let message = target ?? this.create(), end = reader.pos + length;
6384
- while (reader.pos < end) {
6385
- let [fieldNo, wireType] = reader.tag();
6386
- switch (fieldNo) {
6387
- case /* stream.video.sfu.models.CallEndedReason reason */ 1:
6388
- message.reason = reader.int32();
6389
- break;
6390
- default:
6391
- let u = options.readUnknownField;
6392
- if (u === 'throw')
6393
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
6394
- let d = reader.skip(wireType);
6395
- if (u !== false)
6396
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
6397
- }
6398
- }
6399
- return message;
6400
- }
6401
- internalBinaryWrite(message, writer, options) {
6402
- /* stream.video.sfu.models.CallEndedReason reason = 1; */
6403
- if (message.reason !== 0)
6404
- writer.tag(1, WireType.Varint).int32(message.reason);
6405
- let u = options.writeUnknownFields;
6406
- if (u !== false)
6407
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
6408
- return writer;
6409
- }
6410
2603
  }
6411
2604
  /**
6412
2605
  * @generated MessageType for protobuf message stream.video.sfu.event.CallEnded
@@ -6820,7 +3013,7 @@ const retryable = async (rpc, signal) => {
6820
3013
  return result;
6821
3014
  };
6822
3015
 
6823
- const version = "1.6.4" ;
3016
+ const version = "1.7.0";
6824
3017
  const [major, minor, patch] = version.split('.');
6825
3018
  let sdkInfo = {
6826
3019
  type: SdkType.PLAIN_JAVASCRIPT,
@@ -10597,7 +6790,7 @@ const transform = (report, opts) => {
10597
6790
  stat.kind === trackKind)
10598
6791
  .map((stat) => {
10599
6792
  const rtcStreamStats = stat;
10600
- const codec = stats.find((s) => s.type === 'codec' && s.id === rtcStreamStats.codecId); // FIXME OL: incorrect type!
6793
+ const codec = stats.find((s) => s.type === 'codec' && s.id === rtcStreamStats.codecId);
10601
6794
  const transport = stats.find((s) => s.type === 'transport' && s.id === rtcStreamStats.transportId);
10602
6795
  let roundTripTime;
10603
6796
  if (transport && transport.dtlsState === 'connected') {
@@ -10638,6 +6831,7 @@ const getEmptyStats = (stats) => {
10638
6831
  highestFrameWidth: 0,
10639
6832
  highestFrameHeight: 0,
10640
6833
  highestFramesPerSecond: 0,
6834
+ codec: '',
10641
6835
  timestamp: Date.now(),
10642
6836
  };
10643
6837
  };
@@ -10671,6 +6865,8 @@ const aggregate = (stats) => {
10671
6865
  if (streams.length > 0) {
10672
6866
  report.averageJitterInMs = Math.round((report.averageJitterInMs / streams.length) * 1000);
10673
6867
  report.averageRoundTripTimeInMs = Math.round((report.averageRoundTripTimeInMs / streams.length) * 1000);
6868
+ // we take the first codec we find, as it should be the same for all streams
6869
+ report.codec = streams[0].codec || '';
10674
6870
  }
10675
6871
  const qualityLimitationReason = [
10676
6872
  qualityLimitationReasons.has('cpu') && 'cpu',
@@ -11769,10 +7965,12 @@ class InputMediaDeviceManager {
11769
7965
  await this.applySettingsToStream();
11770
7966
  }
11771
7967
  async applySettingsToStream() {
11772
- if (this.enabled) {
11773
- await this.muteStream();
11774
- await this.unmuteStream();
11775
- }
7968
+ await withCancellation(this.statusChangeConcurrencyTag, async () => {
7969
+ if (this.enabled) {
7970
+ await this.muteStream();
7971
+ await this.unmuteStream();
7972
+ }
7973
+ });
11776
7974
  }
11777
7975
  getTracks() {
11778
7976
  return this.state.mediaStream?.getTracks() ?? [];
@@ -11915,17 +8113,19 @@ class InputMediaDeviceManager {
11915
8113
  }
11916
8114
  if (this.state.mediaStream !== stream) {
11917
8115
  this.state.setMediaStream(stream, await rootStream);
8116
+ const handleTrackEnded = async () => {
8117
+ await this.statusChangeSettled();
8118
+ if (this.enabled) {
8119
+ this.isTrackStoppedDueToTrackEnd = true;
8120
+ setTimeout(() => {
8121
+ this.isTrackStoppedDueToTrackEnd = false;
8122
+ }, 2000);
8123
+ await this.disable();
8124
+ }
8125
+ };
11918
8126
  this.getTracks().forEach((track) => {
11919
- track.addEventListener('ended', async () => {
11920
- await this.statusChangeSettled();
11921
- if (this.enabled) {
11922
- this.isTrackStoppedDueToTrackEnd = true;
11923
- setTimeout(() => {
11924
- this.isTrackStoppedDueToTrackEnd = false;
11925
- }, 2000);
11926
- await this.disable();
11927
- }
11928
- });
8127
+ track.addEventListener('ended', handleTrackEnded);
8128
+ this.subscriptions.push(() => track.removeEventListener('ended', handleTrackEnded));
11929
8129
  });
11930
8130
  }
11931
8131
  }
@@ -15797,10 +11997,6 @@ class StreamClient {
15797
11997
  * https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent
15798
11998
  */
15799
11999
  this.closeConnection = async (timeout) => {
15800
- if (this.cleaningIntervalRef != null) {
15801
- clearInterval(this.cleaningIntervalRef);
15802
- this.cleaningIntervalRef = undefined;
15803
- }
15804
12000
  await Promise.all([
15805
12001
  this.wsConnection?.disconnect(timeout),
15806
12002
  this.wsFallback?.disconnect(timeout),
@@ -16114,7 +12310,7 @@ class StreamClient {
16114
12310
  });
16115
12311
  };
16116
12312
  this.getUserAgent = () => {
16117
- const version = "1.6.4" ;
12313
+ const version = "1.7.0";
16118
12314
  return (this.userAgent ||
16119
12315
  `stream-video-javascript-client-${this.node ? 'node' : 'browser'}-${version}`);
16120
12316
  };