@m1kad0/hannah-proto 3.7.0 → 3.7.2

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.
Files changed (26) hide show
  1. package/dist/activity_log.js +216 -166
  2. package/dist/agent.js +1330 -1050
  3. package/dist/automation.js +142 -92
  4. package/dist/car_state.js +245 -195
  5. package/dist/compat_versions.js +1 -1
  6. package/dist/control.js +1675 -1255
  7. package/dist/descriptor.binpb +0 -0
  8. package/dist/device_control_menu.js +302 -222
  9. package/dist/event_stream.js +236 -166
  10. package/dist/google/protobuf/descriptor.js +1721 -1381
  11. package/dist/hannah.js +1 -1
  12. package/dist/messages.d.ts +8 -0
  13. package/dist/messages.js +220 -126
  14. package/dist/options.js +1 -1
  15. package/dist/satellite.js +314 -244
  16. package/dist/satellite_provisioning.js +38 -28
  17. package/dist/satellite_proxy.d.ts +5 -2
  18. package/dist/satellite_proxy.js +278 -208
  19. package/dist/shared.js +111 -71
  20. package/dist/speaker_enrollment.js +38 -28
  21. package/dist/timer_admin.js +131 -91
  22. package/dist/timer_service.js +467 -327
  23. package/dist/user_registry.js +724 -534
  24. package/dist/wakeword_capture.js +295 -195
  25. package/dist/weather.js +172 -142
  26. package/package.json +2 -2
package/dist/agent.js CHANGED
@@ -1,7 +1,7 @@
1
1
  "use strict";
2
2
  // Code generated by protoc-gen-ts_proto. DO NOT EDIT.
3
3
  // versions:
4
- // protoc-gen-ts_proto v2.12.0
4
+ // protoc-gen-ts_proto v2.12.1
5
5
  // protoc unknown
6
6
  // source: hannah/agent.proto
7
7
  Object.defineProperty(exports, "__esModule", { value: true });
@@ -66,81 +66,91 @@ exports.AgentMessage = {
66
66
  },
67
67
  decode(input, length) {
68
68
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
69
- const end = length === undefined ? reader.len : reader.pos + length;
70
- const message = createBaseAgentMessage();
71
- while (reader.pos < end) {
72
- const tag = reader.uint32();
73
- switch (tag >>> 3) {
74
- case 1: {
75
- if (tag !== 10) {
76
- break;
77
- }
78
- message.stateUpdate = exports.AgentStateUpdate.decode(reader, reader.uint32());
79
- continue;
80
- }
81
- case 2: {
82
- if (tag !== 18) {
83
- break;
84
- }
85
- message.residentUpdate = exports.AgentResident.decode(reader, reader.uint32());
86
- continue;
87
- }
88
- case 3: {
89
- if (tag !== 26) {
90
- break;
91
- }
92
- message.textCommand = exports.AgentTextCommand.decode(reader, reader.uint32());
93
- continue;
94
- }
95
- case 4: {
96
- if (tag !== 34) {
97
- break;
98
- }
99
- message.satelliteControl = exports.AgentSatelliteControl.decode(reader, reader.uint32());
100
- continue;
101
- }
102
- case 5: {
103
- if (tag !== 42) {
104
- break;
105
- }
106
- message.sendSnapshot = exports.AgentDeviceSnapshot.decode(reader, reader.uint32());
107
- continue;
108
- }
109
- case 6: {
110
- if (tag !== 50) {
111
- break;
112
- }
113
- message.sendResidents = exports.AgentResidentSnapshot.decode(reader, reader.uint32());
114
- continue;
115
- }
116
- case 7: {
117
- if (tag !== 58) {
118
- break;
119
- }
120
- message.askResident = exports.AgentAskResident.decode(reader, reader.uint32());
121
- continue;
122
- }
123
- case 8: {
124
- if (tag !== 66) {
125
- break;
126
- }
127
- message.sendRooms = exports.AgentRoomSnapshot.decode(reader, reader.uint32());
128
- continue;
129
- }
130
- case 9: {
131
- if (tag !== 74) {
132
- break;
133
- }
134
- message.weatherUpdate = weather_1.AgentWeatherUpdate.decode(reader, reader.uint32());
135
- continue;
136
- }
137
- }
138
- if ((tag & 7) === 4 || tag === 0) {
139
- break;
69
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
70
+ if (previousRecursionDepth >= 100) {
71
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
72
+ }
73
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
74
+ try {
75
+ const end = length === undefined ? reader.len : reader.pos + length;
76
+ const message = createBaseAgentMessage();
77
+ while (reader.pos < end) {
78
+ const tag = reader.uint32();
79
+ switch (tag >>> 3) {
80
+ case 1: {
81
+ if (tag !== 10) {
82
+ break;
83
+ }
84
+ message.stateUpdate = exports.AgentStateUpdate.decode(reader, reader.uint32());
85
+ continue;
86
+ }
87
+ case 2: {
88
+ if (tag !== 18) {
89
+ break;
90
+ }
91
+ message.residentUpdate = exports.AgentResident.decode(reader, reader.uint32());
92
+ continue;
93
+ }
94
+ case 3: {
95
+ if (tag !== 26) {
96
+ break;
97
+ }
98
+ message.textCommand = exports.AgentTextCommand.decode(reader, reader.uint32());
99
+ continue;
100
+ }
101
+ case 4: {
102
+ if (tag !== 34) {
103
+ break;
104
+ }
105
+ message.satelliteControl = exports.AgentSatelliteControl.decode(reader, reader.uint32());
106
+ continue;
107
+ }
108
+ case 5: {
109
+ if (tag !== 42) {
110
+ break;
111
+ }
112
+ message.sendSnapshot = exports.AgentDeviceSnapshot.decode(reader, reader.uint32());
113
+ continue;
114
+ }
115
+ case 6: {
116
+ if (tag !== 50) {
117
+ break;
118
+ }
119
+ message.sendResidents = exports.AgentResidentSnapshot.decode(reader, reader.uint32());
120
+ continue;
121
+ }
122
+ case 7: {
123
+ if (tag !== 58) {
124
+ break;
125
+ }
126
+ message.askResident = exports.AgentAskResident.decode(reader, reader.uint32());
127
+ continue;
128
+ }
129
+ case 8: {
130
+ if (tag !== 66) {
131
+ break;
132
+ }
133
+ message.sendRooms = exports.AgentRoomSnapshot.decode(reader, reader.uint32());
134
+ continue;
135
+ }
136
+ case 9: {
137
+ if (tag !== 74) {
138
+ break;
139
+ }
140
+ message.weatherUpdate = weather_1.AgentWeatherUpdate.decode(reader, reader.uint32());
141
+ continue;
142
+ }
143
+ }
144
+ if ((tag & 7) === 4 || tag === 0) {
145
+ break;
146
+ }
147
+ reader.skip(tag & 7);
140
148
  }
141
- reader.skip(tag & 7);
149
+ return message;
150
+ }
151
+ finally {
152
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
142
153
  }
143
- return message;
144
154
  },
145
155
  create(base) {
146
156
  return exports.AgentMessage.fromPartial(base ?? {});
@@ -223,81 +233,91 @@ exports.AgentSatelliteControl = {
223
233
  },
224
234
  decode(input, length) {
225
235
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
226
- const end = length === undefined ? reader.len : reader.pos + length;
227
- const message = createBaseAgentSatelliteControl();
228
- while (reader.pos < end) {
229
- const tag = reader.uint32();
230
- switch (tag >>> 3) {
231
- case 1: {
232
- if (tag !== 10) {
233
- break;
234
- }
235
- message.room = reader.string();
236
- continue;
237
- }
238
- case 7: {
239
- if (tag !== 58) {
240
- break;
241
- }
242
- message.deviceId = reader.string();
243
- continue;
244
- }
245
- case 2: {
246
- if (tag !== 16) {
247
- break;
248
- }
249
- message.dnd = reader.bool();
250
- continue;
251
- }
252
- case 3: {
253
- if (tag !== 24) {
254
- break;
255
- }
256
- message.mute = reader.bool();
257
- continue;
258
- }
259
- case 4: {
260
- if (tag !== 32) {
261
- break;
262
- }
263
- message.volume = reader.int32();
264
- continue;
265
- }
266
- case 5: {
267
- if (tag !== 42) {
268
- break;
269
- }
270
- message.announcement = reader.string();
271
- continue;
272
- }
273
- case 6: {
274
- if (tag !== 50) {
275
- break;
276
- }
277
- message.announcementSsml = reader.string();
278
- continue;
279
- }
280
- case 8: {
281
- if (tag !== 66) {
282
- break;
283
- }
284
- message.announcementRephrase = reader.string();
285
- continue;
286
- }
287
- case 9: {
288
- if (tag !== 74) {
289
- break;
290
- }
291
- message.capture = exports.CaptureControl.decode(reader, reader.uint32());
292
- continue;
293
- }
294
- }
295
- if ((tag & 7) === 4 || tag === 0) {
296
- break;
236
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
237
+ if (previousRecursionDepth >= 100) {
238
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
239
+ }
240
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
241
+ try {
242
+ const end = length === undefined ? reader.len : reader.pos + length;
243
+ const message = createBaseAgentSatelliteControl();
244
+ while (reader.pos < end) {
245
+ const tag = reader.uint32();
246
+ switch (tag >>> 3) {
247
+ case 1: {
248
+ if (tag !== 10) {
249
+ break;
250
+ }
251
+ message.room = reader.string();
252
+ continue;
253
+ }
254
+ case 7: {
255
+ if (tag !== 58) {
256
+ break;
257
+ }
258
+ message.deviceId = reader.string();
259
+ continue;
260
+ }
261
+ case 2: {
262
+ if (tag !== 16) {
263
+ break;
264
+ }
265
+ message.dnd = reader.bool();
266
+ continue;
267
+ }
268
+ case 3: {
269
+ if (tag !== 24) {
270
+ break;
271
+ }
272
+ message.mute = reader.bool();
273
+ continue;
274
+ }
275
+ case 4: {
276
+ if (tag !== 32) {
277
+ break;
278
+ }
279
+ message.volume = reader.int32();
280
+ continue;
281
+ }
282
+ case 5: {
283
+ if (tag !== 42) {
284
+ break;
285
+ }
286
+ message.announcement = reader.string();
287
+ continue;
288
+ }
289
+ case 6: {
290
+ if (tag !== 50) {
291
+ break;
292
+ }
293
+ message.announcementSsml = reader.string();
294
+ continue;
295
+ }
296
+ case 8: {
297
+ if (tag !== 66) {
298
+ break;
299
+ }
300
+ message.announcementRephrase = reader.string();
301
+ continue;
302
+ }
303
+ case 9: {
304
+ if (tag !== 74) {
305
+ break;
306
+ }
307
+ message.capture = exports.CaptureControl.decode(reader, reader.uint32());
308
+ continue;
309
+ }
310
+ }
311
+ if ((tag & 7) === 4 || tag === 0) {
312
+ break;
313
+ }
314
+ reader.skip(tag & 7);
297
315
  }
298
- reader.skip(tag & 7);
316
+ return message;
317
+ }
318
+ finally {
319
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
299
320
  }
300
- return message;
301
321
  },
302
322
  create(base) {
303
323
  return exports.AgentSatelliteControl.fromPartial(base ?? {});
@@ -336,39 +356,49 @@ exports.CaptureControl = {
336
356
  },
337
357
  decode(input, length) {
338
358
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
339
- const end = length === undefined ? reader.len : reader.pos + length;
340
- const message = createBaseCaptureControl();
341
- while (reader.pos < end) {
342
- const tag = reader.uint32();
343
- switch (tag >>> 3) {
344
- case 1: {
345
- if (tag !== 10) {
346
- break;
347
- }
348
- message.sampleType = wakeword_capture_1.SampleType.decode(reader, reader.uint32());
349
- continue;
350
- }
351
- case 2: {
352
- if (tag !== 16) {
353
- break;
354
- }
355
- message.captureMode = reader.int32();
356
- continue;
357
- }
358
- case 3: {
359
- if (tag !== 24) {
360
- break;
361
- }
362
- message.stop = reader.bool();
363
- continue;
364
- }
359
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
360
+ if (previousRecursionDepth >= 100) {
361
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
362
+ }
363
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
364
+ try {
365
+ const end = length === undefined ? reader.len : reader.pos + length;
366
+ const message = createBaseCaptureControl();
367
+ while (reader.pos < end) {
368
+ const tag = reader.uint32();
369
+ switch (tag >>> 3) {
370
+ case 1: {
371
+ if (tag !== 10) {
372
+ break;
373
+ }
374
+ message.sampleType = wakeword_capture_1.SampleType.decode(reader, reader.uint32());
375
+ continue;
376
+ }
377
+ case 2: {
378
+ if (tag !== 16) {
379
+ break;
380
+ }
381
+ message.captureMode = reader.int32();
382
+ continue;
383
+ }
384
+ case 3: {
385
+ if (tag !== 24) {
386
+ break;
387
+ }
388
+ message.stop = reader.bool();
389
+ continue;
390
+ }
391
+ }
392
+ if ((tag & 7) === 4 || tag === 0) {
393
+ break;
394
+ }
395
+ reader.skip(tag & 7);
365
396
  }
366
- if ((tag & 7) === 4 || tag === 0) {
367
- break;
368
- }
369
- reader.skip(tag & 7);
397
+ return message;
398
+ }
399
+ finally {
400
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
370
401
  }
371
- return message;
372
402
  },
373
403
  create(base) {
374
404
  return exports.CaptureControl.fromPartial(base ?? {});
@@ -407,46 +437,56 @@ exports.AgentStateUpdate = {
407
437
  },
408
438
  decode(input, length) {
409
439
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
410
- const end = length === undefined ? reader.len : reader.pos + length;
411
- const message = createBaseAgentStateUpdate();
412
- while (reader.pos < end) {
413
- const tag = reader.uint32();
414
- switch (tag >>> 3) {
415
- case 1: {
416
- if (tag !== 10) {
417
- break;
418
- }
419
- message.stateId = reader.string();
420
- continue;
421
- }
422
- case 2: {
423
- if (tag !== 18) {
424
- break;
425
- }
426
- message.value = reader.string();
427
- continue;
428
- }
429
- case 3: {
430
- if (tag !== 24) {
431
- break;
432
- }
433
- message.ack = reader.bool();
434
- continue;
435
- }
436
- case 4: {
437
- if (tag !== 32) {
438
- break;
439
- }
440
- message.ts = reader.int64();
441
- continue;
442
- }
443
- }
444
- if ((tag & 7) === 4 || tag === 0) {
445
- break;
440
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
441
+ if (previousRecursionDepth >= 100) {
442
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
443
+ }
444
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
445
+ try {
446
+ const end = length === undefined ? reader.len : reader.pos + length;
447
+ const message = createBaseAgentStateUpdate();
448
+ while (reader.pos < end) {
449
+ const tag = reader.uint32();
450
+ switch (tag >>> 3) {
451
+ case 1: {
452
+ if (tag !== 10) {
453
+ break;
454
+ }
455
+ message.stateId = reader.string();
456
+ continue;
457
+ }
458
+ case 2: {
459
+ if (tag !== 18) {
460
+ break;
461
+ }
462
+ message.value = reader.string();
463
+ continue;
464
+ }
465
+ case 3: {
466
+ if (tag !== 24) {
467
+ break;
468
+ }
469
+ message.ack = reader.bool();
470
+ continue;
471
+ }
472
+ case 4: {
473
+ if (tag !== 32) {
474
+ break;
475
+ }
476
+ message.ts = reader.int64();
477
+ continue;
478
+ }
479
+ }
480
+ if ((tag & 7) === 4 || tag === 0) {
481
+ break;
482
+ }
483
+ reader.skip(tag & 7);
446
484
  }
447
- reader.skip(tag & 7);
485
+ return message;
486
+ }
487
+ finally {
488
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
448
489
  }
449
- return message;
450
490
  },
451
491
  create(base) {
452
492
  return exports.AgentStateUpdate.fromPartial(base ?? {});
@@ -472,25 +512,35 @@ exports.AgentTextCommand = {
472
512
  },
473
513
  decode(input, length) {
474
514
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
475
- const end = length === undefined ? reader.len : reader.pos + length;
476
- const message = createBaseAgentTextCommand();
477
- while (reader.pos < end) {
478
- const tag = reader.uint32();
479
- switch (tag >>> 3) {
480
- case 1: {
481
- if (tag !== 10) {
482
- break;
483
- }
484
- message.text = reader.string();
485
- continue;
486
- }
487
- }
488
- if ((tag & 7) === 4 || tag === 0) {
489
- break;
515
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
516
+ if (previousRecursionDepth >= 100) {
517
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
518
+ }
519
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
520
+ try {
521
+ const end = length === undefined ? reader.len : reader.pos + length;
522
+ const message = createBaseAgentTextCommand();
523
+ while (reader.pos < end) {
524
+ const tag = reader.uint32();
525
+ switch (tag >>> 3) {
526
+ case 1: {
527
+ if (tag !== 10) {
528
+ break;
529
+ }
530
+ message.text = reader.string();
531
+ continue;
532
+ }
533
+ }
534
+ if ((tag & 7) === 4 || tag === 0) {
535
+ break;
536
+ }
537
+ reader.skip(tag & 7);
490
538
  }
491
- reader.skip(tag & 7);
539
+ return message;
540
+ }
541
+ finally {
542
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
492
543
  }
493
- return message;
494
544
  },
495
545
  create(base) {
496
546
  return exports.AgentTextCommand.fromPartial(base ?? {});
@@ -555,95 +605,105 @@ exports.AgentCommand = {
555
605
  },
556
606
  decode(input, length) {
557
607
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
558
- const end = length === undefined ? reader.len : reader.pos + length;
559
- const message = createBaseAgentCommand();
560
- while (reader.pos < end) {
561
- const tag = reader.uint32();
562
- switch (tag >>> 3) {
563
- case 1: {
564
- if (tag !== 10) {
565
- break;
566
- }
567
- message.setState = exports.AgentSetState.decode(reader, reader.uint32());
568
- continue;
569
- }
570
- case 2: {
571
- if (tag !== 18) {
572
- break;
573
- }
574
- message.watchMore = exports.AgentWatchMore.decode(reader, reader.uint32());
575
- continue;
576
- }
577
- case 3: {
578
- if (tag !== 26) {
579
- break;
580
- }
581
- message.setResident = exports.AgentSetResident.decode(reader, reader.uint32());
582
- continue;
583
- }
584
- case 4: {
585
- if (tag !== 34) {
586
- break;
587
- }
588
- message.satelliteUpdate = exports.AgentSatelliteUpdate.decode(reader, reader.uint32());
589
- continue;
590
- }
591
- case 5: {
592
- if (tag !== 42) {
593
- break;
594
- }
595
- message.textAnswer = exports.AgentTextAnswer.decode(reader, reader.uint32());
596
- continue;
597
- }
598
- case 6: {
599
- if (tag !== 50) {
600
- break;
601
- }
602
- message.firmwareEvent = exports.AgentFirmwareEvent.decode(reader, reader.uint32());
603
- continue;
604
- }
605
- case 7: {
606
- if (tag !== 58) {
607
- break;
608
- }
609
- message.bleUpdate = exports.AgentBleUpdate.decode(reader, reader.uint32());
610
- continue;
611
- }
612
- case 8: {
613
- if (tag !== 66) {
614
- break;
615
- }
616
- message.sensorUpdate = exports.AgentSensorUpdate.decode(reader, reader.uint32());
617
- continue;
618
- }
619
- case 9: {
620
- if (tag !== 74) {
621
- break;
622
- }
623
- message.residentAnswered = exports.AgentResidentAnswered.decode(reader, reader.uint32());
624
- continue;
625
- }
626
- case 10: {
627
- if (tag !== 82) {
628
- break;
629
- }
630
- message.satelliteDeleted = exports.AgentSatelliteDeleted.decode(reader, reader.uint32());
631
- continue;
632
- }
633
- case 11: {
634
- if (tag !== 90) {
635
- break;
636
- }
637
- message.setResidentMood = exports.AgentSetResidentMood.decode(reader, reader.uint32());
638
- continue;
639
- }
608
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
609
+ if (previousRecursionDepth >= 100) {
610
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
611
+ }
612
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
613
+ try {
614
+ const end = length === undefined ? reader.len : reader.pos + length;
615
+ const message = createBaseAgentCommand();
616
+ while (reader.pos < end) {
617
+ const tag = reader.uint32();
618
+ switch (tag >>> 3) {
619
+ case 1: {
620
+ if (tag !== 10) {
621
+ break;
622
+ }
623
+ message.setState = exports.AgentSetState.decode(reader, reader.uint32());
624
+ continue;
625
+ }
626
+ case 2: {
627
+ if (tag !== 18) {
628
+ break;
629
+ }
630
+ message.watchMore = exports.AgentWatchMore.decode(reader, reader.uint32());
631
+ continue;
632
+ }
633
+ case 3: {
634
+ if (tag !== 26) {
635
+ break;
636
+ }
637
+ message.setResident = exports.AgentSetResident.decode(reader, reader.uint32());
638
+ continue;
639
+ }
640
+ case 4: {
641
+ if (tag !== 34) {
642
+ break;
643
+ }
644
+ message.satelliteUpdate = exports.AgentSatelliteUpdate.decode(reader, reader.uint32());
645
+ continue;
646
+ }
647
+ case 5: {
648
+ if (tag !== 42) {
649
+ break;
650
+ }
651
+ message.textAnswer = exports.AgentTextAnswer.decode(reader, reader.uint32());
652
+ continue;
653
+ }
654
+ case 6: {
655
+ if (tag !== 50) {
656
+ break;
657
+ }
658
+ message.firmwareEvent = exports.AgentFirmwareEvent.decode(reader, reader.uint32());
659
+ continue;
660
+ }
661
+ case 7: {
662
+ if (tag !== 58) {
663
+ break;
664
+ }
665
+ message.bleUpdate = exports.AgentBleUpdate.decode(reader, reader.uint32());
666
+ continue;
667
+ }
668
+ case 8: {
669
+ if (tag !== 66) {
670
+ break;
671
+ }
672
+ message.sensorUpdate = exports.AgentSensorUpdate.decode(reader, reader.uint32());
673
+ continue;
674
+ }
675
+ case 9: {
676
+ if (tag !== 74) {
677
+ break;
678
+ }
679
+ message.residentAnswered = exports.AgentResidentAnswered.decode(reader, reader.uint32());
680
+ continue;
681
+ }
682
+ case 10: {
683
+ if (tag !== 82) {
684
+ break;
685
+ }
686
+ message.satelliteDeleted = exports.AgentSatelliteDeleted.decode(reader, reader.uint32());
687
+ continue;
688
+ }
689
+ case 11: {
690
+ if (tag !== 90) {
691
+ break;
692
+ }
693
+ message.setResidentMood = exports.AgentSetResidentMood.decode(reader, reader.uint32());
694
+ continue;
695
+ }
696
+ }
697
+ if ((tag & 7) === 4 || tag === 0) {
698
+ break;
699
+ }
700
+ reader.skip(tag & 7);
640
701
  }
641
- if ((tag & 7) === 4 || tag === 0) {
642
- break;
643
- }
644
- reader.skip(tag & 7);
702
+ return message;
703
+ }
704
+ finally {
705
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
645
706
  }
646
- return message;
647
707
  },
648
708
  create(base) {
649
709
  return exports.AgentCommand.fromPartial(base ?? {});
@@ -704,39 +764,49 @@ exports.AgentFirmwareEvent = {
704
764
  },
705
765
  decode(input, length) {
706
766
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
707
- const end = length === undefined ? reader.len : reader.pos + length;
708
- const message = createBaseAgentFirmwareEvent();
709
- while (reader.pos < end) {
710
- const tag = reader.uint32();
711
- switch (tag >>> 3) {
712
- case 1: {
713
- if (tag !== 10) {
714
- break;
715
- }
716
- message.device = reader.string();
717
- continue;
718
- }
719
- case 2: {
720
- if (tag !== 18) {
721
- break;
722
- }
723
- message.version = reader.string();
724
- continue;
725
- }
726
- case 3: {
727
- if (tag !== 24) {
728
- break;
729
- }
730
- message.updateAvailable = reader.bool();
731
- continue;
732
- }
767
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
768
+ if (previousRecursionDepth >= 100) {
769
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
770
+ }
771
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
772
+ try {
773
+ const end = length === undefined ? reader.len : reader.pos + length;
774
+ const message = createBaseAgentFirmwareEvent();
775
+ while (reader.pos < end) {
776
+ const tag = reader.uint32();
777
+ switch (tag >>> 3) {
778
+ case 1: {
779
+ if (tag !== 10) {
780
+ break;
781
+ }
782
+ message.device = reader.string();
783
+ continue;
784
+ }
785
+ case 2: {
786
+ if (tag !== 18) {
787
+ break;
788
+ }
789
+ message.version = reader.string();
790
+ continue;
791
+ }
792
+ case 3: {
793
+ if (tag !== 24) {
794
+ break;
795
+ }
796
+ message.updateAvailable = reader.bool();
797
+ continue;
798
+ }
799
+ }
800
+ if ((tag & 7) === 4 || tag === 0) {
801
+ break;
802
+ }
803
+ reader.skip(tag & 7);
733
804
  }
734
- if ((tag & 7) === 4 || tag === 0) {
735
- break;
736
- }
737
- reader.skip(tag & 7);
805
+ return message;
806
+ }
807
+ finally {
808
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
738
809
  }
739
- return message;
740
810
  },
741
811
  create(base) {
742
812
  return exports.AgentFirmwareEvent.fromPartial(base ?? {});
@@ -764,32 +834,42 @@ exports.AgentSetState = {
764
834
  },
765
835
  decode(input, length) {
766
836
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
767
- const end = length === undefined ? reader.len : reader.pos + length;
768
- const message = createBaseAgentSetState();
769
- while (reader.pos < end) {
770
- const tag = reader.uint32();
771
- switch (tag >>> 3) {
772
- case 1: {
773
- if (tag !== 10) {
774
- break;
775
- }
776
- message.stateId = reader.string();
777
- continue;
778
- }
779
- case 2: {
780
- if (tag !== 18) {
781
- break;
782
- }
783
- message.value = reader.string();
784
- continue;
785
- }
837
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
838
+ if (previousRecursionDepth >= 100) {
839
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
840
+ }
841
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
842
+ try {
843
+ const end = length === undefined ? reader.len : reader.pos + length;
844
+ const message = createBaseAgentSetState();
845
+ while (reader.pos < end) {
846
+ const tag = reader.uint32();
847
+ switch (tag >>> 3) {
848
+ case 1: {
849
+ if (tag !== 10) {
850
+ break;
851
+ }
852
+ message.stateId = reader.string();
853
+ continue;
854
+ }
855
+ case 2: {
856
+ if (tag !== 18) {
857
+ break;
858
+ }
859
+ message.value = reader.string();
860
+ continue;
861
+ }
862
+ }
863
+ if ((tag & 7) === 4 || tag === 0) {
864
+ break;
865
+ }
866
+ reader.skip(tag & 7);
786
867
  }
787
- if ((tag & 7) === 4 || tag === 0) {
788
- break;
789
- }
790
- reader.skip(tag & 7);
868
+ return message;
869
+ }
870
+ finally {
871
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
791
872
  }
792
- return message;
793
873
  },
794
874
  create(base) {
795
875
  return exports.AgentSetState.fromPartial(base ?? {});
@@ -813,25 +893,35 @@ exports.AgentWatchMore = {
813
893
  },
814
894
  decode(input, length) {
815
895
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
816
- const end = length === undefined ? reader.len : reader.pos + length;
817
- const message = createBaseAgentWatchMore();
818
- while (reader.pos < end) {
819
- const tag = reader.uint32();
820
- switch (tag >>> 3) {
821
- case 1: {
822
- if (tag !== 10) {
823
- break;
824
- }
825
- message.stateIds.push(reader.string());
826
- continue;
827
- }
896
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
897
+ if (previousRecursionDepth >= 100) {
898
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
899
+ }
900
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
901
+ try {
902
+ const end = length === undefined ? reader.len : reader.pos + length;
903
+ const message = createBaseAgentWatchMore();
904
+ while (reader.pos < end) {
905
+ const tag = reader.uint32();
906
+ switch (tag >>> 3) {
907
+ case 1: {
908
+ if (tag !== 10) {
909
+ break;
910
+ }
911
+ message.stateIds.push(reader.string());
912
+ continue;
913
+ }
914
+ }
915
+ if ((tag & 7) === 4 || tag === 0) {
916
+ break;
917
+ }
918
+ reader.skip(tag & 7);
828
919
  }
829
- if ((tag & 7) === 4 || tag === 0) {
830
- break;
831
- }
832
- reader.skip(tag & 7);
920
+ return message;
921
+ }
922
+ finally {
923
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
833
924
  }
834
- return message;
835
925
  },
836
926
  create(base) {
837
927
  return exports.AgentWatchMore.fromPartial(base ?? {});
@@ -860,39 +950,49 @@ exports.AgentSetResident = {
860
950
  },
861
951
  decode(input, length) {
862
952
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
863
- const end = length === undefined ? reader.len : reader.pos + length;
864
- const message = createBaseAgentSetResident();
865
- while (reader.pos < end) {
866
- const tag = reader.uint32();
867
- switch (tag >>> 3) {
868
- case 1: {
869
- if (tag !== 10) {
870
- break;
871
- }
872
- message.residentId = reader.string();
873
- continue;
874
- }
875
- case 2: {
876
- if (tag !== 16) {
877
- break;
878
- }
879
- message.presenceState = reader.int32();
880
- continue;
881
- }
882
- case 3: {
883
- if (tag !== 24) {
884
- break;
885
- }
886
- message.type = reader.int32();
887
- continue;
888
- }
953
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
954
+ if (previousRecursionDepth >= 100) {
955
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
956
+ }
957
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
958
+ try {
959
+ const end = length === undefined ? reader.len : reader.pos + length;
960
+ const message = createBaseAgentSetResident();
961
+ while (reader.pos < end) {
962
+ const tag = reader.uint32();
963
+ switch (tag >>> 3) {
964
+ case 1: {
965
+ if (tag !== 10) {
966
+ break;
967
+ }
968
+ message.residentId = reader.string();
969
+ continue;
970
+ }
971
+ case 2: {
972
+ if (tag !== 16) {
973
+ break;
974
+ }
975
+ message.presenceState = reader.int32();
976
+ continue;
977
+ }
978
+ case 3: {
979
+ if (tag !== 24) {
980
+ break;
981
+ }
982
+ message.type = reader.int32();
983
+ continue;
984
+ }
985
+ }
986
+ if ((tag & 7) === 4 || tag === 0) {
987
+ break;
988
+ }
989
+ reader.skip(tag & 7);
889
990
  }
890
- if ((tag & 7) === 4 || tag === 0) {
891
- break;
892
- }
893
- reader.skip(tag & 7);
991
+ return message;
992
+ }
993
+ finally {
994
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
894
995
  }
895
- return message;
896
996
  },
897
997
  create(base) {
898
998
  return exports.AgentSetResident.fromPartial(base ?? {});
@@ -923,39 +1023,49 @@ exports.AgentSetResidentMood = {
923
1023
  },
924
1024
  decode(input, length) {
925
1025
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
926
- const end = length === undefined ? reader.len : reader.pos + length;
927
- const message = createBaseAgentSetResidentMood();
928
- while (reader.pos < end) {
929
- const tag = reader.uint32();
930
- switch (tag >>> 3) {
931
- case 1: {
932
- if (tag !== 10) {
933
- break;
934
- }
935
- message.residentId = reader.string();
936
- continue;
937
- }
938
- case 2: {
939
- if (tag !== 16) {
940
- break;
941
- }
942
- message.mood = reader.int32();
943
- continue;
944
- }
945
- case 3: {
946
- if (tag !== 24) {
947
- break;
948
- }
949
- message.type = reader.int32();
950
- continue;
951
- }
952
- }
953
- if ((tag & 7) === 4 || tag === 0) {
954
- break;
1026
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
1027
+ if (previousRecursionDepth >= 100) {
1028
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
1029
+ }
1030
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
1031
+ try {
1032
+ const end = length === undefined ? reader.len : reader.pos + length;
1033
+ const message = createBaseAgentSetResidentMood();
1034
+ while (reader.pos < end) {
1035
+ const tag = reader.uint32();
1036
+ switch (tag >>> 3) {
1037
+ case 1: {
1038
+ if (tag !== 10) {
1039
+ break;
1040
+ }
1041
+ message.residentId = reader.string();
1042
+ continue;
1043
+ }
1044
+ case 2: {
1045
+ if (tag !== 16) {
1046
+ break;
1047
+ }
1048
+ message.mood = reader.int32();
1049
+ continue;
1050
+ }
1051
+ case 3: {
1052
+ if (tag !== 24) {
1053
+ break;
1054
+ }
1055
+ message.type = reader.int32();
1056
+ continue;
1057
+ }
1058
+ }
1059
+ if ((tag & 7) === 4 || tag === 0) {
1060
+ break;
1061
+ }
1062
+ reader.skip(tag & 7);
955
1063
  }
956
- reader.skip(tag & 7);
1064
+ return message;
1065
+ }
1066
+ finally {
1067
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
957
1068
  }
958
- return message;
959
1069
  },
960
1070
  create(base) {
961
1071
  return exports.AgentSetResidentMood.fromPartial(base ?? {});
@@ -1010,74 +1120,84 @@ exports.AgentSatelliteUpdate = {
1010
1120
  },
1011
1121
  decode(input, length) {
1012
1122
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
1013
- const end = length === undefined ? reader.len : reader.pos + length;
1014
- const message = createBaseAgentSatelliteUpdate();
1015
- while (reader.pos < end) {
1016
- const tag = reader.uint32();
1017
- switch (tag >>> 3) {
1018
- case 1: {
1019
- if (tag !== 10) {
1020
- break;
1021
- }
1022
- message.deviceId = reader.string();
1023
- continue;
1024
- }
1025
- case 2: {
1026
- if (tag !== 18) {
1027
- break;
1028
- }
1029
- message.room = reader.string();
1030
- continue;
1031
- }
1032
- case 3: {
1033
- if (tag !== 26) {
1034
- break;
1035
- }
1036
- message.address = reader.string();
1037
- continue;
1038
- }
1039
- case 4: {
1040
- if (tag !== 32) {
1041
- break;
1042
- }
1043
- message.online = reader.bool();
1044
- continue;
1045
- }
1046
- case 5: {
1047
- if (tag !== 40) {
1048
- break;
1049
- }
1050
- message.volume = reader.int32();
1051
- continue;
1052
- }
1053
- case 6: {
1054
- if (tag !== 48) {
1055
- break;
1056
- }
1057
- message.mute = reader.bool();
1058
- continue;
1059
- }
1060
- case 8: {
1061
- if (tag !== 66) {
1062
- break;
1063
- }
1064
- message.displayName = reader.string();
1065
- continue;
1066
- }
1067
- case 9: {
1068
- if (tag !== 72) {
1069
- break;
1070
- }
1071
- message.dnd = reader.bool();
1072
- continue;
1073
- }
1074
- }
1075
- if ((tag & 7) === 4 || tag === 0) {
1076
- break;
1123
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
1124
+ if (previousRecursionDepth >= 100) {
1125
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
1126
+ }
1127
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
1128
+ try {
1129
+ const end = length === undefined ? reader.len : reader.pos + length;
1130
+ const message = createBaseAgentSatelliteUpdate();
1131
+ while (reader.pos < end) {
1132
+ const tag = reader.uint32();
1133
+ switch (tag >>> 3) {
1134
+ case 1: {
1135
+ if (tag !== 10) {
1136
+ break;
1137
+ }
1138
+ message.deviceId = reader.string();
1139
+ continue;
1140
+ }
1141
+ case 2: {
1142
+ if (tag !== 18) {
1143
+ break;
1144
+ }
1145
+ message.room = reader.string();
1146
+ continue;
1147
+ }
1148
+ case 3: {
1149
+ if (tag !== 26) {
1150
+ break;
1151
+ }
1152
+ message.address = reader.string();
1153
+ continue;
1154
+ }
1155
+ case 4: {
1156
+ if (tag !== 32) {
1157
+ break;
1158
+ }
1159
+ message.online = reader.bool();
1160
+ continue;
1161
+ }
1162
+ case 5: {
1163
+ if (tag !== 40) {
1164
+ break;
1165
+ }
1166
+ message.volume = reader.int32();
1167
+ continue;
1168
+ }
1169
+ case 6: {
1170
+ if (tag !== 48) {
1171
+ break;
1172
+ }
1173
+ message.mute = reader.bool();
1174
+ continue;
1175
+ }
1176
+ case 8: {
1177
+ if (tag !== 66) {
1178
+ break;
1179
+ }
1180
+ message.displayName = reader.string();
1181
+ continue;
1182
+ }
1183
+ case 9: {
1184
+ if (tag !== 72) {
1185
+ break;
1186
+ }
1187
+ message.dnd = reader.bool();
1188
+ continue;
1189
+ }
1190
+ }
1191
+ if ((tag & 7) === 4 || tag === 0) {
1192
+ break;
1193
+ }
1194
+ reader.skip(tag & 7);
1077
1195
  }
1078
- reader.skip(tag & 7);
1196
+ return message;
1197
+ }
1198
+ finally {
1199
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
1079
1200
  }
1080
- return message;
1081
1201
  },
1082
1202
  create(base) {
1083
1203
  return exports.AgentSatelliteUpdate.fromPartial(base ?? {});
@@ -1110,32 +1230,42 @@ exports.AgentSatelliteDeleted = {
1110
1230
  },
1111
1231
  decode(input, length) {
1112
1232
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
1113
- const end = length === undefined ? reader.len : reader.pos + length;
1114
- const message = createBaseAgentSatelliteDeleted();
1115
- while (reader.pos < end) {
1116
- const tag = reader.uint32();
1117
- switch (tag >>> 3) {
1118
- case 1: {
1119
- if (tag !== 10) {
1120
- break;
1121
- }
1122
- message.deviceId = reader.string();
1123
- continue;
1124
- }
1125
- case 2: {
1126
- if (tag !== 18) {
1127
- break;
1128
- }
1129
- message.room = reader.string();
1130
- continue;
1131
- }
1132
- }
1133
- if ((tag & 7) === 4 || tag === 0) {
1134
- break;
1233
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
1234
+ if (previousRecursionDepth >= 100) {
1235
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
1236
+ }
1237
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
1238
+ try {
1239
+ const end = length === undefined ? reader.len : reader.pos + length;
1240
+ const message = createBaseAgentSatelliteDeleted();
1241
+ while (reader.pos < end) {
1242
+ const tag = reader.uint32();
1243
+ switch (tag >>> 3) {
1244
+ case 1: {
1245
+ if (tag !== 10) {
1246
+ break;
1247
+ }
1248
+ message.deviceId = reader.string();
1249
+ continue;
1250
+ }
1251
+ case 2: {
1252
+ if (tag !== 18) {
1253
+ break;
1254
+ }
1255
+ message.room = reader.string();
1256
+ continue;
1257
+ }
1258
+ }
1259
+ if ((tag & 7) === 4 || tag === 0) {
1260
+ break;
1261
+ }
1262
+ reader.skip(tag & 7);
1135
1263
  }
1136
- reader.skip(tag & 7);
1264
+ return message;
1265
+ }
1266
+ finally {
1267
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
1137
1268
  }
1138
- return message;
1139
1269
  },
1140
1270
  create(base) {
1141
1271
  return exports.AgentSatelliteDeleted.fromPartial(base ?? {});
@@ -1162,32 +1292,42 @@ exports.AgentTextAnswer = {
1162
1292
  },
1163
1293
  decode(input, length) {
1164
1294
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
1165
- const end = length === undefined ? reader.len : reader.pos + length;
1166
- const message = createBaseAgentTextAnswer();
1167
- while (reader.pos < end) {
1168
- const tag = reader.uint32();
1169
- switch (tag >>> 3) {
1170
- case 1: {
1171
- if (tag !== 10) {
1172
- break;
1173
- }
1174
- message.text = reader.string();
1175
- continue;
1176
- }
1177
- case 2: {
1178
- if (tag !== 18) {
1179
- break;
1180
- }
1181
- message.intent = reader.string();
1182
- continue;
1183
- }
1184
- }
1185
- if ((tag & 7) === 4 || tag === 0) {
1186
- break;
1295
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
1296
+ if (previousRecursionDepth >= 100) {
1297
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
1298
+ }
1299
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
1300
+ try {
1301
+ const end = length === undefined ? reader.len : reader.pos + length;
1302
+ const message = createBaseAgentTextAnswer();
1303
+ while (reader.pos < end) {
1304
+ const tag = reader.uint32();
1305
+ switch (tag >>> 3) {
1306
+ case 1: {
1307
+ if (tag !== 10) {
1308
+ break;
1309
+ }
1310
+ message.text = reader.string();
1311
+ continue;
1312
+ }
1313
+ case 2: {
1314
+ if (tag !== 18) {
1315
+ break;
1316
+ }
1317
+ message.intent = reader.string();
1318
+ continue;
1319
+ }
1320
+ }
1321
+ if ((tag & 7) === 4 || tag === 0) {
1322
+ break;
1323
+ }
1324
+ reader.skip(tag & 7);
1187
1325
  }
1188
- reader.skip(tag & 7);
1326
+ return message;
1327
+ }
1328
+ finally {
1329
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
1189
1330
  }
1190
- return message;
1191
1331
  },
1192
1332
  create(base) {
1193
1333
  return exports.AgentTextAnswer.fromPartial(base ?? {});
@@ -1217,39 +1357,49 @@ exports.AgentNotification = {
1217
1357
  },
1218
1358
  decode(input, length) {
1219
1359
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
1220
- const end = length === undefined ? reader.len : reader.pos + length;
1221
- const message = createBaseAgentNotification();
1222
- while (reader.pos < end) {
1223
- const tag = reader.uint32();
1224
- switch (tag >>> 3) {
1225
- case 1: {
1226
- if (tag !== 10) {
1227
- break;
1228
- }
1229
- message.text = reader.string();
1230
- continue;
1231
- }
1232
- case 2: {
1233
- if (tag !== 16) {
1234
- break;
1235
- }
1236
- message.direct = reader.bool();
1237
- continue;
1238
- }
1239
- case 3: {
1240
- if (tag !== 26) {
1241
- break;
1242
- }
1243
- message.severity = reader.string();
1244
- continue;
1245
- }
1246
- }
1247
- if ((tag & 7) === 4 || tag === 0) {
1248
- break;
1360
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
1361
+ if (previousRecursionDepth >= 100) {
1362
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
1363
+ }
1364
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
1365
+ try {
1366
+ const end = length === undefined ? reader.len : reader.pos + length;
1367
+ const message = createBaseAgentNotification();
1368
+ while (reader.pos < end) {
1369
+ const tag = reader.uint32();
1370
+ switch (tag >>> 3) {
1371
+ case 1: {
1372
+ if (tag !== 10) {
1373
+ break;
1374
+ }
1375
+ message.text = reader.string();
1376
+ continue;
1377
+ }
1378
+ case 2: {
1379
+ if (tag !== 16) {
1380
+ break;
1381
+ }
1382
+ message.direct = reader.bool();
1383
+ continue;
1384
+ }
1385
+ case 3: {
1386
+ if (tag !== 26) {
1387
+ break;
1388
+ }
1389
+ message.severity = reader.string();
1390
+ continue;
1391
+ }
1392
+ }
1393
+ if ((tag & 7) === 4 || tag === 0) {
1394
+ break;
1395
+ }
1396
+ reader.skip(tag & 7);
1249
1397
  }
1250
- reader.skip(tag & 7);
1398
+ return message;
1399
+ }
1400
+ finally {
1401
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
1251
1402
  }
1252
- return message;
1253
1403
  },
1254
1404
  create(base) {
1255
1405
  return exports.AgentNotification.fromPartial(base ?? {});
@@ -1277,32 +1427,42 @@ exports.AgentStateValue = {
1277
1427
  },
1278
1428
  decode(input, length) {
1279
1429
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
1280
- const end = length === undefined ? reader.len : reader.pos + length;
1281
- const message = createBaseAgentStateValue();
1282
- while (reader.pos < end) {
1283
- const tag = reader.uint32();
1284
- switch (tag >>> 3) {
1285
- case 1: {
1286
- if (tag !== 10) {
1287
- break;
1288
- }
1289
- message.value = reader.string();
1290
- continue;
1291
- }
1292
- case 2: {
1293
- if (tag !== 16) {
1294
- break;
1295
- }
1296
- message.ack = reader.bool();
1297
- continue;
1298
- }
1299
- }
1300
- if ((tag & 7) === 4 || tag === 0) {
1301
- break;
1430
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
1431
+ if (previousRecursionDepth >= 100) {
1432
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
1433
+ }
1434
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
1435
+ try {
1436
+ const end = length === undefined ? reader.len : reader.pos + length;
1437
+ const message = createBaseAgentStateValue();
1438
+ while (reader.pos < end) {
1439
+ const tag = reader.uint32();
1440
+ switch (tag >>> 3) {
1441
+ case 1: {
1442
+ if (tag !== 10) {
1443
+ break;
1444
+ }
1445
+ message.value = reader.string();
1446
+ continue;
1447
+ }
1448
+ case 2: {
1449
+ if (tag !== 16) {
1450
+ break;
1451
+ }
1452
+ message.ack = reader.bool();
1453
+ continue;
1454
+ }
1455
+ }
1456
+ if ((tag & 7) === 4 || tag === 0) {
1457
+ break;
1458
+ }
1459
+ reader.skip(tag & 7);
1302
1460
  }
1303
- reader.skip(tag & 7);
1461
+ return message;
1462
+ }
1463
+ finally {
1464
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
1304
1465
  }
1305
- return message;
1306
1466
  },
1307
1467
  create(base) {
1308
1468
  return exports.AgentStateValue.fromPartial(base ?? {});
@@ -1368,98 +1528,108 @@ exports.AgentDevice = {
1368
1528
  },
1369
1529
  decode(input, length) {
1370
1530
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
1371
- const end = length === undefined ? reader.len : reader.pos + length;
1372
- const message = createBaseAgentDevice();
1373
- while (reader.pos < end) {
1374
- const tag = reader.uint32();
1375
- switch (tag >>> 3) {
1376
- case 1: {
1377
- if (tag !== 10) {
1378
- break;
1379
- }
1380
- message.stateId = reader.string();
1381
- continue;
1382
- }
1383
- case 2: {
1384
- if (tag !== 18) {
1385
- break;
1386
- }
1387
- message.floor = reader.string();
1388
- continue;
1389
- }
1390
- case 3: {
1391
- if (tag !== 26) {
1392
- break;
1393
- }
1394
- message.room = reader.string();
1395
- continue;
1396
- }
1397
- case 4: {
1398
- if (tag !== 34) {
1399
- break;
1400
- }
1401
- message.device = reader.string();
1402
- continue;
1403
- }
1404
- case 5: {
1405
- if (tag !== 42) {
1406
- break;
1407
- }
1408
- message.deviceType = reader.string();
1409
- continue;
1410
- }
1411
- case 6: {
1412
- if (tag !== 50) {
1413
- break;
1414
- }
1415
- message.functions.push(reader.string());
1416
- continue;
1417
- }
1418
- case 7: {
1419
- if (tag !== 58) {
1420
- break;
1421
- }
1422
- message.value = exports.AgentStateValue.decode(reader, reader.uint32());
1423
- continue;
1424
- }
1425
- case 8: {
1426
- if (tag !== 66) {
1427
- break;
1428
- }
1429
- const entry8 = exports.AgentDevice_RoomNamesEntry.decode(reader, reader.uint32());
1430
- if (entry8.value !== undefined) {
1431
- message.roomNames[entry8.key] = entry8.value;
1432
- }
1433
- continue;
1434
- }
1435
- case 9: {
1436
- if (tag !== 72) {
1437
- break;
1438
- }
1439
- message.stateType = reader.int32();
1440
- continue;
1441
- }
1442
- case 10: {
1443
- if (tag !== 82) {
1444
- break;
1445
- }
1446
- message.enumValues = shared_1.EnumValues.decode(reader, reader.uint32());
1447
- continue;
1448
- }
1449
- case 11: {
1450
- if (tag !== 88) {
1451
- break;
1452
- }
1453
- message.writable = reader.bool();
1454
- continue;
1455
- }
1531
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
1532
+ if (previousRecursionDepth >= 100) {
1533
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
1534
+ }
1535
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
1536
+ try {
1537
+ const end = length === undefined ? reader.len : reader.pos + length;
1538
+ const message = createBaseAgentDevice();
1539
+ while (reader.pos < end) {
1540
+ const tag = reader.uint32();
1541
+ switch (tag >>> 3) {
1542
+ case 1: {
1543
+ if (tag !== 10) {
1544
+ break;
1545
+ }
1546
+ message.stateId = reader.string();
1547
+ continue;
1548
+ }
1549
+ case 2: {
1550
+ if (tag !== 18) {
1551
+ break;
1552
+ }
1553
+ message.floor = reader.string();
1554
+ continue;
1555
+ }
1556
+ case 3: {
1557
+ if (tag !== 26) {
1558
+ break;
1559
+ }
1560
+ message.room = reader.string();
1561
+ continue;
1562
+ }
1563
+ case 4: {
1564
+ if (tag !== 34) {
1565
+ break;
1566
+ }
1567
+ message.device = reader.string();
1568
+ continue;
1569
+ }
1570
+ case 5: {
1571
+ if (tag !== 42) {
1572
+ break;
1573
+ }
1574
+ message.deviceType = reader.string();
1575
+ continue;
1576
+ }
1577
+ case 6: {
1578
+ if (tag !== 50) {
1579
+ break;
1580
+ }
1581
+ message.functions.push(reader.string());
1582
+ continue;
1583
+ }
1584
+ case 7: {
1585
+ if (tag !== 58) {
1586
+ break;
1587
+ }
1588
+ message.value = exports.AgentStateValue.decode(reader, reader.uint32());
1589
+ continue;
1590
+ }
1591
+ case 8: {
1592
+ if (tag !== 66) {
1593
+ break;
1594
+ }
1595
+ const entry8 = exports.AgentDevice_RoomNamesEntry.decode(reader, reader.uint32());
1596
+ if (entry8.value !== undefined) {
1597
+ message.roomNames[entry8.key] = entry8.value;
1598
+ }
1599
+ continue;
1600
+ }
1601
+ case 9: {
1602
+ if (tag !== 72) {
1603
+ break;
1604
+ }
1605
+ message.stateType = reader.int32();
1606
+ continue;
1607
+ }
1608
+ case 10: {
1609
+ if (tag !== 82) {
1610
+ break;
1611
+ }
1612
+ message.enumValues = shared_1.EnumValues.decode(reader, reader.uint32());
1613
+ continue;
1614
+ }
1615
+ case 11: {
1616
+ if (tag !== 88) {
1617
+ break;
1618
+ }
1619
+ message.writable = reader.bool();
1620
+ continue;
1621
+ }
1622
+ }
1623
+ if ((tag & 7) === 4 || tag === 0) {
1624
+ break;
1625
+ }
1626
+ reader.skip(tag & 7);
1456
1627
  }
1457
- if ((tag & 7) === 4 || tag === 0) {
1458
- break;
1459
- }
1460
- reader.skip(tag & 7);
1628
+ return message;
1629
+ }
1630
+ finally {
1631
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
1461
1632
  }
1462
- return message;
1463
1633
  },
1464
1634
  create(base) {
1465
1635
  return exports.AgentDevice.fromPartial(base ?? {});
@@ -1504,32 +1674,42 @@ exports.AgentDevice_RoomNamesEntry = {
1504
1674
  },
1505
1675
  decode(input, length) {
1506
1676
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
1507
- const end = length === undefined ? reader.len : reader.pos + length;
1508
- const message = createBaseAgentDevice_RoomNamesEntry();
1509
- while (reader.pos < end) {
1510
- const tag = reader.uint32();
1511
- switch (tag >>> 3) {
1512
- case 1: {
1513
- if (tag !== 10) {
1514
- break;
1515
- }
1516
- message.key = reader.string();
1517
- continue;
1518
- }
1519
- case 2: {
1520
- if (tag !== 18) {
1521
- break;
1522
- }
1523
- message.value = reader.string();
1524
- continue;
1525
- }
1526
- }
1527
- if ((tag & 7) === 4 || tag === 0) {
1528
- break;
1677
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
1678
+ if (previousRecursionDepth >= 100) {
1679
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
1680
+ }
1681
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
1682
+ try {
1683
+ const end = length === undefined ? reader.len : reader.pos + length;
1684
+ const message = createBaseAgentDevice_RoomNamesEntry();
1685
+ while (reader.pos < end) {
1686
+ const tag = reader.uint32();
1687
+ switch (tag >>> 3) {
1688
+ case 1: {
1689
+ if (tag !== 10) {
1690
+ break;
1691
+ }
1692
+ message.key = reader.string();
1693
+ continue;
1694
+ }
1695
+ case 2: {
1696
+ if (tag !== 18) {
1697
+ break;
1698
+ }
1699
+ message.value = reader.string();
1700
+ continue;
1701
+ }
1702
+ }
1703
+ if ((tag & 7) === 4 || tag === 0) {
1704
+ break;
1705
+ }
1706
+ reader.skip(tag & 7);
1529
1707
  }
1530
- reader.skip(tag & 7);
1708
+ return message;
1709
+ }
1710
+ finally {
1711
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
1531
1712
  }
1532
- return message;
1533
1713
  },
1534
1714
  create(base) {
1535
1715
  return exports.AgentDevice_RoomNamesEntry.fromPartial(base ?? {});
@@ -1553,25 +1733,35 @@ exports.AgentDeviceSnapshot = {
1553
1733
  },
1554
1734
  decode(input, length) {
1555
1735
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
1556
- const end = length === undefined ? reader.len : reader.pos + length;
1557
- const message = createBaseAgentDeviceSnapshot();
1558
- while (reader.pos < end) {
1559
- const tag = reader.uint32();
1560
- switch (tag >>> 3) {
1561
- case 1: {
1562
- if (tag !== 10) {
1563
- break;
1564
- }
1565
- message.devices.push(exports.AgentDevice.decode(reader, reader.uint32()));
1566
- continue;
1567
- }
1568
- }
1569
- if ((tag & 7) === 4 || tag === 0) {
1570
- break;
1736
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
1737
+ if (previousRecursionDepth >= 100) {
1738
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
1739
+ }
1740
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
1741
+ try {
1742
+ const end = length === undefined ? reader.len : reader.pos + length;
1743
+ const message = createBaseAgentDeviceSnapshot();
1744
+ while (reader.pos < end) {
1745
+ const tag = reader.uint32();
1746
+ switch (tag >>> 3) {
1747
+ case 1: {
1748
+ if (tag !== 10) {
1749
+ break;
1750
+ }
1751
+ message.devices.push(exports.AgentDevice.decode(reader, reader.uint32()));
1752
+ continue;
1753
+ }
1754
+ }
1755
+ if ((tag & 7) === 4 || tag === 0) {
1756
+ break;
1757
+ }
1758
+ reader.skip(tag & 7);
1571
1759
  }
1572
- reader.skip(tag & 7);
1760
+ return message;
1761
+ }
1762
+ finally {
1763
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
1573
1764
  }
1574
- return message;
1575
1765
  },
1576
1766
  create(base) {
1577
1767
  return exports.AgentDeviceSnapshot.fromPartial(base ?? {});
@@ -1597,35 +1787,45 @@ exports.AgentRoom = {
1597
1787
  },
1598
1788
  decode(input, length) {
1599
1789
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
1600
- const end = length === undefined ? reader.len : reader.pos + length;
1601
- const message = createBaseAgentRoom();
1602
- while (reader.pos < end) {
1603
- const tag = reader.uint32();
1604
- switch (tag >>> 3) {
1605
- case 1: {
1606
- if (tag !== 10) {
1607
- break;
1608
- }
1609
- message.roomId = reader.string();
1610
- continue;
1611
- }
1612
- case 2: {
1613
- if (tag !== 18) {
1614
- break;
1615
- }
1616
- const entry2 = exports.AgentRoom_DisplayNamesEntry.decode(reader, reader.uint32());
1617
- if (entry2.value !== undefined) {
1618
- message.displayNames[entry2.key] = entry2.value;
1619
- }
1620
- continue;
1621
- }
1622
- }
1623
- if ((tag & 7) === 4 || tag === 0) {
1624
- break;
1790
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
1791
+ if (previousRecursionDepth >= 100) {
1792
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
1793
+ }
1794
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
1795
+ try {
1796
+ const end = length === undefined ? reader.len : reader.pos + length;
1797
+ const message = createBaseAgentRoom();
1798
+ while (reader.pos < end) {
1799
+ const tag = reader.uint32();
1800
+ switch (tag >>> 3) {
1801
+ case 1: {
1802
+ if (tag !== 10) {
1803
+ break;
1804
+ }
1805
+ message.roomId = reader.string();
1806
+ continue;
1807
+ }
1808
+ case 2: {
1809
+ if (tag !== 18) {
1810
+ break;
1811
+ }
1812
+ const entry2 = exports.AgentRoom_DisplayNamesEntry.decode(reader, reader.uint32());
1813
+ if (entry2.value !== undefined) {
1814
+ message.displayNames[entry2.key] = entry2.value;
1815
+ }
1816
+ continue;
1817
+ }
1818
+ }
1819
+ if ((tag & 7) === 4 || tag === 0) {
1820
+ break;
1821
+ }
1822
+ reader.skip(tag & 7);
1625
1823
  }
1626
- reader.skip(tag & 7);
1824
+ return message;
1825
+ }
1826
+ finally {
1827
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
1627
1828
  }
1628
- return message;
1629
1829
  },
1630
1830
  create(base) {
1631
1831
  return exports.AgentRoom.fromPartial(base ?? {});
@@ -1657,32 +1857,42 @@ exports.AgentRoom_DisplayNamesEntry = {
1657
1857
  },
1658
1858
  decode(input, length) {
1659
1859
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
1660
- const end = length === undefined ? reader.len : reader.pos + length;
1661
- const message = createBaseAgentRoom_DisplayNamesEntry();
1662
- while (reader.pos < end) {
1663
- const tag = reader.uint32();
1664
- switch (tag >>> 3) {
1665
- case 1: {
1666
- if (tag !== 10) {
1667
- break;
1668
- }
1669
- message.key = reader.string();
1670
- continue;
1671
- }
1672
- case 2: {
1673
- if (tag !== 18) {
1674
- break;
1675
- }
1676
- message.value = reader.string();
1677
- continue;
1678
- }
1679
- }
1680
- if ((tag & 7) === 4 || tag === 0) {
1681
- break;
1860
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
1861
+ if (previousRecursionDepth >= 100) {
1862
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
1863
+ }
1864
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
1865
+ try {
1866
+ const end = length === undefined ? reader.len : reader.pos + length;
1867
+ const message = createBaseAgentRoom_DisplayNamesEntry();
1868
+ while (reader.pos < end) {
1869
+ const tag = reader.uint32();
1870
+ switch (tag >>> 3) {
1871
+ case 1: {
1872
+ if (tag !== 10) {
1873
+ break;
1874
+ }
1875
+ message.key = reader.string();
1876
+ continue;
1877
+ }
1878
+ case 2: {
1879
+ if (tag !== 18) {
1880
+ break;
1881
+ }
1882
+ message.value = reader.string();
1883
+ continue;
1884
+ }
1885
+ }
1886
+ if ((tag & 7) === 4 || tag === 0) {
1887
+ break;
1888
+ }
1889
+ reader.skip(tag & 7);
1682
1890
  }
1683
- reader.skip(tag & 7);
1891
+ return message;
1892
+ }
1893
+ finally {
1894
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
1684
1895
  }
1685
- return message;
1686
1896
  },
1687
1897
  create(base) {
1688
1898
  return exports.AgentRoom_DisplayNamesEntry.fromPartial(base ?? {});
@@ -1706,25 +1916,35 @@ exports.AgentRoomSnapshot = {
1706
1916
  },
1707
1917
  decode(input, length) {
1708
1918
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
1709
- const end = length === undefined ? reader.len : reader.pos + length;
1710
- const message = createBaseAgentRoomSnapshot();
1711
- while (reader.pos < end) {
1712
- const tag = reader.uint32();
1713
- switch (tag >>> 3) {
1714
- case 1: {
1715
- if (tag !== 10) {
1716
- break;
1717
- }
1718
- message.rooms.push(exports.AgentRoom.decode(reader, reader.uint32()));
1719
- continue;
1720
- }
1721
- }
1722
- if ((tag & 7) === 4 || tag === 0) {
1723
- break;
1919
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
1920
+ if (previousRecursionDepth >= 100) {
1921
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
1922
+ }
1923
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
1924
+ try {
1925
+ const end = length === undefined ? reader.len : reader.pos + length;
1926
+ const message = createBaseAgentRoomSnapshot();
1927
+ while (reader.pos < end) {
1928
+ const tag = reader.uint32();
1929
+ switch (tag >>> 3) {
1930
+ case 1: {
1931
+ if (tag !== 10) {
1932
+ break;
1933
+ }
1934
+ message.rooms.push(exports.AgentRoom.decode(reader, reader.uint32()));
1935
+ continue;
1936
+ }
1937
+ }
1938
+ if ((tag & 7) === 4 || tag === 0) {
1939
+ break;
1940
+ }
1941
+ reader.skip(tag & 7);
1724
1942
  }
1725
- reader.skip(tag & 7);
1943
+ return message;
1944
+ }
1945
+ finally {
1946
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
1726
1947
  }
1727
- return message;
1728
1948
  },
1729
1949
  create(base) {
1730
1950
  return exports.AgentRoomSnapshot.fromPartial(base ?? {});
@@ -1759,53 +1979,63 @@ exports.AgentResident = {
1759
1979
  },
1760
1980
  decode(input, length) {
1761
1981
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
1762
- const end = length === undefined ? reader.len : reader.pos + length;
1763
- const message = createBaseAgentResident();
1764
- while (reader.pos < end) {
1765
- const tag = reader.uint32();
1766
- switch (tag >>> 3) {
1767
- case 1: {
1768
- if (tag !== 10) {
1769
- break;
1770
- }
1771
- message.roomieId = reader.string();
1772
- continue;
1773
- }
1774
- case 2: {
1775
- if (tag !== 18) {
1776
- break;
1777
- }
1778
- message.name = reader.string();
1779
- continue;
1780
- }
1781
- case 3: {
1782
- if (tag !== 24) {
1783
- break;
1784
- }
1785
- message.type = reader.int32();
1786
- continue;
1787
- }
1788
- case 4: {
1789
- if (tag !== 32) {
1790
- break;
1791
- }
1792
- message.moodLevel = reader.int32();
1793
- continue;
1794
- }
1795
- case 5: {
1796
- if (tag !== 40) {
1797
- break;
1798
- }
1799
- message.presenceState = reader.int32();
1800
- continue;
1801
- }
1802
- }
1803
- if ((tag & 7) === 4 || tag === 0) {
1804
- break;
1982
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
1983
+ if (previousRecursionDepth >= 100) {
1984
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
1985
+ }
1986
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
1987
+ try {
1988
+ const end = length === undefined ? reader.len : reader.pos + length;
1989
+ const message = createBaseAgentResident();
1990
+ while (reader.pos < end) {
1991
+ const tag = reader.uint32();
1992
+ switch (tag >>> 3) {
1993
+ case 1: {
1994
+ if (tag !== 10) {
1995
+ break;
1996
+ }
1997
+ message.roomieId = reader.string();
1998
+ continue;
1999
+ }
2000
+ case 2: {
2001
+ if (tag !== 18) {
2002
+ break;
2003
+ }
2004
+ message.name = reader.string();
2005
+ continue;
2006
+ }
2007
+ case 3: {
2008
+ if (tag !== 24) {
2009
+ break;
2010
+ }
2011
+ message.type = reader.int32();
2012
+ continue;
2013
+ }
2014
+ case 4: {
2015
+ if (tag !== 32) {
2016
+ break;
2017
+ }
2018
+ message.moodLevel = reader.int32();
2019
+ continue;
2020
+ }
2021
+ case 5: {
2022
+ if (tag !== 40) {
2023
+ break;
2024
+ }
2025
+ message.presenceState = reader.int32();
2026
+ continue;
2027
+ }
2028
+ }
2029
+ if ((tag & 7) === 4 || tag === 0) {
2030
+ break;
2031
+ }
2032
+ reader.skip(tag & 7);
1805
2033
  }
1806
- reader.skip(tag & 7);
2034
+ return message;
2035
+ }
2036
+ finally {
2037
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
1807
2038
  }
1808
- return message;
1809
2039
  },
1810
2040
  create(base) {
1811
2041
  return exports.AgentResident.fromPartial(base ?? {});
@@ -1832,25 +2062,35 @@ exports.AgentResidentSnapshot = {
1832
2062
  },
1833
2063
  decode(input, length) {
1834
2064
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
1835
- const end = length === undefined ? reader.len : reader.pos + length;
1836
- const message = createBaseAgentResidentSnapshot();
1837
- while (reader.pos < end) {
1838
- const tag = reader.uint32();
1839
- switch (tag >>> 3) {
1840
- case 1: {
1841
- if (tag !== 10) {
1842
- break;
1843
- }
1844
- message.residents.push(exports.AgentResident.decode(reader, reader.uint32()));
1845
- continue;
1846
- }
1847
- }
1848
- if ((tag & 7) === 4 || tag === 0) {
1849
- break;
2065
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
2066
+ if (previousRecursionDepth >= 100) {
2067
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
2068
+ }
2069
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
2070
+ try {
2071
+ const end = length === undefined ? reader.len : reader.pos + length;
2072
+ const message = createBaseAgentResidentSnapshot();
2073
+ while (reader.pos < end) {
2074
+ const tag = reader.uint32();
2075
+ switch (tag >>> 3) {
2076
+ case 1: {
2077
+ if (tag !== 10) {
2078
+ break;
2079
+ }
2080
+ message.residents.push(exports.AgentResident.decode(reader, reader.uint32()));
2081
+ continue;
2082
+ }
2083
+ }
2084
+ if ((tag & 7) === 4 || tag === 0) {
2085
+ break;
2086
+ }
2087
+ reader.skip(tag & 7);
1850
2088
  }
1851
- reader.skip(tag & 7);
2089
+ return message;
2090
+ }
2091
+ finally {
2092
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
1852
2093
  }
1853
- return message;
1854
2094
  },
1855
2095
  create(base) {
1856
2096
  return exports.AgentResidentSnapshot.fromPartial(base ?? {});
@@ -1879,39 +2119,49 @@ exports.AgentAskResident = {
1879
2119
  },
1880
2120
  decode(input, length) {
1881
2121
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
1882
- const end = length === undefined ? reader.len : reader.pos + length;
1883
- const message = createBaseAgentAskResident();
1884
- while (reader.pos < end) {
1885
- const tag = reader.uint32();
1886
- switch (tag >>> 3) {
1887
- case 3: {
1888
- if (tag !== 26) {
1889
- break;
1890
- }
1891
- message.correlationId = reader.string();
1892
- continue;
1893
- }
1894
- case 1: {
1895
- if (tag !== 10) {
1896
- break;
1897
- }
1898
- message.room = reader.string();
1899
- continue;
1900
- }
1901
- case 2: {
1902
- if (tag !== 18) {
1903
- break;
1904
- }
1905
- message.question = reader.string();
1906
- continue;
1907
- }
2122
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
2123
+ if (previousRecursionDepth >= 100) {
2124
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
2125
+ }
2126
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
2127
+ try {
2128
+ const end = length === undefined ? reader.len : reader.pos + length;
2129
+ const message = createBaseAgentAskResident();
2130
+ while (reader.pos < end) {
2131
+ const tag = reader.uint32();
2132
+ switch (tag >>> 3) {
2133
+ case 3: {
2134
+ if (tag !== 26) {
2135
+ break;
2136
+ }
2137
+ message.correlationId = reader.string();
2138
+ continue;
2139
+ }
2140
+ case 1: {
2141
+ if (tag !== 10) {
2142
+ break;
2143
+ }
2144
+ message.room = reader.string();
2145
+ continue;
2146
+ }
2147
+ case 2: {
2148
+ if (tag !== 18) {
2149
+ break;
2150
+ }
2151
+ message.question = reader.string();
2152
+ continue;
2153
+ }
2154
+ }
2155
+ if ((tag & 7) === 4 || tag === 0) {
2156
+ break;
2157
+ }
2158
+ reader.skip(tag & 7);
1908
2159
  }
1909
- if ((tag & 7) === 4 || tag === 0) {
1910
- break;
1911
- }
1912
- reader.skip(tag & 7);
2160
+ return message;
2161
+ }
2162
+ finally {
2163
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
1913
2164
  }
1914
- return message;
1915
2165
  },
1916
2166
  create(base) {
1917
2167
  return exports.AgentAskResident.fromPartial(base ?? {});
@@ -1939,32 +2189,42 @@ exports.AgentResidentAnswered = {
1939
2189
  },
1940
2190
  decode(input, length) {
1941
2191
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
1942
- const end = length === undefined ? reader.len : reader.pos + length;
1943
- const message = createBaseAgentResidentAnswered();
1944
- while (reader.pos < end) {
1945
- const tag = reader.uint32();
1946
- switch (tag >>> 3) {
1947
- case 1: {
1948
- if (tag !== 10) {
1949
- break;
1950
- }
1951
- message.correlationId = reader.string();
1952
- continue;
1953
- }
1954
- case 2: {
1955
- if (tag !== 18) {
1956
- break;
1957
- }
1958
- message.answer = reader.string();
1959
- continue;
1960
- }
2192
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
2193
+ if (previousRecursionDepth >= 100) {
2194
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
2195
+ }
2196
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
2197
+ try {
2198
+ const end = length === undefined ? reader.len : reader.pos + length;
2199
+ const message = createBaseAgentResidentAnswered();
2200
+ while (reader.pos < end) {
2201
+ const tag = reader.uint32();
2202
+ switch (tag >>> 3) {
2203
+ case 1: {
2204
+ if (tag !== 10) {
2205
+ break;
2206
+ }
2207
+ message.correlationId = reader.string();
2208
+ continue;
2209
+ }
2210
+ case 2: {
2211
+ if (tag !== 18) {
2212
+ break;
2213
+ }
2214
+ message.answer = reader.string();
2215
+ continue;
2216
+ }
2217
+ }
2218
+ if ((tag & 7) === 4 || tag === 0) {
2219
+ break;
2220
+ }
2221
+ reader.skip(tag & 7);
1961
2222
  }
1962
- if ((tag & 7) === 4 || tag === 0) {
1963
- break;
1964
- }
1965
- reader.skip(tag & 7);
2223
+ return message;
2224
+ }
2225
+ finally {
2226
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
1966
2227
  }
1967
- return message;
1968
2228
  },
1969
2229
  create(base) {
1970
2230
  return exports.AgentResidentAnswered.fromPartial(base ?? {});
@@ -2000,53 +2260,63 @@ exports.AgentBleUpdate = {
2000
2260
  },
2001
2261
  decode(input, length) {
2002
2262
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
2003
- const end = length === undefined ? reader.len : reader.pos + length;
2004
- const message = createBaseAgentBleUpdate();
2005
- while (reader.pos < end) {
2006
- const tag = reader.uint32();
2007
- switch (tag >>> 3) {
2008
- case 1: {
2009
- if (tag !== 10) {
2010
- break;
2011
- }
2012
- message.label = reader.string();
2013
- continue;
2014
- }
2015
- case 2: {
2016
- if (tag !== 18) {
2017
- break;
2018
- }
2019
- message.mac = reader.string();
2020
- continue;
2021
- }
2022
- case 3: {
2023
- if (tag !== 26) {
2024
- break;
2025
- }
2026
- message.room = reader.string();
2027
- continue;
2028
- }
2029
- case 4: {
2030
- if (tag !== 34) {
2031
- break;
2032
- }
2033
- message.satellite = reader.string();
2034
- continue;
2035
- }
2036
- case 5: {
2037
- if (tag !== 40) {
2038
- break;
2039
- }
2040
- message.rssi = reader.int32();
2041
- continue;
2042
- }
2043
- }
2044
- if ((tag & 7) === 4 || tag === 0) {
2045
- break;
2263
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
2264
+ if (previousRecursionDepth >= 100) {
2265
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
2266
+ }
2267
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
2268
+ try {
2269
+ const end = length === undefined ? reader.len : reader.pos + length;
2270
+ const message = createBaseAgentBleUpdate();
2271
+ while (reader.pos < end) {
2272
+ const tag = reader.uint32();
2273
+ switch (tag >>> 3) {
2274
+ case 1: {
2275
+ if (tag !== 10) {
2276
+ break;
2277
+ }
2278
+ message.label = reader.string();
2279
+ continue;
2280
+ }
2281
+ case 2: {
2282
+ if (tag !== 18) {
2283
+ break;
2284
+ }
2285
+ message.mac = reader.string();
2286
+ continue;
2287
+ }
2288
+ case 3: {
2289
+ if (tag !== 26) {
2290
+ break;
2291
+ }
2292
+ message.room = reader.string();
2293
+ continue;
2294
+ }
2295
+ case 4: {
2296
+ if (tag !== 34) {
2297
+ break;
2298
+ }
2299
+ message.satellite = reader.string();
2300
+ continue;
2301
+ }
2302
+ case 5: {
2303
+ if (tag !== 40) {
2304
+ break;
2305
+ }
2306
+ message.rssi = reader.int32();
2307
+ continue;
2308
+ }
2309
+ }
2310
+ if ((tag & 7) === 4 || tag === 0) {
2311
+ break;
2312
+ }
2313
+ reader.skip(tag & 7);
2046
2314
  }
2047
- reader.skip(tag & 7);
2315
+ return message;
2316
+ }
2317
+ finally {
2318
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
2048
2319
  }
2049
- return message;
2050
2320
  },
2051
2321
  create(base) {
2052
2322
  return exports.AgentBleUpdate.fromPartial(base ?? {});
@@ -2094,74 +2364,84 @@ exports.AgentSensorUpdate = {
2094
2364
  },
2095
2365
  decode(input, length) {
2096
2366
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
2097
- const end = length === undefined ? reader.len : reader.pos + length;
2098
- const message = createBaseAgentSensorUpdate();
2099
- while (reader.pos < end) {
2100
- const tag = reader.uint32();
2101
- switch (tag >>> 3) {
2102
- case 1: {
2103
- if (tag !== 10) {
2104
- break;
2105
- }
2106
- message.device = reader.string();
2107
- continue;
2108
- }
2109
- case 2: {
2110
- if (tag !== 21) {
2111
- break;
2112
- }
2113
- message.temperature = reader.float();
2114
- continue;
2115
- }
2116
- case 3: {
2117
- if (tag !== 29) {
2118
- break;
2119
- }
2120
- message.pressure = reader.float();
2121
- continue;
2122
- }
2123
- case 4: {
2124
- if (tag !== 37) {
2125
- break;
2126
- }
2127
- message.humidity = reader.float();
2128
- continue;
2129
- }
2130
- case 6: {
2131
- if (tag !== 53) {
2132
- break;
2133
- }
2134
- message.iaq = reader.float();
2135
- continue;
2136
- }
2137
- case 7: {
2138
- if (tag !== 56) {
2139
- break;
2140
- }
2141
- message.iaqAccuracy = reader.uint32();
2142
- continue;
2143
- }
2144
- case 8: {
2145
- if (tag !== 69) {
2146
- break;
2147
- }
2148
- message.co2Equiv = reader.float();
2149
- continue;
2150
- }
2151
- case 9: {
2152
- if (tag !== 77) {
2153
- break;
2154
- }
2155
- message.vocEquiv = reader.float();
2156
- continue;
2157
- }
2158
- }
2159
- if ((tag & 7) === 4 || tag === 0) {
2160
- break;
2367
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
2368
+ if (previousRecursionDepth >= 100) {
2369
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
2370
+ }
2371
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
2372
+ try {
2373
+ const end = length === undefined ? reader.len : reader.pos + length;
2374
+ const message = createBaseAgentSensorUpdate();
2375
+ while (reader.pos < end) {
2376
+ const tag = reader.uint32();
2377
+ switch (tag >>> 3) {
2378
+ case 1: {
2379
+ if (tag !== 10) {
2380
+ break;
2381
+ }
2382
+ message.device = reader.string();
2383
+ continue;
2384
+ }
2385
+ case 2: {
2386
+ if (tag !== 21) {
2387
+ break;
2388
+ }
2389
+ message.temperature = reader.float();
2390
+ continue;
2391
+ }
2392
+ case 3: {
2393
+ if (tag !== 29) {
2394
+ break;
2395
+ }
2396
+ message.pressure = reader.float();
2397
+ continue;
2398
+ }
2399
+ case 4: {
2400
+ if (tag !== 37) {
2401
+ break;
2402
+ }
2403
+ message.humidity = reader.float();
2404
+ continue;
2405
+ }
2406
+ case 6: {
2407
+ if (tag !== 53) {
2408
+ break;
2409
+ }
2410
+ message.iaq = reader.float();
2411
+ continue;
2412
+ }
2413
+ case 7: {
2414
+ if (tag !== 56) {
2415
+ break;
2416
+ }
2417
+ message.iaqAccuracy = reader.uint32();
2418
+ continue;
2419
+ }
2420
+ case 8: {
2421
+ if (tag !== 69) {
2422
+ break;
2423
+ }
2424
+ message.co2Equiv = reader.float();
2425
+ continue;
2426
+ }
2427
+ case 9: {
2428
+ if (tag !== 77) {
2429
+ break;
2430
+ }
2431
+ message.vocEquiv = reader.float();
2432
+ continue;
2433
+ }
2434
+ }
2435
+ if ((tag & 7) === 4 || tag === 0) {
2436
+ break;
2437
+ }
2438
+ reader.skip(tag & 7);
2161
2439
  }
2162
- reader.skip(tag & 7);
2440
+ return message;
2441
+ }
2442
+ finally {
2443
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
2163
2444
  }
2164
- return message;
2165
2445
  },
2166
2446
  create(base) {
2167
2447
  return exports.AgentSensorUpdate.fromPartial(base ?? {});