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