@m1kad0/hannah-proto 3.7.1 → 3.8.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.
Files changed (26) hide show
  1. package/dist/activity_log.js +216 -166
  2. package/dist/agent.d.ts +17 -0
  3. package/dist/agent.js +1354 -1050
  4. package/dist/automation.js +142 -92
  5. package/dist/car_state.js +245 -195
  6. package/dist/compat_versions.js +1 -1
  7. package/dist/control.js +1675 -1255
  8. package/dist/descriptor.binpb +0 -0
  9. package/dist/device_control_menu.js +302 -222
  10. package/dist/event_stream.js +236 -166
  11. package/dist/google/protobuf/descriptor.js +1721 -1381
  12. package/dist/hannah.js +1 -1
  13. package/dist/messages.js +198 -148
  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
- }
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);
137
148
  }
138
- if ((tag & 7) === 4 || tag === 0) {
139
- break;
140
- }
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
- }
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);
294
315
  }
295
- if ((tag & 7) === 4 || tag === 0) {
296
- break;
297
- }
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
- }
365
- }
366
- if ((tag & 7) === 4 || tag === 0) {
367
- break;
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);
368
396
  }
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
- }
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);
443
484
  }
444
- if ((tag & 7) === 4 || tag === 0) {
445
- break;
446
- }
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
- }
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);
487
538
  }
488
- if ((tag & 7) === 4 || tag === 0) {
489
- break;
490
- }
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
- }
640
- }
641
- if ((tag & 7) === 4 || tag === 0) {
642
- break;
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);
643
701
  }
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
- }
786
- }
787
- if ((tag & 7) === 4 || tag === 0) {
788
- break;
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);
789
867
  }
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
- }
828
- }
829
- if ((tag & 7) === 4 || tag === 0) {
830
- break;
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);
831
919
  }
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
- }
889
- }
890
- if ((tag & 7) === 4 || tag === 0) {
891
- break;
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);
892
990
  }
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
- }
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);
1246
1397
  }
1247
- if ((tag & 7) === 4 || tag === 0) {
1248
- break;
1249
- }
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 ?? {});
@@ -1327,6 +1487,8 @@ function createBaseAgentDevice() {
1327
1487
  stateType: 0,
1328
1488
  enumValues: undefined,
1329
1489
  writable: false,
1490
+ deviceId: "",
1491
+ canonicalKey: "",
1330
1492
  };
1331
1493
  }
1332
1494
  exports.AgentDevice = {
@@ -1364,102 +1526,132 @@ exports.AgentDevice = {
1364
1526
  if (message.writable !== false) {
1365
1527
  writer.uint32(88).bool(message.writable);
1366
1528
  }
1529
+ if (message.deviceId !== "") {
1530
+ writer.uint32(98).string(message.deviceId);
1531
+ }
1532
+ if (message.canonicalKey !== "") {
1533
+ writer.uint32(106).string(message.canonicalKey);
1534
+ }
1367
1535
  return writer;
1368
1536
  },
1369
1537
  decode(input, length) {
1370
1538
  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
- }
1539
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
1540
+ if (previousRecursionDepth >= 100) {
1541
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
1542
+ }
1543
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
1544
+ try {
1545
+ const end = length === undefined ? reader.len : reader.pos + length;
1546
+ const message = createBaseAgentDevice();
1547
+ while (reader.pos < end) {
1548
+ const tag = reader.uint32();
1549
+ switch (tag >>> 3) {
1550
+ case 1: {
1551
+ if (tag !== 10) {
1552
+ break;
1553
+ }
1554
+ message.stateId = reader.string();
1555
+ continue;
1556
+ }
1557
+ case 2: {
1558
+ if (tag !== 18) {
1559
+ break;
1560
+ }
1561
+ message.floor = reader.string();
1562
+ continue;
1563
+ }
1564
+ case 3: {
1565
+ if (tag !== 26) {
1566
+ break;
1567
+ }
1568
+ message.room = reader.string();
1569
+ continue;
1570
+ }
1571
+ case 4: {
1572
+ if (tag !== 34) {
1573
+ break;
1574
+ }
1575
+ message.device = reader.string();
1576
+ continue;
1577
+ }
1578
+ case 5: {
1579
+ if (tag !== 42) {
1580
+ break;
1581
+ }
1582
+ message.deviceType = reader.string();
1583
+ continue;
1584
+ }
1585
+ case 6: {
1586
+ if (tag !== 50) {
1587
+ break;
1588
+ }
1589
+ message.functions.push(reader.string());
1590
+ continue;
1591
+ }
1592
+ case 7: {
1593
+ if (tag !== 58) {
1594
+ break;
1595
+ }
1596
+ message.value = exports.AgentStateValue.decode(reader, reader.uint32());
1597
+ continue;
1598
+ }
1599
+ case 8: {
1600
+ if (tag !== 66) {
1601
+ break;
1602
+ }
1603
+ const entry8 = exports.AgentDevice_RoomNamesEntry.decode(reader, reader.uint32());
1604
+ if (entry8.value !== undefined) {
1605
+ message.roomNames[entry8.key] = entry8.value;
1606
+ }
1607
+ continue;
1608
+ }
1609
+ case 9: {
1610
+ if (tag !== 72) {
1611
+ break;
1612
+ }
1613
+ message.stateType = reader.int32();
1614
+ continue;
1615
+ }
1616
+ case 10: {
1617
+ if (tag !== 82) {
1618
+ break;
1619
+ }
1620
+ message.enumValues = shared_1.EnumValues.decode(reader, reader.uint32());
1621
+ continue;
1622
+ }
1623
+ case 11: {
1624
+ if (tag !== 88) {
1625
+ break;
1626
+ }
1627
+ message.writable = reader.bool();
1628
+ continue;
1629
+ }
1630
+ case 12: {
1631
+ if (tag !== 98) {
1632
+ break;
1633
+ }
1634
+ message.deviceId = reader.string();
1635
+ continue;
1636
+ }
1637
+ case 13: {
1638
+ if (tag !== 106) {
1639
+ break;
1640
+ }
1641
+ message.canonicalKey = reader.string();
1642
+ continue;
1643
+ }
1644
+ }
1645
+ if ((tag & 7) === 4 || tag === 0) {
1646
+ break;
1647
+ }
1648
+ reader.skip(tag & 7);
1456
1649
  }
1457
- if ((tag & 7) === 4 || tag === 0) {
1458
- break;
1459
- }
1460
- reader.skip(tag & 7);
1650
+ return message;
1651
+ }
1652
+ finally {
1653
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
1461
1654
  }
1462
- return message;
1463
1655
  },
1464
1656
  create(base) {
1465
1657
  return exports.AgentDevice.fromPartial(base ?? {});
@@ -1486,6 +1678,8 @@ exports.AgentDevice = {
1486
1678
  ? shared_1.EnumValues.fromPartial(object.enumValues)
1487
1679
  : undefined;
1488
1680
  message.writable = object.writable ?? false;
1681
+ message.deviceId = object.deviceId ?? "";
1682
+ message.canonicalKey = object.canonicalKey ?? "";
1489
1683
  return message;
1490
1684
  },
1491
1685
  };
@@ -1504,32 +1698,42 @@ exports.AgentDevice_RoomNamesEntry = {
1504
1698
  },
1505
1699
  decode(input, length) {
1506
1700
  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;
1701
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
1702
+ if (previousRecursionDepth >= 100) {
1703
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
1704
+ }
1705
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
1706
+ try {
1707
+ const end = length === undefined ? reader.len : reader.pos + length;
1708
+ const message = createBaseAgentDevice_RoomNamesEntry();
1709
+ while (reader.pos < end) {
1710
+ const tag = reader.uint32();
1711
+ switch (tag >>> 3) {
1712
+ case 1: {
1713
+ if (tag !== 10) {
1714
+ break;
1715
+ }
1716
+ message.key = reader.string();
1717
+ continue;
1718
+ }
1719
+ case 2: {
1720
+ if (tag !== 18) {
1721
+ break;
1722
+ }
1723
+ message.value = reader.string();
1724
+ continue;
1725
+ }
1726
+ }
1727
+ if ((tag & 7) === 4 || tag === 0) {
1728
+ break;
1729
+ }
1730
+ reader.skip(tag & 7);
1529
1731
  }
1530
- reader.skip(tag & 7);
1732
+ return message;
1733
+ }
1734
+ finally {
1735
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
1531
1736
  }
1532
- return message;
1533
1737
  },
1534
1738
  create(base) {
1535
1739
  return exports.AgentDevice_RoomNamesEntry.fromPartial(base ?? {});
@@ -1553,25 +1757,35 @@ exports.AgentDeviceSnapshot = {
1553
1757
  },
1554
1758
  decode(input, length) {
1555
1759
  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;
1760
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
1761
+ if (previousRecursionDepth >= 100) {
1762
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
1763
+ }
1764
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
1765
+ try {
1766
+ const end = length === undefined ? reader.len : reader.pos + length;
1767
+ const message = createBaseAgentDeviceSnapshot();
1768
+ while (reader.pos < end) {
1769
+ const tag = reader.uint32();
1770
+ switch (tag >>> 3) {
1771
+ case 1: {
1772
+ if (tag !== 10) {
1773
+ break;
1774
+ }
1775
+ message.devices.push(exports.AgentDevice.decode(reader, reader.uint32()));
1776
+ continue;
1777
+ }
1778
+ }
1779
+ if ((tag & 7) === 4 || tag === 0) {
1780
+ break;
1781
+ }
1782
+ reader.skip(tag & 7);
1571
1783
  }
1572
- reader.skip(tag & 7);
1784
+ return message;
1785
+ }
1786
+ finally {
1787
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
1573
1788
  }
1574
- return message;
1575
1789
  },
1576
1790
  create(base) {
1577
1791
  return exports.AgentDeviceSnapshot.fromPartial(base ?? {});
@@ -1597,35 +1811,45 @@ exports.AgentRoom = {
1597
1811
  },
1598
1812
  decode(input, length) {
1599
1813
  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
- }
1814
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
1815
+ if (previousRecursionDepth >= 100) {
1816
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
1817
+ }
1818
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
1819
+ try {
1820
+ const end = length === undefined ? reader.len : reader.pos + length;
1821
+ const message = createBaseAgentRoom();
1822
+ while (reader.pos < end) {
1823
+ const tag = reader.uint32();
1824
+ switch (tag >>> 3) {
1825
+ case 1: {
1826
+ if (tag !== 10) {
1827
+ break;
1828
+ }
1829
+ message.roomId = reader.string();
1830
+ continue;
1831
+ }
1832
+ case 2: {
1833
+ if (tag !== 18) {
1834
+ break;
1835
+ }
1836
+ const entry2 = exports.AgentRoom_DisplayNamesEntry.decode(reader, reader.uint32());
1837
+ if (entry2.value !== undefined) {
1838
+ message.displayNames[entry2.key] = entry2.value;
1839
+ }
1840
+ continue;
1841
+ }
1842
+ }
1843
+ if ((tag & 7) === 4 || tag === 0) {
1844
+ break;
1845
+ }
1846
+ reader.skip(tag & 7);
1622
1847
  }
1623
- if ((tag & 7) === 4 || tag === 0) {
1624
- break;
1625
- }
1626
- reader.skip(tag & 7);
1848
+ return message;
1849
+ }
1850
+ finally {
1851
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
1627
1852
  }
1628
- return message;
1629
1853
  },
1630
1854
  create(base) {
1631
1855
  return exports.AgentRoom.fromPartial(base ?? {});
@@ -1657,32 +1881,42 @@ exports.AgentRoom_DisplayNamesEntry = {
1657
1881
  },
1658
1882
  decode(input, length) {
1659
1883
  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
- }
1884
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
1885
+ if (previousRecursionDepth >= 100) {
1886
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
1887
+ }
1888
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
1889
+ try {
1890
+ const end = length === undefined ? reader.len : reader.pos + length;
1891
+ const message = createBaseAgentRoom_DisplayNamesEntry();
1892
+ while (reader.pos < end) {
1893
+ const tag = reader.uint32();
1894
+ switch (tag >>> 3) {
1895
+ case 1: {
1896
+ if (tag !== 10) {
1897
+ break;
1898
+ }
1899
+ message.key = reader.string();
1900
+ continue;
1901
+ }
1902
+ case 2: {
1903
+ if (tag !== 18) {
1904
+ break;
1905
+ }
1906
+ message.value = reader.string();
1907
+ continue;
1908
+ }
1909
+ }
1910
+ if ((tag & 7) === 4 || tag === 0) {
1911
+ break;
1912
+ }
1913
+ reader.skip(tag & 7);
1679
1914
  }
1680
- if ((tag & 7) === 4 || tag === 0) {
1681
- break;
1682
- }
1683
- reader.skip(tag & 7);
1915
+ return message;
1916
+ }
1917
+ finally {
1918
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
1684
1919
  }
1685
- return message;
1686
1920
  },
1687
1921
  create(base) {
1688
1922
  return exports.AgentRoom_DisplayNamesEntry.fromPartial(base ?? {});
@@ -1706,25 +1940,35 @@ exports.AgentRoomSnapshot = {
1706
1940
  },
1707
1941
  decode(input, length) {
1708
1942
  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
- }
1943
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
1944
+ if (previousRecursionDepth >= 100) {
1945
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
1946
+ }
1947
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
1948
+ try {
1949
+ const end = length === undefined ? reader.len : reader.pos + length;
1950
+ const message = createBaseAgentRoomSnapshot();
1951
+ while (reader.pos < end) {
1952
+ const tag = reader.uint32();
1953
+ switch (tag >>> 3) {
1954
+ case 1: {
1955
+ if (tag !== 10) {
1956
+ break;
1957
+ }
1958
+ message.rooms.push(exports.AgentRoom.decode(reader, reader.uint32()));
1959
+ continue;
1960
+ }
1961
+ }
1962
+ if ((tag & 7) === 4 || tag === 0) {
1963
+ break;
1964
+ }
1965
+ reader.skip(tag & 7);
1721
1966
  }
1722
- if ((tag & 7) === 4 || tag === 0) {
1723
- break;
1724
- }
1725
- reader.skip(tag & 7);
1967
+ return message;
1968
+ }
1969
+ finally {
1970
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
1726
1971
  }
1727
- return message;
1728
1972
  },
1729
1973
  create(base) {
1730
1974
  return exports.AgentRoomSnapshot.fromPartial(base ?? {});
@@ -1759,53 +2003,63 @@ exports.AgentResident = {
1759
2003
  },
1760
2004
  decode(input, length) {
1761
2005
  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;
2006
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
2007
+ if (previousRecursionDepth >= 100) {
2008
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
2009
+ }
2010
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
2011
+ try {
2012
+ const end = length === undefined ? reader.len : reader.pos + length;
2013
+ const message = createBaseAgentResident();
2014
+ while (reader.pos < end) {
2015
+ const tag = reader.uint32();
2016
+ switch (tag >>> 3) {
2017
+ case 1: {
2018
+ if (tag !== 10) {
2019
+ break;
2020
+ }
2021
+ message.roomieId = reader.string();
2022
+ continue;
2023
+ }
2024
+ case 2: {
2025
+ if (tag !== 18) {
2026
+ break;
2027
+ }
2028
+ message.name = reader.string();
2029
+ continue;
2030
+ }
2031
+ case 3: {
2032
+ if (tag !== 24) {
2033
+ break;
2034
+ }
2035
+ message.type = reader.int32();
2036
+ continue;
2037
+ }
2038
+ case 4: {
2039
+ if (tag !== 32) {
2040
+ break;
2041
+ }
2042
+ message.moodLevel = reader.int32();
2043
+ continue;
2044
+ }
2045
+ case 5: {
2046
+ if (tag !== 40) {
2047
+ break;
2048
+ }
2049
+ message.presenceState = reader.int32();
2050
+ continue;
2051
+ }
2052
+ }
2053
+ if ((tag & 7) === 4 || tag === 0) {
2054
+ break;
2055
+ }
2056
+ reader.skip(tag & 7);
1805
2057
  }
1806
- reader.skip(tag & 7);
2058
+ return message;
2059
+ }
2060
+ finally {
2061
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
1807
2062
  }
1808
- return message;
1809
2063
  },
1810
2064
  create(base) {
1811
2065
  return exports.AgentResident.fromPartial(base ?? {});
@@ -1832,25 +2086,35 @@ exports.AgentResidentSnapshot = {
1832
2086
  },
1833
2087
  decode(input, length) {
1834
2088
  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;
2089
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
2090
+ if (previousRecursionDepth >= 100) {
2091
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
2092
+ }
2093
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
2094
+ try {
2095
+ const end = length === undefined ? reader.len : reader.pos + length;
2096
+ const message = createBaseAgentResidentSnapshot();
2097
+ while (reader.pos < end) {
2098
+ const tag = reader.uint32();
2099
+ switch (tag >>> 3) {
2100
+ case 1: {
2101
+ if (tag !== 10) {
2102
+ break;
2103
+ }
2104
+ message.residents.push(exports.AgentResident.decode(reader, reader.uint32()));
2105
+ continue;
2106
+ }
2107
+ }
2108
+ if ((tag & 7) === 4 || tag === 0) {
2109
+ break;
2110
+ }
2111
+ reader.skip(tag & 7);
1850
2112
  }
1851
- reader.skip(tag & 7);
2113
+ return message;
2114
+ }
2115
+ finally {
2116
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
1852
2117
  }
1853
- return message;
1854
2118
  },
1855
2119
  create(base) {
1856
2120
  return exports.AgentResidentSnapshot.fromPartial(base ?? {});
@@ -1879,39 +2143,49 @@ exports.AgentAskResident = {
1879
2143
  },
1880
2144
  decode(input, length) {
1881
2145
  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
- }
2146
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
2147
+ if (previousRecursionDepth >= 100) {
2148
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
2149
+ }
2150
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
2151
+ try {
2152
+ const end = length === undefined ? reader.len : reader.pos + length;
2153
+ const message = createBaseAgentAskResident();
2154
+ while (reader.pos < end) {
2155
+ const tag = reader.uint32();
2156
+ switch (tag >>> 3) {
2157
+ case 3: {
2158
+ if (tag !== 26) {
2159
+ break;
2160
+ }
2161
+ message.correlationId = reader.string();
2162
+ continue;
2163
+ }
2164
+ case 1: {
2165
+ if (tag !== 10) {
2166
+ break;
2167
+ }
2168
+ message.room = reader.string();
2169
+ continue;
2170
+ }
2171
+ case 2: {
2172
+ if (tag !== 18) {
2173
+ break;
2174
+ }
2175
+ message.question = reader.string();
2176
+ continue;
2177
+ }
2178
+ }
2179
+ if ((tag & 7) === 4 || tag === 0) {
2180
+ break;
2181
+ }
2182
+ reader.skip(tag & 7);
1908
2183
  }
1909
- if ((tag & 7) === 4 || tag === 0) {
1910
- break;
1911
- }
1912
- reader.skip(tag & 7);
2184
+ return message;
2185
+ }
2186
+ finally {
2187
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
1913
2188
  }
1914
- return message;
1915
2189
  },
1916
2190
  create(base) {
1917
2191
  return exports.AgentAskResident.fromPartial(base ?? {});
@@ -1939,32 +2213,42 @@ exports.AgentResidentAnswered = {
1939
2213
  },
1940
2214
  decode(input, length) {
1941
2215
  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
- }
2216
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
2217
+ if (previousRecursionDepth >= 100) {
2218
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
2219
+ }
2220
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
2221
+ try {
2222
+ const end = length === undefined ? reader.len : reader.pos + length;
2223
+ const message = createBaseAgentResidentAnswered();
2224
+ while (reader.pos < end) {
2225
+ const tag = reader.uint32();
2226
+ switch (tag >>> 3) {
2227
+ case 1: {
2228
+ if (tag !== 10) {
2229
+ break;
2230
+ }
2231
+ message.correlationId = reader.string();
2232
+ continue;
2233
+ }
2234
+ case 2: {
2235
+ if (tag !== 18) {
2236
+ break;
2237
+ }
2238
+ message.answer = reader.string();
2239
+ continue;
2240
+ }
2241
+ }
2242
+ if ((tag & 7) === 4 || tag === 0) {
2243
+ break;
2244
+ }
2245
+ reader.skip(tag & 7);
1961
2246
  }
1962
- if ((tag & 7) === 4 || tag === 0) {
1963
- break;
1964
- }
1965
- reader.skip(tag & 7);
2247
+ return message;
2248
+ }
2249
+ finally {
2250
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
1966
2251
  }
1967
- return message;
1968
2252
  },
1969
2253
  create(base) {
1970
2254
  return exports.AgentResidentAnswered.fromPartial(base ?? {});
@@ -2000,53 +2284,63 @@ exports.AgentBleUpdate = {
2000
2284
  },
2001
2285
  decode(input, length) {
2002
2286
  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;
2287
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
2288
+ if (previousRecursionDepth >= 100) {
2289
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
2290
+ }
2291
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
2292
+ try {
2293
+ const end = length === undefined ? reader.len : reader.pos + length;
2294
+ const message = createBaseAgentBleUpdate();
2295
+ while (reader.pos < end) {
2296
+ const tag = reader.uint32();
2297
+ switch (tag >>> 3) {
2298
+ case 1: {
2299
+ if (tag !== 10) {
2300
+ break;
2301
+ }
2302
+ message.label = reader.string();
2303
+ continue;
2304
+ }
2305
+ case 2: {
2306
+ if (tag !== 18) {
2307
+ break;
2308
+ }
2309
+ message.mac = reader.string();
2310
+ continue;
2311
+ }
2312
+ case 3: {
2313
+ if (tag !== 26) {
2314
+ break;
2315
+ }
2316
+ message.room = reader.string();
2317
+ continue;
2318
+ }
2319
+ case 4: {
2320
+ if (tag !== 34) {
2321
+ break;
2322
+ }
2323
+ message.satellite = reader.string();
2324
+ continue;
2325
+ }
2326
+ case 5: {
2327
+ if (tag !== 40) {
2328
+ break;
2329
+ }
2330
+ message.rssi = reader.int32();
2331
+ continue;
2332
+ }
2333
+ }
2334
+ if ((tag & 7) === 4 || tag === 0) {
2335
+ break;
2336
+ }
2337
+ reader.skip(tag & 7);
2046
2338
  }
2047
- reader.skip(tag & 7);
2339
+ return message;
2340
+ }
2341
+ finally {
2342
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
2048
2343
  }
2049
- return message;
2050
2344
  },
2051
2345
  create(base) {
2052
2346
  return exports.AgentBleUpdate.fromPartial(base ?? {});
@@ -2094,74 +2388,84 @@ exports.AgentSensorUpdate = {
2094
2388
  },
2095
2389
  decode(input, length) {
2096
2390
  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;
2391
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
2392
+ if (previousRecursionDepth >= 100) {
2393
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
2394
+ }
2395
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
2396
+ try {
2397
+ const end = length === undefined ? reader.len : reader.pos + length;
2398
+ const message = createBaseAgentSensorUpdate();
2399
+ while (reader.pos < end) {
2400
+ const tag = reader.uint32();
2401
+ switch (tag >>> 3) {
2402
+ case 1: {
2403
+ if (tag !== 10) {
2404
+ break;
2405
+ }
2406
+ message.device = reader.string();
2407
+ continue;
2408
+ }
2409
+ case 2: {
2410
+ if (tag !== 21) {
2411
+ break;
2412
+ }
2413
+ message.temperature = reader.float();
2414
+ continue;
2415
+ }
2416
+ case 3: {
2417
+ if (tag !== 29) {
2418
+ break;
2419
+ }
2420
+ message.pressure = reader.float();
2421
+ continue;
2422
+ }
2423
+ case 4: {
2424
+ if (tag !== 37) {
2425
+ break;
2426
+ }
2427
+ message.humidity = reader.float();
2428
+ continue;
2429
+ }
2430
+ case 6: {
2431
+ if (tag !== 53) {
2432
+ break;
2433
+ }
2434
+ message.iaq = reader.float();
2435
+ continue;
2436
+ }
2437
+ case 7: {
2438
+ if (tag !== 56) {
2439
+ break;
2440
+ }
2441
+ message.iaqAccuracy = reader.uint32();
2442
+ continue;
2443
+ }
2444
+ case 8: {
2445
+ if (tag !== 69) {
2446
+ break;
2447
+ }
2448
+ message.co2Equiv = reader.float();
2449
+ continue;
2450
+ }
2451
+ case 9: {
2452
+ if (tag !== 77) {
2453
+ break;
2454
+ }
2455
+ message.vocEquiv = reader.float();
2456
+ continue;
2457
+ }
2458
+ }
2459
+ if ((tag & 7) === 4 || tag === 0) {
2460
+ break;
2461
+ }
2462
+ reader.skip(tag & 7);
2161
2463
  }
2162
- reader.skip(tag & 7);
2464
+ return message;
2465
+ }
2466
+ finally {
2467
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
2163
2468
  }
2164
- return message;
2165
2469
  },
2166
2470
  create(base) {
2167
2471
  return exports.AgentSensorUpdate.fromPartial(base ?? {});