@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/control.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/control.proto
7
7
  Object.defineProperty(exports, "__esModule", { value: true });
@@ -27,39 +27,49 @@ exports.SubmitTextRequest = {
27
27
  },
28
28
  decode(input, length) {
29
29
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
30
- const end = length === undefined ? reader.len : reader.pos + length;
31
- const message = createBaseSubmitTextRequest();
32
- while (reader.pos < end) {
33
- const tag = reader.uint32();
34
- switch (tag >>> 3) {
35
- case 1: {
36
- if (tag !== 10) {
37
- break;
30
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
31
+ if (previousRecursionDepth >= 100) {
32
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
33
+ }
34
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
35
+ try {
36
+ const end = length === undefined ? reader.len : reader.pos + length;
37
+ const message = createBaseSubmitTextRequest();
38
+ while (reader.pos < end) {
39
+ const tag = reader.uint32();
40
+ switch (tag >>> 3) {
41
+ case 1: {
42
+ if (tag !== 10) {
43
+ break;
44
+ }
45
+ message.text = reader.string();
46
+ continue;
38
47
  }
39
- message.text = reader.string();
40
- continue;
41
- }
42
- case 2: {
43
- if (tag !== 18) {
44
- break;
48
+ case 2: {
49
+ if (tag !== 18) {
50
+ break;
51
+ }
52
+ message.sourceService = reader.string();
53
+ continue;
45
54
  }
46
- message.sourceService = reader.string();
47
- continue;
48
- }
49
- case 3: {
50
- if (tag !== 26) {
51
- break;
55
+ case 3: {
56
+ if (tag !== 26) {
57
+ break;
58
+ }
59
+ message.sourceUserId = reader.string();
60
+ continue;
52
61
  }
53
- message.sourceUserId = reader.string();
54
- continue;
55
62
  }
63
+ if ((tag & 7) === 4 || tag === 0) {
64
+ break;
65
+ }
66
+ reader.skip(tag & 7);
56
67
  }
57
- if ((tag & 7) === 4 || tag === 0) {
58
- break;
59
- }
60
- reader.skip(tag & 7);
68
+ return message;
69
+ }
70
+ finally {
71
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
61
72
  }
62
- return message;
63
73
  },
64
74
  create(base) {
65
75
  return exports.SubmitTextRequest.fromPartial(base ?? {});
@@ -87,32 +97,42 @@ exports.SubmitTextResponse = {
87
97
  },
88
98
  decode(input, length) {
89
99
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
90
- const end = length === undefined ? reader.len : reader.pos + length;
91
- const message = createBaseSubmitTextResponse();
92
- while (reader.pos < end) {
93
- const tag = reader.uint32();
94
- switch (tag >>> 3) {
95
- case 1: {
96
- if (tag !== 10) {
97
- break;
100
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
101
+ if (previousRecursionDepth >= 100) {
102
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
103
+ }
104
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
105
+ try {
106
+ const end = length === undefined ? reader.len : reader.pos + length;
107
+ const message = createBaseSubmitTextResponse();
108
+ while (reader.pos < end) {
109
+ const tag = reader.uint32();
110
+ switch (tag >>> 3) {
111
+ case 1: {
112
+ if (tag !== 10) {
113
+ break;
114
+ }
115
+ message.answer = reader.string();
116
+ continue;
98
117
  }
99
- message.answer = reader.string();
100
- continue;
101
- }
102
- case 2: {
103
- if (tag !== 18) {
104
- break;
118
+ case 2: {
119
+ if (tag !== 18) {
120
+ break;
121
+ }
122
+ message.intentName = reader.string();
123
+ continue;
105
124
  }
106
- message.intentName = reader.string();
107
- continue;
108
125
  }
126
+ if ((tag & 7) === 4 || tag === 0) {
127
+ break;
128
+ }
129
+ reader.skip(tag & 7);
109
130
  }
110
- if ((tag & 7) === 4 || tag === 0) {
111
- break;
112
- }
113
- reader.skip(tag & 7);
131
+ return message;
132
+ }
133
+ finally {
134
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
114
135
  }
115
- return message;
116
136
  },
117
137
  create(base) {
118
138
  return exports.SubmitTextResponse.fromPartial(base ?? {});
@@ -142,39 +162,49 @@ exports.SubmitVoiceRequest = {
142
162
  },
143
163
  decode(input, length) {
144
164
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
145
- const end = length === undefined ? reader.len : reader.pos + length;
146
- const message = createBaseSubmitVoiceRequest();
147
- while (reader.pos < end) {
148
- const tag = reader.uint32();
149
- switch (tag >>> 3) {
150
- case 1: {
151
- if (tag !== 10) {
152
- break;
165
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
166
+ if (previousRecursionDepth >= 100) {
167
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
168
+ }
169
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
170
+ try {
171
+ const end = length === undefined ? reader.len : reader.pos + length;
172
+ const message = createBaseSubmitVoiceRequest();
173
+ while (reader.pos < end) {
174
+ const tag = reader.uint32();
175
+ switch (tag >>> 3) {
176
+ case 1: {
177
+ if (tag !== 10) {
178
+ break;
179
+ }
180
+ message.audio = reader.bytes();
181
+ continue;
153
182
  }
154
- message.audio = reader.bytes();
155
- continue;
156
- }
157
- case 2: {
158
- if (tag !== 18) {
159
- break;
183
+ case 2: {
184
+ if (tag !== 18) {
185
+ break;
186
+ }
187
+ message.sourceService = reader.string();
188
+ continue;
160
189
  }
161
- message.sourceService = reader.string();
162
- continue;
163
- }
164
- case 3: {
165
- if (tag !== 26) {
166
- break;
190
+ case 3: {
191
+ if (tag !== 26) {
192
+ break;
193
+ }
194
+ message.sourceUserId = reader.string();
195
+ continue;
167
196
  }
168
- message.sourceUserId = reader.string();
169
- continue;
170
197
  }
198
+ if ((tag & 7) === 4 || tag === 0) {
199
+ break;
200
+ }
201
+ reader.skip(tag & 7);
171
202
  }
172
- if ((tag & 7) === 4 || tag === 0) {
173
- break;
174
- }
175
- reader.skip(tag & 7);
203
+ return message;
204
+ }
205
+ finally {
206
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
176
207
  }
177
- return message;
178
208
  },
179
209
  create(base) {
180
210
  return exports.SubmitVoiceRequest.fromPartial(base ?? {});
@@ -208,46 +238,56 @@ exports.SubmitVoiceResponse = {
208
238
  },
209
239
  decode(input, length) {
210
240
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
211
- const end = length === undefined ? reader.len : reader.pos + length;
212
- const message = createBaseSubmitVoiceResponse();
213
- while (reader.pos < end) {
214
- const tag = reader.uint32();
215
- switch (tag >>> 3) {
216
- case 1: {
217
- if (tag !== 10) {
218
- break;
241
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
242
+ if (previousRecursionDepth >= 100) {
243
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
244
+ }
245
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
246
+ try {
247
+ const end = length === undefined ? reader.len : reader.pos + length;
248
+ const message = createBaseSubmitVoiceResponse();
249
+ while (reader.pos < end) {
250
+ const tag = reader.uint32();
251
+ switch (tag >>> 3) {
252
+ case 1: {
253
+ if (tag !== 10) {
254
+ break;
255
+ }
256
+ message.transcript = reader.string();
257
+ continue;
219
258
  }
220
- message.transcript = reader.string();
221
- continue;
222
- }
223
- case 2: {
224
- if (tag !== 18) {
225
- break;
259
+ case 2: {
260
+ if (tag !== 18) {
261
+ break;
262
+ }
263
+ message.answer = reader.string();
264
+ continue;
226
265
  }
227
- message.answer = reader.string();
228
- continue;
229
- }
230
- case 3: {
231
- if (tag !== 26) {
232
- break;
266
+ case 3: {
267
+ if (tag !== 26) {
268
+ break;
269
+ }
270
+ message.intentName = reader.string();
271
+ continue;
233
272
  }
234
- message.intentName = reader.string();
235
- continue;
236
- }
237
- case 4: {
238
- if (tag !== 34) {
239
- break;
273
+ case 4: {
274
+ if (tag !== 34) {
275
+ break;
276
+ }
277
+ message.audioOgg = reader.bytes();
278
+ continue;
240
279
  }
241
- message.audioOgg = reader.bytes();
242
- continue;
243
280
  }
281
+ if ((tag & 7) === 4 || tag === 0) {
282
+ break;
283
+ }
284
+ reader.skip(tag & 7);
244
285
  }
245
- if ((tag & 7) === 4 || tag === 0) {
246
- break;
247
- }
248
- reader.skip(tag & 7);
286
+ return message;
287
+ }
288
+ finally {
289
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
249
290
  }
250
- return message;
251
291
  },
252
292
  create(base) {
253
293
  return exports.SubmitVoiceResponse.fromPartial(base ?? {});
@@ -282,46 +322,56 @@ exports.AnnounceRequest = {
282
322
  },
283
323
  decode(input, length) {
284
324
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
285
- const end = length === undefined ? reader.len : reader.pos + length;
286
- const message = createBaseAnnounceRequest();
287
- while (reader.pos < end) {
288
- const tag = reader.uint32();
289
- switch (tag >>> 3) {
290
- case 1: {
291
- if (tag !== 10) {
292
- break;
325
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
326
+ if (previousRecursionDepth >= 100) {
327
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
328
+ }
329
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
330
+ try {
331
+ const end = length === undefined ? reader.len : reader.pos + length;
332
+ const message = createBaseAnnounceRequest();
333
+ while (reader.pos < end) {
334
+ const tag = reader.uint32();
335
+ switch (tag >>> 3) {
336
+ case 1: {
337
+ if (tag !== 10) {
338
+ break;
339
+ }
340
+ message.text = reader.string();
341
+ continue;
293
342
  }
294
- message.text = reader.string();
295
- continue;
296
- }
297
- case 2: {
298
- if (tag !== 18) {
299
- break;
343
+ case 2: {
344
+ if (tag !== 18) {
345
+ break;
346
+ }
347
+ message.device = reader.string();
348
+ continue;
300
349
  }
301
- message.device = reader.string();
302
- continue;
303
- }
304
- case 3: {
305
- if (tag !== 26) {
306
- break;
350
+ case 3: {
351
+ if (tag !== 26) {
352
+ break;
353
+ }
354
+ message.roomId = reader.string();
355
+ continue;
307
356
  }
308
- message.roomId = reader.string();
309
- continue;
310
- }
311
- case 4: {
312
- if (tag !== 32) {
313
- break;
357
+ case 4: {
358
+ if (tag !== 32) {
359
+ break;
360
+ }
361
+ message.userId = reader.int32();
362
+ continue;
314
363
  }
315
- message.userId = reader.int32();
316
- continue;
317
364
  }
365
+ if ((tag & 7) === 4 || tag === 0) {
366
+ break;
367
+ }
368
+ reader.skip(tag & 7);
318
369
  }
319
- if ((tag & 7) === 4 || tag === 0) {
320
- break;
321
- }
322
- reader.skip(tag & 7);
370
+ return message;
371
+ }
372
+ finally {
373
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
323
374
  }
324
- return message;
325
375
  },
326
376
  create(base) {
327
377
  return exports.AnnounceRequest.fromPartial(base ?? {});
@@ -350,32 +400,42 @@ exports.Room = {
350
400
  },
351
401
  decode(input, length) {
352
402
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
353
- const end = length === undefined ? reader.len : reader.pos + length;
354
- const message = createBaseRoom();
355
- while (reader.pos < end) {
356
- const tag = reader.uint32();
357
- switch (tag >>> 3) {
358
- case 1: {
359
- if (tag !== 10) {
360
- break;
403
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
404
+ if (previousRecursionDepth >= 100) {
405
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
406
+ }
407
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
408
+ try {
409
+ const end = length === undefined ? reader.len : reader.pos + length;
410
+ const message = createBaseRoom();
411
+ while (reader.pos < end) {
412
+ const tag = reader.uint32();
413
+ switch (tag >>> 3) {
414
+ case 1: {
415
+ if (tag !== 10) {
416
+ break;
417
+ }
418
+ message.roomId = reader.string();
419
+ continue;
361
420
  }
362
- message.roomId = reader.string();
363
- continue;
364
- }
365
- case 2: {
366
- if (tag !== 18) {
367
- break;
421
+ case 2: {
422
+ if (tag !== 18) {
423
+ break;
424
+ }
425
+ message.displayName = reader.string();
426
+ continue;
368
427
  }
369
- message.displayName = reader.string();
370
- continue;
371
428
  }
429
+ if ((tag & 7) === 4 || tag === 0) {
430
+ break;
431
+ }
432
+ reader.skip(tag & 7);
372
433
  }
373
- if ((tag & 7) === 4 || tag === 0) {
374
- break;
375
- }
376
- reader.skip(tag & 7);
434
+ return message;
435
+ }
436
+ finally {
437
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
377
438
  }
378
- return message;
379
439
  },
380
440
  create(base) {
381
441
  return exports.Room.fromPartial(base ?? {});
@@ -399,25 +459,35 @@ exports.GetRoomsResponse = {
399
459
  },
400
460
  decode(input, length) {
401
461
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
402
- const end = length === undefined ? reader.len : reader.pos + length;
403
- const message = createBaseGetRoomsResponse();
404
- while (reader.pos < end) {
405
- const tag = reader.uint32();
406
- switch (tag >>> 3) {
407
- case 1: {
408
- if (tag !== 10) {
409
- break;
462
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
463
+ if (previousRecursionDepth >= 100) {
464
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
465
+ }
466
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
467
+ try {
468
+ const end = length === undefined ? reader.len : reader.pos + length;
469
+ const message = createBaseGetRoomsResponse();
470
+ while (reader.pos < end) {
471
+ const tag = reader.uint32();
472
+ switch (tag >>> 3) {
473
+ case 1: {
474
+ if (tag !== 10) {
475
+ break;
476
+ }
477
+ message.rooms.push(exports.Room.decode(reader, reader.uint32()));
478
+ continue;
410
479
  }
411
- message.rooms.push(exports.Room.decode(reader, reader.uint32()));
412
- continue;
413
480
  }
481
+ if ((tag & 7) === 4 || tag === 0) {
482
+ break;
483
+ }
484
+ reader.skip(tag & 7);
414
485
  }
415
- if ((tag & 7) === 4 || tag === 0) {
416
- break;
417
- }
418
- reader.skip(tag & 7);
486
+ return message;
487
+ }
488
+ finally {
489
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
419
490
  }
420
- return message;
421
491
  },
422
492
  create(base) {
423
493
  return exports.GetRoomsResponse.fromPartial(base ?? {});
@@ -446,39 +516,49 @@ exports.GroupSatellite = {
446
516
  },
447
517
  decode(input, length) {
448
518
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
449
- const end = length === undefined ? reader.len : reader.pos + length;
450
- const message = createBaseGroupSatellite();
451
- while (reader.pos < end) {
452
- const tag = reader.uint32();
453
- switch (tag >>> 3) {
454
- case 1: {
455
- if (tag !== 10) {
456
- break;
519
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
520
+ if (previousRecursionDepth >= 100) {
521
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
522
+ }
523
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
524
+ try {
525
+ const end = length === undefined ? reader.len : reader.pos + length;
526
+ const message = createBaseGroupSatellite();
527
+ while (reader.pos < end) {
528
+ const tag = reader.uint32();
529
+ switch (tag >>> 3) {
530
+ case 1: {
531
+ if (tag !== 10) {
532
+ break;
533
+ }
534
+ message.deviceId = reader.string();
535
+ continue;
457
536
  }
458
- message.deviceId = reader.string();
459
- continue;
460
- }
461
- case 2: {
462
- if (tag !== 18) {
463
- break;
537
+ case 2: {
538
+ if (tag !== 18) {
539
+ break;
540
+ }
541
+ message.displayName = reader.string();
542
+ continue;
464
543
  }
465
- message.displayName = reader.string();
466
- continue;
467
- }
468
- case 3: {
469
- if (tag !== 26) {
470
- break;
544
+ case 3: {
545
+ if (tag !== 26) {
546
+ break;
547
+ }
548
+ message.roomId = reader.string();
549
+ continue;
471
550
  }
472
- message.roomId = reader.string();
473
- continue;
474
551
  }
552
+ if ((tag & 7) === 4 || tag === 0) {
553
+ break;
554
+ }
555
+ reader.skip(tag & 7);
475
556
  }
476
- if ((tag & 7) === 4 || tag === 0) {
477
- break;
478
- }
479
- reader.skip(tag & 7);
557
+ return message;
558
+ }
559
+ finally {
560
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
480
561
  }
481
- return message;
482
562
  },
483
563
  create(base) {
484
564
  return exports.GroupSatellite.fromPartial(base ?? {});
@@ -509,39 +589,49 @@ exports.Group = {
509
589
  },
510
590
  decode(input, length) {
511
591
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
512
- const end = length === undefined ? reader.len : reader.pos + length;
513
- const message = createBaseGroup();
514
- while (reader.pos < end) {
515
- const tag = reader.uint32();
516
- switch (tag >>> 3) {
517
- case 1: {
518
- if (tag !== 10) {
519
- break;
592
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
593
+ if (previousRecursionDepth >= 100) {
594
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
595
+ }
596
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
597
+ try {
598
+ const end = length === undefined ? reader.len : reader.pos + length;
599
+ const message = createBaseGroup();
600
+ while (reader.pos < end) {
601
+ const tag = reader.uint32();
602
+ switch (tag >>> 3) {
603
+ case 1: {
604
+ if (tag !== 10) {
605
+ break;
606
+ }
607
+ message.groupId = reader.string();
608
+ continue;
520
609
  }
521
- message.groupId = reader.string();
522
- continue;
523
- }
524
- case 2: {
525
- if (tag !== 18) {
526
- break;
610
+ case 2: {
611
+ if (tag !== 18) {
612
+ break;
613
+ }
614
+ message.displayName = reader.string();
615
+ continue;
527
616
  }
528
- message.displayName = reader.string();
529
- continue;
530
- }
531
- case 3: {
532
- if (tag !== 26) {
533
- break;
617
+ case 3: {
618
+ if (tag !== 26) {
619
+ break;
620
+ }
621
+ message.satellites.push(exports.GroupSatellite.decode(reader, reader.uint32()));
622
+ continue;
534
623
  }
535
- message.satellites.push(exports.GroupSatellite.decode(reader, reader.uint32()));
536
- continue;
537
624
  }
625
+ if ((tag & 7) === 4 || tag === 0) {
626
+ break;
627
+ }
628
+ reader.skip(tag & 7);
538
629
  }
539
- if ((tag & 7) === 4 || tag === 0) {
540
- break;
541
- }
542
- reader.skip(tag & 7);
630
+ return message;
631
+ }
632
+ finally {
633
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
543
634
  }
544
- return message;
545
635
  },
546
636
  create(base) {
547
637
  return exports.Group.fromPartial(base ?? {});
@@ -566,25 +656,35 @@ exports.GetGroupsResponse = {
566
656
  },
567
657
  decode(input, length) {
568
658
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
569
- const end = length === undefined ? reader.len : reader.pos + length;
570
- const message = createBaseGetGroupsResponse();
571
- while (reader.pos < end) {
572
- const tag = reader.uint32();
573
- switch (tag >>> 3) {
574
- case 1: {
575
- if (tag !== 10) {
576
- break;
659
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
660
+ if (previousRecursionDepth >= 100) {
661
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
662
+ }
663
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
664
+ try {
665
+ const end = length === undefined ? reader.len : reader.pos + length;
666
+ const message = createBaseGetGroupsResponse();
667
+ while (reader.pos < end) {
668
+ const tag = reader.uint32();
669
+ switch (tag >>> 3) {
670
+ case 1: {
671
+ if (tag !== 10) {
672
+ break;
673
+ }
674
+ message.groups.push(exports.Group.decode(reader, reader.uint32()));
675
+ continue;
577
676
  }
578
- message.groups.push(exports.Group.decode(reader, reader.uint32()));
579
- continue;
580
677
  }
678
+ if ((tag & 7) === 4 || tag === 0) {
679
+ break;
680
+ }
681
+ reader.skip(tag & 7);
581
682
  }
582
- if ((tag & 7) === 4 || tag === 0) {
583
- break;
584
- }
585
- reader.skip(tag & 7);
683
+ return message;
684
+ }
685
+ finally {
686
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
586
687
  }
587
- return message;
588
688
  },
589
689
  create(base) {
590
690
  return exports.GetGroupsResponse.fromPartial(base ?? {});
@@ -610,32 +710,42 @@ exports.CreateGroupRequest = {
610
710
  },
611
711
  decode(input, length) {
612
712
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
613
- const end = length === undefined ? reader.len : reader.pos + length;
614
- const message = createBaseCreateGroupRequest();
615
- while (reader.pos < end) {
616
- const tag = reader.uint32();
617
- switch (tag >>> 3) {
618
- case 1: {
619
- if (tag !== 10) {
620
- break;
713
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
714
+ if (previousRecursionDepth >= 100) {
715
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
716
+ }
717
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
718
+ try {
719
+ const end = length === undefined ? reader.len : reader.pos + length;
720
+ const message = createBaseCreateGroupRequest();
721
+ while (reader.pos < end) {
722
+ const tag = reader.uint32();
723
+ switch (tag >>> 3) {
724
+ case 1: {
725
+ if (tag !== 10) {
726
+ break;
727
+ }
728
+ message.groupId = reader.string();
729
+ continue;
621
730
  }
622
- message.groupId = reader.string();
623
- continue;
624
- }
625
- case 2: {
626
- if (tag !== 18) {
627
- break;
731
+ case 2: {
732
+ if (tag !== 18) {
733
+ break;
734
+ }
735
+ message.displayName = reader.string();
736
+ continue;
628
737
  }
629
- message.displayName = reader.string();
630
- continue;
631
738
  }
739
+ if ((tag & 7) === 4 || tag === 0) {
740
+ break;
741
+ }
742
+ reader.skip(tag & 7);
632
743
  }
633
- if ((tag & 7) === 4 || tag === 0) {
634
- break;
635
- }
636
- reader.skip(tag & 7);
744
+ return message;
745
+ }
746
+ finally {
747
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
637
748
  }
638
- return message;
639
749
  },
640
750
  create(base) {
641
751
  return exports.CreateGroupRequest.fromPartial(base ?? {});
@@ -662,32 +772,42 @@ exports.UpdateGroupRequest = {
662
772
  },
663
773
  decode(input, length) {
664
774
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
665
- const end = length === undefined ? reader.len : reader.pos + length;
666
- const message = createBaseUpdateGroupRequest();
667
- while (reader.pos < end) {
668
- const tag = reader.uint32();
669
- switch (tag >>> 3) {
670
- case 1: {
671
- if (tag !== 10) {
672
- break;
775
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
776
+ if (previousRecursionDepth >= 100) {
777
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
778
+ }
779
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
780
+ try {
781
+ const end = length === undefined ? reader.len : reader.pos + length;
782
+ const message = createBaseUpdateGroupRequest();
783
+ while (reader.pos < end) {
784
+ const tag = reader.uint32();
785
+ switch (tag >>> 3) {
786
+ case 1: {
787
+ if (tag !== 10) {
788
+ break;
789
+ }
790
+ message.groupId = reader.string();
791
+ continue;
673
792
  }
674
- message.groupId = reader.string();
675
- continue;
676
- }
677
- case 2: {
678
- if (tag !== 18) {
679
- break;
793
+ case 2: {
794
+ if (tag !== 18) {
795
+ break;
796
+ }
797
+ message.displayName = reader.string();
798
+ continue;
680
799
  }
681
- message.displayName = reader.string();
682
- continue;
683
800
  }
801
+ if ((tag & 7) === 4 || tag === 0) {
802
+ break;
803
+ }
804
+ reader.skip(tag & 7);
684
805
  }
685
- if ((tag & 7) === 4 || tag === 0) {
686
- break;
687
- }
688
- reader.skip(tag & 7);
806
+ return message;
807
+ }
808
+ finally {
809
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
689
810
  }
690
- return message;
691
811
  },
692
812
  create(base) {
693
813
  return exports.UpdateGroupRequest.fromPartial(base ?? {});
@@ -711,25 +831,35 @@ exports.DeleteGroupRequest = {
711
831
  },
712
832
  decode(input, length) {
713
833
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
714
- const end = length === undefined ? reader.len : reader.pos + length;
715
- const message = createBaseDeleteGroupRequest();
716
- while (reader.pos < end) {
717
- const tag = reader.uint32();
718
- switch (tag >>> 3) {
719
- case 1: {
720
- if (tag !== 10) {
721
- break;
834
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
835
+ if (previousRecursionDepth >= 100) {
836
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
837
+ }
838
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
839
+ try {
840
+ const end = length === undefined ? reader.len : reader.pos + length;
841
+ const message = createBaseDeleteGroupRequest();
842
+ while (reader.pos < end) {
843
+ const tag = reader.uint32();
844
+ switch (tag >>> 3) {
845
+ case 1: {
846
+ if (tag !== 10) {
847
+ break;
848
+ }
849
+ message.groupId = reader.string();
850
+ continue;
722
851
  }
723
- message.groupId = reader.string();
724
- continue;
725
852
  }
853
+ if ((tag & 7) === 4 || tag === 0) {
854
+ break;
855
+ }
856
+ reader.skip(tag & 7);
726
857
  }
727
- if ((tag & 7) === 4 || tag === 0) {
728
- break;
729
- }
730
- reader.skip(tag & 7);
858
+ return message;
859
+ }
860
+ finally {
861
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
731
862
  }
732
- return message;
733
863
  },
734
864
  create(base) {
735
865
  return exports.DeleteGroupRequest.fromPartial(base ?? {});
@@ -755,32 +885,42 @@ exports.SetGroupSatellitesRequest = {
755
885
  },
756
886
  decode(input, length) {
757
887
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
758
- const end = length === undefined ? reader.len : reader.pos + length;
759
- const message = createBaseSetGroupSatellitesRequest();
760
- while (reader.pos < end) {
761
- const tag = reader.uint32();
762
- switch (tag >>> 3) {
763
- case 1: {
764
- if (tag !== 10) {
765
- break;
888
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
889
+ if (previousRecursionDepth >= 100) {
890
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
891
+ }
892
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
893
+ try {
894
+ const end = length === undefined ? reader.len : reader.pos + length;
895
+ const message = createBaseSetGroupSatellitesRequest();
896
+ while (reader.pos < end) {
897
+ const tag = reader.uint32();
898
+ switch (tag >>> 3) {
899
+ case 1: {
900
+ if (tag !== 10) {
901
+ break;
902
+ }
903
+ message.groupId = reader.string();
904
+ continue;
766
905
  }
767
- message.groupId = reader.string();
768
- continue;
769
- }
770
- case 2: {
771
- if (tag !== 18) {
772
- break;
906
+ case 2: {
907
+ if (tag !== 18) {
908
+ break;
909
+ }
910
+ message.deviceIds.push(reader.string());
911
+ continue;
773
912
  }
774
- message.deviceIds.push(reader.string());
775
- continue;
776
913
  }
914
+ if ((tag & 7) === 4 || tag === 0) {
915
+ break;
916
+ }
917
+ reader.skip(tag & 7);
777
918
  }
778
- if ((tag & 7) === 4 || tag === 0) {
779
- break;
780
- }
781
- reader.skip(tag & 7);
919
+ return message;
920
+ }
921
+ finally {
922
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
782
923
  }
783
- return message;
784
924
  },
785
925
  create(base) {
786
926
  return exports.SetGroupSatellitesRequest.fromPartial(base ?? {});
@@ -846,95 +986,105 @@ exports.Trigger = {
846
986
  },
847
987
  decode(input, length) {
848
988
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
849
- const end = length === undefined ? reader.len : reader.pos + length;
850
- const message = createBaseTrigger();
851
- while (reader.pos < end) {
852
- const tag = reader.uint32();
853
- switch (tag >>> 3) {
854
- case 1: {
855
- if (tag !== 10) {
856
- break;
989
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
990
+ if (previousRecursionDepth >= 100) {
991
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
992
+ }
993
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
994
+ try {
995
+ const end = length === undefined ? reader.len : reader.pos + length;
996
+ const message = createBaseTrigger();
997
+ while (reader.pos < end) {
998
+ const tag = reader.uint32();
999
+ switch (tag >>> 3) {
1000
+ case 1: {
1001
+ if (tag !== 10) {
1002
+ break;
1003
+ }
1004
+ message.id = reader.string();
1005
+ continue;
857
1006
  }
858
- message.id = reader.string();
859
- continue;
860
- }
861
- case 2: {
862
- if (tag !== 18) {
863
- break;
1007
+ case 2: {
1008
+ if (tag !== 18) {
1009
+ break;
1010
+ }
1011
+ message.whenJson = reader.string();
1012
+ continue;
864
1013
  }
865
- message.whenJson = reader.string();
866
- continue;
867
- }
868
- case 3: {
869
- if (tag !== 26) {
870
- break;
1014
+ case 3: {
1015
+ if (tag !== 26) {
1016
+ break;
1017
+ }
1018
+ message.cancelWhenJson = reader.string();
1019
+ continue;
871
1020
  }
872
- message.cancelWhenJson = reader.string();
873
- continue;
874
- }
875
- case 4: {
876
- if (tag !== 34) {
877
- break;
1021
+ case 4: {
1022
+ if (tag !== 34) {
1023
+ break;
1024
+ }
1025
+ message.onResponseJson = reader.string();
1026
+ continue;
878
1027
  }
879
- message.onResponseJson = reader.string();
880
- continue;
881
- }
882
- case 5: {
883
- if (tag !== 42) {
884
- break;
1028
+ case 5: {
1029
+ if (tag !== 42) {
1030
+ break;
1031
+ }
1032
+ message.say = reader.string();
1033
+ continue;
885
1034
  }
886
- message.say = reader.string();
887
- continue;
888
- }
889
- case 6: {
890
- if (tag !== 50) {
891
- break;
1035
+ case 6: {
1036
+ if (tag !== 50) {
1037
+ break;
1038
+ }
1039
+ message.ask = reader.string();
1040
+ continue;
892
1041
  }
893
- message.ask = reader.string();
894
- continue;
895
- }
896
- case 7: {
897
- if (tag !== 56) {
898
- break;
1042
+ case 7: {
1043
+ if (tag !== 56) {
1044
+ break;
1045
+ }
1046
+ message.rephrase = reader.bool();
1047
+ continue;
899
1048
  }
900
- message.rephrase = reader.bool();
901
- continue;
902
- }
903
- case 8: {
904
- if (tag !== 66) {
905
- break;
1049
+ case 8: {
1050
+ if (tag !== 66) {
1051
+ break;
1052
+ }
1053
+ message.room = reader.string();
1054
+ continue;
906
1055
  }
907
- message.room = reader.string();
908
- continue;
909
- }
910
- case 9: {
911
- if (tag !== 72) {
912
- break;
1056
+ case 9: {
1057
+ if (tag !== 72) {
1058
+ break;
1059
+ }
1060
+ message.cooldown = reader.int32();
1061
+ continue;
913
1062
  }
914
- message.cooldown = reader.int32();
915
- continue;
916
- }
917
- case 10: {
918
- if (tag !== 82) {
919
- break;
1063
+ case 10: {
1064
+ if (tag !== 82) {
1065
+ break;
1066
+ }
1067
+ message.delay = reader.string();
1068
+ continue;
920
1069
  }
921
- message.delay = reader.string();
922
- continue;
923
- }
924
- case 11: {
925
- if (tag !== 90) {
926
- break;
1070
+ case 11: {
1071
+ if (tag !== 90) {
1072
+ break;
1073
+ }
1074
+ message.actionsJson = reader.string();
1075
+ continue;
927
1076
  }
928
- message.actionsJson = reader.string();
929
- continue;
930
1077
  }
1078
+ if ((tag & 7) === 4 || tag === 0) {
1079
+ break;
1080
+ }
1081
+ reader.skip(tag & 7);
931
1082
  }
932
- if ((tag & 7) === 4 || tag === 0) {
933
- break;
934
- }
935
- reader.skip(tag & 7);
1083
+ return message;
1084
+ }
1085
+ finally {
1086
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
936
1087
  }
937
- return message;
938
1088
  },
939
1089
  create(base) {
940
1090
  return exports.Trigger.fromPartial(base ?? {});
@@ -967,25 +1117,35 @@ exports.GetTriggersResponse = {
967
1117
  },
968
1118
  decode(input, length) {
969
1119
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
970
- const end = length === undefined ? reader.len : reader.pos + length;
971
- const message = createBaseGetTriggersResponse();
972
- while (reader.pos < end) {
973
- const tag = reader.uint32();
974
- switch (tag >>> 3) {
975
- case 1: {
976
- if (tag !== 10) {
977
- break;
1120
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
1121
+ if (previousRecursionDepth >= 100) {
1122
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
1123
+ }
1124
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
1125
+ try {
1126
+ const end = length === undefined ? reader.len : reader.pos + length;
1127
+ const message = createBaseGetTriggersResponse();
1128
+ while (reader.pos < end) {
1129
+ const tag = reader.uint32();
1130
+ switch (tag >>> 3) {
1131
+ case 1: {
1132
+ if (tag !== 10) {
1133
+ break;
1134
+ }
1135
+ message.triggers.push(exports.Trigger.decode(reader, reader.uint32()));
1136
+ continue;
978
1137
  }
979
- message.triggers.push(exports.Trigger.decode(reader, reader.uint32()));
980
- continue;
981
1138
  }
1139
+ if ((tag & 7) === 4 || tag === 0) {
1140
+ break;
1141
+ }
1142
+ reader.skip(tag & 7);
982
1143
  }
983
- if ((tag & 7) === 4 || tag === 0) {
984
- break;
985
- }
986
- reader.skip(tag & 7);
1144
+ return message;
1145
+ }
1146
+ finally {
1147
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
987
1148
  }
988
- return message;
989
1149
  },
990
1150
  create(base) {
991
1151
  return exports.GetTriggersResponse.fromPartial(base ?? {});
@@ -1050,95 +1210,105 @@ exports.CreateTriggerRequest = {
1050
1210
  },
1051
1211
  decode(input, length) {
1052
1212
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
1053
- const end = length === undefined ? reader.len : reader.pos + length;
1054
- const message = createBaseCreateTriggerRequest();
1055
- while (reader.pos < end) {
1056
- const tag = reader.uint32();
1057
- switch (tag >>> 3) {
1058
- case 1: {
1059
- if (tag !== 10) {
1060
- break;
1213
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
1214
+ if (previousRecursionDepth >= 100) {
1215
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
1216
+ }
1217
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
1218
+ try {
1219
+ const end = length === undefined ? reader.len : reader.pos + length;
1220
+ const message = createBaseCreateTriggerRequest();
1221
+ while (reader.pos < end) {
1222
+ const tag = reader.uint32();
1223
+ switch (tag >>> 3) {
1224
+ case 1: {
1225
+ if (tag !== 10) {
1226
+ break;
1227
+ }
1228
+ message.id = reader.string();
1229
+ continue;
1061
1230
  }
1062
- message.id = reader.string();
1063
- continue;
1064
- }
1065
- case 2: {
1066
- if (tag !== 18) {
1067
- break;
1231
+ case 2: {
1232
+ if (tag !== 18) {
1233
+ break;
1234
+ }
1235
+ message.whenJson = reader.string();
1236
+ continue;
1068
1237
  }
1069
- message.whenJson = reader.string();
1070
- continue;
1071
- }
1072
- case 3: {
1073
- if (tag !== 26) {
1074
- break;
1238
+ case 3: {
1239
+ if (tag !== 26) {
1240
+ break;
1241
+ }
1242
+ message.cancelWhenJson = reader.string();
1243
+ continue;
1075
1244
  }
1076
- message.cancelWhenJson = reader.string();
1077
- continue;
1078
- }
1079
- case 4: {
1080
- if (tag !== 34) {
1081
- break;
1245
+ case 4: {
1246
+ if (tag !== 34) {
1247
+ break;
1248
+ }
1249
+ message.onResponseJson = reader.string();
1250
+ continue;
1082
1251
  }
1083
- message.onResponseJson = reader.string();
1084
- continue;
1085
- }
1086
- case 5: {
1087
- if (tag !== 42) {
1088
- break;
1252
+ case 5: {
1253
+ if (tag !== 42) {
1254
+ break;
1255
+ }
1256
+ message.say = reader.string();
1257
+ continue;
1089
1258
  }
1090
- message.say = reader.string();
1091
- continue;
1092
- }
1093
- case 6: {
1094
- if (tag !== 50) {
1095
- break;
1259
+ case 6: {
1260
+ if (tag !== 50) {
1261
+ break;
1262
+ }
1263
+ message.ask = reader.string();
1264
+ continue;
1096
1265
  }
1097
- message.ask = reader.string();
1098
- continue;
1099
- }
1100
- case 7: {
1101
- if (tag !== 56) {
1102
- break;
1266
+ case 7: {
1267
+ if (tag !== 56) {
1268
+ break;
1269
+ }
1270
+ message.rephrase = reader.bool();
1271
+ continue;
1103
1272
  }
1104
- message.rephrase = reader.bool();
1105
- continue;
1106
- }
1107
- case 8: {
1108
- if (tag !== 66) {
1109
- break;
1273
+ case 8: {
1274
+ if (tag !== 66) {
1275
+ break;
1276
+ }
1277
+ message.room = reader.string();
1278
+ continue;
1110
1279
  }
1111
- message.room = reader.string();
1112
- continue;
1113
- }
1114
- case 9: {
1115
- if (tag !== 72) {
1116
- break;
1280
+ case 9: {
1281
+ if (tag !== 72) {
1282
+ break;
1283
+ }
1284
+ message.cooldown = reader.int32();
1285
+ continue;
1117
1286
  }
1118
- message.cooldown = reader.int32();
1119
- continue;
1120
- }
1121
- case 10: {
1122
- if (tag !== 82) {
1123
- break;
1287
+ case 10: {
1288
+ if (tag !== 82) {
1289
+ break;
1290
+ }
1291
+ message.delay = reader.string();
1292
+ continue;
1124
1293
  }
1125
- message.delay = reader.string();
1126
- continue;
1127
- }
1128
- case 11: {
1129
- if (tag !== 90) {
1130
- break;
1294
+ case 11: {
1295
+ if (tag !== 90) {
1296
+ break;
1297
+ }
1298
+ message.actionsJson = reader.string();
1299
+ continue;
1131
1300
  }
1132
- message.actionsJson = reader.string();
1133
- continue;
1134
1301
  }
1302
+ if ((tag & 7) === 4 || tag === 0) {
1303
+ break;
1304
+ }
1305
+ reader.skip(tag & 7);
1135
1306
  }
1136
- if ((tag & 7) === 4 || tag === 0) {
1137
- break;
1138
- }
1139
- reader.skip(tag & 7);
1307
+ return message;
1308
+ }
1309
+ finally {
1310
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
1140
1311
  }
1141
- return message;
1142
1312
  },
1143
1313
  create(base) {
1144
1314
  return exports.CreateTriggerRequest.fromPartial(base ?? {});
@@ -1213,95 +1383,105 @@ exports.UpdateTriggerRequest = {
1213
1383
  },
1214
1384
  decode(input, length) {
1215
1385
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
1216
- const end = length === undefined ? reader.len : reader.pos + length;
1217
- const message = createBaseUpdateTriggerRequest();
1218
- while (reader.pos < end) {
1219
- const tag = reader.uint32();
1220
- switch (tag >>> 3) {
1221
- case 1: {
1222
- if (tag !== 10) {
1223
- break;
1386
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
1387
+ if (previousRecursionDepth >= 100) {
1388
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
1389
+ }
1390
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
1391
+ try {
1392
+ const end = length === undefined ? reader.len : reader.pos + length;
1393
+ const message = createBaseUpdateTriggerRequest();
1394
+ while (reader.pos < end) {
1395
+ const tag = reader.uint32();
1396
+ switch (tag >>> 3) {
1397
+ case 1: {
1398
+ if (tag !== 10) {
1399
+ break;
1400
+ }
1401
+ message.id = reader.string();
1402
+ continue;
1224
1403
  }
1225
- message.id = reader.string();
1226
- continue;
1227
- }
1228
- case 2: {
1229
- if (tag !== 18) {
1230
- break;
1404
+ case 2: {
1405
+ if (tag !== 18) {
1406
+ break;
1407
+ }
1408
+ message.whenJson = reader.string();
1409
+ continue;
1231
1410
  }
1232
- message.whenJson = reader.string();
1233
- continue;
1234
- }
1235
- case 3: {
1236
- if (tag !== 26) {
1237
- break;
1411
+ case 3: {
1412
+ if (tag !== 26) {
1413
+ break;
1414
+ }
1415
+ message.cancelWhenJson = reader.string();
1416
+ continue;
1238
1417
  }
1239
- message.cancelWhenJson = reader.string();
1240
- continue;
1241
- }
1242
- case 4: {
1243
- if (tag !== 34) {
1244
- break;
1418
+ case 4: {
1419
+ if (tag !== 34) {
1420
+ break;
1421
+ }
1422
+ message.onResponseJson = reader.string();
1423
+ continue;
1245
1424
  }
1246
- message.onResponseJson = reader.string();
1247
- continue;
1248
- }
1249
- case 5: {
1250
- if (tag !== 42) {
1251
- break;
1425
+ case 5: {
1426
+ if (tag !== 42) {
1427
+ break;
1428
+ }
1429
+ message.say = reader.string();
1430
+ continue;
1252
1431
  }
1253
- message.say = reader.string();
1254
- continue;
1255
- }
1256
- case 6: {
1257
- if (tag !== 50) {
1258
- break;
1432
+ case 6: {
1433
+ if (tag !== 50) {
1434
+ break;
1435
+ }
1436
+ message.ask = reader.string();
1437
+ continue;
1259
1438
  }
1260
- message.ask = reader.string();
1261
- continue;
1262
- }
1263
- case 7: {
1264
- if (tag !== 56) {
1265
- break;
1439
+ case 7: {
1440
+ if (tag !== 56) {
1441
+ break;
1442
+ }
1443
+ message.rephrase = reader.bool();
1444
+ continue;
1266
1445
  }
1267
- message.rephrase = reader.bool();
1268
- continue;
1269
- }
1270
- case 8: {
1271
- if (tag !== 66) {
1272
- break;
1446
+ case 8: {
1447
+ if (tag !== 66) {
1448
+ break;
1449
+ }
1450
+ message.room = reader.string();
1451
+ continue;
1273
1452
  }
1274
- message.room = reader.string();
1275
- continue;
1276
- }
1277
- case 9: {
1278
- if (tag !== 72) {
1279
- break;
1453
+ case 9: {
1454
+ if (tag !== 72) {
1455
+ break;
1456
+ }
1457
+ message.cooldown = reader.int32();
1458
+ continue;
1280
1459
  }
1281
- message.cooldown = reader.int32();
1282
- continue;
1283
- }
1284
- case 10: {
1285
- if (tag !== 82) {
1286
- break;
1460
+ case 10: {
1461
+ if (tag !== 82) {
1462
+ break;
1463
+ }
1464
+ message.delay = reader.string();
1465
+ continue;
1287
1466
  }
1288
- message.delay = reader.string();
1289
- continue;
1290
- }
1291
- case 11: {
1292
- if (tag !== 90) {
1293
- break;
1467
+ case 11: {
1468
+ if (tag !== 90) {
1469
+ break;
1470
+ }
1471
+ message.actionsJson = reader.string();
1472
+ continue;
1294
1473
  }
1295
- message.actionsJson = reader.string();
1296
- continue;
1297
1474
  }
1475
+ if ((tag & 7) === 4 || tag === 0) {
1476
+ break;
1477
+ }
1478
+ reader.skip(tag & 7);
1298
1479
  }
1299
- if ((tag & 7) === 4 || tag === 0) {
1300
- break;
1301
- }
1302
- reader.skip(tag & 7);
1480
+ return message;
1481
+ }
1482
+ finally {
1483
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
1303
1484
  }
1304
- return message;
1305
1485
  },
1306
1486
  create(base) {
1307
1487
  return exports.UpdateTriggerRequest.fromPartial(base ?? {});
@@ -1334,25 +1514,35 @@ exports.DeleteTriggerRequest = {
1334
1514
  },
1335
1515
  decode(input, length) {
1336
1516
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
1337
- const end = length === undefined ? reader.len : reader.pos + length;
1338
- const message = createBaseDeleteTriggerRequest();
1339
- while (reader.pos < end) {
1340
- const tag = reader.uint32();
1341
- switch (tag >>> 3) {
1342
- case 1: {
1343
- if (tag !== 10) {
1344
- break;
1517
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
1518
+ if (previousRecursionDepth >= 100) {
1519
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
1520
+ }
1521
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
1522
+ try {
1523
+ const end = length === undefined ? reader.len : reader.pos + length;
1524
+ const message = createBaseDeleteTriggerRequest();
1525
+ while (reader.pos < end) {
1526
+ const tag = reader.uint32();
1527
+ switch (tag >>> 3) {
1528
+ case 1: {
1529
+ if (tag !== 10) {
1530
+ break;
1531
+ }
1532
+ message.id = reader.string();
1533
+ continue;
1345
1534
  }
1346
- message.id = reader.string();
1347
- continue;
1348
1535
  }
1536
+ if ((tag & 7) === 4 || tag === 0) {
1537
+ break;
1538
+ }
1539
+ reader.skip(tag & 7);
1349
1540
  }
1350
- if ((tag & 7) === 4 || tag === 0) {
1351
- break;
1352
- }
1353
- reader.skip(tag & 7);
1541
+ return message;
1542
+ }
1543
+ finally {
1544
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
1354
1545
  }
1355
- return message;
1356
1546
  },
1357
1547
  create(base) {
1358
1548
  return exports.DeleteTriggerRequest.fromPartial(base ?? {});
@@ -1411,88 +1601,98 @@ exports.Alarm = {
1411
1601
  },
1412
1602
  decode(input, length) {
1413
1603
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
1414
- const end = length === undefined ? reader.len : reader.pos + length;
1415
- const message = createBaseAlarm();
1416
- while (reader.pos < end) {
1417
- const tag = reader.uint32();
1418
- switch (tag >>> 3) {
1419
- case 1: {
1420
- if (tag !== 8) {
1421
- break;
1422
- }
1423
- message.id = reader.int32();
1424
- continue;
1425
- }
1426
- case 2: {
1427
- if (tag !== 18) {
1428
- break;
1604
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
1605
+ if (previousRecursionDepth >= 100) {
1606
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
1607
+ }
1608
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
1609
+ try {
1610
+ const end = length === undefined ? reader.len : reader.pos + length;
1611
+ const message = createBaseAlarm();
1612
+ while (reader.pos < end) {
1613
+ const tag = reader.uint32();
1614
+ switch (tag >>> 3) {
1615
+ case 1: {
1616
+ if (tag !== 8) {
1617
+ break;
1618
+ }
1619
+ message.id = reader.int32();
1620
+ continue;
1429
1621
  }
1430
- message.satelliteId = reader.string();
1431
- continue;
1432
- }
1433
- case 3: {
1434
- if (tag !== 26) {
1435
- break;
1622
+ case 2: {
1623
+ if (tag !== 18) {
1624
+ break;
1625
+ }
1626
+ message.satelliteId = reader.string();
1627
+ continue;
1436
1628
  }
1437
- message.time = reader.string();
1438
- continue;
1439
- }
1440
- case 4: {
1441
- if (tag === 32) {
1442
- message.weekdays.push(reader.int32());
1629
+ case 3: {
1630
+ if (tag !== 26) {
1631
+ break;
1632
+ }
1633
+ message.time = reader.string();
1443
1634
  continue;
1444
1635
  }
1445
- if (tag === 34) {
1446
- const end2 = reader.uint32() + reader.pos;
1447
- while (reader.pos < end2) {
1636
+ case 4: {
1637
+ if (tag === 32) {
1448
1638
  message.weekdays.push(reader.int32());
1639
+ continue;
1449
1640
  }
1641
+ if (tag === 34) {
1642
+ const end2 = reader.uint32() + reader.pos;
1643
+ while (reader.pos < end2) {
1644
+ message.weekdays.push(reader.int32());
1645
+ }
1646
+ continue;
1647
+ }
1648
+ break;
1649
+ }
1650
+ case 5: {
1651
+ if (tag !== 42) {
1652
+ break;
1653
+ }
1654
+ message.skipDates.push(reader.string());
1450
1655
  continue;
1451
1656
  }
1452
- break;
1453
- }
1454
- case 5: {
1455
- if (tag !== 42) {
1456
- break;
1657
+ case 6: {
1658
+ if (tag !== 50) {
1659
+ break;
1660
+ }
1661
+ message.oneShotDate = reader.string();
1662
+ continue;
1457
1663
  }
1458
- message.skipDates.push(reader.string());
1459
- continue;
1460
- }
1461
- case 6: {
1462
- if (tag !== 50) {
1463
- break;
1664
+ case 7: {
1665
+ if (tag !== 56) {
1666
+ break;
1667
+ }
1668
+ message.enabled = reader.bool();
1669
+ continue;
1464
1670
  }
1465
- message.oneShotDate = reader.string();
1466
- continue;
1467
- }
1468
- case 7: {
1469
- if (tag !== 56) {
1470
- break;
1671
+ case 8: {
1672
+ if (tag !== 66) {
1673
+ break;
1674
+ }
1675
+ message.label = reader.string();
1676
+ continue;
1471
1677
  }
1472
- message.enabled = reader.bool();
1473
- continue;
1474
- }
1475
- case 8: {
1476
- if (tag !== 66) {
1477
- break;
1678
+ case 9: {
1679
+ if (tag !== 72) {
1680
+ break;
1681
+ }
1682
+ message.userId = reader.int32();
1683
+ continue;
1478
1684
  }
1479
- message.label = reader.string();
1480
- continue;
1481
1685
  }
1482
- case 9: {
1483
- if (tag !== 72) {
1484
- break;
1485
- }
1486
- message.userId = reader.int32();
1487
- continue;
1686
+ if ((tag & 7) === 4 || tag === 0) {
1687
+ break;
1488
1688
  }
1689
+ reader.skip(tag & 7);
1489
1690
  }
1490
- if ((tag & 7) === 4 || tag === 0) {
1491
- break;
1492
- }
1493
- reader.skip(tag & 7);
1691
+ return message;
1692
+ }
1693
+ finally {
1694
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
1494
1695
  }
1495
- return message;
1496
1696
  },
1497
1697
  create(base) {
1498
1698
  return exports.Alarm.fromPartial(base ?? {});
@@ -1523,25 +1723,35 @@ exports.GetAlarmsResponse = {
1523
1723
  },
1524
1724
  decode(input, length) {
1525
1725
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
1526
- const end = length === undefined ? reader.len : reader.pos + length;
1527
- const message = createBaseGetAlarmsResponse();
1528
- while (reader.pos < end) {
1529
- const tag = reader.uint32();
1530
- switch (tag >>> 3) {
1531
- case 1: {
1532
- if (tag !== 10) {
1533
- break;
1726
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
1727
+ if (previousRecursionDepth >= 100) {
1728
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
1729
+ }
1730
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
1731
+ try {
1732
+ const end = length === undefined ? reader.len : reader.pos + length;
1733
+ const message = createBaseGetAlarmsResponse();
1734
+ while (reader.pos < end) {
1735
+ const tag = reader.uint32();
1736
+ switch (tag >>> 3) {
1737
+ case 1: {
1738
+ if (tag !== 10) {
1739
+ break;
1740
+ }
1741
+ message.alarms.push(exports.Alarm.decode(reader, reader.uint32()));
1742
+ continue;
1534
1743
  }
1535
- message.alarms.push(exports.Alarm.decode(reader, reader.uint32()));
1536
- continue;
1537
1744
  }
1745
+ if ((tag & 7) === 4 || tag === 0) {
1746
+ break;
1747
+ }
1748
+ reader.skip(tag & 7);
1538
1749
  }
1539
- if ((tag & 7) === 4 || tag === 0) {
1540
- break;
1541
- }
1542
- reader.skip(tag & 7);
1750
+ return message;
1751
+ }
1752
+ finally {
1753
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
1543
1754
  }
1544
- return message;
1545
1755
  },
1546
1756
  create(base) {
1547
1757
  return exports.GetAlarmsResponse.fromPartial(base ?? {});
@@ -1581,67 +1791,77 @@ exports.CreateAlarmRequest = {
1581
1791
  },
1582
1792
  decode(input, length) {
1583
1793
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
1584
- const end = length === undefined ? reader.len : reader.pos + length;
1585
- const message = createBaseCreateAlarmRequest();
1586
- while (reader.pos < end) {
1587
- const tag = reader.uint32();
1588
- switch (tag >>> 3) {
1589
- case 1: {
1590
- if (tag !== 10) {
1591
- break;
1592
- }
1593
- message.satelliteId = reader.string();
1594
- continue;
1595
- }
1596
- case 2: {
1597
- if (tag !== 18) {
1598
- break;
1794
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
1795
+ if (previousRecursionDepth >= 100) {
1796
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
1797
+ }
1798
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
1799
+ try {
1800
+ const end = length === undefined ? reader.len : reader.pos + length;
1801
+ const message = createBaseCreateAlarmRequest();
1802
+ while (reader.pos < end) {
1803
+ const tag = reader.uint32();
1804
+ switch (tag >>> 3) {
1805
+ case 1: {
1806
+ if (tag !== 10) {
1807
+ break;
1808
+ }
1809
+ message.satelliteId = reader.string();
1810
+ continue;
1599
1811
  }
1600
- message.time = reader.string();
1601
- continue;
1602
- }
1603
- case 3: {
1604
- if (tag === 24) {
1605
- message.weekdays.push(reader.int32());
1812
+ case 2: {
1813
+ if (tag !== 18) {
1814
+ break;
1815
+ }
1816
+ message.time = reader.string();
1606
1817
  continue;
1607
1818
  }
1608
- if (tag === 26) {
1609
- const end2 = reader.uint32() + reader.pos;
1610
- while (reader.pos < end2) {
1819
+ case 3: {
1820
+ if (tag === 24) {
1611
1821
  message.weekdays.push(reader.int32());
1822
+ continue;
1823
+ }
1824
+ if (tag === 26) {
1825
+ const end2 = reader.uint32() + reader.pos;
1826
+ while (reader.pos < end2) {
1827
+ message.weekdays.push(reader.int32());
1828
+ }
1829
+ continue;
1612
1830
  }
1831
+ break;
1832
+ }
1833
+ case 4: {
1834
+ if (tag !== 34) {
1835
+ break;
1836
+ }
1837
+ message.oneShotDate = reader.string();
1613
1838
  continue;
1614
1839
  }
1615
- break;
1616
- }
1617
- case 4: {
1618
- if (tag !== 34) {
1619
- break;
1840
+ case 5: {
1841
+ if (tag !== 42) {
1842
+ break;
1843
+ }
1844
+ message.label = reader.string();
1845
+ continue;
1620
1846
  }
1621
- message.oneShotDate = reader.string();
1622
- continue;
1623
- }
1624
- case 5: {
1625
- if (tag !== 42) {
1626
- break;
1847
+ case 6: {
1848
+ if (tag !== 48) {
1849
+ break;
1850
+ }
1851
+ message.userId = reader.int32();
1852
+ continue;
1627
1853
  }
1628
- message.label = reader.string();
1629
- continue;
1630
1854
  }
1631
- case 6: {
1632
- if (tag !== 48) {
1633
- break;
1634
- }
1635
- message.userId = reader.int32();
1636
- continue;
1855
+ if ((tag & 7) === 4 || tag === 0) {
1856
+ break;
1637
1857
  }
1858
+ reader.skip(tag & 7);
1638
1859
  }
1639
- if ((tag & 7) === 4 || tag === 0) {
1640
- break;
1641
- }
1642
- reader.skip(tag & 7);
1860
+ return message;
1861
+ }
1862
+ finally {
1863
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
1643
1864
  }
1644
- return message;
1645
1865
  },
1646
1866
  create(base) {
1647
1867
  return exports.CreateAlarmRequest.fromPartial(base ?? {});
@@ -1675,39 +1895,49 @@ exports.CreateAlarmResponse = {
1675
1895
  },
1676
1896
  decode(input, length) {
1677
1897
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
1678
- const end = length === undefined ? reader.len : reader.pos + length;
1679
- const message = createBaseCreateAlarmResponse();
1680
- while (reader.pos < end) {
1681
- const tag = reader.uint32();
1682
- switch (tag >>> 3) {
1683
- case 1: {
1684
- if (tag !== 8) {
1685
- break;
1898
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
1899
+ if (previousRecursionDepth >= 100) {
1900
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
1901
+ }
1902
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
1903
+ try {
1904
+ const end = length === undefined ? reader.len : reader.pos + length;
1905
+ const message = createBaseCreateAlarmResponse();
1906
+ while (reader.pos < end) {
1907
+ const tag = reader.uint32();
1908
+ switch (tag >>> 3) {
1909
+ case 1: {
1910
+ if (tag !== 8) {
1911
+ break;
1912
+ }
1913
+ message.ok = reader.bool();
1914
+ continue;
1686
1915
  }
1687
- message.ok = reader.bool();
1688
- continue;
1689
- }
1690
- case 2: {
1691
- if (tag !== 16) {
1692
- break;
1916
+ case 2: {
1917
+ if (tag !== 16) {
1918
+ break;
1919
+ }
1920
+ message.id = reader.int32();
1921
+ continue;
1693
1922
  }
1694
- message.id = reader.int32();
1695
- continue;
1696
- }
1697
- case 3: {
1698
- if (tag !== 26) {
1699
- break;
1923
+ case 3: {
1924
+ if (tag !== 26) {
1925
+ break;
1926
+ }
1927
+ message.message = reader.string();
1928
+ continue;
1700
1929
  }
1701
- message.message = reader.string();
1702
- continue;
1703
1930
  }
1931
+ if ((tag & 7) === 4 || tag === 0) {
1932
+ break;
1933
+ }
1934
+ reader.skip(tag & 7);
1704
1935
  }
1705
- if ((tag & 7) === 4 || tag === 0) {
1706
- break;
1707
- }
1708
- reader.skip(tag & 7);
1936
+ return message;
1937
+ }
1938
+ finally {
1939
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
1709
1940
  }
1710
- return message;
1711
1941
  },
1712
1942
  create(base) {
1713
1943
  return exports.CreateAlarmResponse.fromPartial(base ?? {});
@@ -1755,81 +1985,91 @@ exports.UpdateAlarmRequest = {
1755
1985
  },
1756
1986
  decode(input, length) {
1757
1987
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
1758
- const end = length === undefined ? reader.len : reader.pos + length;
1759
- const message = createBaseUpdateAlarmRequest();
1760
- while (reader.pos < end) {
1761
- const tag = reader.uint32();
1762
- switch (tag >>> 3) {
1763
- case 1: {
1764
- if (tag !== 8) {
1765
- break;
1766
- }
1767
- message.id = reader.int32();
1768
- continue;
1769
- }
1770
- case 2: {
1771
- if (tag !== 18) {
1772
- break;
1988
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
1989
+ if (previousRecursionDepth >= 100) {
1990
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
1991
+ }
1992
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
1993
+ try {
1994
+ const end = length === undefined ? reader.len : reader.pos + length;
1995
+ const message = createBaseUpdateAlarmRequest();
1996
+ while (reader.pos < end) {
1997
+ const tag = reader.uint32();
1998
+ switch (tag >>> 3) {
1999
+ case 1: {
2000
+ if (tag !== 8) {
2001
+ break;
2002
+ }
2003
+ message.id = reader.int32();
2004
+ continue;
1773
2005
  }
1774
- message.satelliteId = reader.string();
1775
- continue;
1776
- }
1777
- case 3: {
1778
- if (tag !== 26) {
1779
- break;
2006
+ case 2: {
2007
+ if (tag !== 18) {
2008
+ break;
2009
+ }
2010
+ message.satelliteId = reader.string();
2011
+ continue;
1780
2012
  }
1781
- message.time = reader.string();
1782
- continue;
1783
- }
1784
- case 4: {
1785
- if (tag === 32) {
1786
- message.weekdays.push(reader.int32());
2013
+ case 3: {
2014
+ if (tag !== 26) {
2015
+ break;
2016
+ }
2017
+ message.time = reader.string();
1787
2018
  continue;
1788
2019
  }
1789
- if (tag === 34) {
1790
- const end2 = reader.uint32() + reader.pos;
1791
- while (reader.pos < end2) {
2020
+ case 4: {
2021
+ if (tag === 32) {
1792
2022
  message.weekdays.push(reader.int32());
2023
+ continue;
2024
+ }
2025
+ if (tag === 34) {
2026
+ const end2 = reader.uint32() + reader.pos;
2027
+ while (reader.pos < end2) {
2028
+ message.weekdays.push(reader.int32());
2029
+ }
2030
+ continue;
1793
2031
  }
2032
+ break;
2033
+ }
2034
+ case 5: {
2035
+ if (tag !== 42) {
2036
+ break;
2037
+ }
2038
+ message.skipDates.push(reader.string());
1794
2039
  continue;
1795
2040
  }
1796
- break;
1797
- }
1798
- case 5: {
1799
- if (tag !== 42) {
1800
- break;
2041
+ case 6: {
2042
+ if (tag !== 50) {
2043
+ break;
2044
+ }
2045
+ message.oneShotDate = reader.string();
2046
+ continue;
1801
2047
  }
1802
- message.skipDates.push(reader.string());
1803
- continue;
1804
- }
1805
- case 6: {
1806
- if (tag !== 50) {
1807
- break;
2048
+ case 7: {
2049
+ if (tag !== 56) {
2050
+ break;
2051
+ }
2052
+ message.enabled = reader.bool();
2053
+ continue;
1808
2054
  }
1809
- message.oneShotDate = reader.string();
1810
- continue;
1811
- }
1812
- case 7: {
1813
- if (tag !== 56) {
1814
- break;
2055
+ case 8: {
2056
+ if (tag !== 66) {
2057
+ break;
2058
+ }
2059
+ message.label = reader.string();
2060
+ continue;
1815
2061
  }
1816
- message.enabled = reader.bool();
1817
- continue;
1818
2062
  }
1819
- case 8: {
1820
- if (tag !== 66) {
1821
- break;
1822
- }
1823
- message.label = reader.string();
1824
- continue;
2063
+ if ((tag & 7) === 4 || tag === 0) {
2064
+ break;
1825
2065
  }
2066
+ reader.skip(tag & 7);
1826
2067
  }
1827
- if ((tag & 7) === 4 || tag === 0) {
1828
- break;
1829
- }
1830
- reader.skip(tag & 7);
2068
+ return message;
2069
+ }
2070
+ finally {
2071
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
1831
2072
  }
1832
- return message;
1833
2073
  },
1834
2074
  create(base) {
1835
2075
  return exports.UpdateAlarmRequest.fromPartial(base ?? {});
@@ -1859,25 +2099,35 @@ exports.DeleteAlarmRequest = {
1859
2099
  },
1860
2100
  decode(input, length) {
1861
2101
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
1862
- const end = length === undefined ? reader.len : reader.pos + length;
1863
- const message = createBaseDeleteAlarmRequest();
1864
- while (reader.pos < end) {
1865
- const tag = reader.uint32();
1866
- switch (tag >>> 3) {
1867
- case 1: {
1868
- if (tag !== 8) {
1869
- break;
2102
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
2103
+ if (previousRecursionDepth >= 100) {
2104
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
2105
+ }
2106
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
2107
+ try {
2108
+ const end = length === undefined ? reader.len : reader.pos + length;
2109
+ const message = createBaseDeleteAlarmRequest();
2110
+ while (reader.pos < end) {
2111
+ const tag = reader.uint32();
2112
+ switch (tag >>> 3) {
2113
+ case 1: {
2114
+ if (tag !== 8) {
2115
+ break;
2116
+ }
2117
+ message.id = reader.int32();
2118
+ continue;
1870
2119
  }
1871
- message.id = reader.int32();
1872
- continue;
1873
2120
  }
2121
+ if ((tag & 7) === 4 || tag === 0) {
2122
+ break;
2123
+ }
2124
+ reader.skip(tag & 7);
1874
2125
  }
1875
- if ((tag & 7) === 4 || tag === 0) {
1876
- break;
1877
- }
1878
- reader.skip(tag & 7);
2126
+ return message;
2127
+ }
2128
+ finally {
2129
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
1879
2130
  }
1880
- return message;
1881
2131
  },
1882
2132
  create(base) {
1883
2133
  return exports.DeleteAlarmRequest.fromPartial(base ?? {});
@@ -1906,39 +2156,49 @@ exports.Category = {
1906
2156
  },
1907
2157
  decode(input, length) {
1908
2158
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
1909
- const end = length === undefined ? reader.len : reader.pos + length;
1910
- const message = createBaseCategory();
1911
- while (reader.pos < end) {
1912
- const tag = reader.uint32();
1913
- switch (tag >>> 3) {
1914
- case 1: {
1915
- if (tag !== 8) {
1916
- break;
2159
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
2160
+ if (previousRecursionDepth >= 100) {
2161
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
2162
+ }
2163
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
2164
+ try {
2165
+ const end = length === undefined ? reader.len : reader.pos + length;
2166
+ const message = createBaseCategory();
2167
+ while (reader.pos < end) {
2168
+ const tag = reader.uint32();
2169
+ switch (tag >>> 3) {
2170
+ case 1: {
2171
+ if (tag !== 8) {
2172
+ break;
2173
+ }
2174
+ message.id = reader.int32();
2175
+ continue;
1917
2176
  }
1918
- message.id = reader.int32();
1919
- continue;
1920
- }
1921
- case 2: {
1922
- if (tag !== 18) {
1923
- break;
2177
+ case 2: {
2178
+ if (tag !== 18) {
2179
+ break;
2180
+ }
2181
+ message.name = reader.string();
2182
+ continue;
1924
2183
  }
1925
- message.name = reader.string();
1926
- continue;
1927
- }
1928
- case 3: {
1929
- if (tag !== 24) {
1930
- break;
2184
+ case 3: {
2185
+ if (tag !== 24) {
2186
+ break;
2187
+ }
2188
+ message.parentId = reader.int32();
2189
+ continue;
1931
2190
  }
1932
- message.parentId = reader.int32();
1933
- continue;
1934
2191
  }
2192
+ if ((tag & 7) === 4 || tag === 0) {
2193
+ break;
2194
+ }
2195
+ reader.skip(tag & 7);
1935
2196
  }
1936
- if ((tag & 7) === 4 || tag === 0) {
1937
- break;
1938
- }
1939
- reader.skip(tag & 7);
2197
+ return message;
2198
+ }
2199
+ finally {
2200
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
1940
2201
  }
1941
- return message;
1942
2202
  },
1943
2203
  create(base) {
1944
2204
  return exports.Category.fromPartial(base ?? {});
@@ -1972,46 +2232,56 @@ exports.Setting = {
1972
2232
  },
1973
2233
  decode(input, length) {
1974
2234
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
1975
- const end = length === undefined ? reader.len : reader.pos + length;
1976
- const message = createBaseSetting();
1977
- while (reader.pos < end) {
1978
- const tag = reader.uint32();
1979
- switch (tag >>> 3) {
1980
- case 1: {
1981
- if (tag !== 8) {
1982
- break;
2235
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
2236
+ if (previousRecursionDepth >= 100) {
2237
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
2238
+ }
2239
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
2240
+ try {
2241
+ const end = length === undefined ? reader.len : reader.pos + length;
2242
+ const message = createBaseSetting();
2243
+ while (reader.pos < end) {
2244
+ const tag = reader.uint32();
2245
+ switch (tag >>> 3) {
2246
+ case 1: {
2247
+ if (tag !== 8) {
2248
+ break;
2249
+ }
2250
+ message.id = reader.int32();
2251
+ continue;
1983
2252
  }
1984
- message.id = reader.int32();
1985
- continue;
1986
- }
1987
- case 2: {
1988
- if (tag !== 16) {
1989
- break;
2253
+ case 2: {
2254
+ if (tag !== 16) {
2255
+ break;
2256
+ }
2257
+ message.categoryId = reader.int32();
2258
+ continue;
1990
2259
  }
1991
- message.categoryId = reader.int32();
1992
- continue;
1993
- }
1994
- case 3: {
1995
- if (tag !== 26) {
1996
- break;
2260
+ case 3: {
2261
+ if (tag !== 26) {
2262
+ break;
2263
+ }
2264
+ message.name = reader.string();
2265
+ continue;
1997
2266
  }
1998
- message.name = reader.string();
1999
- continue;
2000
- }
2001
- case 4: {
2002
- if (tag !== 34) {
2003
- break;
2267
+ case 4: {
2268
+ if (tag !== 34) {
2269
+ break;
2270
+ }
2271
+ message.value = reader.string();
2272
+ continue;
2004
2273
  }
2005
- message.value = reader.string();
2006
- continue;
2007
2274
  }
2275
+ if ((tag & 7) === 4 || tag === 0) {
2276
+ break;
2277
+ }
2278
+ reader.skip(tag & 7);
2008
2279
  }
2009
- if ((tag & 7) === 4 || tag === 0) {
2010
- break;
2011
- }
2012
- reader.skip(tag & 7);
2280
+ return message;
2281
+ }
2282
+ finally {
2283
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
2013
2284
  }
2014
- return message;
2015
2285
  },
2016
2286
  create(base) {
2017
2287
  return exports.Setting.fromPartial(base ?? {});
@@ -2040,32 +2310,42 @@ exports.GetSettingsResponse = {
2040
2310
  },
2041
2311
  decode(input, length) {
2042
2312
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
2043
- const end = length === undefined ? reader.len : reader.pos + length;
2044
- const message = createBaseGetSettingsResponse();
2045
- while (reader.pos < end) {
2046
- const tag = reader.uint32();
2047
- switch (tag >>> 3) {
2048
- case 1: {
2049
- if (tag !== 10) {
2050
- break;
2313
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
2314
+ if (previousRecursionDepth >= 100) {
2315
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
2316
+ }
2317
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
2318
+ try {
2319
+ const end = length === undefined ? reader.len : reader.pos + length;
2320
+ const message = createBaseGetSettingsResponse();
2321
+ while (reader.pos < end) {
2322
+ const tag = reader.uint32();
2323
+ switch (tag >>> 3) {
2324
+ case 1: {
2325
+ if (tag !== 10) {
2326
+ break;
2327
+ }
2328
+ message.categories.push(exports.Category.decode(reader, reader.uint32()));
2329
+ continue;
2051
2330
  }
2052
- message.categories.push(exports.Category.decode(reader, reader.uint32()));
2053
- continue;
2054
- }
2055
- case 2: {
2056
- if (tag !== 18) {
2057
- break;
2331
+ case 2: {
2332
+ if (tag !== 18) {
2333
+ break;
2334
+ }
2335
+ message.settings.push(exports.Setting.decode(reader, reader.uint32()));
2336
+ continue;
2058
2337
  }
2059
- message.settings.push(exports.Setting.decode(reader, reader.uint32()));
2060
- continue;
2061
2338
  }
2339
+ if ((tag & 7) === 4 || tag === 0) {
2340
+ break;
2341
+ }
2342
+ reader.skip(tag & 7);
2062
2343
  }
2063
- if ((tag & 7) === 4 || tag === 0) {
2064
- break;
2065
- }
2066
- reader.skip(tag & 7);
2344
+ return message;
2345
+ }
2346
+ finally {
2347
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
2067
2348
  }
2068
- return message;
2069
2349
  },
2070
2350
  create(base) {
2071
2351
  return exports.GetSettingsResponse.fromPartial(base ?? {});
@@ -2092,32 +2372,42 @@ exports.SettingUpdate = {
2092
2372
  },
2093
2373
  decode(input, length) {
2094
2374
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
2095
- const end = length === undefined ? reader.len : reader.pos + length;
2096
- const message = createBaseSettingUpdate();
2097
- while (reader.pos < end) {
2098
- const tag = reader.uint32();
2099
- switch (tag >>> 3) {
2100
- case 1: {
2101
- if (tag !== 8) {
2102
- break;
2375
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
2376
+ if (previousRecursionDepth >= 100) {
2377
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
2378
+ }
2379
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
2380
+ try {
2381
+ const end = length === undefined ? reader.len : reader.pos + length;
2382
+ const message = createBaseSettingUpdate();
2383
+ while (reader.pos < end) {
2384
+ const tag = reader.uint32();
2385
+ switch (tag >>> 3) {
2386
+ case 1: {
2387
+ if (tag !== 8) {
2388
+ break;
2389
+ }
2390
+ message.settingId = reader.int32();
2391
+ continue;
2103
2392
  }
2104
- message.settingId = reader.int32();
2105
- continue;
2106
- }
2107
- case 2: {
2108
- if (tag !== 18) {
2109
- break;
2393
+ case 2: {
2394
+ if (tag !== 18) {
2395
+ break;
2396
+ }
2397
+ message.value = reader.string();
2398
+ continue;
2110
2399
  }
2111
- message.value = reader.string();
2112
- continue;
2113
2400
  }
2401
+ if ((tag & 7) === 4 || tag === 0) {
2402
+ break;
2403
+ }
2404
+ reader.skip(tag & 7);
2114
2405
  }
2115
- if ((tag & 7) === 4 || tag === 0) {
2116
- break;
2117
- }
2118
- reader.skip(tag & 7);
2406
+ return message;
2407
+ }
2408
+ finally {
2409
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
2119
2410
  }
2120
- return message;
2121
2411
  },
2122
2412
  create(base) {
2123
2413
  return exports.SettingUpdate.fromPartial(base ?? {});
@@ -2141,25 +2431,35 @@ exports.UpdateConfigRequest = {
2141
2431
  },
2142
2432
  decode(input, length) {
2143
2433
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
2144
- const end = length === undefined ? reader.len : reader.pos + length;
2145
- const message = createBaseUpdateConfigRequest();
2146
- while (reader.pos < end) {
2147
- const tag = reader.uint32();
2148
- switch (tag >>> 3) {
2149
- case 1: {
2150
- if (tag !== 10) {
2151
- break;
2434
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
2435
+ if (previousRecursionDepth >= 100) {
2436
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
2437
+ }
2438
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
2439
+ try {
2440
+ const end = length === undefined ? reader.len : reader.pos + length;
2441
+ const message = createBaseUpdateConfigRequest();
2442
+ while (reader.pos < end) {
2443
+ const tag = reader.uint32();
2444
+ switch (tag >>> 3) {
2445
+ case 1: {
2446
+ if (tag !== 10) {
2447
+ break;
2448
+ }
2449
+ message.updates.push(exports.SettingUpdate.decode(reader, reader.uint32()));
2450
+ continue;
2152
2451
  }
2153
- message.updates.push(exports.SettingUpdate.decode(reader, reader.uint32()));
2154
- continue;
2155
2452
  }
2453
+ if ((tag & 7) === 4 || tag === 0) {
2454
+ break;
2455
+ }
2456
+ reader.skip(tag & 7);
2156
2457
  }
2157
- if ((tag & 7) === 4 || tag === 0) {
2158
- break;
2159
- }
2160
- reader.skip(tag & 7);
2458
+ return message;
2459
+ }
2460
+ finally {
2461
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
2161
2462
  }
2162
- return message;
2163
2463
  },
2164
2464
  create(base) {
2165
2465
  return exports.UpdateConfigRequest.fromPartial(base ?? {});
@@ -2191,46 +2491,56 @@ exports.BleTag = {
2191
2491
  },
2192
2492
  decode(input, length) {
2193
2493
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
2194
- const end = length === undefined ? reader.len : reader.pos + length;
2195
- const message = createBaseBleTag();
2196
- while (reader.pos < end) {
2197
- const tag = reader.uint32();
2198
- switch (tag >>> 3) {
2199
- case 1: {
2200
- if (tag !== 8) {
2201
- break;
2494
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
2495
+ if (previousRecursionDepth >= 100) {
2496
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
2497
+ }
2498
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
2499
+ try {
2500
+ const end = length === undefined ? reader.len : reader.pos + length;
2501
+ const message = createBaseBleTag();
2502
+ while (reader.pos < end) {
2503
+ const tag = reader.uint32();
2504
+ switch (tag >>> 3) {
2505
+ case 1: {
2506
+ if (tag !== 8) {
2507
+ break;
2508
+ }
2509
+ message.id = reader.int32();
2510
+ continue;
2202
2511
  }
2203
- message.id = reader.int32();
2204
- continue;
2205
- }
2206
- case 2: {
2207
- if (tag !== 18) {
2208
- break;
2512
+ case 2: {
2513
+ if (tag !== 18) {
2514
+ break;
2515
+ }
2516
+ message.macAddress = reader.string();
2517
+ continue;
2209
2518
  }
2210
- message.macAddress = reader.string();
2211
- continue;
2212
- }
2213
- case 3: {
2214
- if (tag !== 26) {
2215
- break;
2519
+ case 3: {
2520
+ if (tag !== 26) {
2521
+ break;
2522
+ }
2523
+ message.label = reader.string();
2524
+ continue;
2216
2525
  }
2217
- message.label = reader.string();
2218
- continue;
2219
- }
2220
- case 4: {
2221
- if (tag !== 32) {
2222
- break;
2526
+ case 4: {
2527
+ if (tag !== 32) {
2528
+ break;
2529
+ }
2530
+ message.userId = reader.int32();
2531
+ continue;
2223
2532
  }
2224
- message.userId = reader.int32();
2225
- continue;
2226
2533
  }
2534
+ if ((tag & 7) === 4 || tag === 0) {
2535
+ break;
2536
+ }
2537
+ reader.skip(tag & 7);
2227
2538
  }
2228
- if ((tag & 7) === 4 || tag === 0) {
2229
- break;
2230
- }
2231
- reader.skip(tag & 7);
2539
+ return message;
2540
+ }
2541
+ finally {
2542
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
2232
2543
  }
2233
- return message;
2234
2544
  },
2235
2545
  create(base) {
2236
2546
  return exports.BleTag.fromPartial(base ?? {});
@@ -2256,25 +2566,35 @@ exports.GetBleTagsResponse = {
2256
2566
  },
2257
2567
  decode(input, length) {
2258
2568
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
2259
- const end = length === undefined ? reader.len : reader.pos + length;
2260
- const message = createBaseGetBleTagsResponse();
2261
- while (reader.pos < end) {
2262
- const tag = reader.uint32();
2263
- switch (tag >>> 3) {
2264
- case 1: {
2265
- if (tag !== 10) {
2266
- break;
2569
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
2570
+ if (previousRecursionDepth >= 100) {
2571
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
2572
+ }
2573
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
2574
+ try {
2575
+ const end = length === undefined ? reader.len : reader.pos + length;
2576
+ const message = createBaseGetBleTagsResponse();
2577
+ while (reader.pos < end) {
2578
+ const tag = reader.uint32();
2579
+ switch (tag >>> 3) {
2580
+ case 1: {
2581
+ if (tag !== 10) {
2582
+ break;
2583
+ }
2584
+ message.tags.push(exports.BleTag.decode(reader, reader.uint32()));
2585
+ continue;
2267
2586
  }
2268
- message.tags.push(exports.BleTag.decode(reader, reader.uint32()));
2269
- continue;
2270
2587
  }
2588
+ if ((tag & 7) === 4 || tag === 0) {
2589
+ break;
2590
+ }
2591
+ reader.skip(tag & 7);
2271
2592
  }
2272
- if ((tag & 7) === 4 || tag === 0) {
2273
- break;
2274
- }
2275
- reader.skip(tag & 7);
2593
+ return message;
2594
+ }
2595
+ finally {
2596
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
2276
2597
  }
2277
- return message;
2278
2598
  },
2279
2599
  create(base) {
2280
2600
  return exports.GetBleTagsResponse.fromPartial(base ?? {});
@@ -2303,39 +2623,49 @@ exports.CreateBleTagRequest = {
2303
2623
  },
2304
2624
  decode(input, length) {
2305
2625
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
2306
- const end = length === undefined ? reader.len : reader.pos + length;
2307
- const message = createBaseCreateBleTagRequest();
2308
- while (reader.pos < end) {
2309
- const tag = reader.uint32();
2310
- switch (tag >>> 3) {
2311
- case 1: {
2312
- if (tag !== 10) {
2313
- break;
2626
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
2627
+ if (previousRecursionDepth >= 100) {
2628
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
2629
+ }
2630
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
2631
+ try {
2632
+ const end = length === undefined ? reader.len : reader.pos + length;
2633
+ const message = createBaseCreateBleTagRequest();
2634
+ while (reader.pos < end) {
2635
+ const tag = reader.uint32();
2636
+ switch (tag >>> 3) {
2637
+ case 1: {
2638
+ if (tag !== 10) {
2639
+ break;
2640
+ }
2641
+ message.macAddress = reader.string();
2642
+ continue;
2314
2643
  }
2315
- message.macAddress = reader.string();
2316
- continue;
2317
- }
2318
- case 2: {
2319
- if (tag !== 18) {
2320
- break;
2644
+ case 2: {
2645
+ if (tag !== 18) {
2646
+ break;
2647
+ }
2648
+ message.label = reader.string();
2649
+ continue;
2321
2650
  }
2322
- message.label = reader.string();
2323
- continue;
2324
- }
2325
- case 3: {
2326
- if (tag !== 24) {
2327
- break;
2651
+ case 3: {
2652
+ if (tag !== 24) {
2653
+ break;
2654
+ }
2655
+ message.userId = reader.int32();
2656
+ continue;
2328
2657
  }
2329
- message.userId = reader.int32();
2330
- continue;
2331
2658
  }
2659
+ if ((tag & 7) === 4 || tag === 0) {
2660
+ break;
2661
+ }
2662
+ reader.skip(tag & 7);
2332
2663
  }
2333
- if ((tag & 7) === 4 || tag === 0) {
2334
- break;
2335
- }
2336
- reader.skip(tag & 7);
2664
+ return message;
2665
+ }
2666
+ finally {
2667
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
2337
2668
  }
2338
- return message;
2339
2669
  },
2340
2670
  create(base) {
2341
2671
  return exports.CreateBleTagRequest.fromPartial(base ?? {});
@@ -2366,39 +2696,49 @@ exports.CreateBleTagResponse = {
2366
2696
  },
2367
2697
  decode(input, length) {
2368
2698
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
2369
- const end = length === undefined ? reader.len : reader.pos + length;
2370
- const message = createBaseCreateBleTagResponse();
2371
- while (reader.pos < end) {
2372
- const tag = reader.uint32();
2373
- switch (tag >>> 3) {
2374
- case 1: {
2375
- if (tag !== 8) {
2376
- break;
2699
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
2700
+ if (previousRecursionDepth >= 100) {
2701
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
2702
+ }
2703
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
2704
+ try {
2705
+ const end = length === undefined ? reader.len : reader.pos + length;
2706
+ const message = createBaseCreateBleTagResponse();
2707
+ while (reader.pos < end) {
2708
+ const tag = reader.uint32();
2709
+ switch (tag >>> 3) {
2710
+ case 1: {
2711
+ if (tag !== 8) {
2712
+ break;
2713
+ }
2714
+ message.ok = reader.bool();
2715
+ continue;
2377
2716
  }
2378
- message.ok = reader.bool();
2379
- continue;
2380
- }
2381
- case 2: {
2382
- if (tag !== 16) {
2383
- break;
2717
+ case 2: {
2718
+ if (tag !== 16) {
2719
+ break;
2720
+ }
2721
+ message.id = reader.int32();
2722
+ continue;
2384
2723
  }
2385
- message.id = reader.int32();
2386
- continue;
2387
- }
2388
- case 3: {
2389
- if (tag !== 26) {
2390
- break;
2724
+ case 3: {
2725
+ if (tag !== 26) {
2726
+ break;
2727
+ }
2728
+ message.message = reader.string();
2729
+ continue;
2391
2730
  }
2392
- message.message = reader.string();
2393
- continue;
2394
2731
  }
2732
+ if ((tag & 7) === 4 || tag === 0) {
2733
+ break;
2734
+ }
2735
+ reader.skip(tag & 7);
2395
2736
  }
2396
- if ((tag & 7) === 4 || tag === 0) {
2397
- break;
2398
- }
2399
- reader.skip(tag & 7);
2737
+ return message;
2738
+ }
2739
+ finally {
2740
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
2400
2741
  }
2401
- return message;
2402
2742
  },
2403
2743
  create(base) {
2404
2744
  return exports.CreateBleTagResponse.fromPartial(base ?? {});
@@ -2432,46 +2772,56 @@ exports.UpdateBleTagRequest = {
2432
2772
  },
2433
2773
  decode(input, length) {
2434
2774
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
2435
- const end = length === undefined ? reader.len : reader.pos + length;
2436
- const message = createBaseUpdateBleTagRequest();
2437
- while (reader.pos < end) {
2438
- const tag = reader.uint32();
2439
- switch (tag >>> 3) {
2440
- case 1: {
2441
- if (tag !== 8) {
2442
- break;
2775
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
2776
+ if (previousRecursionDepth >= 100) {
2777
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
2778
+ }
2779
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
2780
+ try {
2781
+ const end = length === undefined ? reader.len : reader.pos + length;
2782
+ const message = createBaseUpdateBleTagRequest();
2783
+ while (reader.pos < end) {
2784
+ const tag = reader.uint32();
2785
+ switch (tag >>> 3) {
2786
+ case 1: {
2787
+ if (tag !== 8) {
2788
+ break;
2789
+ }
2790
+ message.id = reader.int32();
2791
+ continue;
2443
2792
  }
2444
- message.id = reader.int32();
2445
- continue;
2446
- }
2447
- case 2: {
2448
- if (tag !== 18) {
2449
- break;
2793
+ case 2: {
2794
+ if (tag !== 18) {
2795
+ break;
2796
+ }
2797
+ message.macAddress = reader.string();
2798
+ continue;
2450
2799
  }
2451
- message.macAddress = reader.string();
2452
- continue;
2453
- }
2454
- case 3: {
2455
- if (tag !== 26) {
2456
- break;
2800
+ case 3: {
2801
+ if (tag !== 26) {
2802
+ break;
2803
+ }
2804
+ message.label = reader.string();
2805
+ continue;
2457
2806
  }
2458
- message.label = reader.string();
2459
- continue;
2460
- }
2461
- case 4: {
2462
- if (tag !== 32) {
2463
- break;
2807
+ case 4: {
2808
+ if (tag !== 32) {
2809
+ break;
2810
+ }
2811
+ message.userId = reader.int32();
2812
+ continue;
2464
2813
  }
2465
- message.userId = reader.int32();
2466
- continue;
2467
2814
  }
2815
+ if ((tag & 7) === 4 || tag === 0) {
2816
+ break;
2817
+ }
2818
+ reader.skip(tag & 7);
2468
2819
  }
2469
- if ((tag & 7) === 4 || tag === 0) {
2470
- break;
2471
- }
2472
- reader.skip(tag & 7);
2820
+ return message;
2821
+ }
2822
+ finally {
2823
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
2473
2824
  }
2474
- return message;
2475
2825
  },
2476
2826
  create(base) {
2477
2827
  return exports.UpdateBleTagRequest.fromPartial(base ?? {});
@@ -2497,25 +2847,35 @@ exports.DeleteBleTagRequest = {
2497
2847
  },
2498
2848
  decode(input, length) {
2499
2849
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
2500
- const end = length === undefined ? reader.len : reader.pos + length;
2501
- const message = createBaseDeleteBleTagRequest();
2502
- while (reader.pos < end) {
2503
- const tag = reader.uint32();
2504
- switch (tag >>> 3) {
2505
- case 1: {
2506
- if (tag !== 8) {
2507
- break;
2850
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
2851
+ if (previousRecursionDepth >= 100) {
2852
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
2853
+ }
2854
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
2855
+ try {
2856
+ const end = length === undefined ? reader.len : reader.pos + length;
2857
+ const message = createBaseDeleteBleTagRequest();
2858
+ while (reader.pos < end) {
2859
+ const tag = reader.uint32();
2860
+ switch (tag >>> 3) {
2861
+ case 1: {
2862
+ if (tag !== 8) {
2863
+ break;
2864
+ }
2865
+ message.id = reader.int32();
2866
+ continue;
2508
2867
  }
2509
- message.id = reader.int32();
2510
- continue;
2511
2868
  }
2869
+ if ((tag & 7) === 4 || tag === 0) {
2870
+ break;
2871
+ }
2872
+ reader.skip(tag & 7);
2512
2873
  }
2513
- if ((tag & 7) === 4 || tag === 0) {
2514
- break;
2515
- }
2516
- reader.skip(tag & 7);
2874
+ return message;
2875
+ }
2876
+ finally {
2877
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
2517
2878
  }
2518
- return message;
2519
2879
  },
2520
2880
  create(base) {
2521
2881
  return exports.DeleteBleTagRequest.fromPartial(base ?? {});
@@ -2552,60 +2912,70 @@ exports.Car = {
2552
2912
  },
2553
2913
  decode(input, length) {
2554
2914
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
2555
- const end = length === undefined ? reader.len : reader.pos + length;
2556
- const message = createBaseCar();
2557
- while (reader.pos < end) {
2558
- const tag = reader.uint32();
2559
- switch (tag >>> 3) {
2560
- case 1: {
2561
- if (tag !== 8) {
2562
- break;
2563
- }
2564
- message.id = reader.int32();
2565
- continue;
2566
- }
2567
- case 2: {
2568
- if (tag !== 18) {
2569
- break;
2915
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
2916
+ if (previousRecursionDepth >= 100) {
2917
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
2918
+ }
2919
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
2920
+ try {
2921
+ const end = length === undefined ? reader.len : reader.pos + length;
2922
+ const message = createBaseCar();
2923
+ while (reader.pos < end) {
2924
+ const tag = reader.uint32();
2925
+ switch (tag >>> 3) {
2926
+ case 1: {
2927
+ if (tag !== 8) {
2928
+ break;
2929
+ }
2930
+ message.id = reader.int32();
2931
+ continue;
2570
2932
  }
2571
- message.topicPrefix = reader.string();
2572
- continue;
2573
- }
2574
- case 3: {
2575
- if (tag !== 26) {
2576
- break;
2933
+ case 2: {
2934
+ if (tag !== 18) {
2935
+ break;
2936
+ }
2937
+ message.topicPrefix = reader.string();
2938
+ continue;
2577
2939
  }
2578
- message.homeAddress = reader.string();
2579
- continue;
2580
- }
2581
- case 4: {
2582
- if (tag === 32) {
2583
- message.ownerUserIds.push(reader.int32());
2940
+ case 3: {
2941
+ if (tag !== 26) {
2942
+ break;
2943
+ }
2944
+ message.homeAddress = reader.string();
2584
2945
  continue;
2585
2946
  }
2586
- if (tag === 34) {
2587
- const end2 = reader.uint32() + reader.pos;
2588
- while (reader.pos < end2) {
2947
+ case 4: {
2948
+ if (tag === 32) {
2589
2949
  message.ownerUserIds.push(reader.int32());
2950
+ continue;
2951
+ }
2952
+ if (tag === 34) {
2953
+ const end2 = reader.uint32() + reader.pos;
2954
+ while (reader.pos < end2) {
2955
+ message.ownerUserIds.push(reader.int32());
2956
+ }
2957
+ continue;
2958
+ }
2959
+ break;
2960
+ }
2961
+ case 5: {
2962
+ if (tag !== 42) {
2963
+ break;
2590
2964
  }
2965
+ message.name = reader.string();
2591
2966
  continue;
2592
2967
  }
2593
- break;
2594
2968
  }
2595
- case 5: {
2596
- if (tag !== 42) {
2597
- break;
2598
- }
2599
- message.name = reader.string();
2600
- continue;
2969
+ if ((tag & 7) === 4 || tag === 0) {
2970
+ break;
2601
2971
  }
2972
+ reader.skip(tag & 7);
2602
2973
  }
2603
- if ((tag & 7) === 4 || tag === 0) {
2604
- break;
2605
- }
2606
- reader.skip(tag & 7);
2974
+ return message;
2975
+ }
2976
+ finally {
2977
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
2607
2978
  }
2608
- return message;
2609
2979
  },
2610
2980
  create(base) {
2611
2981
  return exports.Car.fromPartial(base ?? {});
@@ -2632,25 +3002,35 @@ exports.GetCarsResponse = {
2632
3002
  },
2633
3003
  decode(input, length) {
2634
3004
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
2635
- const end = length === undefined ? reader.len : reader.pos + length;
2636
- const message = createBaseGetCarsResponse();
2637
- while (reader.pos < end) {
2638
- const tag = reader.uint32();
2639
- switch (tag >>> 3) {
2640
- case 1: {
2641
- if (tag !== 10) {
2642
- break;
3005
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
3006
+ if (previousRecursionDepth >= 100) {
3007
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
3008
+ }
3009
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
3010
+ try {
3011
+ const end = length === undefined ? reader.len : reader.pos + length;
3012
+ const message = createBaseGetCarsResponse();
3013
+ while (reader.pos < end) {
3014
+ const tag = reader.uint32();
3015
+ switch (tag >>> 3) {
3016
+ case 1: {
3017
+ if (tag !== 10) {
3018
+ break;
3019
+ }
3020
+ message.cars.push(exports.Car.decode(reader, reader.uint32()));
3021
+ continue;
2643
3022
  }
2644
- message.cars.push(exports.Car.decode(reader, reader.uint32()));
2645
- continue;
2646
3023
  }
3024
+ if ((tag & 7) === 4 || tag === 0) {
3025
+ break;
3026
+ }
3027
+ reader.skip(tag & 7);
2647
3028
  }
2648
- if ((tag & 7) === 4 || tag === 0) {
2649
- break;
2650
- }
2651
- reader.skip(tag & 7);
3029
+ return message;
3030
+ }
3031
+ finally {
3032
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
2652
3033
  }
2653
- return message;
2654
3034
  },
2655
3035
  create(base) {
2656
3036
  return exports.GetCarsResponse.fromPartial(base ?? {});
@@ -2684,53 +3064,63 @@ exports.CreateCarRequest = {
2684
3064
  },
2685
3065
  decode(input, length) {
2686
3066
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
2687
- const end = length === undefined ? reader.len : reader.pos + length;
2688
- const message = createBaseCreateCarRequest();
2689
- while (reader.pos < end) {
2690
- const tag = reader.uint32();
2691
- switch (tag >>> 3) {
2692
- case 1: {
2693
- if (tag !== 10) {
2694
- break;
2695
- }
2696
- message.topicPrefix = reader.string();
2697
- continue;
2698
- }
2699
- case 2: {
2700
- if (tag !== 18) {
2701
- break;
3067
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
3068
+ if (previousRecursionDepth >= 100) {
3069
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
3070
+ }
3071
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
3072
+ try {
3073
+ const end = length === undefined ? reader.len : reader.pos + length;
3074
+ const message = createBaseCreateCarRequest();
3075
+ while (reader.pos < end) {
3076
+ const tag = reader.uint32();
3077
+ switch (tag >>> 3) {
3078
+ case 1: {
3079
+ if (tag !== 10) {
3080
+ break;
3081
+ }
3082
+ message.topicPrefix = reader.string();
3083
+ continue;
2702
3084
  }
2703
- message.homeAddress = reader.string();
2704
- continue;
2705
- }
2706
- case 3: {
2707
- if (tag === 24) {
2708
- message.ownerUserIds.push(reader.int32());
3085
+ case 2: {
3086
+ if (tag !== 18) {
3087
+ break;
3088
+ }
3089
+ message.homeAddress = reader.string();
2709
3090
  continue;
2710
3091
  }
2711
- if (tag === 26) {
2712
- const end2 = reader.uint32() + reader.pos;
2713
- while (reader.pos < end2) {
3092
+ case 3: {
3093
+ if (tag === 24) {
2714
3094
  message.ownerUserIds.push(reader.int32());
3095
+ continue;
3096
+ }
3097
+ if (tag === 26) {
3098
+ const end2 = reader.uint32() + reader.pos;
3099
+ while (reader.pos < end2) {
3100
+ message.ownerUserIds.push(reader.int32());
3101
+ }
3102
+ continue;
2715
3103
  }
3104
+ break;
3105
+ }
3106
+ case 4: {
3107
+ if (tag !== 34) {
3108
+ break;
3109
+ }
3110
+ message.name = reader.string();
2716
3111
  continue;
2717
3112
  }
2718
- break;
2719
3113
  }
2720
- case 4: {
2721
- if (tag !== 34) {
2722
- break;
2723
- }
2724
- message.name = reader.string();
2725
- continue;
3114
+ if ((tag & 7) === 4 || tag === 0) {
3115
+ break;
2726
3116
  }
3117
+ reader.skip(tag & 7);
2727
3118
  }
2728
- if ((tag & 7) === 4 || tag === 0) {
2729
- break;
2730
- }
2731
- reader.skip(tag & 7);
3119
+ return message;
3120
+ }
3121
+ finally {
3122
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
2732
3123
  }
2733
- return message;
2734
3124
  },
2735
3125
  create(base) {
2736
3126
  return exports.CreateCarRequest.fromPartial(base ?? {});
@@ -2762,39 +3152,49 @@ exports.CreateCarResponse = {
2762
3152
  },
2763
3153
  decode(input, length) {
2764
3154
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
2765
- const end = length === undefined ? reader.len : reader.pos + length;
2766
- const message = createBaseCreateCarResponse();
2767
- while (reader.pos < end) {
2768
- const tag = reader.uint32();
2769
- switch (tag >>> 3) {
2770
- case 1: {
2771
- if (tag !== 8) {
2772
- break;
3155
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
3156
+ if (previousRecursionDepth >= 100) {
3157
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
3158
+ }
3159
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
3160
+ try {
3161
+ const end = length === undefined ? reader.len : reader.pos + length;
3162
+ const message = createBaseCreateCarResponse();
3163
+ while (reader.pos < end) {
3164
+ const tag = reader.uint32();
3165
+ switch (tag >>> 3) {
3166
+ case 1: {
3167
+ if (tag !== 8) {
3168
+ break;
3169
+ }
3170
+ message.ok = reader.bool();
3171
+ continue;
2773
3172
  }
2774
- message.ok = reader.bool();
2775
- continue;
2776
- }
2777
- case 2: {
2778
- if (tag !== 16) {
2779
- break;
3173
+ case 2: {
3174
+ if (tag !== 16) {
3175
+ break;
3176
+ }
3177
+ message.id = reader.int32();
3178
+ continue;
2780
3179
  }
2781
- message.id = reader.int32();
2782
- continue;
2783
- }
2784
- case 3: {
2785
- if (tag !== 26) {
2786
- break;
3180
+ case 3: {
3181
+ if (tag !== 26) {
3182
+ break;
3183
+ }
3184
+ message.message = reader.string();
3185
+ continue;
2787
3186
  }
2788
- message.message = reader.string();
2789
- continue;
2790
3187
  }
3188
+ if ((tag & 7) === 4 || tag === 0) {
3189
+ break;
3190
+ }
3191
+ reader.skip(tag & 7);
2791
3192
  }
2792
- if ((tag & 7) === 4 || tag === 0) {
2793
- break;
2794
- }
2795
- reader.skip(tag & 7);
3193
+ return message;
3194
+ }
3195
+ finally {
3196
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
2796
3197
  }
2797
- return message;
2798
3198
  },
2799
3199
  create(base) {
2800
3200
  return exports.CreateCarResponse.fromPartial(base ?? {});
@@ -2833,60 +3233,70 @@ exports.UpdateCarRequest = {
2833
3233
  },
2834
3234
  decode(input, length) {
2835
3235
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
2836
- const end = length === undefined ? reader.len : reader.pos + length;
2837
- const message = createBaseUpdateCarRequest();
2838
- while (reader.pos < end) {
2839
- const tag = reader.uint32();
2840
- switch (tag >>> 3) {
2841
- case 1: {
2842
- if (tag !== 8) {
2843
- break;
2844
- }
2845
- message.id = reader.int32();
2846
- continue;
2847
- }
2848
- case 2: {
2849
- if (tag !== 18) {
2850
- break;
3236
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
3237
+ if (previousRecursionDepth >= 100) {
3238
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
3239
+ }
3240
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
3241
+ try {
3242
+ const end = length === undefined ? reader.len : reader.pos + length;
3243
+ const message = createBaseUpdateCarRequest();
3244
+ while (reader.pos < end) {
3245
+ const tag = reader.uint32();
3246
+ switch (tag >>> 3) {
3247
+ case 1: {
3248
+ if (tag !== 8) {
3249
+ break;
3250
+ }
3251
+ message.id = reader.int32();
3252
+ continue;
2851
3253
  }
2852
- message.topicPrefix = reader.string();
2853
- continue;
2854
- }
2855
- case 3: {
2856
- if (tag !== 26) {
2857
- break;
3254
+ case 2: {
3255
+ if (tag !== 18) {
3256
+ break;
3257
+ }
3258
+ message.topicPrefix = reader.string();
3259
+ continue;
2858
3260
  }
2859
- message.homeAddress = reader.string();
2860
- continue;
2861
- }
2862
- case 4: {
2863
- if (tag === 32) {
2864
- message.ownerUserIds.push(reader.int32());
3261
+ case 3: {
3262
+ if (tag !== 26) {
3263
+ break;
3264
+ }
3265
+ message.homeAddress = reader.string();
2865
3266
  continue;
2866
3267
  }
2867
- if (tag === 34) {
2868
- const end2 = reader.uint32() + reader.pos;
2869
- while (reader.pos < end2) {
3268
+ case 4: {
3269
+ if (tag === 32) {
2870
3270
  message.ownerUserIds.push(reader.int32());
3271
+ continue;
3272
+ }
3273
+ if (tag === 34) {
3274
+ const end2 = reader.uint32() + reader.pos;
3275
+ while (reader.pos < end2) {
3276
+ message.ownerUserIds.push(reader.int32());
3277
+ }
3278
+ continue;
3279
+ }
3280
+ break;
3281
+ }
3282
+ case 5: {
3283
+ if (tag !== 42) {
3284
+ break;
2871
3285
  }
3286
+ message.name = reader.string();
2872
3287
  continue;
2873
3288
  }
2874
- break;
2875
3289
  }
2876
- case 5: {
2877
- if (tag !== 42) {
2878
- break;
2879
- }
2880
- message.name = reader.string();
2881
- continue;
3290
+ if ((tag & 7) === 4 || tag === 0) {
3291
+ break;
2882
3292
  }
3293
+ reader.skip(tag & 7);
2883
3294
  }
2884
- if ((tag & 7) === 4 || tag === 0) {
2885
- break;
2886
- }
2887
- reader.skip(tag & 7);
3295
+ return message;
3296
+ }
3297
+ finally {
3298
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
2888
3299
  }
2889
- return message;
2890
3300
  },
2891
3301
  create(base) {
2892
3302
  return exports.UpdateCarRequest.fromPartial(base ?? {});
@@ -2913,25 +3323,35 @@ exports.DeleteCarRequest = {
2913
3323
  },
2914
3324
  decode(input, length) {
2915
3325
  const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
2916
- const end = length === undefined ? reader.len : reader.pos + length;
2917
- const message = createBaseDeleteCarRequest();
2918
- while (reader.pos < end) {
2919
- const tag = reader.uint32();
2920
- switch (tag >>> 3) {
2921
- case 1: {
2922
- if (tag !== 8) {
2923
- break;
3326
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
3327
+ if (previousRecursionDepth >= 100) {
3328
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
3329
+ }
3330
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
3331
+ try {
3332
+ const end = length === undefined ? reader.len : reader.pos + length;
3333
+ const message = createBaseDeleteCarRequest();
3334
+ while (reader.pos < end) {
3335
+ const tag = reader.uint32();
3336
+ switch (tag >>> 3) {
3337
+ case 1: {
3338
+ if (tag !== 8) {
3339
+ break;
3340
+ }
3341
+ message.id = reader.int32();
3342
+ continue;
2924
3343
  }
2925
- message.id = reader.int32();
2926
- continue;
2927
3344
  }
3345
+ if ((tag & 7) === 4 || tag === 0) {
3346
+ break;
3347
+ }
3348
+ reader.skip(tag & 7);
2928
3349
  }
2929
- if ((tag & 7) === 4 || tag === 0) {
2930
- break;
2931
- }
2932
- reader.skip(tag & 7);
3350
+ return message;
3351
+ }
3352
+ finally {
3353
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
2933
3354
  }
2934
- return message;
2935
3355
  },
2936
3356
  create(base) {
2937
3357
  return exports.DeleteCarRequest.fromPartial(base ?? {});