@crossplane-org/function-sdk-typescript 0.5.0 → 0.6.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (18) hide show
  1. package/README.md +19 -0
  2. package/dist/function/function.d.ts.map +1 -1
  3. package/dist/proto/google/protobuf/duration.d.ts.map +1 -1
  4. package/dist/proto/google/protobuf/duration.js +32 -22
  5. package/dist/proto/google/protobuf/duration.js.map +1 -1
  6. package/dist/proto/google/protobuf/struct.d.ts.map +1 -1
  7. package/dist/proto/google/protobuf/struct.js +146 -101
  8. package/dist/proto/google/protobuf/struct.js.map +1 -1
  9. package/dist/proto/run_function.d.ts.map +1 -1
  10. package/dist/proto/run_function.js +1069 -719
  11. package/dist/proto/run_function.js.map +1 -1
  12. package/dist/resource/resource.d.ts +2 -2
  13. package/dist/resource/resource.d.ts.map +1 -1
  14. package/dist/resource/resource.js +7 -4
  15. package/dist/resource/resource.js.map +1 -1
  16. package/dist/response/response.js.map +1 -1
  17. package/dist/vitest.config.d.ts.map +1 -1
  18. package/package.json +11 -8
package/dist/proto/run_function.js CHANGED
@@ -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.11.4
3
+ // protoc-gen-ts_proto v2.12.1
4
4
  // protoc v6.33.4
5
5
  // source: run_function.proto
6
6
  /* eslint-disable */
@@ -329,93 +329,103 @@ export const RunFunctionRequest = {
329
329
  },
330
330
  decode(input, length) {
331
331
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
332
- const end = length === undefined ? reader.len : reader.pos + length;
333
- const message = createBaseRunFunctionRequest();
334
- while (reader.pos < end) {
335
- const tag = reader.uint32();
336
- switch (tag >>> 3) {
337
- case 1: {
338
- if (tag !== 10) {
339
- break;
340
- }
341
- message.meta = RequestMeta.decode(reader, reader.uint32());
342
- continue;
343
- }
344
- case 2: {
345
- if (tag !== 18) {
346
- break;
347
- }
348
- message.observed = State.decode(reader, reader.uint32());
349
- continue;
350
- }
351
- case 3: {
352
- if (tag !== 26) {
353
- break;
332
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
333
+ if (previousRecursionDepth >= 100) {
334
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
335
+ }
336
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
337
+ try {
338
+ const end = length === undefined ? reader.len : reader.pos + length;
339
+ const message = createBaseRunFunctionRequest();
340
+ while (reader.pos < end) {
341
+ const tag = reader.uint32();
342
+ switch (tag >>> 3) {
343
+ case 1: {
344
+ if (tag !== 10) {
345
+ break;
346
+ }
347
+ message.meta = RequestMeta.decode(reader, reader.uint32());
348
+ continue;
354
349
  }
355
- message.desired = State.decode(reader, reader.uint32());
356
- continue;
357
- }
358
- case 4: {
359
- if (tag !== 34) {
360
- break;
350
+ case 2: {
351
+ if (tag !== 18) {
352
+ break;
353
+ }
354
+ message.observed = State.decode(reader, reader.uint32());
355
+ continue;
361
356
  }
362
- message.input = Struct.unwrap(Struct.decode(reader, reader.uint32()));
363
- continue;
364
- }
365
- case 5: {
366
- if (tag !== 42) {
367
- break;
357
+ case 3: {
358
+ if (tag !== 26) {
359
+ break;
360
+ }
361
+ message.desired = State.decode(reader, reader.uint32());
362
+ continue;
368
363
  }
369
- message.context = Struct.unwrap(Struct.decode(reader, reader.uint32()));
370
- continue;
371
- }
372
- case 6: {
373
- if (tag !== 50) {
374
- break;
364
+ case 4: {
365
+ if (tag !== 34) {
366
+ break;
367
+ }
368
+ message.input = Struct.unwrap(Struct.decode(reader, reader.uint32()));
369
+ continue;
375
370
  }
376
- const entry6 = RunFunctionRequest_ExtraResourcesEntry.decode(reader, reader.uint32());
377
- if (entry6.value !== undefined) {
378
- message.extraResources[entry6.key] = entry6.value;
371
+ case 5: {
372
+ if (tag !== 42) {
373
+ break;
374
+ }
375
+ message.context = Struct.unwrap(Struct.decode(reader, reader.uint32()));
376
+ continue;
379
377
  }
380
- continue;
381
- }
382
- case 7: {
383
- if (tag !== 58) {
384
- break;
378
+ case 6: {
379
+ if (tag !== 50) {
380
+ break;
381
+ }
382
+ const entry6 = RunFunctionRequest_ExtraResourcesEntry.decode(reader, reader.uint32());
383
+ if (entry6.value !== undefined) {
384
+ message.extraResources[entry6.key] = entry6.value;
385
+ }
386
+ continue;
385
387
  }
386
- const entry7 = RunFunctionRequest_CredentialsEntry.decode(reader, reader.uint32());
387
- if (entry7.value !== undefined) {
388
- message.credentials[entry7.key] = entry7.value;
388
+ case 7: {
389
+ if (tag !== 58) {
390
+ break;
391
+ }
392
+ const entry7 = RunFunctionRequest_CredentialsEntry.decode(reader, reader.uint32());
393
+ if (entry7.value !== undefined) {
394
+ message.credentials[entry7.key] = entry7.value;
395
+ }
396
+ continue;
389
397
  }
390
- continue;
391
- }
392
- case 8: {
393
- if (tag !== 66) {
394
- break;
398
+ case 8: {
399
+ if (tag !== 66) {
400
+ break;
401
+ }
402
+ const entry8 = RunFunctionRequest_RequiredResourcesEntry.decode(reader, reader.uint32());
403
+ if (entry8.value !== undefined) {
404
+ message.requiredResources[entry8.key] = entry8.value;
405
+ }
406
+ continue;
395
407
  }
396
- const entry8 = RunFunctionRequest_RequiredResourcesEntry.decode(reader, reader.uint32());
397
- if (entry8.value !== undefined) {
398
- message.requiredResources[entry8.key] = entry8.value;
408
+ case 9: {
409
+ if (tag !== 74) {
410
+ break;
411
+ }
412
+ const entry9 = RunFunctionRequest_RequiredSchemasEntry.decode(reader, reader.uint32());
413
+ if (entry9.value !== undefined) {
414
+ message.requiredSchemas[entry9.key] = entry9.value;
415
+ }
416
+ continue;
399
417
  }
400
- continue;
401
418
  }
402
- case 9: {
403
- if (tag !== 74) {
404
- break;
405
- }
406
- const entry9 = RunFunctionRequest_RequiredSchemasEntry.decode(reader, reader.uint32());
407
- if (entry9.value !== undefined) {
408
- message.requiredSchemas[entry9.key] = entry9.value;
409
- }
410
- continue;
419
+ if ((tag & 7) === 4 || tag === 0) {
420
+ break;
411
421
  }
422
+ reader.skip(tag & 7);
412
423
  }
413
- if ((tag & 7) === 4 || tag === 0) {
414
- break;
415
- }
416
- reader.skip(tag & 7);
424
+ return message;
425
+ }
426
+ finally {
427
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
417
428
  }
418
- return message;
419
429
  },
420
430
  fromJSON(object) {
421
431
  return {
@@ -426,40 +436,75 @@ export const RunFunctionRequest = {
426
436
  context: isObject(object.context) ? object.context : undefined,
427
437
  extraResources: isObject(object.extraResources)
428
438
  ? globalThis.Object.entries(object.extraResources).reduce((acc, [key, value]) => {
429
- acc[key] = Resources.fromJSON(value);
439
+ globalThis.Object.defineProperty(acc, key, {
440
+ value: Resources.fromJSON(value),
441
+ enumerable: true,
442
+ configurable: true,
443
+ writable: true,
444
+ });
430
445
  return acc;
431
446
  }, {})
432
447
  : isObject(object.extra_resources)
433
448
  ? globalThis.Object.entries(object.extra_resources).reduce((acc, [key, value]) => {
434
- acc[key] = Resources.fromJSON(value);
449
+ globalThis.Object.defineProperty(acc, key, {
450
+ value: Resources.fromJSON(value),
451
+ enumerable: true,
452
+ configurable: true,
453
+ writable: true,
454
+ });
435
455
  return acc;
436
456
  }, {})
437
457
  : {},
438
458
  credentials: isObject(object.credentials)
439
459
  ? globalThis.Object.entries(object.credentials).reduce((acc, [key, value]) => {
440
- acc[key] = Credentials.fromJSON(value);
460
+ globalThis.Object.defineProperty(acc, key, {
461
+ value: Credentials.fromJSON(value),
462
+ enumerable: true,
463
+ configurable: true,
464
+ writable: true,
465
+ });
441
466
  return acc;
442
467
  }, {})
443
468
  : {},
444
469
  requiredResources: isObject(object.requiredResources)
445
470
  ? globalThis.Object.entries(object.requiredResources).reduce((acc, [key, value]) => {
446
- acc[key] = Resources.fromJSON(value);
471
+ globalThis.Object.defineProperty(acc, key, {
472
+ value: Resources.fromJSON(value),
473
+ enumerable: true,
474
+ configurable: true,
475
+ writable: true,
476
+ });
447
477
  return acc;
448
478
  }, {})
449
479
  : isObject(object.required_resources)
450
480
  ? globalThis.Object.entries(object.required_resources).reduce((acc, [key, value]) => {
451
- acc[key] = Resources.fromJSON(value);
481
+ globalThis.Object.defineProperty(acc, key, {
482
+ value: Resources.fromJSON(value),
483
+ enumerable: true,
484
+ configurable: true,
485
+ writable: true,
486
+ });
452
487
  return acc;
453
488
  }, {})
454
489
  : {},
455
490
  requiredSchemas: isObject(object.requiredSchemas)
456
491
  ? globalThis.Object.entries(object.requiredSchemas).reduce((acc, [key, value]) => {
457
- acc[key] = Schema.fromJSON(value);
492
+ globalThis.Object.defineProperty(acc, key, {
493
+ value: Schema.fromJSON(value),
494
+ enumerable: true,
495
+ configurable: true,
496
+ writable: true,
497
+ });
458
498
  return acc;
459
499
  }, {})
460
500
  : isObject(object.required_schemas)
461
501
  ? globalThis.Object.entries(object.required_schemas).reduce((acc, [key, value]) => {
462
- acc[key] = Schema.fromJSON(value);
502
+ globalThis.Object.defineProperty(acc, key, {
503
+ value: Schema.fromJSON(value),
504
+ enumerable: true,
505
+ configurable: true,
506
+ writable: true,
507
+ });
463
508
  return acc;
464
509
  }, {})
465
510
  : {},
@@ -579,32 +624,42 @@ export const RunFunctionRequest_ExtraResourcesEntry = {
579
624
  },
580
625
  decode(input, length) {
581
626
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
582
- const end = length === undefined ? reader.len : reader.pos + length;
583
- const message = createBaseRunFunctionRequest_ExtraResourcesEntry();
584
- while (reader.pos < end) {
585
- const tag = reader.uint32();
586
- switch (tag >>> 3) {
587
- case 1: {
588
- if (tag !== 10) {
589
- break;
627
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
628
+ if (previousRecursionDepth >= 100) {
629
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
630
+ }
631
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
632
+ try {
633
+ const end = length === undefined ? reader.len : reader.pos + length;
634
+ const message = createBaseRunFunctionRequest_ExtraResourcesEntry();
635
+ while (reader.pos < end) {
636
+ const tag = reader.uint32();
637
+ switch (tag >>> 3) {
638
+ case 1: {
639
+ if (tag !== 10) {
640
+ break;
641
+ }
642
+ message.key = reader.string();
643
+ continue;
590
644
  }
591
- message.key = reader.string();
592
- continue;
593
- }
594
- case 2: {
595
- if (tag !== 18) {
596
- break;
645
+ case 2: {
646
+ if (tag !== 18) {
647
+ break;
648
+ }
649
+ message.value = Resources.decode(reader, reader.uint32());
650
+ continue;
597
651
  }
598
- message.value = Resources.decode(reader, reader.uint32());
599
- continue;
600
652
  }
653
+ if ((tag & 7) === 4 || tag === 0) {
654
+ break;
655
+ }
656
+ reader.skip(tag & 7);
601
657
  }
602
- if ((tag & 7) === 4 || tag === 0) {
603
- break;
604
- }
605
- reader.skip(tag & 7);
658
+ return message;
659
+ }
660
+ finally {
661
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
606
662
  }
607
- return message;
608
663
  },
609
664
  fromJSON(object) {
610
665
  return {
@@ -649,32 +704,42 @@ export const RunFunctionRequest_CredentialsEntry = {
649
704
  },
650
705
  decode(input, length) {
651
706
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
652
- const end = length === undefined ? reader.len : reader.pos + length;
653
- const message = createBaseRunFunctionRequest_CredentialsEntry();
654
- while (reader.pos < end) {
655
- const tag = reader.uint32();
656
- switch (tag >>> 3) {
657
- case 1: {
658
- if (tag !== 10) {
659
- break;
707
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
708
+ if (previousRecursionDepth >= 100) {
709
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
710
+ }
711
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
712
+ try {
713
+ const end = length === undefined ? reader.len : reader.pos + length;
714
+ const message = createBaseRunFunctionRequest_CredentialsEntry();
715
+ while (reader.pos < end) {
716
+ const tag = reader.uint32();
717
+ switch (tag >>> 3) {
718
+ case 1: {
719
+ if (tag !== 10) {
720
+ break;
721
+ }
722
+ message.key = reader.string();
723
+ continue;
660
724
  }
661
- message.key = reader.string();
662
- continue;
663
- }
664
- case 2: {
665
- if (tag !== 18) {
666
- break;
725
+ case 2: {
726
+ if (tag !== 18) {
727
+ break;
728
+ }
729
+ message.value = Credentials.decode(reader, reader.uint32());
730
+ continue;
667
731
  }
668
- message.value = Credentials.decode(reader, reader.uint32());
669
- continue;
670
732
  }
733
+ if ((tag & 7) === 4 || tag === 0) {
734
+ break;
735
+ }
736
+ reader.skip(tag & 7);
671
737
  }
672
- if ((tag & 7) === 4 || tag === 0) {
673
- break;
674
- }
675
- reader.skip(tag & 7);
738
+ return message;
739
+ }
740
+ finally {
741
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
676
742
  }
677
- return message;
678
743
  },
679
744
  fromJSON(object) {
680
745
  return {
@@ -719,32 +784,42 @@ export const RunFunctionRequest_RequiredResourcesEntry = {
719
784
  },
720
785
  decode(input, length) {
721
786
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
722
- const end = length === undefined ? reader.len : reader.pos + length;
723
- const message = createBaseRunFunctionRequest_RequiredResourcesEntry();
724
- while (reader.pos < end) {
725
- const tag = reader.uint32();
726
- switch (tag >>> 3) {
727
- case 1: {
728
- if (tag !== 10) {
729
- break;
787
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
788
+ if (previousRecursionDepth >= 100) {
789
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
790
+ }
791
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
792
+ try {
793
+ const end = length === undefined ? reader.len : reader.pos + length;
794
+ const message = createBaseRunFunctionRequest_RequiredResourcesEntry();
795
+ while (reader.pos < end) {
796
+ const tag = reader.uint32();
797
+ switch (tag >>> 3) {
798
+ case 1: {
799
+ if (tag !== 10) {
800
+ break;
801
+ }
802
+ message.key = reader.string();
803
+ continue;
730
804
  }
731
- message.key = reader.string();
732
- continue;
733
- }
734
- case 2: {
735
- if (tag !== 18) {
736
- break;
805
+ case 2: {
806
+ if (tag !== 18) {
807
+ break;
808
+ }
809
+ message.value = Resources.decode(reader, reader.uint32());
810
+ continue;
737
811
  }
738
- message.value = Resources.decode(reader, reader.uint32());
739
- continue;
740
812
  }
813
+ if ((tag & 7) === 4 || tag === 0) {
814
+ break;
815
+ }
816
+ reader.skip(tag & 7);
741
817
  }
742
- if ((tag & 7) === 4 || tag === 0) {
743
- break;
744
- }
745
- reader.skip(tag & 7);
818
+ return message;
819
+ }
820
+ finally {
821
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
746
822
  }
747
- return message;
748
823
  },
749
824
  fromJSON(object) {
750
825
  return {
@@ -789,32 +864,42 @@ export const RunFunctionRequest_RequiredSchemasEntry = {
789
864
  },
790
865
  decode(input, length) {
791
866
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
792
- const end = length === undefined ? reader.len : reader.pos + length;
793
- const message = createBaseRunFunctionRequest_RequiredSchemasEntry();
794
- while (reader.pos < end) {
795
- const tag = reader.uint32();
796
- switch (tag >>> 3) {
797
- case 1: {
798
- if (tag !== 10) {
799
- break;
867
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
868
+ if (previousRecursionDepth >= 100) {
869
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
870
+ }
871
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
872
+ try {
873
+ const end = length === undefined ? reader.len : reader.pos + length;
874
+ const message = createBaseRunFunctionRequest_RequiredSchemasEntry();
875
+ while (reader.pos < end) {
876
+ const tag = reader.uint32();
877
+ switch (tag >>> 3) {
878
+ case 1: {
879
+ if (tag !== 10) {
880
+ break;
881
+ }
882
+ message.key = reader.string();
883
+ continue;
800
884
  }
801
- message.key = reader.string();
802
- continue;
803
- }
804
- case 2: {
805
- if (tag !== 18) {
806
- break;
885
+ case 2: {
886
+ if (tag !== 18) {
887
+ break;
888
+ }
889
+ message.value = Schema.decode(reader, reader.uint32());
890
+ continue;
807
891
  }
808
- message.value = Schema.decode(reader, reader.uint32());
809
- continue;
810
892
  }
893
+ if ((tag & 7) === 4 || tag === 0) {
894
+ break;
895
+ }
896
+ reader.skip(tag & 7);
811
897
  }
812
- if ((tag & 7) === 4 || tag === 0) {
813
- break;
814
- }
815
- reader.skip(tag & 7);
898
+ return message;
899
+ }
900
+ finally {
901
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
816
902
  }
817
- return message;
818
903
  },
819
904
  fromJSON(object) {
820
905
  return {
@@ -856,25 +941,35 @@ export const Credentials = {
856
941
  },
857
942
  decode(input, length) {
858
943
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
859
- const end = length === undefined ? reader.len : reader.pos + length;
860
- const message = createBaseCredentials();
861
- while (reader.pos < end) {
862
- const tag = reader.uint32();
863
- switch (tag >>> 3) {
864
- case 1: {
865
- if (tag !== 10) {
866
- break;
944
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
945
+ if (previousRecursionDepth >= 100) {
946
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
947
+ }
948
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
949
+ try {
950
+ const end = length === undefined ? reader.len : reader.pos + length;
951
+ const message = createBaseCredentials();
952
+ while (reader.pos < end) {
953
+ const tag = reader.uint32();
954
+ switch (tag >>> 3) {
955
+ case 1: {
956
+ if (tag !== 10) {
957
+ break;
958
+ }
959
+ message.credentialData = CredentialData.decode(reader, reader.uint32());
960
+ continue;
867
961
  }
868
- message.credentialData = CredentialData.decode(reader, reader.uint32());
869
- continue;
870
962
  }
963
+ if ((tag & 7) === 4 || tag === 0) {
964
+ break;
965
+ }
966
+ reader.skip(tag & 7);
871
967
  }
872
- if ((tag & 7) === 4 || tag === 0) {
873
- break;
874
- }
875
- reader.skip(tag & 7);
968
+ return message;
969
+ }
970
+ finally {
971
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
876
972
  }
877
- return message;
878
973
  },
879
974
  fromJSON(object) {
880
975
  return {
@@ -915,34 +1010,49 @@ export const CredentialData = {
915
1010
  },
916
1011
  decode(input, length) {
917
1012
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
918
- const end = length === undefined ? reader.len : reader.pos + length;
919
- const message = createBaseCredentialData();
920
- while (reader.pos < end) {
921
- const tag = reader.uint32();
922
- switch (tag >>> 3) {
923
- case 1: {
924
- if (tag !== 10) {
925
- break;
926
- }
927
- const entry1 = CredentialData_DataEntry.decode(reader, reader.uint32());
928
- if (entry1.value !== undefined) {
929
- message.data[entry1.key] = entry1.value;
1013
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
1014
+ if (previousRecursionDepth >= 100) {
1015
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
1016
+ }
1017
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
1018
+ try {
1019
+ const end = length === undefined ? reader.len : reader.pos + length;
1020
+ const message = createBaseCredentialData();
1021
+ while (reader.pos < end) {
1022
+ const tag = reader.uint32();
1023
+ switch (tag >>> 3) {
1024
+ case 1: {
1025
+ if (tag !== 10) {
1026
+ break;
1027
+ }
1028
+ const entry1 = CredentialData_DataEntry.decode(reader, reader.uint32());
1029
+ if (entry1.value !== undefined) {
1030
+ message.data[entry1.key] = entry1.value;
1031
+ }
1032
+ continue;
930
1033
  }
931
- continue;
932
1034
  }
1035
+ if ((tag & 7) === 4 || tag === 0) {
1036
+ break;
1037
+ }
1038
+ reader.skip(tag & 7);
933
1039
  }
934
- if ((tag & 7) === 4 || tag === 0) {
935
- break;
936
- }
937
- reader.skip(tag & 7);
1040
+ return message;
1041
+ }
1042
+ finally {
1043
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
938
1044
  }
939
- return message;
940
1045
  },
941
1046
  fromJSON(object) {
942
1047
  return {
943
1048
  data: isObject(object.data)
944
1049
  ? globalThis.Object.entries(object.data).reduce((acc, [key, value]) => {
945
- acc[key] = Buffer.from(bytesFromBase64(value));
1050
+ globalThis.Object.defineProperty(acc, key, {
1051
+ value: Buffer.from(bytesFromBase64(value)),
1052
+ enumerable: true,
1053
+ configurable: true,
1054
+ writable: true,
1055
+ });
946
1056
  return acc;
947
1057
  }, {})
948
1058
  : {},
@@ -990,32 +1100,42 @@ export const CredentialData_DataEntry = {
990
1100
  },
991
1101
  decode(input, length) {
992
1102
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
993
- const end = length === undefined ? reader.len : reader.pos + length;
994
- const message = createBaseCredentialData_DataEntry();
995
- while (reader.pos < end) {
996
- const tag = reader.uint32();
997
- switch (tag >>> 3) {
998
- case 1: {
999
- if (tag !== 10) {
1000
- break;
1103
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
1104
+ if (previousRecursionDepth >= 100) {
1105
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
1106
+ }
1107
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
1108
+ try {
1109
+ const end = length === undefined ? reader.len : reader.pos + length;
1110
+ const message = createBaseCredentialData_DataEntry();
1111
+ while (reader.pos < end) {
1112
+ const tag = reader.uint32();
1113
+ switch (tag >>> 3) {
1114
+ case 1: {
1115
+ if (tag !== 10) {
1116
+ break;
1117
+ }
1118
+ message.key = reader.string();
1119
+ continue;
1001
1120
  }
1002
- message.key = reader.string();
1003
- continue;
1004
- }
1005
- case 2: {
1006
- if (tag !== 18) {
1007
- break;
1121
+ case 2: {
1122
+ if (tag !== 18) {
1123
+ break;
1124
+ }
1125
+ message.value = Buffer.from(reader.bytes());
1126
+ continue;
1008
1127
  }
1009
- message.value = Buffer.from(reader.bytes());
1010
- continue;
1011
1128
  }
1129
+ if ((tag & 7) === 4 || tag === 0) {
1130
+ break;
1131
+ }
1132
+ reader.skip(tag & 7);
1012
1133
  }
1013
- if ((tag & 7) === 4 || tag === 0) {
1014
- break;
1015
- }
1016
- reader.skip(tag & 7);
1134
+ return message;
1135
+ }
1136
+ finally {
1137
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
1017
1138
  }
1018
- return message;
1019
1139
  },
1020
1140
  fromJSON(object) {
1021
1141
  return {
@@ -1055,25 +1175,35 @@ export const Resources = {
1055
1175
  },
1056
1176
  decode(input, length) {
1057
1177
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
1058
- const end = length === undefined ? reader.len : reader.pos + length;
1059
- const message = createBaseResources();
1060
- while (reader.pos < end) {
1061
- const tag = reader.uint32();
1062
- switch (tag >>> 3) {
1063
- case 1: {
1064
- if (tag !== 10) {
1065
- break;
1178
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
1179
+ if (previousRecursionDepth >= 100) {
1180
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
1181
+ }
1182
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
1183
+ try {
1184
+ const end = length === undefined ? reader.len : reader.pos + length;
1185
+ const message = createBaseResources();
1186
+ while (reader.pos < end) {
1187
+ const tag = reader.uint32();
1188
+ switch (tag >>> 3) {
1189
+ case 1: {
1190
+ if (tag !== 10) {
1191
+ break;
1192
+ }
1193
+ message.items.push(Resource.decode(reader, reader.uint32()));
1194
+ continue;
1066
1195
  }
1067
- message.items.push(Resource.decode(reader, reader.uint32()));
1068
- continue;
1069
1196
  }
1197
+ if ((tag & 7) === 4 || tag === 0) {
1198
+ break;
1199
+ }
1200
+ reader.skip(tag & 7);
1070
1201
  }
1071
- if ((tag & 7) === 4 || tag === 0) {
1072
- break;
1073
- }
1074
- reader.skip(tag & 7);
1202
+ return message;
1203
+ }
1204
+ finally {
1205
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
1075
1206
  }
1076
- return message;
1077
1207
  },
1078
1208
  fromJSON(object) {
1079
1209
  return { items: globalThis.Array.isArray(object?.items) ? object.items.map((e) => Resource.fromJSON(e)) : [] };
@@ -1132,67 +1262,77 @@ export const RunFunctionResponse = {
1132
1262
  },
1133
1263
  decode(input, length) {
1134
1264
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
1135
- const end = length === undefined ? reader.len : reader.pos + length;
1136
- const message = createBaseRunFunctionResponse();
1137
- while (reader.pos < end) {
1138
- const tag = reader.uint32();
1139
- switch (tag >>> 3) {
1140
- case 1: {
1141
- if (tag !== 10) {
1142
- break;
1265
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
1266
+ if (previousRecursionDepth >= 100) {
1267
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
1268
+ }
1269
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
1270
+ try {
1271
+ const end = length === undefined ? reader.len : reader.pos + length;
1272
+ const message = createBaseRunFunctionResponse();
1273
+ while (reader.pos < end) {
1274
+ const tag = reader.uint32();
1275
+ switch (tag >>> 3) {
1276
+ case 1: {
1277
+ if (tag !== 10) {
1278
+ break;
1279
+ }
1280
+ message.meta = ResponseMeta.decode(reader, reader.uint32());
1281
+ continue;
1143
1282
  }
1144
- message.meta = ResponseMeta.decode(reader, reader.uint32());
1145
- continue;
1146
- }
1147
- case 2: {
1148
- if (tag !== 18) {
1149
- break;
1283
+ case 2: {
1284
+ if (tag !== 18) {
1285
+ break;
1286
+ }
1287
+ message.desired = State.decode(reader, reader.uint32());
1288
+ continue;
1150
1289
  }
1151
- message.desired = State.decode(reader, reader.uint32());
1152
- continue;
1153
- }
1154
- case 3: {
1155
- if (tag !== 26) {
1156
- break;
1290
+ case 3: {
1291
+ if (tag !== 26) {
1292
+ break;
1293
+ }
1294
+ message.results.push(Result.decode(reader, reader.uint32()));
1295
+ continue;
1157
1296
  }
1158
- message.results.push(Result.decode(reader, reader.uint32()));
1159
- continue;
1160
- }
1161
- case 4: {
1162
- if (tag !== 34) {
1163
- break;
1297
+ case 4: {
1298
+ if (tag !== 34) {
1299
+ break;
1300
+ }
1301
+ message.context = Struct.unwrap(Struct.decode(reader, reader.uint32()));
1302
+ continue;
1164
1303
  }
1165
- message.context = Struct.unwrap(Struct.decode(reader, reader.uint32()));
1166
- continue;
1167
- }
1168
- case 5: {
1169
- if (tag !== 42) {
1170
- break;
1304
+ case 5: {
1305
+ if (tag !== 42) {
1306
+ break;
1307
+ }
1308
+ message.requirements = Requirements.decode(reader, reader.uint32());
1309
+ continue;
1171
1310
  }
1172
- message.requirements = Requirements.decode(reader, reader.uint32());
1173
- continue;
1174
- }
1175
- case 6: {
1176
- if (tag !== 50) {
1177
- break;
1311
+ case 6: {
1312
+ if (tag !== 50) {
1313
+ break;
1314
+ }
1315
+ message.conditions.push(Condition.decode(reader, reader.uint32()));
1316
+ continue;
1178
1317
  }
1179
- message.conditions.push(Condition.decode(reader, reader.uint32()));
1180
- continue;
1181
- }
1182
- case 7: {
1183
- if (tag !== 58) {
1184
- break;
1318
+ case 7: {
1319
+ if (tag !== 58) {
1320
+ break;
1321
+ }
1322
+ message.output = Struct.unwrap(Struct.decode(reader, reader.uint32()));
1323
+ continue;
1185
1324
  }
1186
- message.output = Struct.unwrap(Struct.decode(reader, reader.uint32()));
1187
- continue;
1188
1325
  }
1326
+ if ((tag & 7) === 4 || tag === 0) {
1327
+ break;
1328
+ }
1329
+ reader.skip(tag & 7);
1189
1330
  }
1190
- if ((tag & 7) === 4 || tag === 0) {
1191
- break;
1192
- }
1193
- reader.skip(tag & 7);
1331
+ return message;
1332
+ }
1333
+ finally {
1334
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
1194
1335
  }
1195
- return message;
1196
1336
  },
1197
1337
  fromJSON(object) {
1198
1338
  return {
@@ -1270,39 +1410,49 @@ export const RequestMeta = {
1270
1410
  },
1271
1411
  decode(input, length) {
1272
1412
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
1273
- const end = length === undefined ? reader.len : reader.pos + length;
1274
- const message = createBaseRequestMeta();
1275
- while (reader.pos < end) {
1276
- const tag = reader.uint32();
1277
- switch (tag >>> 3) {
1278
- case 1: {
1279
- if (tag !== 10) {
1280
- break;
1281
- }
1282
- message.tag = reader.string();
1283
- continue;
1284
- }
1285
- case 2: {
1286
- if (tag === 16) {
1287
- message.capabilities.push(reader.int32());
1413
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
1414
+ if (previousRecursionDepth >= 100) {
1415
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
1416
+ }
1417
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
1418
+ try {
1419
+ const end = length === undefined ? reader.len : reader.pos + length;
1420
+ const message = createBaseRequestMeta();
1421
+ while (reader.pos < end) {
1422
+ const tag = reader.uint32();
1423
+ switch (tag >>> 3) {
1424
+ case 1: {
1425
+ if (tag !== 10) {
1426
+ break;
1427
+ }
1428
+ message.tag = reader.string();
1288
1429
  continue;
1289
1430
  }
1290
- if (tag === 18) {
1291
- const end2 = reader.uint32() + reader.pos;
1292
- while (reader.pos < end2) {
1431
+ case 2: {
1432
+ if (tag === 16) {
1293
1433
  message.capabilities.push(reader.int32());
1434
+ continue;
1294
1435
  }
1295
- continue;
1436
+ if (tag === 18) {
1437
+ const end2 = reader.uint32() + reader.pos;
1438
+ while (reader.pos < end2) {
1439
+ message.capabilities.push(reader.int32());
1440
+ }
1441
+ continue;
1442
+ }
1443
+ break;
1296
1444
  }
1445
+ }
1446
+ if ((tag & 7) === 4 || tag === 0) {
1297
1447
  break;
1298
1448
  }
1449
+ reader.skip(tag & 7);
1299
1450
  }
1300
- if ((tag & 7) === 4 || tag === 0) {
1301
- break;
1302
- }
1303
- reader.skip(tag & 7);
1451
+ return message;
1452
+ }
1453
+ finally {
1454
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
1304
1455
  }
1305
- return message;
1306
1456
  },
1307
1457
  fromJSON(object) {
1308
1458
  return {
@@ -1350,71 +1500,101 @@ export const Requirements = {
1350
1500
  },
1351
1501
  decode(input, length) {
1352
1502
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
1353
- const end = length === undefined ? reader.len : reader.pos + length;
1354
- const message = createBaseRequirements();
1355
- while (reader.pos < end) {
1356
- const tag = reader.uint32();
1357
- switch (tag >>> 3) {
1358
- case 1: {
1359
- if (tag !== 10) {
1360
- break;
1361
- }
1362
- const entry1 = Requirements_ExtraResourcesEntry.decode(reader, reader.uint32());
1363
- if (entry1.value !== undefined) {
1364
- message.extraResources[entry1.key] = entry1.value;
1503
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
1504
+ if (previousRecursionDepth >= 100) {
1505
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
1506
+ }
1507
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
1508
+ try {
1509
+ const end = length === undefined ? reader.len : reader.pos + length;
1510
+ const message = createBaseRequirements();
1511
+ while (reader.pos < end) {
1512
+ const tag = reader.uint32();
1513
+ switch (tag >>> 3) {
1514
+ case 1: {
1515
+ if (tag !== 10) {
1516
+ break;
1517
+ }
1518
+ const entry1 = Requirements_ExtraResourcesEntry.decode(reader, reader.uint32());
1519
+ if (entry1.value !== undefined) {
1520
+ message.extraResources[entry1.key] = entry1.value;
1521
+ }
1522
+ continue;
1365
1523
  }
1366
- continue;
1367
- }
1368
- case 2: {
1369
- if (tag !== 18) {
1370
- break;
1524
+ case 2: {
1525
+ if (tag !== 18) {
1526
+ break;
1527
+ }
1528
+ const entry2 = Requirements_ResourcesEntry.decode(reader, reader.uint32());
1529
+ if (entry2.value !== undefined) {
1530
+ message.resources[entry2.key] = entry2.value;
1531
+ }
1532
+ continue;
1371
1533
  }
1372
- const entry2 = Requirements_ResourcesEntry.decode(reader, reader.uint32());
1373
- if (entry2.value !== undefined) {
1374
- message.resources[entry2.key] = entry2.value;
1534
+ case 3: {
1535
+ if (tag !== 26) {
1536
+ break;
1537
+ }
1538
+ const entry3 = Requirements_SchemasEntry.decode(reader, reader.uint32());
1539
+ if (entry3.value !== undefined) {
1540
+ message.schemas[entry3.key] = entry3.value;
1541
+ }
1542
+ continue;
1375
1543
  }
1376
- continue;
1377
1544
  }
1378
- case 3: {
1379
- if (tag !== 26) {
1380
- break;
1381
- }
1382
- const entry3 = Requirements_SchemasEntry.decode(reader, reader.uint32());
1383
- if (entry3.value !== undefined) {
1384
- message.schemas[entry3.key] = entry3.value;
1385
- }
1386
- continue;
1545
+ if ((tag & 7) === 4 || tag === 0) {
1546
+ break;
1387
1547
  }
1548
+ reader.skip(tag & 7);
1388
1549
  }
1389
- if ((tag & 7) === 4 || tag === 0) {
1390
- break;
1391
- }
1392
- reader.skip(tag & 7);
1550
+ return message;
1551
+ }
1552
+ finally {
1553
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
1393
1554
  }
1394
- return message;
1395
1555
  },
1396
1556
  fromJSON(object) {
1397
1557
  return {
1398
1558
  extraResources: isObject(object.extraResources)
1399
1559
  ? globalThis.Object.entries(object.extraResources).reduce((acc, [key, value]) => {
1400
- acc[key] = ResourceSelector.fromJSON(value);
1560
+ globalThis.Object.defineProperty(acc, key, {
1561
+ value: ResourceSelector.fromJSON(value),
1562
+ enumerable: true,
1563
+ configurable: true,
1564
+ writable: true,
1565
+ });
1401
1566
  return acc;
1402
1567
  }, {})
1403
1568
  : isObject(object.extra_resources)
1404
1569
  ? globalThis.Object.entries(object.extra_resources).reduce((acc, [key, value]) => {
1405
- acc[key] = ResourceSelector.fromJSON(value);
1570
+ globalThis.Object.defineProperty(acc, key, {
1571
+ value: ResourceSelector.fromJSON(value),
1572
+ enumerable: true,
1573
+ configurable: true,
1574
+ writable: true,
1575
+ });
1406
1576
  return acc;
1407
1577
  }, {})
1408
1578
  : {},
1409
1579
  resources: isObject(object.resources)
1410
1580
  ? globalThis.Object.entries(object.resources).reduce((acc, [key, value]) => {
1411
- acc[key] = ResourceSelector.fromJSON(value);
1581
+ globalThis.Object.defineProperty(acc, key, {
1582
+ value: ResourceSelector.fromJSON(value),
1583
+ enumerable: true,
1584
+ configurable: true,
1585
+ writable: true,
1586
+ });
1412
1587
  return acc;
1413
1588
  }, {})
1414
1589
  : {},
1415
1590
  schemas: isObject(object.schemas)
1416
1591
  ? globalThis.Object.entries(object.schemas).reduce((acc, [key, value]) => {
1417
- acc[key] = SchemaSelector.fromJSON(value);
1592
+ globalThis.Object.defineProperty(acc, key, {
1593
+ value: SchemaSelector.fromJSON(value),
1594
+ enumerable: true,
1595
+ configurable: true,
1596
+ writable: true,
1597
+ });
1418
1598
  return acc;
1419
1599
  }, {})
1420
1600
  : {},
@@ -1493,32 +1673,42 @@ export const Requirements_ExtraResourcesEntry = {
1493
1673
  },
1494
1674
  decode(input, length) {
1495
1675
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
1496
- const end = length === undefined ? reader.len : reader.pos + length;
1497
- const message = createBaseRequirements_ExtraResourcesEntry();
1498
- while (reader.pos < end) {
1499
- const tag = reader.uint32();
1500
- switch (tag >>> 3) {
1501
- case 1: {
1502
- if (tag !== 10) {
1503
- break;
1676
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
1677
+ if (previousRecursionDepth >= 100) {
1678
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
1679
+ }
1680
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
1681
+ try {
1682
+ const end = length === undefined ? reader.len : reader.pos + length;
1683
+ const message = createBaseRequirements_ExtraResourcesEntry();
1684
+ while (reader.pos < end) {
1685
+ const tag = reader.uint32();
1686
+ switch (tag >>> 3) {
1687
+ case 1: {
1688
+ if (tag !== 10) {
1689
+ break;
1690
+ }
1691
+ message.key = reader.string();
1692
+ continue;
1504
1693
  }
1505
- message.key = reader.string();
1506
- continue;
1507
- }
1508
- case 2: {
1509
- if (tag !== 18) {
1510
- break;
1694
+ case 2: {
1695
+ if (tag !== 18) {
1696
+ break;
1697
+ }
1698
+ message.value = ResourceSelector.decode(reader, reader.uint32());
1699
+ continue;
1511
1700
  }
1512
- message.value = ResourceSelector.decode(reader, reader.uint32());
1513
- continue;
1514
1701
  }
1702
+ if ((tag & 7) === 4 || tag === 0) {
1703
+ break;
1704
+ }
1705
+ reader.skip(tag & 7);
1515
1706
  }
1516
- if ((tag & 7) === 4 || tag === 0) {
1517
- break;
1518
- }
1519
- reader.skip(tag & 7);
1707
+ return message;
1708
+ }
1709
+ finally {
1710
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
1520
1711
  }
1521
- return message;
1522
1712
  },
1523
1713
  fromJSON(object) {
1524
1714
  return {
@@ -1563,32 +1753,42 @@ export const Requirements_ResourcesEntry = {
1563
1753
  },
1564
1754
  decode(input, length) {
1565
1755
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
1566
- const end = length === undefined ? reader.len : reader.pos + length;
1567
- const message = createBaseRequirements_ResourcesEntry();
1568
- while (reader.pos < end) {
1569
- const tag = reader.uint32();
1570
- switch (tag >>> 3) {
1571
- case 1: {
1572
- if (tag !== 10) {
1573
- break;
1756
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
1757
+ if (previousRecursionDepth >= 100) {
1758
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
1759
+ }
1760
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
1761
+ try {
1762
+ const end = length === undefined ? reader.len : reader.pos + length;
1763
+ const message = createBaseRequirements_ResourcesEntry();
1764
+ while (reader.pos < end) {
1765
+ const tag = reader.uint32();
1766
+ switch (tag >>> 3) {
1767
+ case 1: {
1768
+ if (tag !== 10) {
1769
+ break;
1770
+ }
1771
+ message.key = reader.string();
1772
+ continue;
1574
1773
  }
1575
- message.key = reader.string();
1576
- continue;
1577
- }
1578
- case 2: {
1579
- if (tag !== 18) {
1580
- break;
1774
+ case 2: {
1775
+ if (tag !== 18) {
1776
+ break;
1777
+ }
1778
+ message.value = ResourceSelector.decode(reader, reader.uint32());
1779
+ continue;
1581
1780
  }
1582
- message.value = ResourceSelector.decode(reader, reader.uint32());
1583
- continue;
1584
1781
  }
1782
+ if ((tag & 7) === 4 || tag === 0) {
1783
+ break;
1784
+ }
1785
+ reader.skip(tag & 7);
1585
1786
  }
1586
- if ((tag & 7) === 4 || tag === 0) {
1587
- break;
1588
- }
1589
- reader.skip(tag & 7);
1787
+ return message;
1788
+ }
1789
+ finally {
1790
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
1590
1791
  }
1591
- return message;
1592
1792
  },
1593
1793
  fromJSON(object) {
1594
1794
  return {
@@ -1633,32 +1833,42 @@ export const Requirements_SchemasEntry = {
1633
1833
  },
1634
1834
  decode(input, length) {
1635
1835
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
1636
- const end = length === undefined ? reader.len : reader.pos + length;
1637
- const message = createBaseRequirements_SchemasEntry();
1638
- while (reader.pos < end) {
1639
- const tag = reader.uint32();
1640
- switch (tag >>> 3) {
1641
- case 1: {
1642
- if (tag !== 10) {
1643
- break;
1836
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
1837
+ if (previousRecursionDepth >= 100) {
1838
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
1839
+ }
1840
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
1841
+ try {
1842
+ const end = length === undefined ? reader.len : reader.pos + length;
1843
+ const message = createBaseRequirements_SchemasEntry();
1844
+ while (reader.pos < end) {
1845
+ const tag = reader.uint32();
1846
+ switch (tag >>> 3) {
1847
+ case 1: {
1848
+ if (tag !== 10) {
1849
+ break;
1850
+ }
1851
+ message.key = reader.string();
1852
+ continue;
1644
1853
  }
1645
- message.key = reader.string();
1646
- continue;
1647
- }
1648
- case 2: {
1649
- if (tag !== 18) {
1650
- break;
1854
+ case 2: {
1855
+ if (tag !== 18) {
1856
+ break;
1857
+ }
1858
+ message.value = SchemaSelector.decode(reader, reader.uint32());
1859
+ continue;
1651
1860
  }
1652
- message.value = SchemaSelector.decode(reader, reader.uint32());
1653
- continue;
1654
1861
  }
1862
+ if ((tag & 7) === 4 || tag === 0) {
1863
+ break;
1864
+ }
1865
+ reader.skip(tag & 7);
1655
1866
  }
1656
- if ((tag & 7) === 4 || tag === 0) {
1657
- break;
1658
- }
1659
- reader.skip(tag & 7);
1867
+ return message;
1868
+ }
1869
+ finally {
1870
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
1660
1871
  }
1661
- return message;
1662
1872
  },
1663
1873
  fromJSON(object) {
1664
1874
  return {
@@ -1703,32 +1913,42 @@ export const SchemaSelector = {
1703
1913
  },
1704
1914
  decode(input, length) {
1705
1915
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
1706
- const end = length === undefined ? reader.len : reader.pos + length;
1707
- const message = createBaseSchemaSelector();
1708
- while (reader.pos < end) {
1709
- const tag = reader.uint32();
1710
- switch (tag >>> 3) {
1711
- case 1: {
1712
- if (tag !== 10) {
1713
- break;
1916
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
1917
+ if (previousRecursionDepth >= 100) {
1918
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
1919
+ }
1920
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
1921
+ try {
1922
+ const end = length === undefined ? reader.len : reader.pos + length;
1923
+ const message = createBaseSchemaSelector();
1924
+ while (reader.pos < end) {
1925
+ const tag = reader.uint32();
1926
+ switch (tag >>> 3) {
1927
+ case 1: {
1928
+ if (tag !== 10) {
1929
+ break;
1930
+ }
1931
+ message.apiVersion = reader.string();
1932
+ continue;
1714
1933
  }
1715
- message.apiVersion = reader.string();
1716
- continue;
1717
- }
1718
- case 2: {
1719
- if (tag !== 18) {
1720
- break;
1934
+ case 2: {
1935
+ if (tag !== 18) {
1936
+ break;
1937
+ }
1938
+ message.kind = reader.string();
1939
+ continue;
1721
1940
  }
1722
- message.kind = reader.string();
1723
- continue;
1724
1941
  }
1942
+ if ((tag & 7) === 4 || tag === 0) {
1943
+ break;
1944
+ }
1945
+ reader.skip(tag & 7);
1725
1946
  }
1726
- if ((tag & 7) === 4 || tag === 0) {
1727
- break;
1728
- }
1729
- reader.skip(tag & 7);
1947
+ return message;
1948
+ }
1949
+ finally {
1950
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
1730
1951
  }
1731
- return message;
1732
1952
  },
1733
1953
  fromJSON(object) {
1734
1954
  return {
@@ -1772,25 +1992,35 @@ export const Schema = {
1772
1992
  },
1773
1993
  decode(input, length) {
1774
1994
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
1775
- const end = length === undefined ? reader.len : reader.pos + length;
1776
- const message = createBaseSchema();
1777
- while (reader.pos < end) {
1778
- const tag = reader.uint32();
1779
- switch (tag >>> 3) {
1780
- case 1: {
1781
- if (tag !== 10) {
1782
- break;
1995
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
1996
+ if (previousRecursionDepth >= 100) {
1997
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
1998
+ }
1999
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
2000
+ try {
2001
+ const end = length === undefined ? reader.len : reader.pos + length;
2002
+ const message = createBaseSchema();
2003
+ while (reader.pos < end) {
2004
+ const tag = reader.uint32();
2005
+ switch (tag >>> 3) {
2006
+ case 1: {
2007
+ if (tag !== 10) {
2008
+ break;
2009
+ }
2010
+ message.openapiV3 = Struct.unwrap(Struct.decode(reader, reader.uint32()));
2011
+ continue;
1783
2012
  }
1784
- message.openapiV3 = Struct.unwrap(Struct.decode(reader, reader.uint32()));
1785
- continue;
1786
2013
  }
2014
+ if ((tag & 7) === 4 || tag === 0) {
2015
+ break;
2016
+ }
2017
+ reader.skip(tag & 7);
1787
2018
  }
1788
- if ((tag & 7) === 4 || tag === 0) {
1789
- break;
1790
- }
1791
- reader.skip(tag & 7);
2019
+ return message;
2020
+ }
2021
+ finally {
2022
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
1792
2023
  }
1793
- return message;
1794
2024
  },
1795
2025
  fromJSON(object) {
1796
2026
  return {
@@ -1841,53 +2071,63 @@ export const ResourceSelector = {
1841
2071
  },
1842
2072
  decode(input, length) {
1843
2073
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
1844
- const end = length === undefined ? reader.len : reader.pos + length;
1845
- const message = createBaseResourceSelector();
1846
- while (reader.pos < end) {
1847
- const tag = reader.uint32();
1848
- switch (tag >>> 3) {
1849
- case 1: {
1850
- if (tag !== 10) {
1851
- break;
2074
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
2075
+ if (previousRecursionDepth >= 100) {
2076
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
2077
+ }
2078
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
2079
+ try {
2080
+ const end = length === undefined ? reader.len : reader.pos + length;
2081
+ const message = createBaseResourceSelector();
2082
+ while (reader.pos < end) {
2083
+ const tag = reader.uint32();
2084
+ switch (tag >>> 3) {
2085
+ case 1: {
2086
+ if (tag !== 10) {
2087
+ break;
2088
+ }
2089
+ message.apiVersion = reader.string();
2090
+ continue;
1852
2091
  }
1853
- message.apiVersion = reader.string();
1854
- continue;
1855
- }
1856
- case 2: {
1857
- if (tag !== 18) {
1858
- break;
2092
+ case 2: {
2093
+ if (tag !== 18) {
2094
+ break;
2095
+ }
2096
+ message.kind = reader.string();
2097
+ continue;
1859
2098
  }
1860
- message.kind = reader.string();
1861
- continue;
1862
- }
1863
- case 3: {
1864
- if (tag !== 26) {
1865
- break;
2099
+ case 3: {
2100
+ if (tag !== 26) {
2101
+ break;
2102
+ }
2103
+ message.matchName = reader.string();
2104
+ continue;
1866
2105
  }
1867
- message.matchName = reader.string();
1868
- continue;
1869
- }
1870
- case 4: {
1871
- if (tag !== 34) {
1872
- break;
2106
+ case 4: {
2107
+ if (tag !== 34) {
2108
+ break;
2109
+ }
2110
+ message.matchLabels = MatchLabels.decode(reader, reader.uint32());
2111
+ continue;
1873
2112
  }
1874
- message.matchLabels = MatchLabels.decode(reader, reader.uint32());
1875
- continue;
1876
- }
1877
- case 5: {
1878
- if (tag !== 42) {
1879
- break;
2113
+ case 5: {
2114
+ if (tag !== 42) {
2115
+ break;
2116
+ }
2117
+ message.namespace = reader.string();
2118
+ continue;
1880
2119
  }
1881
- message.namespace = reader.string();
1882
- continue;
1883
2120
  }
2121
+ if ((tag & 7) === 4 || tag === 0) {
2122
+ break;
2123
+ }
2124
+ reader.skip(tag & 7);
1884
2125
  }
1885
- if ((tag & 7) === 4 || tag === 0) {
1886
- break;
1887
- }
1888
- reader.skip(tag & 7);
2126
+ return message;
2127
+ }
2128
+ finally {
2129
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
1889
2130
  }
1890
- return message;
1891
2131
  },
1892
2132
  fromJSON(object) {
1893
2133
  return {
@@ -1956,34 +2196,49 @@ export const MatchLabels = {
1956
2196
  },
1957
2197
  decode(input, length) {
1958
2198
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
1959
- const end = length === undefined ? reader.len : reader.pos + length;
1960
- const message = createBaseMatchLabels();
1961
- while (reader.pos < end) {
1962
- const tag = reader.uint32();
1963
- switch (tag >>> 3) {
1964
- case 1: {
1965
- if (tag !== 10) {
1966
- break;
1967
- }
1968
- const entry1 = MatchLabels_LabelsEntry.decode(reader, reader.uint32());
1969
- if (entry1.value !== undefined) {
1970
- message.labels[entry1.key] = entry1.value;
2199
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
2200
+ if (previousRecursionDepth >= 100) {
2201
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
2202
+ }
2203
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
2204
+ try {
2205
+ const end = length === undefined ? reader.len : reader.pos + length;
2206
+ const message = createBaseMatchLabels();
2207
+ while (reader.pos < end) {
2208
+ const tag = reader.uint32();
2209
+ switch (tag >>> 3) {
2210
+ case 1: {
2211
+ if (tag !== 10) {
2212
+ break;
2213
+ }
2214
+ const entry1 = MatchLabels_LabelsEntry.decode(reader, reader.uint32());
2215
+ if (entry1.value !== undefined) {
2216
+ message.labels[entry1.key] = entry1.value;
2217
+ }
2218
+ continue;
1971
2219
  }
1972
- continue;
1973
2220
  }
2221
+ if ((tag & 7) === 4 || tag === 0) {
2222
+ break;
2223
+ }
2224
+ reader.skip(tag & 7);
1974
2225
  }
1975
- if ((tag & 7) === 4 || tag === 0) {
1976
- break;
1977
- }
1978
- reader.skip(tag & 7);
2226
+ return message;
2227
+ }
2228
+ finally {
2229
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
1979
2230
  }
1980
- return message;
1981
2231
  },
1982
2232
  fromJSON(object) {
1983
2233
  return {
1984
2234
  labels: isObject(object.labels)
1985
2235
  ? globalThis.Object.entries(object.labels).reduce((acc, [key, value]) => {
1986
- acc[key] = globalThis.String(value);
2236
+ globalThis.Object.defineProperty(acc, key, {
2237
+ value: globalThis.String(value),
2238
+ enumerable: true,
2239
+ configurable: true,
2240
+ writable: true,
2241
+ });
1987
2242
  return acc;
1988
2243
  }, {})
1989
2244
  : {},
@@ -2031,32 +2286,42 @@ export const MatchLabels_LabelsEntry = {
2031
2286
  },
2032
2287
  decode(input, length) {
2033
2288
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
2034
- const end = length === undefined ? reader.len : reader.pos + length;
2035
- const message = createBaseMatchLabels_LabelsEntry();
2036
- while (reader.pos < end) {
2037
- const tag = reader.uint32();
2038
- switch (tag >>> 3) {
2039
- case 1: {
2040
- if (tag !== 10) {
2041
- break;
2289
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
2290
+ if (previousRecursionDepth >= 100) {
2291
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
2292
+ }
2293
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
2294
+ try {
2295
+ const end = length === undefined ? reader.len : reader.pos + length;
2296
+ const message = createBaseMatchLabels_LabelsEntry();
2297
+ while (reader.pos < end) {
2298
+ const tag = reader.uint32();
2299
+ switch (tag >>> 3) {
2300
+ case 1: {
2301
+ if (tag !== 10) {
2302
+ break;
2303
+ }
2304
+ message.key = reader.string();
2305
+ continue;
2042
2306
  }
2043
- message.key = reader.string();
2044
- continue;
2045
- }
2046
- case 2: {
2047
- if (tag !== 18) {
2048
- break;
2307
+ case 2: {
2308
+ if (tag !== 18) {
2309
+ break;
2310
+ }
2311
+ message.value = reader.string();
2312
+ continue;
2049
2313
  }
2050
- message.value = reader.string();
2051
- continue;
2052
2314
  }
2315
+ if ((tag & 7) === 4 || tag === 0) {
2316
+ break;
2317
+ }
2318
+ reader.skip(tag & 7);
2053
2319
  }
2054
- if ((tag & 7) === 4 || tag === 0) {
2055
- break;
2056
- }
2057
- reader.skip(tag & 7);
2320
+ return message;
2321
+ }
2322
+ finally {
2323
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
2058
2324
  }
2059
- return message;
2060
2325
  },
2061
2326
  fromJSON(object) {
2062
2327
  return {
@@ -2099,32 +2364,42 @@ export const ResponseMeta = {
2099
2364
  },
2100
2365
  decode(input, length) {
2101
2366
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
2102
- const end = length === undefined ? reader.len : reader.pos + length;
2103
- const message = createBaseResponseMeta();
2104
- while (reader.pos < end) {
2105
- const tag = reader.uint32();
2106
- switch (tag >>> 3) {
2107
- case 1: {
2108
- if (tag !== 10) {
2109
- break;
2367
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
2368
+ if (previousRecursionDepth >= 100) {
2369
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
2370
+ }
2371
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
2372
+ try {
2373
+ const end = length === undefined ? reader.len : reader.pos + length;
2374
+ const message = createBaseResponseMeta();
2375
+ while (reader.pos < end) {
2376
+ const tag = reader.uint32();
2377
+ switch (tag >>> 3) {
2378
+ case 1: {
2379
+ if (tag !== 10) {
2380
+ break;
2381
+ }
2382
+ message.tag = reader.string();
2383
+ continue;
2110
2384
  }
2111
- message.tag = reader.string();
2112
- continue;
2113
- }
2114
- case 2: {
2115
- if (tag !== 18) {
2116
- break;
2385
+ case 2: {
2386
+ if (tag !== 18) {
2387
+ break;
2388
+ }
2389
+ message.ttl = Duration.decode(reader, reader.uint32());
2390
+ continue;
2117
2391
  }
2118
- message.ttl = Duration.decode(reader, reader.uint32());
2119
- continue;
2120
2392
  }
2393
+ if ((tag & 7) === 4 || tag === 0) {
2394
+ break;
2395
+ }
2396
+ reader.skip(tag & 7);
2121
2397
  }
2122
- if ((tag & 7) === 4 || tag === 0) {
2123
- break;
2124
- }
2125
- reader.skip(tag & 7);
2398
+ return message;
2399
+ }
2400
+ finally {
2401
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
2126
2402
  }
2127
- return message;
2128
2403
  },
2129
2404
  fromJSON(object) {
2130
2405
  return {
@@ -2167,42 +2442,57 @@ export const State = {
2167
2442
  },
2168
2443
  decode(input, length) {
2169
2444
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
2170
- const end = length === undefined ? reader.len : reader.pos + length;
2171
- const message = createBaseState();
2172
- while (reader.pos < end) {
2173
- const tag = reader.uint32();
2174
- switch (tag >>> 3) {
2175
- case 1: {
2176
- if (tag !== 10) {
2177
- break;
2178
- }
2179
- message.composite = Resource.decode(reader, reader.uint32());
2180
- continue;
2181
- }
2182
- case 2: {
2183
- if (tag !== 18) {
2184
- break;
2445
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
2446
+ if (previousRecursionDepth >= 100) {
2447
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
2448
+ }
2449
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
2450
+ try {
2451
+ const end = length === undefined ? reader.len : reader.pos + length;
2452
+ const message = createBaseState();
2453
+ while (reader.pos < end) {
2454
+ const tag = reader.uint32();
2455
+ switch (tag >>> 3) {
2456
+ case 1: {
2457
+ if (tag !== 10) {
2458
+ break;
2459
+ }
2460
+ message.composite = Resource.decode(reader, reader.uint32());
2461
+ continue;
2185
2462
  }
2186
- const entry2 = State_ResourcesEntry.decode(reader, reader.uint32());
2187
- if (entry2.value !== undefined) {
2188
- message.resources[entry2.key] = entry2.value;
2463
+ case 2: {
2464
+ if (tag !== 18) {
2465
+ break;
2466
+ }
2467
+ const entry2 = State_ResourcesEntry.decode(reader, reader.uint32());
2468
+ if (entry2.value !== undefined) {
2469
+ message.resources[entry2.key] = entry2.value;
2470
+ }
2471
+ continue;
2189
2472
  }
2190
- continue;
2191
2473
  }
2474
+ if ((tag & 7) === 4 || tag === 0) {
2475
+ break;
2476
+ }
2477
+ reader.skip(tag & 7);
2192
2478
  }
2193
- if ((tag & 7) === 4 || tag === 0) {
2194
- break;
2195
- }
2196
- reader.skip(tag & 7);
2479
+ return message;
2480
+ }
2481
+ finally {
2482
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
2197
2483
  }
2198
- return message;
2199
2484
  },
2200
2485
  fromJSON(object) {
2201
2486
  return {
2202
2487
  composite: isSet(object.composite) ? Resource.fromJSON(object.composite) : undefined,
2203
2488
  resources: isObject(object.resources)
2204
2489
  ? globalThis.Object.entries(object.resources).reduce((acc, [key, value]) => {
2205
- acc[key] = Resource.fromJSON(value);
2490
+ globalThis.Object.defineProperty(acc, key, {
2491
+ value: Resource.fromJSON(value),
2492
+ enumerable: true,
2493
+ configurable: true,
2494
+ writable: true,
2495
+ });
2206
2496
  return acc;
2207
2497
  }, {})
2208
2498
  : {},
@@ -2256,32 +2546,42 @@ export const State_ResourcesEntry = {
2256
2546
  },
2257
2547
  decode(input, length) {
2258
2548
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
2259
- const end = length === undefined ? reader.len : reader.pos + length;
2260
- const message = createBaseState_ResourcesEntry();
2261
- while (reader.pos < end) {
2262
- const tag = reader.uint32();
2263
- switch (tag >>> 3) {
2264
- case 1: {
2265
- if (tag !== 10) {
2266
- break;
2549
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
2550
+ if (previousRecursionDepth >= 100) {
2551
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
2552
+ }
2553
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
2554
+ try {
2555
+ const end = length === undefined ? reader.len : reader.pos + length;
2556
+ const message = createBaseState_ResourcesEntry();
2557
+ while (reader.pos < end) {
2558
+ const tag = reader.uint32();
2559
+ switch (tag >>> 3) {
2560
+ case 1: {
2561
+ if (tag !== 10) {
2562
+ break;
2563
+ }
2564
+ message.key = reader.string();
2565
+ continue;
2267
2566
  }
2268
- message.key = reader.string();
2269
- continue;
2270
- }
2271
- case 2: {
2272
- if (tag !== 18) {
2273
- break;
2567
+ case 2: {
2568
+ if (tag !== 18) {
2569
+ break;
2570
+ }
2571
+ message.value = Resource.decode(reader, reader.uint32());
2572
+ continue;
2274
2573
  }
2275
- message.value = Resource.decode(reader, reader.uint32());
2276
- continue;
2277
2574
  }
2575
+ if ((tag & 7) === 4 || tag === 0) {
2576
+ break;
2577
+ }
2578
+ reader.skip(tag & 7);
2278
2579
  }
2279
- if ((tag & 7) === 4 || tag === 0) {
2280
- break;
2281
- }
2282
- reader.skip(tag & 7);
2580
+ return message;
2581
+ }
2582
+ finally {
2583
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
2283
2584
  }
2284
- return message;
2285
2585
  },
2286
2586
  fromJSON(object) {
2287
2587
  return {
@@ -2329,54 +2629,74 @@ export const Resource = {
2329
2629
  },
2330
2630
  decode(input, length) {
2331
2631
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
2332
- const end = length === undefined ? reader.len : reader.pos + length;
2333
- const message = createBaseResource();
2334
- while (reader.pos < end) {
2335
- const tag = reader.uint32();
2336
- switch (tag >>> 3) {
2337
- case 1: {
2338
- if (tag !== 10) {
2339
- break;
2632
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
2633
+ if (previousRecursionDepth >= 100) {
2634
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
2635
+ }
2636
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
2637
+ try {
2638
+ const end = length === undefined ? reader.len : reader.pos + length;
2639
+ const message = createBaseResource();
2640
+ while (reader.pos < end) {
2641
+ const tag = reader.uint32();
2642
+ switch (tag >>> 3) {
2643
+ case 1: {
2644
+ if (tag !== 10) {
2645
+ break;
2646
+ }
2647
+ message.resource = Struct.unwrap(Struct.decode(reader, reader.uint32()));
2648
+ continue;
2340
2649
  }
2341
- message.resource = Struct.unwrap(Struct.decode(reader, reader.uint32()));
2342
- continue;
2343
- }
2344
- case 2: {
2345
- if (tag !== 18) {
2346
- break;
2650
+ case 2: {
2651
+ if (tag !== 18) {
2652
+ break;
2653
+ }
2654
+ const entry2 = Resource_ConnectionDetailsEntry.decode(reader, reader.uint32());
2655
+ if (entry2.value !== undefined) {
2656
+ message.connectionDetails[entry2.key] = entry2.value;
2657
+ }
2658
+ continue;
2347
2659
  }
2348
- const entry2 = Resource_ConnectionDetailsEntry.decode(reader, reader.uint32());
2349
- if (entry2.value !== undefined) {
2350
- message.connectionDetails[entry2.key] = entry2.value;
2660
+ case 3: {
2661
+ if (tag !== 24) {
2662
+ break;
2663
+ }
2664
+ message.ready = reader.int32();
2665
+ continue;
2351
2666
  }
2352
- continue;
2353
2667
  }
2354
- case 3: {
2355
- if (tag !== 24) {
2356
- break;
2357
- }
2358
- message.ready = reader.int32();
2359
- continue;
2668
+ if ((tag & 7) === 4 || tag === 0) {
2669
+ break;
2360
2670
  }
2671
+ reader.skip(tag & 7);
2361
2672
  }
2362
- if ((tag & 7) === 4 || tag === 0) {
2363
- break;
2364
- }
2365
- reader.skip(tag & 7);
2673
+ return message;
2674
+ }
2675
+ finally {
2676
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
2366
2677
  }
2367
- return message;
2368
2678
  },
2369
2679
  fromJSON(object) {
2370
2680
  return {
2371
2681
  resource: isObject(object.resource) ? object.resource : undefined,
2372
2682
  connectionDetails: isObject(object.connectionDetails)
2373
2683
  ? globalThis.Object.entries(object.connectionDetails).reduce((acc, [key, value]) => {
2374
- acc[key] = Buffer.from(bytesFromBase64(value));
2684
+ globalThis.Object.defineProperty(acc, key, {
2685
+ value: Buffer.from(bytesFromBase64(value)),
2686
+ enumerable: true,
2687
+ configurable: true,
2688
+ writable: true,
2689
+ });
2375
2690
  return acc;
2376
2691
  }, {})
2377
2692
  : isObject(object.connection_details)
2378
2693
  ? globalThis.Object.entries(object.connection_details).reduce((acc, [key, value]) => {
2379
- acc[key] = Buffer.from(bytesFromBase64(value));
2694
+ globalThis.Object.defineProperty(acc, key, {
2695
+ value: Buffer.from(bytesFromBase64(value)),
2696
+ enumerable: true,
2697
+ configurable: true,
2698
+ writable: true,
2699
+ });
2380
2700
  return acc;
2381
2701
  }, {})
2382
2702
  : {},
@@ -2434,32 +2754,42 @@ export const Resource_ConnectionDetailsEntry = {
2434
2754
  },
2435
2755
  decode(input, length) {
2436
2756
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
2437
- const end = length === undefined ? reader.len : reader.pos + length;
2438
- const message = createBaseResource_ConnectionDetailsEntry();
2439
- while (reader.pos < end) {
2440
- const tag = reader.uint32();
2441
- switch (tag >>> 3) {
2442
- case 1: {
2443
- if (tag !== 10) {
2444
- break;
2757
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
2758
+ if (previousRecursionDepth >= 100) {
2759
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
2760
+ }
2761
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
2762
+ try {
2763
+ const end = length === undefined ? reader.len : reader.pos + length;
2764
+ const message = createBaseResource_ConnectionDetailsEntry();
2765
+ while (reader.pos < end) {
2766
+ const tag = reader.uint32();
2767
+ switch (tag >>> 3) {
2768
+ case 1: {
2769
+ if (tag !== 10) {
2770
+ break;
2771
+ }
2772
+ message.key = reader.string();
2773
+ continue;
2445
2774
  }
2446
- message.key = reader.string();
2447
- continue;
2448
- }
2449
- case 2: {
2450
- if (tag !== 18) {
2451
- break;
2775
+ case 2: {
2776
+ if (tag !== 18) {
2777
+ break;
2778
+ }
2779
+ message.value = Buffer.from(reader.bytes());
2780
+ continue;
2452
2781
  }
2453
- message.value = Buffer.from(reader.bytes());
2454
- continue;
2455
2782
  }
2783
+ if ((tag & 7) === 4 || tag === 0) {
2784
+ break;
2785
+ }
2786
+ reader.skip(tag & 7);
2456
2787
  }
2457
- if ((tag & 7) === 4 || tag === 0) {
2458
- break;
2459
- }
2460
- reader.skip(tag & 7);
2788
+ return message;
2789
+ }
2790
+ finally {
2791
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
2461
2792
  }
2462
- return message;
2463
2793
  },
2464
2794
  fromJSON(object) {
2465
2795
  return {
@@ -2508,46 +2838,56 @@ export const Result = {
2508
2838
  },
2509
2839
  decode(input, length) {
2510
2840
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
2511
- const end = length === undefined ? reader.len : reader.pos + length;
2512
- const message = createBaseResult();
2513
- while (reader.pos < end) {
2514
- const tag = reader.uint32();
2515
- switch (tag >>> 3) {
2516
- case 1: {
2517
- if (tag !== 8) {
2518
- break;
2841
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
2842
+ if (previousRecursionDepth >= 100) {
2843
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
2844
+ }
2845
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
2846
+ try {
2847
+ const end = length === undefined ? reader.len : reader.pos + length;
2848
+ const message = createBaseResult();
2849
+ while (reader.pos < end) {
2850
+ const tag = reader.uint32();
2851
+ switch (tag >>> 3) {
2852
+ case 1: {
2853
+ if (tag !== 8) {
2854
+ break;
2855
+ }
2856
+ message.severity = reader.int32();
2857
+ continue;
2519
2858
  }
2520
- message.severity = reader.int32();
2521
- continue;
2522
- }
2523
- case 2: {
2524
- if (tag !== 18) {
2525
- break;
2859
+ case 2: {
2860
+ if (tag !== 18) {
2861
+ break;
2862
+ }
2863
+ message.message = reader.string();
2864
+ continue;
2526
2865
  }
2527
- message.message = reader.string();
2528
- continue;
2529
- }
2530
- case 3: {
2531
- if (tag !== 26) {
2532
- break;
2866
+ case 3: {
2867
+ if (tag !== 26) {
2868
+ break;
2869
+ }
2870
+ message.reason = reader.string();
2871
+ continue;
2533
2872
  }
2534
- message.reason = reader.string();
2535
- continue;
2536
- }
2537
- case 4: {
2538
- if (tag !== 32) {
2539
- break;
2873
+ case 4: {
2874
+ if (tag !== 32) {
2875
+ break;
2876
+ }
2877
+ message.target = reader.int32();
2878
+ continue;
2540
2879
  }
2541
- message.target = reader.int32();
2542
- continue;
2543
2880
  }
2881
+ if ((tag & 7) === 4 || tag === 0) {
2882
+ break;
2883
+ }
2884
+ reader.skip(tag & 7);
2544
2885
  }
2545
- if ((tag & 7) === 4 || tag === 0) {
2546
- break;
2547
- }
2548
- reader.skip(tag & 7);
2886
+ return message;
2887
+ }
2888
+ finally {
2889
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
2549
2890
  }
2550
- return message;
2551
2891
  },
2552
2892
  fromJSON(object) {
2553
2893
  return {
@@ -2609,53 +2949,63 @@ export const Condition = {
2609
2949
  },
2610
2950
  decode(input, length) {
2611
2951
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
2612
- const end = length === undefined ? reader.len : reader.pos + length;
2613
- const message = createBaseCondition();
2614
- while (reader.pos < end) {
2615
- const tag = reader.uint32();
2616
- switch (tag >>> 3) {
2617
- case 1: {
2618
- if (tag !== 10) {
2619
- break;
2952
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
2953
+ if (previousRecursionDepth >= 100) {
2954
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
2955
+ }
2956
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
2957
+ try {
2958
+ const end = length === undefined ? reader.len : reader.pos + length;
2959
+ const message = createBaseCondition();
2960
+ while (reader.pos < end) {
2961
+ const tag = reader.uint32();
2962
+ switch (tag >>> 3) {
2963
+ case 1: {
2964
+ if (tag !== 10) {
2965
+ break;
2966
+ }
2967
+ message.type = reader.string();
2968
+ continue;
2620
2969
  }
2621
- message.type = reader.string();
2622
- continue;
2623
- }
2624
- case 2: {
2625
- if (tag !== 16) {
2626
- break;
2970
+ case 2: {
2971
+ if (tag !== 16) {
2972
+ break;
2973
+ }
2974
+ message.status = reader.int32();
2975
+ continue;
2627
2976
  }
2628
- message.status = reader.int32();
2629
- continue;
2630
- }
2631
- case 3: {
2632
- if (tag !== 26) {
2633
- break;
2977
+ case 3: {
2978
+ if (tag !== 26) {
2979
+ break;
2980
+ }
2981
+ message.reason = reader.string();
2982
+ continue;
2634
2983
  }
2635
- message.reason = reader.string();
2636
- continue;
2637
- }
2638
- case 4: {
2639
- if (tag !== 34) {
2640
- break;
2984
+ case 4: {
2985
+ if (tag !== 34) {
2986
+ break;
2987
+ }
2988
+ message.message = reader.string();
2989
+ continue;
2641
2990
  }
2642
- message.message = reader.string();
2643
- continue;
2644
- }
2645
- case 5: {
2646
- if (tag !== 40) {
2647
- break;
2991
+ case 5: {
2992
+ if (tag !== 40) {
2993
+ break;
2994
+ }
2995
+ message.target = reader.int32();
2996
+ continue;
2648
2997
  }
2649
- message.target = reader.int32();
2650
- continue;
2651
2998
  }
2999
+ if ((tag & 7) === 4 || tag === 0) {
3000
+ break;
3001
+ }
3002
+ reader.skip(tag & 7);
2652
3003
  }
2653
- if ((tag & 7) === 4 || tag === 0) {
2654
- break;
2655
- }
2656
- reader.skip(tag & 7);
3004
+ return message;
3005
+ }
3006
+ finally {
3007
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
2657
3008
  }
2658
- return message;
2659
3009
  },
2660
3010
  fromJSON(object) {
2661
3011
  return {