@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/derived_metric_gateway.proto
6
6
 
@@ -378,122 +378,131 @@ export const DerivedMetric: MessageFns<DerivedMetric> = {
378
378
 
379
379
  decode(input: BinaryReader | Uint8Array, length?: number): DerivedMetric {
380
380
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
381
- const end = length === undefined ? reader.len : reader.pos + length;
382
- const message = createBaseDerivedMetric();
383
- while (reader.pos < end) {
384
- const tag = reader.uint32();
385
- switch (tag >>> 3) {
386
- case 1: {
387
- if (tag !== 10) {
388
- break;
381
+ const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
382
+ if (previousRecursionDepth >= 100) {
383
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
384
+ }
385
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
386
+ try {
387
+ const end = length === undefined ? reader.len : reader.pos + length;
388
+ const message = createBaseDerivedMetric();
389
+ while (reader.pos < end) {
390
+ const tag = reader.uint32();
391
+ switch (tag >>> 3) {
392
+ case 1: {
393
+ if (tag !== 10) {
394
+ break;
395
+ }
396
+
397
+ message.id = reader.string();
398
+ continue;
389
399
  }
400
+ case 2: {
401
+ if (tag !== 18) {
402
+ break;
403
+ }
404
+
405
+ message.organizationId = reader.string();
406
+ continue;
407
+ }
408
+ case 3: {
409
+ if (tag !== 26) {
410
+ break;
411
+ }
412
+
413
+ message.projectId = reader.string();
414
+ continue;
415
+ }
416
+ case 4: {
417
+ if (tag !== 34) {
418
+ break;
419
+ }
420
+
421
+ message.slug = reader.string();
422
+ continue;
423
+ }
424
+ case 5: {
425
+ if (tag !== 42) {
426
+ break;
427
+ }
428
+
429
+ message.displayName = reader.string();
430
+ continue;
431
+ }
432
+ case 6: {
433
+ if (tag !== 50) {
434
+ break;
435
+ }
436
+
437
+ message.description = reader.string();
438
+ continue;
439
+ }
440
+ case 7: {
441
+ if (tag !== 56) {
442
+ break;
443
+ }
444
+
445
+ message.enabled = reader.bool();
446
+ continue;
447
+ }
448
+ case 8: {
449
+ if (tag !== 66) {
450
+ break;
451
+ }
452
+
453
+ message.metricName = reader.string();
454
+ continue;
455
+ }
456
+ case 9: {
457
+ if (tag !== 74) {
458
+ break;
459
+ }
460
+
461
+ message.unit = reader.string();
462
+ continue;
463
+ }
464
+ case 10: {
465
+ if (tag !== 82) {
466
+ break;
467
+ }
468
+
469
+ message.program = DerivedMetricProgram.decode(reader, reader.uint32());
470
+ continue;
471
+ }
472
+ case 11: {
473
+ if (tag !== 90) {
474
+ break;
475
+ }
476
+
477
+ message.createdAt = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
478
+ continue;
479
+ }
480
+ case 12: {
481
+ if (tag !== 98) {
482
+ break;
483
+ }
390
484
 
391
- message.id = reader.string();
392
- continue;
393
- }
394
- case 2: {
395
- if (tag !== 18) {
396
- break;
485
+ message.updatedAt = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
486
+ continue;
397
487
  }
488
+ case 13: {
489
+ if (tag !== 104) {
490
+ break;
491
+ }
398
492
 
399
- message.organizationId = reader.string();
400
- continue;
401
- }
402
- case 3: {
403
- if (tag !== 26) {
404
- break;
493
+ message.source = reader.int32() as any;
494
+ continue;
405
495
  }
406
-
407
- message.projectId = reader.string();
408
- continue;
409
496
  }
410
- case 4: {
411
- if (tag !== 34) {
412
- break;
413
- }
414
-
415
- message.slug = reader.string();
416
- continue;
417
- }
418
- case 5: {
419
- if (tag !== 42) {
420
- break;
421
- }
422
-
423
- message.displayName = reader.string();
424
- continue;
425
- }
426
- case 6: {
427
- if (tag !== 50) {
428
- break;
429
- }
430
-
431
- message.description = reader.string();
432
- continue;
433
- }
434
- case 7: {
435
- if (tag !== 56) {
436
- break;
437
- }
438
-
439
- message.enabled = reader.bool();
440
- continue;
441
- }
442
- case 8: {
443
- if (tag !== 66) {
444
- break;
445
- }
446
-
447
- message.metricName = reader.string();
448
- continue;
449
- }
450
- case 9: {
451
- if (tag !== 74) {
452
- break;
453
- }
454
-
455
- message.unit = reader.string();
456
- continue;
457
- }
458
- case 10: {
459
- if (tag !== 82) {
460
- break;
461
- }
462
-
463
- message.program = DerivedMetricProgram.decode(reader, reader.uint32());
464
- continue;
465
- }
466
- case 11: {
467
- if (tag !== 90) {
468
- break;
469
- }
470
-
471
- message.createdAt = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
472
- continue;
473
- }
474
- case 12: {
475
- if (tag !== 98) {
476
- break;
477
- }
478
-
479
- message.updatedAt = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
480
- continue;
481
- }
482
- case 13: {
483
- if (tag !== 104) {
484
- break;
485
- }
486
-
487
- message.source = reader.int32() as any;
488
- continue;
497
+ if ((tag & 7) === 4 || tag === 0) {
498
+ break;
489
499
  }
500
+ reader.skip(tag & 7);
490
501
  }
491
- if ((tag & 7) === 4 || tag === 0) {
492
- break;
493
- }
494
- reader.skip(tag & 7);
502
+ return message;
503
+ } finally {
504
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
495
505
  }
496
- return message;
497
506
  },
498
507
 
499
508
  fromJSON(object: any): DerivedMetric {
@@ -626,42 +635,51 @@ export const DerivedMetricProgram: MessageFns<DerivedMetricProgram> = {
626
635
 
627
636
  decode(input: BinaryReader | Uint8Array, length?: number): DerivedMetricProgram {
628
637
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
629
- const end = length === undefined ? reader.len : reader.pos + length;
630
- const message = createBaseDerivedMetricProgram();
631
- while (reader.pos < end) {
632
- const tag = reader.uint32();
633
- switch (tag >>> 3) {
634
- case 1: {
635
- if (tag !== 10) {
636
- break;
637
- }
638
-
639
- message.populationExpression = reader.string();
640
- continue;
641
- }
642
- case 2: {
643
- if (tag !== 18) {
644
- break;
645
- }
646
-
647
- message.valueExpression = reader.string();
648
- continue;
649
- }
650
- case 4: {
651
- if (tag !== 34) {
652
- break;
653
- }
654
-
655
- message.dimensions.push(reader.string());
656
- continue;
657
- }
638
+ const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
639
+ if (previousRecursionDepth >= 100) {
640
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
641
+ }
642
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
643
+ try {
644
+ const end = length === undefined ? reader.len : reader.pos + length;
645
+ const message = createBaseDerivedMetricProgram();
646
+ while (reader.pos < end) {
647
+ const tag = reader.uint32();
648
+ switch (tag >>> 3) {
649
+ case 1: {
650
+ if (tag !== 10) {
651
+ break;
652
+ }
653
+
654
+ message.populationExpression = reader.string();
655
+ continue;
656
+ }
657
+ case 2: {
658
+ if (tag !== 18) {
659
+ break;
660
+ }
661
+
662
+ message.valueExpression = reader.string();
663
+ continue;
664
+ }
665
+ case 4: {
666
+ if (tag !== 34) {
667
+ break;
668
+ }
669
+
670
+ message.dimensions.push(reader.string());
671
+ continue;
672
+ }
673
+ }
674
+ if ((tag & 7) === 4 || tag === 0) {
675
+ break;
676
+ }
677
+ reader.skip(tag & 7);
658
678
  }
659
- if ((tag & 7) === 4 || tag === 0) {
660
- break;
661
- }
662
- reader.skip(tag & 7);
679
+ return message;
680
+ } finally {
681
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
663
682
  }
664
- return message;
665
683
  },
666
684
 
667
685
  fromJSON(object: any): DerivedMetricProgram {
@@ -756,90 +774,99 @@ export const CreateDerivedMetricRequest: MessageFns<CreateDerivedMetricRequest>
756
774
 
757
775
  decode(input: BinaryReader | Uint8Array, length?: number): CreateDerivedMetricRequest {
758
776
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
759
- const end = length === undefined ? reader.len : reader.pos + length;
760
- const message = createBaseCreateDerivedMetricRequest();
761
- while (reader.pos < end) {
762
- const tag = reader.uint32();
763
- switch (tag >>> 3) {
764
- case 1: {
765
- if (tag !== 10) {
766
- break;
767
- }
768
-
769
- message.organizationId = reader.string();
770
- continue;
771
- }
772
- case 2: {
773
- if (tag !== 18) {
774
- break;
775
- }
776
-
777
- message.projectId = reader.string();
778
- continue;
779
- }
780
- case 3: {
781
- if (tag !== 26) {
782
- break;
783
- }
784
-
785
- message.slug = reader.string();
786
- continue;
787
- }
788
- case 4: {
789
- if (tag !== 34) {
790
- break;
791
- }
792
-
793
- message.displayName = reader.string();
794
- continue;
795
- }
796
- case 5: {
797
- if (tag !== 42) {
798
- break;
799
- }
800
-
801
- message.description = reader.string();
802
- continue;
803
- }
804
- case 6: {
805
- if (tag !== 48) {
806
- break;
807
- }
808
-
809
- message.enabled = reader.bool();
810
- continue;
811
- }
812
- case 7: {
813
- if (tag !== 58) {
814
- break;
815
- }
816
-
817
- message.unit = reader.string();
818
- continue;
819
- }
820
- case 8: {
821
- if (tag !== 66) {
822
- break;
823
- }
824
-
825
- message.program = DerivedMetricProgram.decode(reader, reader.uint32());
826
- continue;
827
- }
828
- case 9: {
829
- if (tag !== 72) {
830
- break;
831
- }
832
-
833
- message.source = reader.int32() as any;
834
- continue;
835
- }
777
+ const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
778
+ if (previousRecursionDepth >= 100) {
779
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
780
+ }
781
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
782
+ try {
783
+ const end = length === undefined ? reader.len : reader.pos + length;
784
+ const message = createBaseCreateDerivedMetricRequest();
785
+ while (reader.pos < end) {
786
+ const tag = reader.uint32();
787
+ switch (tag >>> 3) {
788
+ case 1: {
789
+ if (tag !== 10) {
790
+ break;
791
+ }
792
+
793
+ message.organizationId = reader.string();
794
+ continue;
795
+ }
796
+ case 2: {
797
+ if (tag !== 18) {
798
+ break;
799
+ }
800
+
801
+ message.projectId = reader.string();
802
+ continue;
803
+ }
804
+ case 3: {
805
+ if (tag !== 26) {
806
+ break;
807
+ }
808
+
809
+ message.slug = reader.string();
810
+ continue;
811
+ }
812
+ case 4: {
813
+ if (tag !== 34) {
814
+ break;
815
+ }
816
+
817
+ message.displayName = reader.string();
818
+ continue;
819
+ }
820
+ case 5: {
821
+ if (tag !== 42) {
822
+ break;
823
+ }
824
+
825
+ message.description = reader.string();
826
+ continue;
827
+ }
828
+ case 6: {
829
+ if (tag !== 48) {
830
+ break;
831
+ }
832
+
833
+ message.enabled = reader.bool();
834
+ continue;
835
+ }
836
+ case 7: {
837
+ if (tag !== 58) {
838
+ break;
839
+ }
840
+
841
+ message.unit = reader.string();
842
+ continue;
843
+ }
844
+ case 8: {
845
+ if (tag !== 66) {
846
+ break;
847
+ }
848
+
849
+ message.program = DerivedMetricProgram.decode(reader, reader.uint32());
850
+ continue;
851
+ }
852
+ case 9: {
853
+ if (tag !== 72) {
854
+ break;
855
+ }
856
+
857
+ message.source = reader.int32() as any;
858
+ continue;
859
+ }
860
+ }
861
+ if ((tag & 7) === 4 || tag === 0) {
862
+ break;
863
+ }
864
+ reader.skip(tag & 7);
836
865
  }
837
- if ((tag & 7) === 4 || tag === 0) {
838
- break;
839
- }
840
- reader.skip(tag & 7);
866
+ return message;
867
+ } finally {
868
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
841
869
  }
842
- return message;
843
870
  },
844
871
 
845
872
  fromJSON(object: any): CreateDerivedMetricRequest {
@@ -937,34 +964,43 @@ export const CreateDerivedMetricResponse: MessageFns<CreateDerivedMetricResponse
937
964
 
938
965
  decode(input: BinaryReader | Uint8Array, length?: number): CreateDerivedMetricResponse {
939
966
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
940
- const end = length === undefined ? reader.len : reader.pos + length;
941
- const message = createBaseCreateDerivedMetricResponse();
942
- while (reader.pos < end) {
943
- const tag = reader.uint32();
944
- switch (tag >>> 3) {
945
- case 1: {
946
- if (tag !== 10) {
947
- break;
948
- }
949
-
950
- message.status = ResponseStatus.decode(reader, reader.uint32());
951
- continue;
952
- }
953
- case 2: {
954
- if (tag !== 18) {
955
- break;
956
- }
957
-
958
- message.derivedMetric = DerivedMetric.decode(reader, reader.uint32());
959
- continue;
960
- }
961
- }
962
- if ((tag & 7) === 4 || tag === 0) {
963
- break;
967
+ const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
968
+ if (previousRecursionDepth >= 100) {
969
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
970
+ }
971
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
972
+ try {
973
+ const end = length === undefined ? reader.len : reader.pos + length;
974
+ const message = createBaseCreateDerivedMetricResponse();
975
+ while (reader.pos < end) {
976
+ const tag = reader.uint32();
977
+ switch (tag >>> 3) {
978
+ case 1: {
979
+ if (tag !== 10) {
980
+ break;
981
+ }
982
+
983
+ message.status = ResponseStatus.decode(reader, reader.uint32());
984
+ continue;
985
+ }
986
+ case 2: {
987
+ if (tag !== 18) {
988
+ break;
989
+ }
990
+
991
+ message.derivedMetric = DerivedMetric.decode(reader, reader.uint32());
992
+ continue;
993
+ }
994
+ }
995
+ if ((tag & 7) === 4 || tag === 0) {
996
+ break;
997
+ }
998
+ reader.skip(tag & 7);
964
999
  }
965
- reader.skip(tag & 7);
1000
+ return message;
1001
+ } finally {
1002
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
966
1003
  }
967
- return message;
968
1004
  },
969
1005
 
970
1006
  fromJSON(object: any): CreateDerivedMetricResponse {
@@ -1024,42 +1060,51 @@ export const GetDerivedMetricRequest: MessageFns<GetDerivedMetricRequest> = {
1024
1060
 
1025
1061
  decode(input: BinaryReader | Uint8Array, length?: number): GetDerivedMetricRequest {
1026
1062
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
1027
- const end = length === undefined ? reader.len : reader.pos + length;
1028
- const message = createBaseGetDerivedMetricRequest();
1029
- while (reader.pos < end) {
1030
- const tag = reader.uint32();
1031
- switch (tag >>> 3) {
1032
- case 1: {
1033
- if (tag !== 10) {
1034
- break;
1035
- }
1036
-
1037
- message.organizationId = reader.string();
1038
- continue;
1039
- }
1040
- case 2: {
1041
- if (tag !== 18) {
1042
- break;
1043
- }
1044
-
1045
- message.projectId = reader.string();
1046
- continue;
1047
- }
1048
- case 3: {
1049
- if (tag !== 26) {
1050
- break;
1051
- }
1052
-
1053
- message.derivedMetricId = reader.string();
1054
- continue;
1055
- }
1056
- }
1057
- if ((tag & 7) === 4 || tag === 0) {
1058
- break;
1063
+ const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
1064
+ if (previousRecursionDepth >= 100) {
1065
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
1066
+ }
1067
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
1068
+ try {
1069
+ const end = length === undefined ? reader.len : reader.pos + length;
1070
+ const message = createBaseGetDerivedMetricRequest();
1071
+ while (reader.pos < end) {
1072
+ const tag = reader.uint32();
1073
+ switch (tag >>> 3) {
1074
+ case 1: {
1075
+ if (tag !== 10) {
1076
+ break;
1077
+ }
1078
+
1079
+ message.organizationId = reader.string();
1080
+ continue;
1081
+ }
1082
+ case 2: {
1083
+ if (tag !== 18) {
1084
+ break;
1085
+ }
1086
+
1087
+ message.projectId = reader.string();
1088
+ continue;
1089
+ }
1090
+ case 3: {
1091
+ if (tag !== 26) {
1092
+ break;
1093
+ }
1094
+
1095
+ message.derivedMetricId = reader.string();
1096
+ continue;
1097
+ }
1098
+ }
1099
+ if ((tag & 7) === 4 || tag === 0) {
1100
+ break;
1101
+ }
1102
+ reader.skip(tag & 7);
1059
1103
  }
1060
- reader.skip(tag & 7);
1104
+ return message;
1105
+ } finally {
1106
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
1061
1107
  }
1062
- return message;
1063
1108
  },
1064
1109
 
1065
1110
  fromJSON(object: any): GetDerivedMetricRequest {
@@ -1125,34 +1170,43 @@ export const GetDerivedMetricResponse: MessageFns<GetDerivedMetricResponse> = {
1125
1170
 
1126
1171
  decode(input: BinaryReader | Uint8Array, length?: number): GetDerivedMetricResponse {
1127
1172
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
1128
- const end = length === undefined ? reader.len : reader.pos + length;
1129
- const message = createBaseGetDerivedMetricResponse();
1130
- while (reader.pos < end) {
1131
- const tag = reader.uint32();
1132
- switch (tag >>> 3) {
1133
- case 1: {
1134
- if (tag !== 10) {
1135
- break;
1136
- }
1137
-
1138
- message.status = ResponseStatus.decode(reader, reader.uint32());
1139
- continue;
1140
- }
1141
- case 2: {
1142
- if (tag !== 18) {
1143
- break;
1144
- }
1145
-
1146
- message.derivedMetric = DerivedMetric.decode(reader, reader.uint32());
1147
- continue;
1148
- }
1173
+ const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
1174
+ if (previousRecursionDepth >= 100) {
1175
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
1176
+ }
1177
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
1178
+ try {
1179
+ const end = length === undefined ? reader.len : reader.pos + length;
1180
+ const message = createBaseGetDerivedMetricResponse();
1181
+ while (reader.pos < end) {
1182
+ const tag = reader.uint32();
1183
+ switch (tag >>> 3) {
1184
+ case 1: {
1185
+ if (tag !== 10) {
1186
+ break;
1187
+ }
1188
+
1189
+ message.status = ResponseStatus.decode(reader, reader.uint32());
1190
+ continue;
1191
+ }
1192
+ case 2: {
1193
+ if (tag !== 18) {
1194
+ break;
1195
+ }
1196
+
1197
+ message.derivedMetric = DerivedMetric.decode(reader, reader.uint32());
1198
+ continue;
1199
+ }
1200
+ }
1201
+ if ((tag & 7) === 4 || tag === 0) {
1202
+ break;
1203
+ }
1204
+ reader.skip(tag & 7);
1149
1205
  }
1150
- if ((tag & 7) === 4 || tag === 0) {
1151
- break;
1152
- }
1153
- reader.skip(tag & 7);
1206
+ return message;
1207
+ } finally {
1208
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
1154
1209
  }
1155
- return message;
1156
1210
  },
1157
1211
 
1158
1212
  fromJSON(object: any): GetDerivedMetricResponse {
@@ -1209,34 +1263,43 @@ export const ListDerivedMetricsRequest: MessageFns<ListDerivedMetricsRequest> =
1209
1263
 
1210
1264
  decode(input: BinaryReader | Uint8Array, length?: number): ListDerivedMetricsRequest {
1211
1265
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
1212
- const end = length === undefined ? reader.len : reader.pos + length;
1213
- const message = createBaseListDerivedMetricsRequest();
1214
- while (reader.pos < end) {
1215
- const tag = reader.uint32();
1216
- switch (tag >>> 3) {
1217
- case 1: {
1218
- if (tag !== 10) {
1219
- break;
1220
- }
1221
-
1222
- message.organizationId = reader.string();
1223
- continue;
1224
- }
1225
- case 2: {
1226
- if (tag !== 18) {
1227
- break;
1228
- }
1229
-
1230
- message.projectId = reader.string();
1231
- continue;
1232
- }
1233
- }
1234
- if ((tag & 7) === 4 || tag === 0) {
1235
- break;
1266
+ const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
1267
+ if (previousRecursionDepth >= 100) {
1268
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
1269
+ }
1270
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
1271
+ try {
1272
+ const end = length === undefined ? reader.len : reader.pos + length;
1273
+ const message = createBaseListDerivedMetricsRequest();
1274
+ while (reader.pos < end) {
1275
+ const tag = reader.uint32();
1276
+ switch (tag >>> 3) {
1277
+ case 1: {
1278
+ if (tag !== 10) {
1279
+ break;
1280
+ }
1281
+
1282
+ message.organizationId = reader.string();
1283
+ continue;
1284
+ }
1285
+ case 2: {
1286
+ if (tag !== 18) {
1287
+ break;
1288
+ }
1289
+
1290
+ message.projectId = reader.string();
1291
+ continue;
1292
+ }
1293
+ }
1294
+ if ((tag & 7) === 4 || tag === 0) {
1295
+ break;
1296
+ }
1297
+ reader.skip(tag & 7);
1236
1298
  }
1237
- reader.skip(tag & 7);
1299
+ return message;
1300
+ } finally {
1301
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
1238
1302
  }
1239
- return message;
1240
1303
  },
1241
1304
 
1242
1305
  fromJSON(object: any): ListDerivedMetricsRequest {
@@ -1293,34 +1356,43 @@ export const ListDerivedMetricsResponse: MessageFns<ListDerivedMetricsResponse>
1293
1356
 
1294
1357
  decode(input: BinaryReader | Uint8Array, length?: number): ListDerivedMetricsResponse {
1295
1358
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
1296
- const end = length === undefined ? reader.len : reader.pos + length;
1297
- const message = createBaseListDerivedMetricsResponse();
1298
- while (reader.pos < end) {
1299
- const tag = reader.uint32();
1300
- switch (tag >>> 3) {
1301
- case 1: {
1302
- if (tag !== 10) {
1303
- break;
1304
- }
1305
-
1306
- message.status = ResponseStatus.decode(reader, reader.uint32());
1307
- continue;
1308
- }
1309
- case 2: {
1310
- if (tag !== 18) {
1311
- break;
1312
- }
1313
-
1314
- message.derivedMetrics.push(DerivedMetric.decode(reader, reader.uint32()));
1315
- continue;
1316
- }
1359
+ const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
1360
+ if (previousRecursionDepth >= 100) {
1361
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
1362
+ }
1363
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
1364
+ try {
1365
+ const end = length === undefined ? reader.len : reader.pos + length;
1366
+ const message = createBaseListDerivedMetricsResponse();
1367
+ while (reader.pos < end) {
1368
+ const tag = reader.uint32();
1369
+ switch (tag >>> 3) {
1370
+ case 1: {
1371
+ if (tag !== 10) {
1372
+ break;
1373
+ }
1374
+
1375
+ message.status = ResponseStatus.decode(reader, reader.uint32());
1376
+ continue;
1377
+ }
1378
+ case 2: {
1379
+ if (tag !== 18) {
1380
+ break;
1381
+ }
1382
+
1383
+ message.derivedMetrics.push(DerivedMetric.decode(reader, reader.uint32()));
1384
+ continue;
1385
+ }
1386
+ }
1387
+ if ((tag & 7) === 4 || tag === 0) {
1388
+ break;
1389
+ }
1390
+ reader.skip(tag & 7);
1317
1391
  }
1318
- if ((tag & 7) === 4 || tag === 0) {
1319
- break;
1320
- }
1321
- reader.skip(tag & 7);
1392
+ return message;
1393
+ } finally {
1394
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
1322
1395
  }
1323
- return message;
1324
1396
  },
1325
1397
 
1326
1398
  fromJSON(object: any): ListDerivedMetricsResponse {
@@ -1381,50 +1453,59 @@ export const UpdateDerivedMetricRequest: MessageFns<UpdateDerivedMetricRequest>
1381
1453
 
1382
1454
  decode(input: BinaryReader | Uint8Array, length?: number): UpdateDerivedMetricRequest {
1383
1455
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
1384
- const end = length === undefined ? reader.len : reader.pos + length;
1385
- const message = createBaseUpdateDerivedMetricRequest();
1386
- while (reader.pos < end) {
1387
- const tag = reader.uint32();
1388
- switch (tag >>> 3) {
1389
- case 1: {
1390
- if (tag !== 10) {
1391
- break;
1392
- }
1393
-
1394
- message.organizationId = reader.string();
1395
- continue;
1396
- }
1397
- case 2: {
1398
- if (tag !== 18) {
1399
- break;
1400
- }
1401
-
1402
- message.projectId = reader.string();
1403
- continue;
1404
- }
1405
- case 3: {
1406
- if (tag !== 26) {
1407
- break;
1408
- }
1409
-
1410
- message.derivedMetricId = reader.string();
1411
- continue;
1412
- }
1413
- case 4: {
1414
- if (tag !== 34) {
1415
- break;
1416
- }
1417
-
1418
- message.updates = UpdateDerivedMetricRequest_DerivedMetricUpdates.decode(reader, reader.uint32());
1419
- continue;
1420
- }
1456
+ const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
1457
+ if (previousRecursionDepth >= 100) {
1458
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
1459
+ }
1460
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
1461
+ try {
1462
+ const end = length === undefined ? reader.len : reader.pos + length;
1463
+ const message = createBaseUpdateDerivedMetricRequest();
1464
+ while (reader.pos < end) {
1465
+ const tag = reader.uint32();
1466
+ switch (tag >>> 3) {
1467
+ case 1: {
1468
+ if (tag !== 10) {
1469
+ break;
1470
+ }
1471
+
1472
+ message.organizationId = reader.string();
1473
+ continue;
1474
+ }
1475
+ case 2: {
1476
+ if (tag !== 18) {
1477
+ break;
1478
+ }
1479
+
1480
+ message.projectId = reader.string();
1481
+ continue;
1482
+ }
1483
+ case 3: {
1484
+ if (tag !== 26) {
1485
+ break;
1486
+ }
1487
+
1488
+ message.derivedMetricId = reader.string();
1489
+ continue;
1490
+ }
1491
+ case 4: {
1492
+ if (tag !== 34) {
1493
+ break;
1494
+ }
1495
+
1496
+ message.updates = UpdateDerivedMetricRequest_DerivedMetricUpdates.decode(reader, reader.uint32());
1497
+ continue;
1498
+ }
1499
+ }
1500
+ if ((tag & 7) === 4 || tag === 0) {
1501
+ break;
1502
+ }
1503
+ reader.skip(tag & 7);
1421
1504
  }
1422
- if ((tag & 7) === 4 || tag === 0) {
1423
- break;
1424
- }
1425
- reader.skip(tag & 7);
1505
+ return message;
1506
+ } finally {
1507
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
1426
1508
  }
1427
- return message;
1428
1509
  },
1429
1510
 
1430
1511
  fromJSON(object: any): UpdateDerivedMetricRequest {
@@ -1507,42 +1588,51 @@ export const UpdateDerivedMetricRequest_DerivedMetricUpdates: MessageFns<
1507
1588
 
1508
1589
  decode(input: BinaryReader | Uint8Array, length?: number): UpdateDerivedMetricRequest_DerivedMetricUpdates {
1509
1590
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
1510
- const end = length === undefined ? reader.len : reader.pos + length;
1511
- const message = createBaseUpdateDerivedMetricRequest_DerivedMetricUpdates();
1512
- while (reader.pos < end) {
1513
- const tag = reader.uint32();
1514
- switch (tag >>> 3) {
1515
- case 1: {
1516
- if (tag !== 10) {
1517
- break;
1518
- }
1519
-
1520
- message.displayName = reader.string();
1521
- continue;
1522
- }
1523
- case 2: {
1524
- if (tag !== 18) {
1525
- break;
1526
- }
1527
-
1528
- message.description = reader.string();
1529
- continue;
1530
- }
1531
- case 3: {
1532
- if (tag !== 24) {
1533
- break;
1534
- }
1535
-
1536
- message.enabled = reader.bool();
1537
- continue;
1538
- }
1591
+ const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
1592
+ if (previousRecursionDepth >= 100) {
1593
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
1594
+ }
1595
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
1596
+ try {
1597
+ const end = length === undefined ? reader.len : reader.pos + length;
1598
+ const message = createBaseUpdateDerivedMetricRequest_DerivedMetricUpdates();
1599
+ while (reader.pos < end) {
1600
+ const tag = reader.uint32();
1601
+ switch (tag >>> 3) {
1602
+ case 1: {
1603
+ if (tag !== 10) {
1604
+ break;
1605
+ }
1606
+
1607
+ message.displayName = reader.string();
1608
+ continue;
1609
+ }
1610
+ case 2: {
1611
+ if (tag !== 18) {
1612
+ break;
1613
+ }
1614
+
1615
+ message.description = reader.string();
1616
+ continue;
1617
+ }
1618
+ case 3: {
1619
+ if (tag !== 24) {
1620
+ break;
1621
+ }
1622
+
1623
+ message.enabled = reader.bool();
1624
+ continue;
1625
+ }
1626
+ }
1627
+ if ((tag & 7) === 4 || tag === 0) {
1628
+ break;
1629
+ }
1630
+ reader.skip(tag & 7);
1539
1631
  }
1540
- if ((tag & 7) === 4 || tag === 0) {
1541
- break;
1542
- }
1543
- reader.skip(tag & 7);
1632
+ return message;
1633
+ } finally {
1634
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
1544
1635
  }
1545
- return message;
1546
1636
  },
1547
1637
 
1548
1638
  fromJSON(object: any): UpdateDerivedMetricRequest_DerivedMetricUpdates {
@@ -1604,34 +1694,43 @@ export const UpdateDerivedMetricResponse: MessageFns<UpdateDerivedMetricResponse
1604
1694
 
1605
1695
  decode(input: BinaryReader | Uint8Array, length?: number): UpdateDerivedMetricResponse {
1606
1696
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
1607
- const end = length === undefined ? reader.len : reader.pos + length;
1608
- const message = createBaseUpdateDerivedMetricResponse();
1609
- while (reader.pos < end) {
1610
- const tag = reader.uint32();
1611
- switch (tag >>> 3) {
1612
- case 1: {
1613
- if (tag !== 10) {
1614
- break;
1615
- }
1616
-
1617
- message.status = ResponseStatus.decode(reader, reader.uint32());
1618
- continue;
1619
- }
1620
- case 2: {
1621
- if (tag !== 18) {
1622
- break;
1623
- }
1624
-
1625
- message.derivedMetric = DerivedMetric.decode(reader, reader.uint32());
1626
- continue;
1627
- }
1628
- }
1629
- if ((tag & 7) === 4 || tag === 0) {
1630
- break;
1697
+ const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
1698
+ if (previousRecursionDepth >= 100) {
1699
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
1700
+ }
1701
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
1702
+ try {
1703
+ const end = length === undefined ? reader.len : reader.pos + length;
1704
+ const message = createBaseUpdateDerivedMetricResponse();
1705
+ while (reader.pos < end) {
1706
+ const tag = reader.uint32();
1707
+ switch (tag >>> 3) {
1708
+ case 1: {
1709
+ if (tag !== 10) {
1710
+ break;
1711
+ }
1712
+
1713
+ message.status = ResponseStatus.decode(reader, reader.uint32());
1714
+ continue;
1715
+ }
1716
+ case 2: {
1717
+ if (tag !== 18) {
1718
+ break;
1719
+ }
1720
+
1721
+ message.derivedMetric = DerivedMetric.decode(reader, reader.uint32());
1722
+ continue;
1723
+ }
1724
+ }
1725
+ if ((tag & 7) === 4 || tag === 0) {
1726
+ break;
1727
+ }
1728
+ reader.skip(tag & 7);
1631
1729
  }
1632
- reader.skip(tag & 7);
1730
+ return message;
1731
+ } finally {
1732
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
1633
1733
  }
1634
- return message;
1635
1734
  },
1636
1735
 
1637
1736
  fromJSON(object: any): UpdateDerivedMetricResponse {
@@ -1691,42 +1790,51 @@ export const DeleteDerivedMetricRequest: MessageFns<DeleteDerivedMetricRequest>
1691
1790
 
1692
1791
  decode(input: BinaryReader | Uint8Array, length?: number): DeleteDerivedMetricRequest {
1693
1792
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
1694
- const end = length === undefined ? reader.len : reader.pos + length;
1695
- const message = createBaseDeleteDerivedMetricRequest();
1696
- while (reader.pos < end) {
1697
- const tag = reader.uint32();
1698
- switch (tag >>> 3) {
1699
- case 1: {
1700
- if (tag !== 10) {
1701
- break;
1702
- }
1703
-
1704
- message.organizationId = reader.string();
1705
- continue;
1706
- }
1707
- case 2: {
1708
- if (tag !== 18) {
1709
- break;
1710
- }
1711
-
1712
- message.projectId = reader.string();
1713
- continue;
1714
- }
1715
- case 3: {
1716
- if (tag !== 26) {
1717
- break;
1718
- }
1719
-
1720
- message.derivedMetricId = reader.string();
1721
- continue;
1722
- }
1723
- }
1724
- if ((tag & 7) === 4 || tag === 0) {
1725
- break;
1793
+ const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
1794
+ if (previousRecursionDepth >= 100) {
1795
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
1796
+ }
1797
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
1798
+ try {
1799
+ const end = length === undefined ? reader.len : reader.pos + length;
1800
+ const message = createBaseDeleteDerivedMetricRequest();
1801
+ while (reader.pos < end) {
1802
+ const tag = reader.uint32();
1803
+ switch (tag >>> 3) {
1804
+ case 1: {
1805
+ if (tag !== 10) {
1806
+ break;
1807
+ }
1808
+
1809
+ message.organizationId = reader.string();
1810
+ continue;
1811
+ }
1812
+ case 2: {
1813
+ if (tag !== 18) {
1814
+ break;
1815
+ }
1816
+
1817
+ message.projectId = reader.string();
1818
+ continue;
1819
+ }
1820
+ case 3: {
1821
+ if (tag !== 26) {
1822
+ break;
1823
+ }
1824
+
1825
+ message.derivedMetricId = reader.string();
1826
+ continue;
1827
+ }
1828
+ }
1829
+ if ((tag & 7) === 4 || tag === 0) {
1830
+ break;
1831
+ }
1832
+ reader.skip(tag & 7);
1726
1833
  }
1727
- reader.skip(tag & 7);
1834
+ return message;
1835
+ } finally {
1836
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
1728
1837
  }
1729
- return message;
1730
1838
  },
1731
1839
 
1732
1840
  fromJSON(object: any): DeleteDerivedMetricRequest {
@@ -1789,26 +1897,35 @@ export const DeleteDerivedMetricResponse: MessageFns<DeleteDerivedMetricResponse
1789
1897
 
1790
1898
  decode(input: BinaryReader | Uint8Array, length?: number): DeleteDerivedMetricResponse {
1791
1899
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
1792
- const end = length === undefined ? reader.len : reader.pos + length;
1793
- const message = createBaseDeleteDerivedMetricResponse();
1794
- while (reader.pos < end) {
1795
- const tag = reader.uint32();
1796
- switch (tag >>> 3) {
1797
- case 1: {
1798
- if (tag !== 10) {
1799
- break;
1800
- }
1801
-
1802
- message.status = ResponseStatus.decode(reader, reader.uint32());
1803
- continue;
1804
- }
1805
- }
1806
- if ((tag & 7) === 4 || tag === 0) {
1807
- break;
1900
+ const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
1901
+ if (previousRecursionDepth >= 100) {
1902
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
1903
+ }
1904
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
1905
+ try {
1906
+ const end = length === undefined ? reader.len : reader.pos + length;
1907
+ const message = createBaseDeleteDerivedMetricResponse();
1908
+ while (reader.pos < end) {
1909
+ const tag = reader.uint32();
1910
+ switch (tag >>> 3) {
1911
+ case 1: {
1912
+ if (tag !== 10) {
1913
+ break;
1914
+ }
1915
+
1916
+ message.status = ResponseStatus.decode(reader, reader.uint32());
1917
+ continue;
1918
+ }
1919
+ }
1920
+ if ((tag & 7) === 4 || tag === 0) {
1921
+ break;
1922
+ }
1923
+ reader.skip(tag & 7);
1808
1924
  }
1809
- reader.skip(tag & 7);
1925
+ return message;
1926
+ } finally {
1927
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
1810
1928
  }
1811
- return message;
1812
1929
  },
1813
1930
 
1814
1931
  fromJSON(object: any): DeleteDerivedMetricResponse {
@@ -1858,50 +1975,59 @@ export const DryRunDerivedMetricRequest: MessageFns<DryRunDerivedMetricRequest>
1858
1975
 
1859
1976
  decode(input: BinaryReader | Uint8Array, length?: number): DryRunDerivedMetricRequest {
1860
1977
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
1861
- const end = length === undefined ? reader.len : reader.pos + length;
1862
- const message = createBaseDryRunDerivedMetricRequest();
1863
- while (reader.pos < end) {
1864
- const tag = reader.uint32();
1865
- switch (tag >>> 3) {
1866
- case 1: {
1867
- if (tag !== 10) {
1868
- break;
1869
- }
1870
-
1871
- message.organizationId = reader.string();
1872
- continue;
1873
- }
1874
- case 2: {
1875
- if (tag !== 18) {
1876
- break;
1877
- }
1878
-
1879
- message.projectId = reader.string();
1880
- continue;
1881
- }
1882
- case 3: {
1883
- if (tag !== 26) {
1884
- break;
1885
- }
1886
-
1887
- message.program = DerivedMetricProgram.decode(reader, reader.uint32());
1888
- continue;
1889
- }
1890
- case 4: {
1891
- if (tag !== 32) {
1892
- break;
1893
- }
1894
-
1895
- message.traceLimit = reader.int32();
1896
- continue;
1897
- }
1978
+ const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
1979
+ if (previousRecursionDepth >= 100) {
1980
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
1981
+ }
1982
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
1983
+ try {
1984
+ const end = length === undefined ? reader.len : reader.pos + length;
1985
+ const message = createBaseDryRunDerivedMetricRequest();
1986
+ while (reader.pos < end) {
1987
+ const tag = reader.uint32();
1988
+ switch (tag >>> 3) {
1989
+ case 1: {
1990
+ if (tag !== 10) {
1991
+ break;
1992
+ }
1993
+
1994
+ message.organizationId = reader.string();
1995
+ continue;
1996
+ }
1997
+ case 2: {
1998
+ if (tag !== 18) {
1999
+ break;
2000
+ }
2001
+
2002
+ message.projectId = reader.string();
2003
+ continue;
2004
+ }
2005
+ case 3: {
2006
+ if (tag !== 26) {
2007
+ break;
2008
+ }
2009
+
2010
+ message.program = DerivedMetricProgram.decode(reader, reader.uint32());
2011
+ continue;
2012
+ }
2013
+ case 4: {
2014
+ if (tag !== 32) {
2015
+ break;
2016
+ }
2017
+
2018
+ message.traceLimit = reader.int32();
2019
+ continue;
2020
+ }
2021
+ }
2022
+ if ((tag & 7) === 4 || tag === 0) {
2023
+ break;
2024
+ }
2025
+ reader.skip(tag & 7);
1898
2026
  }
1899
- if ((tag & 7) === 4 || tag === 0) {
1900
- break;
1901
- }
1902
- reader.skip(tag & 7);
2027
+ return message;
2028
+ } finally {
2029
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
1903
2030
  }
1904
- return message;
1905
2031
  },
1906
2032
 
1907
2033
  fromJSON(object: any): DryRunDerivedMetricRequest {
@@ -1980,50 +2106,59 @@ export const DryRunDerivedMetricResponse: MessageFns<DryRunDerivedMetricResponse
1980
2106
 
1981
2107
  decode(input: BinaryReader | Uint8Array, length?: number): DryRunDerivedMetricResponse {
1982
2108
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
1983
- const end = length === undefined ? reader.len : reader.pos + length;
1984
- const message = createBaseDryRunDerivedMetricResponse();
1985
- while (reader.pos < end) {
1986
- const tag = reader.uint32();
1987
- switch (tag >>> 3) {
1988
- case 1: {
1989
- if (tag !== 10) {
1990
- break;
1991
- }
1992
-
1993
- message.status = ResponseStatus.decode(reader, reader.uint32());
1994
- continue;
1995
- }
1996
- case 2: {
1997
- if (tag !== 18) {
1998
- break;
1999
- }
2000
-
2001
- message.traceResults.push(DryRunTraceResult.decode(reader, reader.uint32()));
2002
- continue;
2003
- }
2004
- case 3: {
2005
- if (tag !== 26) {
2006
- break;
2007
- }
2008
-
2009
- message.outcomeCounts.push(DerivedMetricOutcomeCount.decode(reader, reader.uint32()));
2010
- continue;
2011
- }
2012
- case 4: {
2013
- if (tag !== 32) {
2014
- break;
2015
- }
2016
-
2017
- message.tracesSelected = reader.uint32();
2018
- continue;
2019
- }
2020
- }
2021
- if ((tag & 7) === 4 || tag === 0) {
2022
- break;
2109
+ const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
2110
+ if (previousRecursionDepth >= 100) {
2111
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
2112
+ }
2113
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
2114
+ try {
2115
+ const end = length === undefined ? reader.len : reader.pos + length;
2116
+ const message = createBaseDryRunDerivedMetricResponse();
2117
+ while (reader.pos < end) {
2118
+ const tag = reader.uint32();
2119
+ switch (tag >>> 3) {
2120
+ case 1: {
2121
+ if (tag !== 10) {
2122
+ break;
2123
+ }
2124
+
2125
+ message.status = ResponseStatus.decode(reader, reader.uint32());
2126
+ continue;
2127
+ }
2128
+ case 2: {
2129
+ if (tag !== 18) {
2130
+ break;
2131
+ }
2132
+
2133
+ message.traceResults.push(DryRunTraceResult.decode(reader, reader.uint32()));
2134
+ continue;
2135
+ }
2136
+ case 3: {
2137
+ if (tag !== 26) {
2138
+ break;
2139
+ }
2140
+
2141
+ message.outcomeCounts.push(DerivedMetricOutcomeCount.decode(reader, reader.uint32()));
2142
+ continue;
2143
+ }
2144
+ case 4: {
2145
+ if (tag !== 32) {
2146
+ break;
2147
+ }
2148
+
2149
+ message.tracesSelected = reader.uint32();
2150
+ continue;
2151
+ }
2152
+ }
2153
+ if ((tag & 7) === 4 || tag === 0) {
2154
+ break;
2155
+ }
2156
+ reader.skip(tag & 7);
2023
2157
  }
2024
- reader.skip(tag & 7);
2158
+ return message;
2159
+ } finally {
2160
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
2025
2161
  }
2026
- return message;
2027
2162
  },
2028
2163
 
2029
2164
  fromJSON(object: any): DryRunDerivedMetricResponse {
@@ -2099,42 +2234,51 @@ export const DryRunTraceResult: MessageFns<DryRunTraceResult> = {
2099
2234
 
2100
2235
  decode(input: BinaryReader | Uint8Array, length?: number): DryRunTraceResult {
2101
2236
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
2102
- const end = length === undefined ? reader.len : reader.pos + length;
2103
- const message = createBaseDryRunTraceResult();
2104
- while (reader.pos < end) {
2105
- const tag = reader.uint32();
2106
- switch (tag >>> 3) {
2107
- case 1: {
2108
- if (tag !== 10) {
2109
- break;
2110
- }
2111
-
2112
- message.traceId = reader.string();
2113
- continue;
2114
- }
2115
- case 2: {
2116
- if (tag !== 18) {
2117
- break;
2118
- }
2119
-
2120
- message.emitted = DryRunEmission.decode(reader, reader.uint32());
2121
- continue;
2122
- }
2123
- case 3: {
2124
- if (tag !== 26) {
2125
- break;
2126
- }
2127
-
2128
- message.notEmitted = DryRunNonEmission.decode(reader, reader.uint32());
2129
- continue;
2130
- }
2131
- }
2132
- if ((tag & 7) === 4 || tag === 0) {
2133
- break;
2237
+ const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
2238
+ if (previousRecursionDepth >= 100) {
2239
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
2240
+ }
2241
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
2242
+ try {
2243
+ const end = length === undefined ? reader.len : reader.pos + length;
2244
+ const message = createBaseDryRunTraceResult();
2245
+ while (reader.pos < end) {
2246
+ const tag = reader.uint32();
2247
+ switch (tag >>> 3) {
2248
+ case 1: {
2249
+ if (tag !== 10) {
2250
+ break;
2251
+ }
2252
+
2253
+ message.traceId = reader.string();
2254
+ continue;
2255
+ }
2256
+ case 2: {
2257
+ if (tag !== 18) {
2258
+ break;
2259
+ }
2260
+
2261
+ message.emitted = DryRunEmission.decode(reader, reader.uint32());
2262
+ continue;
2263
+ }
2264
+ case 3: {
2265
+ if (tag !== 26) {
2266
+ break;
2267
+ }
2268
+
2269
+ message.notEmitted = DryRunNonEmission.decode(reader, reader.uint32());
2270
+ continue;
2271
+ }
2272
+ }
2273
+ if ((tag & 7) === 4 || tag === 0) {
2274
+ break;
2275
+ }
2276
+ reader.skip(tag & 7);
2134
2277
  }
2135
- reader.skip(tag & 7);
2278
+ return message;
2279
+ } finally {
2280
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
2136
2281
  }
2137
- return message;
2138
2282
  },
2139
2283
 
2140
2284
  fromJSON(object: any): DryRunTraceResult {
@@ -2200,37 +2344,46 @@ export const DryRunEmission: MessageFns<DryRunEmission> = {
2200
2344
 
2201
2345
  decode(input: BinaryReader | Uint8Array, length?: number): DryRunEmission {
2202
2346
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
2203
- const end = length === undefined ? reader.len : reader.pos + length;
2204
- const message = createBaseDryRunEmission();
2205
- while (reader.pos < end) {
2206
- const tag = reader.uint32();
2207
- switch (tag >>> 3) {
2208
- case 1: {
2209
- if (tag !== 9) {
2210
- break;
2211
- }
2212
-
2213
- message.value = reader.double();
2214
- continue;
2215
- }
2216
- case 3: {
2217
- if (tag !== 26) {
2218
- break;
2219
- }
2220
-
2221
- const entry3 = DryRunEmission_ResolvedDimensionsEntry.decode(reader, reader.uint32());
2222
- if (entry3.value !== undefined) {
2223
- message.resolvedDimensions[entry3.key] = entry3.value;
2224
- }
2225
- continue;
2226
- }
2227
- }
2228
- if ((tag & 7) === 4 || tag === 0) {
2229
- break;
2347
+ const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
2348
+ if (previousRecursionDepth >= 100) {
2349
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
2350
+ }
2351
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
2352
+ try {
2353
+ const end = length === undefined ? reader.len : reader.pos + length;
2354
+ const message = createBaseDryRunEmission();
2355
+ while (reader.pos < end) {
2356
+ const tag = reader.uint32();
2357
+ switch (tag >>> 3) {
2358
+ case 1: {
2359
+ if (tag !== 9) {
2360
+ break;
2361
+ }
2362
+
2363
+ message.value = reader.double();
2364
+ continue;
2365
+ }
2366
+ case 3: {
2367
+ if (tag !== 26) {
2368
+ break;
2369
+ }
2370
+
2371
+ const entry3 = DryRunEmission_ResolvedDimensionsEntry.decode(reader, reader.uint32());
2372
+ if (entry3.value !== undefined) {
2373
+ message.resolvedDimensions[entry3.key] = entry3.value;
2374
+ }
2375
+ continue;
2376
+ }
2377
+ }
2378
+ if ((tag & 7) === 4 || tag === 0) {
2379
+ break;
2380
+ }
2381
+ reader.skip(tag & 7);
2230
2382
  }
2231
- reader.skip(tag & 7);
2383
+ return message;
2384
+ } finally {
2385
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
2232
2386
  }
2233
- return message;
2234
2387
  },
2235
2388
 
2236
2389
  fromJSON(object: any): DryRunEmission {
@@ -2239,7 +2392,12 @@ export const DryRunEmission: MessageFns<DryRunEmission> = {
2239
2392
  resolvedDimensions: isObject(object.resolvedDimensions)
2240
2393
  ? (globalThis.Object.entries(object.resolvedDimensions) as [string, any][]).reduce(
2241
2394
  (acc: { [key: string]: string }, [key, value]: [string, any]) => {
2242
- acc[key] = globalThis.String(value);
2395
+ globalThis.Object.defineProperty(acc, key, {
2396
+ value: globalThis.String(value),
2397
+ enumerable: true,
2398
+ configurable: true,
2399
+ writable: true,
2400
+ });
2243
2401
  return acc;
2244
2402
  },
2245
2403
  {},
@@ -2247,7 +2405,12 @@ export const DryRunEmission: MessageFns<DryRunEmission> = {
2247
2405
  : isObject(object.resolved_dimensions)
2248
2406
  ? (globalThis.Object.entries(object.resolved_dimensions) as [string, any][]).reduce(
2249
2407
  (acc: { [key: string]: string }, [key, value]: [string, any]) => {
2250
- acc[key] = globalThis.String(value);
2408
+ globalThis.Object.defineProperty(acc, key, {
2409
+ value: globalThis.String(value),
2410
+ enumerable: true,
2411
+ configurable: true,
2412
+ writable: true,
2413
+ });
2251
2414
  return acc;
2252
2415
  },
2253
2416
  {},
@@ -2307,34 +2470,43 @@ export const DryRunEmission_ResolvedDimensionsEntry: MessageFns<DryRunEmission_R
2307
2470
 
2308
2471
  decode(input: BinaryReader | Uint8Array, length?: number): DryRunEmission_ResolvedDimensionsEntry {
2309
2472
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
2310
- const end = length === undefined ? reader.len : reader.pos + length;
2311
- const message = createBaseDryRunEmission_ResolvedDimensionsEntry();
2312
- while (reader.pos < end) {
2313
- const tag = reader.uint32();
2314
- switch (tag >>> 3) {
2315
- case 1: {
2316
- if (tag !== 10) {
2317
- break;
2318
- }
2319
-
2320
- message.key = reader.string();
2321
- continue;
2322
- }
2323
- case 2: {
2324
- if (tag !== 18) {
2325
- break;
2326
- }
2327
-
2328
- message.value = reader.string();
2329
- continue;
2330
- }
2473
+ const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
2474
+ if (previousRecursionDepth >= 100) {
2475
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
2476
+ }
2477
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
2478
+ try {
2479
+ const end = length === undefined ? reader.len : reader.pos + length;
2480
+ const message = createBaseDryRunEmission_ResolvedDimensionsEntry();
2481
+ while (reader.pos < end) {
2482
+ const tag = reader.uint32();
2483
+ switch (tag >>> 3) {
2484
+ case 1: {
2485
+ if (tag !== 10) {
2486
+ break;
2487
+ }
2488
+
2489
+ message.key = reader.string();
2490
+ continue;
2491
+ }
2492
+ case 2: {
2493
+ if (tag !== 18) {
2494
+ break;
2495
+ }
2496
+
2497
+ message.value = reader.string();
2498
+ continue;
2499
+ }
2500
+ }
2501
+ if ((tag & 7) === 4 || tag === 0) {
2502
+ break;
2503
+ }
2504
+ reader.skip(tag & 7);
2331
2505
  }
2332
- if ((tag & 7) === 4 || tag === 0) {
2333
- break;
2334
- }
2335
- reader.skip(tag & 7);
2506
+ return message;
2507
+ } finally {
2508
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
2336
2509
  }
2337
- return message;
2338
2510
  },
2339
2511
 
2340
2512
  fromJSON(object: any): DryRunEmission_ResolvedDimensionsEntry {
@@ -2387,34 +2559,43 @@ export const DryRunNonEmission: MessageFns<DryRunNonEmission> = {
2387
2559
 
2388
2560
  decode(input: BinaryReader | Uint8Array, length?: number): DryRunNonEmission {
2389
2561
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
2390
- const end = length === undefined ? reader.len : reader.pos + length;
2391
- const message = createBaseDryRunNonEmission();
2392
- while (reader.pos < end) {
2393
- const tag = reader.uint32();
2394
- switch (tag >>> 3) {
2395
- case 1: {
2396
- if (tag !== 8) {
2397
- break;
2398
- }
2399
-
2400
- message.outcome = reader.int32() as any;
2401
- continue;
2402
- }
2403
- case 2: {
2404
- if (tag !== 18) {
2405
- break;
2406
- }
2407
-
2408
- message.detail = reader.string();
2409
- continue;
2410
- }
2411
- }
2412
- if ((tag & 7) === 4 || tag === 0) {
2413
- break;
2562
+ const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
2563
+ if (previousRecursionDepth >= 100) {
2564
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
2565
+ }
2566
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
2567
+ try {
2568
+ const end = length === undefined ? reader.len : reader.pos + length;
2569
+ const message = createBaseDryRunNonEmission();
2570
+ while (reader.pos < end) {
2571
+ const tag = reader.uint32();
2572
+ switch (tag >>> 3) {
2573
+ case 1: {
2574
+ if (tag !== 8) {
2575
+ break;
2576
+ }
2577
+
2578
+ message.outcome = reader.int32() as any;
2579
+ continue;
2580
+ }
2581
+ case 2: {
2582
+ if (tag !== 18) {
2583
+ break;
2584
+ }
2585
+
2586
+ message.detail = reader.string();
2587
+ continue;
2588
+ }
2589
+ }
2590
+ if ((tag & 7) === 4 || tag === 0) {
2591
+ break;
2592
+ }
2593
+ reader.skip(tag & 7);
2414
2594
  }
2415
- reader.skip(tag & 7);
2595
+ return message;
2596
+ } finally {
2597
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
2416
2598
  }
2417
- return message;
2418
2599
  },
2419
2600
 
2420
2601
  fromJSON(object: any): DryRunNonEmission {
@@ -2463,34 +2644,43 @@ export const DerivedMetricOutcomeCount: MessageFns<DerivedMetricOutcomeCount> =
2463
2644
 
2464
2645
  decode(input: BinaryReader | Uint8Array, length?: number): DerivedMetricOutcomeCount {
2465
2646
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
2466
- const end = length === undefined ? reader.len : reader.pos + length;
2467
- const message = createBaseDerivedMetricOutcomeCount();
2468
- while (reader.pos < end) {
2469
- const tag = reader.uint32();
2470
- switch (tag >>> 3) {
2471
- case 1: {
2472
- if (tag !== 8) {
2473
- break;
2474
- }
2475
-
2476
- message.outcome = reader.int32() as any;
2477
- continue;
2478
- }
2479
- case 2: {
2480
- if (tag !== 16) {
2481
- break;
2482
- }
2483
-
2484
- message.count = reader.uint32();
2485
- continue;
2486
- }
2647
+ const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
2648
+ if (previousRecursionDepth >= 100) {
2649
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
2650
+ }
2651
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
2652
+ try {
2653
+ const end = length === undefined ? reader.len : reader.pos + length;
2654
+ const message = createBaseDerivedMetricOutcomeCount();
2655
+ while (reader.pos < end) {
2656
+ const tag = reader.uint32();
2657
+ switch (tag >>> 3) {
2658
+ case 1: {
2659
+ if (tag !== 8) {
2660
+ break;
2661
+ }
2662
+
2663
+ message.outcome = reader.int32() as any;
2664
+ continue;
2665
+ }
2666
+ case 2: {
2667
+ if (tag !== 16) {
2668
+ break;
2669
+ }
2670
+
2671
+ message.count = reader.uint32();
2672
+ continue;
2673
+ }
2674
+ }
2675
+ if ((tag & 7) === 4 || tag === 0) {
2676
+ break;
2677
+ }
2678
+ reader.skip(tag & 7);
2487
2679
  }
2488
- if ((tag & 7) === 4 || tag === 0) {
2489
- break;
2490
- }
2491
- reader.skip(tag & 7);
2680
+ return message;
2681
+ } finally {
2682
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
2492
2683
  }
2493
- return message;
2494
2684
  },
2495
2685
 
2496
2686
  fromJSON(object: any): DerivedMetricOutcomeCount {