@miradorlabs/web-grpc 2.32.0 → 2.35.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -1,6 +1,6 @@
1
1
  // Code generated by protoc-gen-ts_proto. DO NOT EDIT.
2
2
  // versions:
3
- // protoc-gen-ts_proto v2.12.0
3
+ // protoc-gen-ts_proto v2.12.1
4
4
  // protoc v3.21.12
5
5
  // source: proto/gateway/web/v1/oauth_gateway.proto
6
6
 
@@ -173,106 +173,115 @@ export const OAuthConnection: MessageFns<OAuthConnection> = {
173
173
 
174
174
  decode(input: BinaryReader | Uint8Array, length?: number): OAuthConnection {
175
175
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
176
- const end = length === undefined ? reader.len : reader.pos + length;
177
- const message = createBaseOAuthConnection();
178
- while (reader.pos < end) {
179
- const tag = reader.uint32();
180
- switch (tag >>> 3) {
181
- case 1: {
182
- if (tag !== 10) {
183
- break;
176
+ const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
177
+ if (previousRecursionDepth >= 100) {
178
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
179
+ }
180
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
181
+ try {
182
+ const end = length === undefined ? reader.len : reader.pos + length;
183
+ const message = createBaseOAuthConnection();
184
+ while (reader.pos < end) {
185
+ const tag = reader.uint32();
186
+ switch (tag >>> 3) {
187
+ case 1: {
188
+ if (tag !== 10) {
189
+ break;
190
+ }
191
+
192
+ message.id = reader.string();
193
+ continue;
184
194
  }
195
+ case 2: {
196
+ if (tag !== 18) {
197
+ break;
198
+ }
185
199
 
186
- message.id = reader.string();
187
- continue;
188
- }
189
- case 2: {
190
- if (tag !== 18) {
191
- break;
200
+ message.organizationId = reader.string();
201
+ continue;
192
202
  }
203
+ case 3: {
204
+ if (tag !== 26) {
205
+ break;
206
+ }
193
207
 
194
- message.organizationId = reader.string();
195
- continue;
196
- }
197
- case 3: {
198
- if (tag !== 26) {
199
- break;
208
+ message.provider = reader.string();
209
+ continue;
200
210
  }
211
+ case 4: {
212
+ if (tag !== 34) {
213
+ break;
214
+ }
201
215
 
202
- message.provider = reader.string();
203
- continue;
204
- }
205
- case 4: {
206
- if (tag !== 34) {
207
- break;
216
+ message.providerTeamId = reader.string();
217
+ continue;
208
218
  }
219
+ case 5: {
220
+ if (tag !== 42) {
221
+ break;
222
+ }
209
223
 
210
- message.providerTeamId = reader.string();
211
- continue;
212
- }
213
- case 5: {
214
- if (tag !== 42) {
215
- break;
224
+ message.providerTeamName = reader.string();
225
+ continue;
216
226
  }
227
+ case 6: {
228
+ if (tag !== 50) {
229
+ break;
230
+ }
217
231
 
218
- message.providerTeamName = reader.string();
219
- continue;
220
- }
221
- case 6: {
222
- if (tag !== 50) {
223
- break;
232
+ message.installedBy = reader.string();
233
+ continue;
224
234
  }
235
+ case 7: {
236
+ if (tag !== 58) {
237
+ break;
238
+ }
225
239
 
226
- message.installedBy = reader.string();
227
- continue;
228
- }
229
- case 7: {
230
- if (tag !== 58) {
231
- break;
240
+ message.createdAt = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
241
+ continue;
232
242
  }
243
+ case 8: {
244
+ if (tag !== 66) {
245
+ break;
246
+ }
233
247
 
234
- message.createdAt = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
235
- continue;
236
- }
237
- case 8: {
238
- if (tag !== 66) {
239
- break;
248
+ message.updatedAt = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
249
+ continue;
240
250
  }
251
+ case 9: {
252
+ if (tag !== 74) {
253
+ break;
254
+ }
241
255
 
242
- message.updatedAt = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
243
- continue;
244
- }
245
- case 9: {
246
- if (tag !== 74) {
247
- break;
256
+ message.providerAccountId = reader.string();
257
+ continue;
248
258
  }
259
+ case 10: {
260
+ if (tag !== 82) {
261
+ break;
262
+ }
249
263
 
250
- message.providerAccountId = reader.string();
251
- continue;
252
- }
253
- case 10: {
254
- if (tag !== 82) {
255
- break;
264
+ message.providerAccountName = reader.string();
265
+ continue;
256
266
  }
267
+ case 11: {
268
+ if (tag !== 90) {
269
+ break;
270
+ }
257
271
 
258
- message.providerAccountName = reader.string();
259
- continue;
260
- }
261
- case 11: {
262
- if (tag !== 90) {
263
- break;
272
+ message.providerRegion = reader.string();
273
+ continue;
264
274
  }
265
-
266
- message.providerRegion = reader.string();
267
- continue;
268
275
  }
276
+ if ((tag & 7) === 4 || tag === 0) {
277
+ break;
278
+ }
279
+ reader.skip(tag & 7);
269
280
  }
270
- if ((tag & 7) === 4 || tag === 0) {
271
- break;
272
- }
273
- reader.skip(tag & 7);
281
+ return message;
282
+ } finally {
283
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
274
284
  }
275
- return message;
276
285
  },
277
286
 
278
287
  fromJSON(object: any): OAuthConnection {
@@ -402,34 +411,43 @@ export const InitiateSlackOAuthRequest: MessageFns<InitiateSlackOAuthRequest> =
402
411
 
403
412
  decode(input: BinaryReader | Uint8Array, length?: number): InitiateSlackOAuthRequest {
404
413
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
405
- const end = length === undefined ? reader.len : reader.pos + length;
406
- const message = createBaseInitiateSlackOAuthRequest();
407
- while (reader.pos < end) {
408
- const tag = reader.uint32();
409
- switch (tag >>> 3) {
410
- case 1: {
411
- if (tag !== 10) {
412
- break;
414
+ const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
415
+ if (previousRecursionDepth >= 100) {
416
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
417
+ }
418
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
419
+ try {
420
+ const end = length === undefined ? reader.len : reader.pos + length;
421
+ const message = createBaseInitiateSlackOAuthRequest();
422
+ while (reader.pos < end) {
423
+ const tag = reader.uint32();
424
+ switch (tag >>> 3) {
425
+ case 1: {
426
+ if (tag !== 10) {
427
+ break;
428
+ }
429
+
430
+ message.organizationId = reader.string();
431
+ continue;
413
432
  }
433
+ case 2: {
434
+ if (tag !== 18) {
435
+ break;
436
+ }
414
437
 
415
- message.organizationId = reader.string();
416
- continue;
417
- }
418
- case 2: {
419
- if (tag !== 18) {
420
- break;
438
+ message.redirectUri = reader.string();
439
+ continue;
421
440
  }
422
-
423
- message.redirectUri = reader.string();
424
- continue;
425
441
  }
442
+ if ((tag & 7) === 4 || tag === 0) {
443
+ break;
444
+ }
445
+ reader.skip(tag & 7);
426
446
  }
427
- if ((tag & 7) === 4 || tag === 0) {
428
- break;
429
- }
430
- reader.skip(tag & 7);
447
+ return message;
448
+ } finally {
449
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
431
450
  }
432
- return message;
433
451
  },
434
452
 
435
453
  fromJSON(object: any): InitiateSlackOAuthRequest {
@@ -489,42 +507,51 @@ export const InitiateSlackOAuthResponse: MessageFns<InitiateSlackOAuthResponse>
489
507
 
490
508
  decode(input: BinaryReader | Uint8Array, length?: number): InitiateSlackOAuthResponse {
491
509
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
492
- const end = length === undefined ? reader.len : reader.pos + length;
493
- const message = createBaseInitiateSlackOAuthResponse();
494
- while (reader.pos < end) {
495
- const tag = reader.uint32();
496
- switch (tag >>> 3) {
497
- case 1: {
498
- if (tag !== 10) {
499
- break;
510
+ const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
511
+ if (previousRecursionDepth >= 100) {
512
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
513
+ }
514
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
515
+ try {
516
+ const end = length === undefined ? reader.len : reader.pos + length;
517
+ const message = createBaseInitiateSlackOAuthResponse();
518
+ while (reader.pos < end) {
519
+ const tag = reader.uint32();
520
+ switch (tag >>> 3) {
521
+ case 1: {
522
+ if (tag !== 10) {
523
+ break;
524
+ }
525
+
526
+ message.status = ResponseStatus.decode(reader, reader.uint32());
527
+ continue;
500
528
  }
529
+ case 2: {
530
+ if (tag !== 18) {
531
+ break;
532
+ }
501
533
 
502
- message.status = ResponseStatus.decode(reader, reader.uint32());
503
- continue;
504
- }
505
- case 2: {
506
- if (tag !== 18) {
507
- break;
534
+ message.oauthUrl = reader.string();
535
+ continue;
508
536
  }
537
+ case 3: {
538
+ if (tag !== 26) {
539
+ break;
540
+ }
509
541
 
510
- message.oauthUrl = reader.string();
511
- continue;
512
- }
513
- case 3: {
514
- if (tag !== 26) {
515
- break;
542
+ message.state = reader.string();
543
+ continue;
516
544
  }
517
-
518
- message.state = reader.string();
519
- continue;
520
545
  }
546
+ if ((tag & 7) === 4 || tag === 0) {
547
+ break;
548
+ }
549
+ reader.skip(tag & 7);
521
550
  }
522
- if ((tag & 7) === 4 || tag === 0) {
523
- break;
524
- }
525
- reader.skip(tag & 7);
551
+ return message;
552
+ } finally {
553
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
526
554
  }
527
- return message;
528
555
  },
529
556
 
530
557
  fromJSON(object: any): InitiateSlackOAuthResponse {
@@ -590,50 +617,59 @@ export const CompleteSlackOAuthRequest: MessageFns<CompleteSlackOAuthRequest> =
590
617
 
591
618
  decode(input: BinaryReader | Uint8Array, length?: number): CompleteSlackOAuthRequest {
592
619
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
593
- const end = length === undefined ? reader.len : reader.pos + length;
594
- const message = createBaseCompleteSlackOAuthRequest();
595
- while (reader.pos < end) {
596
- const tag = reader.uint32();
597
- switch (tag >>> 3) {
598
- case 1: {
599
- if (tag !== 10) {
600
- break;
620
+ const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
621
+ if (previousRecursionDepth >= 100) {
622
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
623
+ }
624
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
625
+ try {
626
+ const end = length === undefined ? reader.len : reader.pos + length;
627
+ const message = createBaseCompleteSlackOAuthRequest();
628
+ while (reader.pos < end) {
629
+ const tag = reader.uint32();
630
+ switch (tag >>> 3) {
631
+ case 1: {
632
+ if (tag !== 10) {
633
+ break;
634
+ }
635
+
636
+ message.organizationId = reader.string();
637
+ continue;
601
638
  }
639
+ case 2: {
640
+ if (tag !== 18) {
641
+ break;
642
+ }
602
643
 
603
- message.organizationId = reader.string();
604
- continue;
605
- }
606
- case 2: {
607
- if (tag !== 18) {
608
- break;
644
+ message.code = reader.string();
645
+ continue;
609
646
  }
647
+ case 3: {
648
+ if (tag !== 26) {
649
+ break;
650
+ }
610
651
 
611
- message.code = reader.string();
612
- continue;
613
- }
614
- case 3: {
615
- if (tag !== 26) {
616
- break;
652
+ message.redirectUri = reader.string();
653
+ continue;
617
654
  }
655
+ case 4: {
656
+ if (tag !== 34) {
657
+ break;
658
+ }
618
659
 
619
- message.redirectUri = reader.string();
620
- continue;
621
- }
622
- case 4: {
623
- if (tag !== 34) {
624
- break;
660
+ message.state = reader.string();
661
+ continue;
625
662
  }
626
-
627
- message.state = reader.string();
628
- continue;
629
663
  }
664
+ if ((tag & 7) === 4 || tag === 0) {
665
+ break;
666
+ }
667
+ reader.skip(tag & 7);
630
668
  }
631
- if ((tag & 7) === 4 || tag === 0) {
632
- break;
633
- }
634
- reader.skip(tag & 7);
669
+ return message;
670
+ } finally {
671
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
635
672
  }
636
- return message;
637
673
  },
638
674
 
639
675
  fromJSON(object: any): CompleteSlackOAuthRequest {
@@ -700,34 +736,43 @@ export const CompleteSlackOAuthResponse: MessageFns<CompleteSlackOAuthResponse>
700
736
 
701
737
  decode(input: BinaryReader | Uint8Array, length?: number): CompleteSlackOAuthResponse {
702
738
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
703
- const end = length === undefined ? reader.len : reader.pos + length;
704
- const message = createBaseCompleteSlackOAuthResponse();
705
- while (reader.pos < end) {
706
- const tag = reader.uint32();
707
- switch (tag >>> 3) {
708
- case 1: {
709
- if (tag !== 10) {
710
- break;
739
+ const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
740
+ if (previousRecursionDepth >= 100) {
741
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
742
+ }
743
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
744
+ try {
745
+ const end = length === undefined ? reader.len : reader.pos + length;
746
+ const message = createBaseCompleteSlackOAuthResponse();
747
+ while (reader.pos < end) {
748
+ const tag = reader.uint32();
749
+ switch (tag >>> 3) {
750
+ case 1: {
751
+ if (tag !== 10) {
752
+ break;
753
+ }
754
+
755
+ message.status = ResponseStatus.decode(reader, reader.uint32());
756
+ continue;
711
757
  }
758
+ case 2: {
759
+ if (tag !== 18) {
760
+ break;
761
+ }
712
762
 
713
- message.status = ResponseStatus.decode(reader, reader.uint32());
714
- continue;
715
- }
716
- case 2: {
717
- if (tag !== 18) {
718
- break;
763
+ message.oauthConnection = OAuthConnection.decode(reader, reader.uint32());
764
+ continue;
719
765
  }
720
-
721
- message.oauthConnection = OAuthConnection.decode(reader, reader.uint32());
722
- continue;
723
766
  }
767
+ if ((tag & 7) === 4 || tag === 0) {
768
+ break;
769
+ }
770
+ reader.skip(tag & 7);
724
771
  }
725
- if ((tag & 7) === 4 || tag === 0) {
726
- break;
727
- }
728
- reader.skip(tag & 7);
772
+ return message;
773
+ } finally {
774
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
729
775
  }
730
- return message;
731
776
  },
732
777
 
733
778
  fromJSON(object: any): CompleteSlackOAuthResponse {
@@ -784,34 +829,43 @@ export const GetOAuthConnectionRequest: MessageFns<GetOAuthConnectionRequest> =
784
829
 
785
830
  decode(input: BinaryReader | Uint8Array, length?: number): GetOAuthConnectionRequest {
786
831
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
787
- const end = length === undefined ? reader.len : reader.pos + length;
788
- const message = createBaseGetOAuthConnectionRequest();
789
- while (reader.pos < end) {
790
- const tag = reader.uint32();
791
- switch (tag >>> 3) {
792
- case 1: {
793
- if (tag !== 10) {
794
- break;
832
+ const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
833
+ if (previousRecursionDepth >= 100) {
834
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
835
+ }
836
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
837
+ try {
838
+ const end = length === undefined ? reader.len : reader.pos + length;
839
+ const message = createBaseGetOAuthConnectionRequest();
840
+ while (reader.pos < end) {
841
+ const tag = reader.uint32();
842
+ switch (tag >>> 3) {
843
+ case 1: {
844
+ if (tag !== 10) {
845
+ break;
846
+ }
847
+
848
+ message.organizationId = reader.string();
849
+ continue;
795
850
  }
851
+ case 2: {
852
+ if (tag !== 18) {
853
+ break;
854
+ }
796
855
 
797
- message.organizationId = reader.string();
798
- continue;
799
- }
800
- case 2: {
801
- if (tag !== 18) {
802
- break;
856
+ message.provider = reader.string();
857
+ continue;
803
858
  }
804
-
805
- message.provider = reader.string();
806
- continue;
807
859
  }
860
+ if ((tag & 7) === 4 || tag === 0) {
861
+ break;
862
+ }
863
+ reader.skip(tag & 7);
808
864
  }
809
- if ((tag & 7) === 4 || tag === 0) {
810
- break;
811
- }
812
- reader.skip(tag & 7);
865
+ return message;
866
+ } finally {
867
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
813
868
  }
814
- return message;
815
869
  },
816
870
 
817
871
  fromJSON(object: any): GetOAuthConnectionRequest {
@@ -864,34 +918,43 @@ export const GetOAuthConnectionResponse: MessageFns<GetOAuthConnectionResponse>
864
918
 
865
919
  decode(input: BinaryReader | Uint8Array, length?: number): GetOAuthConnectionResponse {
866
920
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
867
- const end = length === undefined ? reader.len : reader.pos + length;
868
- const message = createBaseGetOAuthConnectionResponse();
869
- while (reader.pos < end) {
870
- const tag = reader.uint32();
871
- switch (tag >>> 3) {
872
- case 1: {
873
- if (tag !== 10) {
874
- break;
921
+ const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
922
+ if (previousRecursionDepth >= 100) {
923
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
924
+ }
925
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
926
+ try {
927
+ const end = length === undefined ? reader.len : reader.pos + length;
928
+ const message = createBaseGetOAuthConnectionResponse();
929
+ while (reader.pos < end) {
930
+ const tag = reader.uint32();
931
+ switch (tag >>> 3) {
932
+ case 1: {
933
+ if (tag !== 10) {
934
+ break;
935
+ }
936
+
937
+ message.status = ResponseStatus.decode(reader, reader.uint32());
938
+ continue;
875
939
  }
940
+ case 2: {
941
+ if (tag !== 18) {
942
+ break;
943
+ }
876
944
 
877
- message.status = ResponseStatus.decode(reader, reader.uint32());
878
- continue;
879
- }
880
- case 2: {
881
- if (tag !== 18) {
882
- break;
945
+ message.oauthConnection = OAuthConnection.decode(reader, reader.uint32());
946
+ continue;
883
947
  }
884
-
885
- message.oauthConnection = OAuthConnection.decode(reader, reader.uint32());
886
- continue;
887
948
  }
949
+ if ((tag & 7) === 4 || tag === 0) {
950
+ break;
951
+ }
952
+ reader.skip(tag & 7);
888
953
  }
889
- if ((tag & 7) === 4 || tag === 0) {
890
- break;
891
- }
892
- reader.skip(tag & 7);
954
+ return message;
955
+ } finally {
956
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
893
957
  }
894
- return message;
895
958
  },
896
959
 
897
960
  fromJSON(object: any): GetOAuthConnectionResponse {
@@ -945,26 +1008,35 @@ export const ListSlackChannelsRequest: MessageFns<ListSlackChannelsRequest> = {
945
1008
 
946
1009
  decode(input: BinaryReader | Uint8Array, length?: number): ListSlackChannelsRequest {
947
1010
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
948
- const end = length === undefined ? reader.len : reader.pos + length;
949
- const message = createBaseListSlackChannelsRequest();
950
- while (reader.pos < end) {
951
- const tag = reader.uint32();
952
- switch (tag >>> 3) {
953
- case 1: {
954
- if (tag !== 10) {
955
- break;
1011
+ const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
1012
+ if (previousRecursionDepth >= 100) {
1013
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
1014
+ }
1015
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
1016
+ try {
1017
+ const end = length === undefined ? reader.len : reader.pos + length;
1018
+ const message = createBaseListSlackChannelsRequest();
1019
+ while (reader.pos < end) {
1020
+ const tag = reader.uint32();
1021
+ switch (tag >>> 3) {
1022
+ case 1: {
1023
+ if (tag !== 10) {
1024
+ break;
1025
+ }
1026
+
1027
+ message.organizationId = reader.string();
1028
+ continue;
956
1029
  }
957
-
958
- message.organizationId = reader.string();
959
- continue;
960
1030
  }
1031
+ if ((tag & 7) === 4 || tag === 0) {
1032
+ break;
1033
+ }
1034
+ reader.skip(tag & 7);
961
1035
  }
962
- if ((tag & 7) === 4 || tag === 0) {
963
- break;
964
- }
965
- reader.skip(tag & 7);
1036
+ return message;
1037
+ } finally {
1038
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
966
1039
  }
967
- return message;
968
1040
  },
969
1041
 
970
1042
  fromJSON(object: any): ListSlackChannelsRequest {
@@ -1012,34 +1084,43 @@ export const ListSlackChannelsResponse: MessageFns<ListSlackChannelsResponse> =
1012
1084
 
1013
1085
  decode(input: BinaryReader | Uint8Array, length?: number): ListSlackChannelsResponse {
1014
1086
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
1015
- const end = length === undefined ? reader.len : reader.pos + length;
1016
- const message = createBaseListSlackChannelsResponse();
1017
- while (reader.pos < end) {
1018
- const tag = reader.uint32();
1019
- switch (tag >>> 3) {
1020
- case 1: {
1021
- if (tag !== 10) {
1022
- break;
1087
+ const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
1088
+ if (previousRecursionDepth >= 100) {
1089
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
1090
+ }
1091
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
1092
+ try {
1093
+ const end = length === undefined ? reader.len : reader.pos + length;
1094
+ const message = createBaseListSlackChannelsResponse();
1095
+ while (reader.pos < end) {
1096
+ const tag = reader.uint32();
1097
+ switch (tag >>> 3) {
1098
+ case 1: {
1099
+ if (tag !== 10) {
1100
+ break;
1101
+ }
1102
+
1103
+ message.status = ResponseStatus.decode(reader, reader.uint32());
1104
+ continue;
1023
1105
  }
1106
+ case 2: {
1107
+ if (tag !== 18) {
1108
+ break;
1109
+ }
1024
1110
 
1025
- message.status = ResponseStatus.decode(reader, reader.uint32());
1026
- continue;
1027
- }
1028
- case 2: {
1029
- if (tag !== 18) {
1030
- break;
1111
+ message.channels.push(SlackChannel.decode(reader, reader.uint32()));
1112
+ continue;
1031
1113
  }
1032
-
1033
- message.channels.push(SlackChannel.decode(reader, reader.uint32()));
1034
- continue;
1035
1114
  }
1115
+ if ((tag & 7) === 4 || tag === 0) {
1116
+ break;
1117
+ }
1118
+ reader.skip(tag & 7);
1036
1119
  }
1037
- if ((tag & 7) === 4 || tag === 0) {
1038
- break;
1039
- }
1040
- reader.skip(tag & 7);
1120
+ return message;
1121
+ } finally {
1122
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
1041
1123
  }
1042
- return message;
1043
1124
  },
1044
1125
 
1045
1126
  fromJSON(object: any): ListSlackChannelsResponse {
@@ -1095,42 +1176,51 @@ export const SlackChannel: MessageFns<SlackChannel> = {
1095
1176
 
1096
1177
  decode(input: BinaryReader | Uint8Array, length?: number): SlackChannel {
1097
1178
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
1098
- const end = length === undefined ? reader.len : reader.pos + length;
1099
- const message = createBaseSlackChannel();
1100
- while (reader.pos < end) {
1101
- const tag = reader.uint32();
1102
- switch (tag >>> 3) {
1103
- case 1: {
1104
- if (tag !== 10) {
1105
- break;
1179
+ const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
1180
+ if (previousRecursionDepth >= 100) {
1181
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
1182
+ }
1183
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
1184
+ try {
1185
+ const end = length === undefined ? reader.len : reader.pos + length;
1186
+ const message = createBaseSlackChannel();
1187
+ while (reader.pos < end) {
1188
+ const tag = reader.uint32();
1189
+ switch (tag >>> 3) {
1190
+ case 1: {
1191
+ if (tag !== 10) {
1192
+ break;
1193
+ }
1194
+
1195
+ message.id = reader.string();
1196
+ continue;
1106
1197
  }
1198
+ case 2: {
1199
+ if (tag !== 18) {
1200
+ break;
1201
+ }
1107
1202
 
1108
- message.id = reader.string();
1109
- continue;
1110
- }
1111
- case 2: {
1112
- if (tag !== 18) {
1113
- break;
1203
+ message.name = reader.string();
1204
+ continue;
1114
1205
  }
1206
+ case 3: {
1207
+ if (tag !== 24) {
1208
+ break;
1209
+ }
1115
1210
 
1116
- message.name = reader.string();
1117
- continue;
1118
- }
1119
- case 3: {
1120
- if (tag !== 24) {
1121
- break;
1211
+ message.isPrivate = reader.bool();
1212
+ continue;
1122
1213
  }
1123
-
1124
- message.isPrivate = reader.bool();
1125
- continue;
1126
1214
  }
1215
+ if ((tag & 7) === 4 || tag === 0) {
1216
+ break;
1217
+ }
1218
+ reader.skip(tag & 7);
1127
1219
  }
1128
- if ((tag & 7) === 4 || tag === 0) {
1129
- break;
1130
- }
1131
- reader.skip(tag & 7);
1220
+ return message;
1221
+ } finally {
1222
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
1132
1223
  }
1133
- return message;
1134
1224
  },
1135
1225
 
1136
1226
  fromJSON(object: any): SlackChannel {
@@ -1188,34 +1278,43 @@ export const InitiatePagerDutyOAuthRequest: MessageFns<InitiatePagerDutyOAuthReq
1188
1278
 
1189
1279
  decode(input: BinaryReader | Uint8Array, length?: number): InitiatePagerDutyOAuthRequest {
1190
1280
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
1191
- const end = length === undefined ? reader.len : reader.pos + length;
1192
- const message = createBaseInitiatePagerDutyOAuthRequest();
1193
- while (reader.pos < end) {
1194
- const tag = reader.uint32();
1195
- switch (tag >>> 3) {
1196
- case 1: {
1197
- if (tag !== 10) {
1198
- break;
1281
+ const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
1282
+ if (previousRecursionDepth >= 100) {
1283
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
1284
+ }
1285
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
1286
+ try {
1287
+ const end = length === undefined ? reader.len : reader.pos + length;
1288
+ const message = createBaseInitiatePagerDutyOAuthRequest();
1289
+ while (reader.pos < end) {
1290
+ const tag = reader.uint32();
1291
+ switch (tag >>> 3) {
1292
+ case 1: {
1293
+ if (tag !== 10) {
1294
+ break;
1295
+ }
1296
+
1297
+ message.organizationId = reader.string();
1298
+ continue;
1199
1299
  }
1300
+ case 2: {
1301
+ if (tag !== 18) {
1302
+ break;
1303
+ }
1200
1304
 
1201
- message.organizationId = reader.string();
1202
- continue;
1203
- }
1204
- case 2: {
1205
- if (tag !== 18) {
1206
- break;
1305
+ message.redirectUri = reader.string();
1306
+ continue;
1207
1307
  }
1208
-
1209
- message.redirectUri = reader.string();
1210
- continue;
1211
1308
  }
1309
+ if ((tag & 7) === 4 || tag === 0) {
1310
+ break;
1311
+ }
1312
+ reader.skip(tag & 7);
1212
1313
  }
1213
- if ((tag & 7) === 4 || tag === 0) {
1214
- break;
1215
- }
1216
- reader.skip(tag & 7);
1314
+ return message;
1315
+ } finally {
1316
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
1217
1317
  }
1218
- return message;
1219
1318
  },
1220
1319
 
1221
1320
  fromJSON(object: any): InitiatePagerDutyOAuthRequest {
@@ -1277,42 +1376,51 @@ export const InitiatePagerDutyOAuthResponse: MessageFns<InitiatePagerDutyOAuthRe
1277
1376
 
1278
1377
  decode(input: BinaryReader | Uint8Array, length?: number): InitiatePagerDutyOAuthResponse {
1279
1378
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
1280
- const end = length === undefined ? reader.len : reader.pos + length;
1281
- const message = createBaseInitiatePagerDutyOAuthResponse();
1282
- while (reader.pos < end) {
1283
- const tag = reader.uint32();
1284
- switch (tag >>> 3) {
1285
- case 1: {
1286
- if (tag !== 10) {
1287
- break;
1379
+ const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
1380
+ if (previousRecursionDepth >= 100) {
1381
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
1382
+ }
1383
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
1384
+ try {
1385
+ const end = length === undefined ? reader.len : reader.pos + length;
1386
+ const message = createBaseInitiatePagerDutyOAuthResponse();
1387
+ while (reader.pos < end) {
1388
+ const tag = reader.uint32();
1389
+ switch (tag >>> 3) {
1390
+ case 1: {
1391
+ if (tag !== 10) {
1392
+ break;
1393
+ }
1394
+
1395
+ message.status = ResponseStatus.decode(reader, reader.uint32());
1396
+ continue;
1288
1397
  }
1398
+ case 2: {
1399
+ if (tag !== 18) {
1400
+ break;
1401
+ }
1289
1402
 
1290
- message.status = ResponseStatus.decode(reader, reader.uint32());
1291
- continue;
1292
- }
1293
- case 2: {
1294
- if (tag !== 18) {
1295
- break;
1403
+ message.oauthUrl = reader.string();
1404
+ continue;
1296
1405
  }
1406
+ case 3: {
1407
+ if (tag !== 26) {
1408
+ break;
1409
+ }
1297
1410
 
1298
- message.oauthUrl = reader.string();
1299
- continue;
1300
- }
1301
- case 3: {
1302
- if (tag !== 26) {
1303
- break;
1411
+ message.flowId = reader.string();
1412
+ continue;
1304
1413
  }
1305
-
1306
- message.flowId = reader.string();
1307
- continue;
1308
1414
  }
1415
+ if ((tag & 7) === 4 || tag === 0) {
1416
+ break;
1417
+ }
1418
+ reader.skip(tag & 7);
1309
1419
  }
1310
- if ((tag & 7) === 4 || tag === 0) {
1311
- break;
1312
- }
1313
- reader.skip(tag & 7);
1420
+ return message;
1421
+ } finally {
1422
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
1314
1423
  }
1315
- return message;
1316
1424
  },
1317
1425
 
1318
1426
  fromJSON(object: any): InitiatePagerDutyOAuthResponse {
@@ -1384,50 +1492,59 @@ export const CompletePagerDutyOAuthRequest: MessageFns<CompletePagerDutyOAuthReq
1384
1492
 
1385
1493
  decode(input: BinaryReader | Uint8Array, length?: number): CompletePagerDutyOAuthRequest {
1386
1494
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
1387
- const end = length === undefined ? reader.len : reader.pos + length;
1388
- const message = createBaseCompletePagerDutyOAuthRequest();
1389
- while (reader.pos < end) {
1390
- const tag = reader.uint32();
1391
- switch (tag >>> 3) {
1392
- case 1: {
1393
- if (tag !== 10) {
1394
- break;
1495
+ const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
1496
+ if (previousRecursionDepth >= 100) {
1497
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
1498
+ }
1499
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
1500
+ try {
1501
+ const end = length === undefined ? reader.len : reader.pos + length;
1502
+ const message = createBaseCompletePagerDutyOAuthRequest();
1503
+ while (reader.pos < end) {
1504
+ const tag = reader.uint32();
1505
+ switch (tag >>> 3) {
1506
+ case 1: {
1507
+ if (tag !== 10) {
1508
+ break;
1509
+ }
1510
+
1511
+ message.organizationId = reader.string();
1512
+ continue;
1395
1513
  }
1514
+ case 2: {
1515
+ if (tag !== 18) {
1516
+ break;
1517
+ }
1396
1518
 
1397
- message.organizationId = reader.string();
1398
- continue;
1399
- }
1400
- case 2: {
1401
- if (tag !== 18) {
1402
- break;
1519
+ message.code = reader.string();
1520
+ continue;
1403
1521
  }
1522
+ case 3: {
1523
+ if (tag !== 26) {
1524
+ break;
1525
+ }
1404
1526
 
1405
- message.code = reader.string();
1406
- continue;
1407
- }
1408
- case 3: {
1409
- if (tag !== 26) {
1410
- break;
1527
+ message.redirectUri = reader.string();
1528
+ continue;
1411
1529
  }
1530
+ case 4: {
1531
+ if (tag !== 34) {
1532
+ break;
1533
+ }
1412
1534
 
1413
- message.redirectUri = reader.string();
1414
- continue;
1415
- }
1416
- case 4: {
1417
- if (tag !== 34) {
1418
- break;
1535
+ message.flowId = reader.string();
1536
+ continue;
1419
1537
  }
1420
-
1421
- message.flowId = reader.string();
1422
- continue;
1423
1538
  }
1539
+ if ((tag & 7) === 4 || tag === 0) {
1540
+ break;
1541
+ }
1542
+ reader.skip(tag & 7);
1424
1543
  }
1425
- if ((tag & 7) === 4 || tag === 0) {
1426
- break;
1427
- }
1428
- reader.skip(tag & 7);
1544
+ return message;
1545
+ } finally {
1546
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
1429
1547
  }
1430
- return message;
1431
1548
  },
1432
1549
 
1433
1550
  fromJSON(object: any): CompletePagerDutyOAuthRequest {
@@ -1500,34 +1617,43 @@ export const CompletePagerDutyOAuthResponse: MessageFns<CompletePagerDutyOAuthRe
1500
1617
 
1501
1618
  decode(input: BinaryReader | Uint8Array, length?: number): CompletePagerDutyOAuthResponse {
1502
1619
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
1503
- const end = length === undefined ? reader.len : reader.pos + length;
1504
- const message = createBaseCompletePagerDutyOAuthResponse();
1505
- while (reader.pos < end) {
1506
- const tag = reader.uint32();
1507
- switch (tag >>> 3) {
1508
- case 1: {
1509
- if (tag !== 10) {
1510
- break;
1620
+ const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
1621
+ if (previousRecursionDepth >= 100) {
1622
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
1623
+ }
1624
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
1625
+ try {
1626
+ const end = length === undefined ? reader.len : reader.pos + length;
1627
+ const message = createBaseCompletePagerDutyOAuthResponse();
1628
+ while (reader.pos < end) {
1629
+ const tag = reader.uint32();
1630
+ switch (tag >>> 3) {
1631
+ case 1: {
1632
+ if (tag !== 10) {
1633
+ break;
1634
+ }
1635
+
1636
+ message.status = ResponseStatus.decode(reader, reader.uint32());
1637
+ continue;
1511
1638
  }
1639
+ case 2: {
1640
+ if (tag !== 18) {
1641
+ break;
1642
+ }
1512
1643
 
1513
- message.status = ResponseStatus.decode(reader, reader.uint32());
1514
- continue;
1515
- }
1516
- case 2: {
1517
- if (tag !== 18) {
1518
- break;
1644
+ message.oauthConnection = OAuthConnection.decode(reader, reader.uint32());
1645
+ continue;
1519
1646
  }
1520
-
1521
- message.oauthConnection = OAuthConnection.decode(reader, reader.uint32());
1522
- continue;
1523
1647
  }
1648
+ if ((tag & 7) === 4 || tag === 0) {
1649
+ break;
1650
+ }
1651
+ reader.skip(tag & 7);
1524
1652
  }
1525
- if ((tag & 7) === 4 || tag === 0) {
1526
- break;
1527
- }
1528
- reader.skip(tag & 7);
1653
+ return message;
1654
+ } finally {
1655
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
1529
1656
  }
1530
- return message;
1531
1657
  },
1532
1658
 
1533
1659
  fromJSON(object: any): CompletePagerDutyOAuthResponse {
@@ -1592,50 +1718,59 @@ export const ListPagerDutyServicesRequest: MessageFns<ListPagerDutyServicesReque
1592
1718
 
1593
1719
  decode(input: BinaryReader | Uint8Array, length?: number): ListPagerDutyServicesRequest {
1594
1720
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
1595
- const end = length === undefined ? reader.len : reader.pos + length;
1596
- const message = createBaseListPagerDutyServicesRequest();
1597
- while (reader.pos < end) {
1598
- const tag = reader.uint32();
1599
- switch (tag >>> 3) {
1600
- case 1: {
1601
- if (tag !== 10) {
1602
- break;
1721
+ const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
1722
+ if (previousRecursionDepth >= 100) {
1723
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
1724
+ }
1725
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
1726
+ try {
1727
+ const end = length === undefined ? reader.len : reader.pos + length;
1728
+ const message = createBaseListPagerDutyServicesRequest();
1729
+ while (reader.pos < end) {
1730
+ const tag = reader.uint32();
1731
+ switch (tag >>> 3) {
1732
+ case 1: {
1733
+ if (tag !== 10) {
1734
+ break;
1735
+ }
1736
+
1737
+ message.organizationId = reader.string();
1738
+ continue;
1603
1739
  }
1740
+ case 2: {
1741
+ if (tag !== 18) {
1742
+ break;
1743
+ }
1604
1744
 
1605
- message.organizationId = reader.string();
1606
- continue;
1607
- }
1608
- case 2: {
1609
- if (tag !== 18) {
1610
- break;
1745
+ message.query = reader.string();
1746
+ continue;
1611
1747
  }
1748
+ case 3: {
1749
+ if (tag !== 24) {
1750
+ break;
1751
+ }
1612
1752
 
1613
- message.query = reader.string();
1614
- continue;
1615
- }
1616
- case 3: {
1617
- if (tag !== 24) {
1618
- break;
1753
+ message.limit = reader.int32();
1754
+ continue;
1619
1755
  }
1756
+ case 4: {
1757
+ if (tag !== 32) {
1758
+ break;
1759
+ }
1620
1760
 
1621
- message.limit = reader.int32();
1622
- continue;
1623
- }
1624
- case 4: {
1625
- if (tag !== 32) {
1626
- break;
1761
+ message.offset = reader.int32();
1762
+ continue;
1627
1763
  }
1628
-
1629
- message.offset = reader.int32();
1630
- continue;
1631
1764
  }
1765
+ if ((tag & 7) === 4 || tag === 0) {
1766
+ break;
1767
+ }
1768
+ reader.skip(tag & 7);
1632
1769
  }
1633
- if ((tag & 7) === 4 || tag === 0) {
1634
- break;
1635
- }
1636
- reader.skip(tag & 7);
1770
+ return message;
1771
+ } finally {
1772
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
1637
1773
  }
1638
- return message;
1639
1774
  },
1640
1775
 
1641
1776
  fromJSON(object: any): ListPagerDutyServicesRequest {
@@ -1707,58 +1842,67 @@ export const ListPagerDutyServicesResponse: MessageFns<ListPagerDutyServicesResp
1707
1842
 
1708
1843
  decode(input: BinaryReader | Uint8Array, length?: number): ListPagerDutyServicesResponse {
1709
1844
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
1710
- const end = length === undefined ? reader.len : reader.pos + length;
1711
- const message = createBaseListPagerDutyServicesResponse();
1712
- while (reader.pos < end) {
1713
- const tag = reader.uint32();
1714
- switch (tag >>> 3) {
1715
- case 1: {
1716
- if (tag !== 10) {
1717
- break;
1845
+ const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
1846
+ if (previousRecursionDepth >= 100) {
1847
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
1848
+ }
1849
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
1850
+ try {
1851
+ const end = length === undefined ? reader.len : reader.pos + length;
1852
+ const message = createBaseListPagerDutyServicesResponse();
1853
+ while (reader.pos < end) {
1854
+ const tag = reader.uint32();
1855
+ switch (tag >>> 3) {
1856
+ case 1: {
1857
+ if (tag !== 10) {
1858
+ break;
1859
+ }
1860
+
1861
+ message.status = ResponseStatus.decode(reader, reader.uint32());
1862
+ continue;
1718
1863
  }
1864
+ case 2: {
1865
+ if (tag !== 18) {
1866
+ break;
1867
+ }
1719
1868
 
1720
- message.status = ResponseStatus.decode(reader, reader.uint32());
1721
- continue;
1722
- }
1723
- case 2: {
1724
- if (tag !== 18) {
1725
- break;
1869
+ message.services.push(PagerDutyService.decode(reader, reader.uint32()));
1870
+ continue;
1726
1871
  }
1872
+ case 3: {
1873
+ if (tag !== 24) {
1874
+ break;
1875
+ }
1727
1876
 
1728
- message.services.push(PagerDutyService.decode(reader, reader.uint32()));
1729
- continue;
1730
- }
1731
- case 3: {
1732
- if (tag !== 24) {
1733
- break;
1877
+ message.more = reader.bool();
1878
+ continue;
1734
1879
  }
1880
+ case 4: {
1881
+ if (tag !== 32) {
1882
+ break;
1883
+ }
1735
1884
 
1736
- message.more = reader.bool();
1737
- continue;
1738
- }
1739
- case 4: {
1740
- if (tag !== 32) {
1741
- break;
1885
+ message.limit = reader.int32();
1886
+ continue;
1742
1887
  }
1888
+ case 5: {
1889
+ if (tag !== 40) {
1890
+ break;
1891
+ }
1743
1892
 
1744
- message.limit = reader.int32();
1745
- continue;
1746
- }
1747
- case 5: {
1748
- if (tag !== 40) {
1749
- break;
1893
+ message.offset = reader.int32();
1894
+ continue;
1750
1895
  }
1751
-
1752
- message.offset = reader.int32();
1753
- continue;
1754
1896
  }
1897
+ if ((tag & 7) === 4 || tag === 0) {
1898
+ break;
1899
+ }
1900
+ reader.skip(tag & 7);
1755
1901
  }
1756
- if ((tag & 7) === 4 || tag === 0) {
1757
- break;
1758
- }
1759
- reader.skip(tag & 7);
1902
+ return message;
1903
+ } finally {
1904
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
1760
1905
  }
1761
- return message;
1762
1906
  },
1763
1907
 
1764
1908
  fromJSON(object: any): ListPagerDutyServicesResponse {
@@ -1828,34 +1972,43 @@ export const PagerDutyService: MessageFns<PagerDutyService> = {
1828
1972
 
1829
1973
  decode(input: BinaryReader | Uint8Array, length?: number): PagerDutyService {
1830
1974
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
1831
- const end = length === undefined ? reader.len : reader.pos + length;
1832
- const message = createBasePagerDutyService();
1833
- while (reader.pos < end) {
1834
- const tag = reader.uint32();
1835
- switch (tag >>> 3) {
1836
- case 1: {
1837
- if (tag !== 10) {
1838
- break;
1975
+ const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
1976
+ if (previousRecursionDepth >= 100) {
1977
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
1978
+ }
1979
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
1980
+ try {
1981
+ const end = length === undefined ? reader.len : reader.pos + length;
1982
+ const message = createBasePagerDutyService();
1983
+ while (reader.pos < end) {
1984
+ const tag = reader.uint32();
1985
+ switch (tag >>> 3) {
1986
+ case 1: {
1987
+ if (tag !== 10) {
1988
+ break;
1989
+ }
1990
+
1991
+ message.id = reader.string();
1992
+ continue;
1839
1993
  }
1994
+ case 2: {
1995
+ if (tag !== 18) {
1996
+ break;
1997
+ }
1840
1998
 
1841
- message.id = reader.string();
1842
- continue;
1843
- }
1844
- case 2: {
1845
- if (tag !== 18) {
1846
- break;
1999
+ message.name = reader.string();
2000
+ continue;
1847
2001
  }
1848
-
1849
- message.name = reader.string();
1850
- continue;
1851
2002
  }
2003
+ if ((tag & 7) === 4 || tag === 0) {
2004
+ break;
2005
+ }
2006
+ reader.skip(tag & 7);
1852
2007
  }
1853
- if ((tag & 7) === 4 || tag === 0) {
1854
- break;
1855
- }
1856
- reader.skip(tag & 7);
2008
+ return message;
2009
+ } finally {
2010
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
1857
2011
  }
1858
- return message;
1859
2012
  },
1860
2013
 
1861
2014
  fromJSON(object: any): PagerDutyService {