@alienplatform/sdk 3.3.14 → 3.3.16

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.
@@ -28964,24 +28964,31 @@ const Timestamp = {
28964
28964
  },
28965
28965
  decode(input, length) {
28966
28966
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
28967
- const end = length === void 0 ? reader.len : reader.pos + length;
28968
- const message = createBaseTimestamp();
28969
- while (reader.pos < end) {
28970
- const tag = reader.uint32();
28971
- switch (tag >>> 3) {
28972
- case 1:
28973
- if (tag !== 8) break;
28974
- message.seconds = longToNumber$2(reader.int64());
28975
- continue;
28976
- case 2:
28977
- if (tag !== 16) break;
28978
- message.nanos = reader.int32();
28979
- continue;
28967
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
28968
+ if (previousRecursionDepth >= 100) throw new globalThis.Error("protobuf decode recursion limit exceeded");
28969
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
28970
+ try {
28971
+ const end = length === void 0 ? reader.len : reader.pos + length;
28972
+ const message = createBaseTimestamp();
28973
+ while (reader.pos < end) {
28974
+ const tag = reader.uint32();
28975
+ switch (tag >>> 3) {
28976
+ case 1:
28977
+ if (tag !== 8) break;
28978
+ message.seconds = longToNumber$2(reader.int64());
28979
+ continue;
28980
+ case 2:
28981
+ if (tag !== 16) break;
28982
+ message.nanos = reader.int32();
28983
+ continue;
28984
+ }
28985
+ if ((tag & 7) === 4 || tag === 0) break;
28986
+ reader.skip(tag & 7);
28980
28987
  }
28981
- if ((tag & 7) === 4 || tag === 0) break;
28982
- reader.skip(tag & 7);
28988
+ return message;
28989
+ } finally {
28990
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
28983
28991
  }
28984
- return message;
28985
28992
  },
28986
28993
  fromJSON(object) {
28987
28994
  return {
@@ -29026,20 +29033,27 @@ const RegisterHttpServerRequest = {
29026
29033
  },
29027
29034
  decode(input, length) {
29028
29035
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
29029
- const end = length === void 0 ? reader.len : reader.pos + length;
29030
- const message = createBaseRegisterHttpServerRequest();
29031
- while (reader.pos < end) {
29032
- const tag = reader.uint32();
29033
- switch (tag >>> 3) {
29034
- case 1:
29035
- if (tag !== 8) break;
29036
- message.port = reader.uint32();
29037
- continue;
29036
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
29037
+ if (previousRecursionDepth >= 100) throw new globalThis.Error("protobuf decode recursion limit exceeded");
29038
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
29039
+ try {
29040
+ const end = length === void 0 ? reader.len : reader.pos + length;
29041
+ const message = createBaseRegisterHttpServerRequest();
29042
+ while (reader.pos < end) {
29043
+ const tag = reader.uint32();
29044
+ switch (tag >>> 3) {
29045
+ case 1:
29046
+ if (tag !== 8) break;
29047
+ message.port = reader.uint32();
29048
+ continue;
29049
+ }
29050
+ if ((tag & 7) === 4 || tag === 0) break;
29051
+ reader.skip(tag & 7);
29038
29052
  }
29039
- if ((tag & 7) === 4 || tag === 0) break;
29040
- reader.skip(tag & 7);
29053
+ return message;
29054
+ } finally {
29055
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
29041
29056
  }
29042
- return message;
29043
29057
  },
29044
29058
  fromJSON(object) {
29045
29059
  return { port: isSet$2(object.port) ? globalThis.Number(object.port) : 0 };
@@ -29068,20 +29082,27 @@ const RegisterHttpServerResponse = {
29068
29082
  },
29069
29083
  decode(input, length) {
29070
29084
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
29071
- const end = length === void 0 ? reader.len : reader.pos + length;
29072
- const message = createBaseRegisterHttpServerResponse();
29073
- while (reader.pos < end) {
29074
- const tag = reader.uint32();
29075
- switch (tag >>> 3) {
29076
- case 1:
29077
- if (tag !== 8) break;
29078
- message.success = reader.bool();
29079
- continue;
29085
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
29086
+ if (previousRecursionDepth >= 100) throw new globalThis.Error("protobuf decode recursion limit exceeded");
29087
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
29088
+ try {
29089
+ const end = length === void 0 ? reader.len : reader.pos + length;
29090
+ const message = createBaseRegisterHttpServerResponse();
29091
+ while (reader.pos < end) {
29092
+ const tag = reader.uint32();
29093
+ switch (tag >>> 3) {
29094
+ case 1:
29095
+ if (tag !== 8) break;
29096
+ message.success = reader.bool();
29097
+ continue;
29098
+ }
29099
+ if ((tag & 7) === 4 || tag === 0) break;
29100
+ reader.skip(tag & 7);
29080
29101
  }
29081
- if ((tag & 7) === 4 || tag === 0) break;
29082
- reader.skip(tag & 7);
29102
+ return message;
29103
+ } finally {
29104
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
29083
29105
  }
29084
- return message;
29085
29106
  },
29086
29107
  fromJSON(object) {
29087
29108
  return { success: isSet$2(object.success) ? globalThis.Boolean(object.success) : false };
@@ -29114,24 +29135,31 @@ const RegisterEventHandlerRequest = {
29114
29135
  },
29115
29136
  decode(input, length) {
29116
29137
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
29117
- const end = length === void 0 ? reader.len : reader.pos + length;
29118
- const message = createBaseRegisterEventHandlerRequest();
29119
- while (reader.pos < end) {
29120
- const tag = reader.uint32();
29121
- switch (tag >>> 3) {
29122
- case 1:
29123
- if (tag !== 10) break;
29124
- message.handlerType = reader.string();
29125
- continue;
29126
- case 2:
29127
- if (tag !== 18) break;
29128
- message.resourceName = reader.string();
29129
- continue;
29138
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
29139
+ if (previousRecursionDepth >= 100) throw new globalThis.Error("protobuf decode recursion limit exceeded");
29140
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
29141
+ try {
29142
+ const end = length === void 0 ? reader.len : reader.pos + length;
29143
+ const message = createBaseRegisterEventHandlerRequest();
29144
+ while (reader.pos < end) {
29145
+ const tag = reader.uint32();
29146
+ switch (tag >>> 3) {
29147
+ case 1:
29148
+ if (tag !== 10) break;
29149
+ message.handlerType = reader.string();
29150
+ continue;
29151
+ case 2:
29152
+ if (tag !== 18) break;
29153
+ message.resourceName = reader.string();
29154
+ continue;
29155
+ }
29156
+ if ((tag & 7) === 4 || tag === 0) break;
29157
+ reader.skip(tag & 7);
29130
29158
  }
29131
- if ((tag & 7) === 4 || tag === 0) break;
29132
- reader.skip(tag & 7);
29159
+ return message;
29160
+ } finally {
29161
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
29133
29162
  }
29134
- return message;
29135
29163
  },
29136
29164
  fromJSON(object) {
29137
29165
  return {
@@ -29165,20 +29193,27 @@ const RegisterEventHandlerResponse = {
29165
29193
  },
29166
29194
  decode(input, length) {
29167
29195
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
29168
- const end = length === void 0 ? reader.len : reader.pos + length;
29169
- const message = createBaseRegisterEventHandlerResponse();
29170
- while (reader.pos < end) {
29171
- const tag = reader.uint32();
29172
- switch (tag >>> 3) {
29173
- case 1:
29174
- if (tag !== 8) break;
29175
- message.success = reader.bool();
29176
- continue;
29196
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
29197
+ if (previousRecursionDepth >= 100) throw new globalThis.Error("protobuf decode recursion limit exceeded");
29198
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
29199
+ try {
29200
+ const end = length === void 0 ? reader.len : reader.pos + length;
29201
+ const message = createBaseRegisterEventHandlerResponse();
29202
+ while (reader.pos < end) {
29203
+ const tag = reader.uint32();
29204
+ switch (tag >>> 3) {
29205
+ case 1:
29206
+ if (tag !== 8) break;
29207
+ message.success = reader.bool();
29208
+ continue;
29209
+ }
29210
+ if ((tag & 7) === 4 || tag === 0) break;
29211
+ reader.skip(tag & 7);
29177
29212
  }
29178
- if ((tag & 7) === 4 || tag === 0) break;
29179
- reader.skip(tag & 7);
29213
+ return message;
29214
+ } finally {
29215
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
29180
29216
  }
29181
- return message;
29182
29217
  },
29183
29218
  fromJSON(object) {
29184
29219
  return { success: isSet$2(object.success) ? globalThis.Boolean(object.success) : false };
@@ -29207,20 +29242,27 @@ const WaitForTasksRequest = {
29207
29242
  },
29208
29243
  decode(input, length) {
29209
29244
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
29210
- const end = length === void 0 ? reader.len : reader.pos + length;
29211
- const message = createBaseWaitForTasksRequest();
29212
- while (reader.pos < end) {
29213
- const tag = reader.uint32();
29214
- switch (tag >>> 3) {
29215
- case 1:
29216
- if (tag !== 10) break;
29217
- message.applicationId = reader.string();
29218
- continue;
29245
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
29246
+ if (previousRecursionDepth >= 100) throw new globalThis.Error("protobuf decode recursion limit exceeded");
29247
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
29248
+ try {
29249
+ const end = length === void 0 ? reader.len : reader.pos + length;
29250
+ const message = createBaseWaitForTasksRequest();
29251
+ while (reader.pos < end) {
29252
+ const tag = reader.uint32();
29253
+ switch (tag >>> 3) {
29254
+ case 1:
29255
+ if (tag !== 10) break;
29256
+ message.applicationId = reader.string();
29257
+ continue;
29258
+ }
29259
+ if ((tag & 7) === 4 || tag === 0) break;
29260
+ reader.skip(tag & 7);
29219
29261
  }
29220
- if ((tag & 7) === 4 || tag === 0) break;
29221
- reader.skip(tag & 7);
29262
+ return message;
29263
+ } finally {
29264
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
29222
29265
  }
29223
- return message;
29224
29266
  },
29225
29267
  fromJSON(object) {
29226
29268
  return { applicationId: isSet$2(object.applicationId) ? globalThis.String(object.applicationId) : isSet$2(object.application_id) ? globalThis.String(object.application_id) : "" };
@@ -29259,36 +29301,43 @@ const Task = {
29259
29301
  },
29260
29302
  decode(input, length) {
29261
29303
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
29262
- const end = length === void 0 ? reader.len : reader.pos + length;
29263
- const message = createBaseTask();
29264
- while (reader.pos < end) {
29265
- const tag = reader.uint32();
29266
- switch (tag >>> 3) {
29267
- case 1:
29268
- if (tag !== 10) break;
29269
- message.taskId = reader.string();
29270
- continue;
29271
- case 2:
29272
- if (tag !== 18) break;
29273
- message.storageEvent = StorageEvent.decode(reader, reader.uint32());
29274
- continue;
29275
- case 3:
29276
- if (tag !== 26) break;
29277
- message.cronEvent = CronEvent.decode(reader, reader.uint32());
29278
- continue;
29279
- case 4:
29280
- if (tag !== 34) break;
29281
- message.queueMessage = QueueMessage.decode(reader, reader.uint32());
29282
- continue;
29283
- case 5:
29284
- if (tag !== 42) break;
29285
- message.arcCommand = ArcCommand.decode(reader, reader.uint32());
29286
- continue;
29304
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
29305
+ if (previousRecursionDepth >= 100) throw new globalThis.Error("protobuf decode recursion limit exceeded");
29306
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
29307
+ try {
29308
+ const end = length === void 0 ? reader.len : reader.pos + length;
29309
+ const message = createBaseTask();
29310
+ while (reader.pos < end) {
29311
+ const tag = reader.uint32();
29312
+ switch (tag >>> 3) {
29313
+ case 1:
29314
+ if (tag !== 10) break;
29315
+ message.taskId = reader.string();
29316
+ continue;
29317
+ case 2:
29318
+ if (tag !== 18) break;
29319
+ message.storageEvent = StorageEvent.decode(reader, reader.uint32());
29320
+ continue;
29321
+ case 3:
29322
+ if (tag !== 26) break;
29323
+ message.cronEvent = CronEvent.decode(reader, reader.uint32());
29324
+ continue;
29325
+ case 4:
29326
+ if (tag !== 34) break;
29327
+ message.queueMessage = QueueMessage.decode(reader, reader.uint32());
29328
+ continue;
29329
+ case 5:
29330
+ if (tag !== 42) break;
29331
+ message.arcCommand = ArcCommand.decode(reader, reader.uint32());
29332
+ continue;
29333
+ }
29334
+ if ((tag & 7) === 4 || tag === 0) break;
29335
+ reader.skip(tag & 7);
29287
29336
  }
29288
- if ((tag & 7) === 4 || tag === 0) break;
29289
- reader.skip(tag & 7);
29337
+ return message;
29338
+ } finally {
29339
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
29290
29340
  }
29291
- return message;
29292
29341
  },
29293
29342
  fromJSON(object) {
29294
29343
  return {
@@ -29358,62 +29407,69 @@ const StorageEvent = {
29358
29407
  },
29359
29408
  decode(input, length) {
29360
29409
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
29361
- const end = length === void 0 ? reader.len : reader.pos + length;
29362
- const message = createBaseStorageEvent();
29363
- while (reader.pos < end) {
29364
- const tag = reader.uint32();
29365
- switch (tag >>> 3) {
29366
- case 1:
29367
- if (tag !== 10) break;
29368
- message.key = reader.string();
29369
- continue;
29370
- case 2:
29371
- if (tag !== 18) break;
29372
- message.eventType = reader.string();
29373
- continue;
29374
- case 3:
29375
- if (tag !== 26) break;
29376
- message.bucket = reader.string();
29377
- continue;
29378
- case 4:
29379
- if (tag !== 32) break;
29380
- message.size = longToNumber$1(reader.uint64());
29381
- continue;
29382
- case 5:
29383
- if (tag !== 42) break;
29384
- message.contentType = reader.string();
29385
- continue;
29386
- case 6:
29387
- if (tag !== 50) break;
29388
- message.timestamp = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
29389
- continue;
29390
- case 7:
29391
- if (tag !== 58) break;
29392
- message.etag = reader.string();
29393
- continue;
29394
- case 8:
29395
- if (tag !== 66) break;
29396
- message.region = reader.string();
29397
- continue;
29398
- case 9:
29399
- if (tag !== 74) break;
29400
- message.versionId = reader.string();
29401
- continue;
29402
- case 10:
29403
- if (tag !== 82) break;
29404
- message.currentTier = reader.string();
29405
- continue;
29406
- case 11: {
29407
- if (tag !== 90) break;
29408
- const entry11 = StorageEvent_MetadataEntry.decode(reader, reader.uint32());
29409
- if (entry11.value !== void 0) message.metadata[entry11.key] = entry11.value;
29410
- continue;
29410
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
29411
+ if (previousRecursionDepth >= 100) throw new globalThis.Error("protobuf decode recursion limit exceeded");
29412
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
29413
+ try {
29414
+ const end = length === void 0 ? reader.len : reader.pos + length;
29415
+ const message = createBaseStorageEvent();
29416
+ while (reader.pos < end) {
29417
+ const tag = reader.uint32();
29418
+ switch (tag >>> 3) {
29419
+ case 1:
29420
+ if (tag !== 10) break;
29421
+ message.key = reader.string();
29422
+ continue;
29423
+ case 2:
29424
+ if (tag !== 18) break;
29425
+ message.eventType = reader.string();
29426
+ continue;
29427
+ case 3:
29428
+ if (tag !== 26) break;
29429
+ message.bucket = reader.string();
29430
+ continue;
29431
+ case 4:
29432
+ if (tag !== 32) break;
29433
+ message.size = longToNumber$1(reader.uint64());
29434
+ continue;
29435
+ case 5:
29436
+ if (tag !== 42) break;
29437
+ message.contentType = reader.string();
29438
+ continue;
29439
+ case 6:
29440
+ if (tag !== 50) break;
29441
+ message.timestamp = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
29442
+ continue;
29443
+ case 7:
29444
+ if (tag !== 58) break;
29445
+ message.etag = reader.string();
29446
+ continue;
29447
+ case 8:
29448
+ if (tag !== 66) break;
29449
+ message.region = reader.string();
29450
+ continue;
29451
+ case 9:
29452
+ if (tag !== 74) break;
29453
+ message.versionId = reader.string();
29454
+ continue;
29455
+ case 10:
29456
+ if (tag !== 82) break;
29457
+ message.currentTier = reader.string();
29458
+ continue;
29459
+ case 11: {
29460
+ if (tag !== 90) break;
29461
+ const entry11 = StorageEvent_MetadataEntry.decode(reader, reader.uint32());
29462
+ if (entry11.value !== void 0) message.metadata[entry11.key] = entry11.value;
29463
+ continue;
29464
+ }
29411
29465
  }
29466
+ if ((tag & 7) === 4 || tag === 0) break;
29467
+ reader.skip(tag & 7);
29412
29468
  }
29413
- if ((tag & 7) === 4 || tag === 0) break;
29414
- reader.skip(tag & 7);
29469
+ return message;
29470
+ } finally {
29471
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
29415
29472
  }
29416
- return message;
29417
29473
  },
29418
29474
  fromJSON(object) {
29419
29475
  return {
@@ -29428,7 +29484,12 @@ const StorageEvent = {
29428
29484
  versionId: isSet$2(object.versionId) ? globalThis.String(object.versionId) : isSet$2(object.version_id) ? globalThis.String(object.version_id) : "",
29429
29485
  currentTier: isSet$2(object.currentTier) ? globalThis.String(object.currentTier) : isSet$2(object.current_tier) ? globalThis.String(object.current_tier) : "",
29430
29486
  metadata: isObject(object.metadata) ? globalThis.Object.entries(object.metadata).reduce((acc, [key, value]) => {
29431
- acc[key] = globalThis.String(value);
29487
+ globalThis.Object.defineProperty(acc, key, {
29488
+ value: globalThis.String(value),
29489
+ enumerable: true,
29490
+ configurable: true,
29491
+ writable: true
29492
+ });
29432
29493
  return acc;
29433
29494
  }, {}) : {}
29434
29495
  };
@@ -29492,24 +29553,31 @@ const StorageEvent_MetadataEntry = {
29492
29553
  },
29493
29554
  decode(input, length) {
29494
29555
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
29495
- const end = length === void 0 ? reader.len : reader.pos + length;
29496
- const message = createBaseStorageEvent_MetadataEntry();
29497
- while (reader.pos < end) {
29498
- const tag = reader.uint32();
29499
- switch (tag >>> 3) {
29500
- case 1:
29501
- if (tag !== 10) break;
29502
- message.key = reader.string();
29503
- continue;
29504
- case 2:
29505
- if (tag !== 18) break;
29506
- message.value = reader.string();
29507
- continue;
29556
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
29557
+ if (previousRecursionDepth >= 100) throw new globalThis.Error("protobuf decode recursion limit exceeded");
29558
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
29559
+ try {
29560
+ const end = length === void 0 ? reader.len : reader.pos + length;
29561
+ const message = createBaseStorageEvent_MetadataEntry();
29562
+ while (reader.pos < end) {
29563
+ const tag = reader.uint32();
29564
+ switch (tag >>> 3) {
29565
+ case 1:
29566
+ if (tag !== 10) break;
29567
+ message.key = reader.string();
29568
+ continue;
29569
+ case 2:
29570
+ if (tag !== 18) break;
29571
+ message.value = reader.string();
29572
+ continue;
29573
+ }
29574
+ if ((tag & 7) === 4 || tag === 0) break;
29575
+ reader.skip(tag & 7);
29508
29576
  }
29509
- if ((tag & 7) === 4 || tag === 0) break;
29510
- reader.skip(tag & 7);
29577
+ return message;
29578
+ } finally {
29579
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
29511
29580
  }
29512
- return message;
29513
29581
  },
29514
29582
  fromJSON(object) {
29515
29583
  return {
@@ -29547,24 +29615,31 @@ const CronEvent = {
29547
29615
  },
29548
29616
  decode(input, length) {
29549
29617
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
29550
- const end = length === void 0 ? reader.len : reader.pos + length;
29551
- const message = createBaseCronEvent();
29552
- while (reader.pos < end) {
29553
- const tag = reader.uint32();
29554
- switch (tag >>> 3) {
29555
- case 1:
29556
- if (tag !== 10) break;
29557
- message.scheduleName = reader.string();
29558
- continue;
29559
- case 2:
29560
- if (tag !== 18) break;
29561
- message.scheduledTime = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
29562
- continue;
29618
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
29619
+ if (previousRecursionDepth >= 100) throw new globalThis.Error("protobuf decode recursion limit exceeded");
29620
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
29621
+ try {
29622
+ const end = length === void 0 ? reader.len : reader.pos + length;
29623
+ const message = createBaseCronEvent();
29624
+ while (reader.pos < end) {
29625
+ const tag = reader.uint32();
29626
+ switch (tag >>> 3) {
29627
+ case 1:
29628
+ if (tag !== 10) break;
29629
+ message.scheduleName = reader.string();
29630
+ continue;
29631
+ case 2:
29632
+ if (tag !== 18) break;
29633
+ message.scheduledTime = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
29634
+ continue;
29635
+ }
29636
+ if ((tag & 7) === 4 || tag === 0) break;
29637
+ reader.skip(tag & 7);
29563
29638
  }
29564
- if ((tag & 7) === 4 || tag === 0) break;
29565
- reader.skip(tag & 7);
29639
+ return message;
29640
+ } finally {
29641
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
29566
29642
  }
29567
- return message;
29568
29643
  },
29569
29644
  fromJSON(object) {
29570
29645
  return {
@@ -29617,46 +29692,53 @@ const QueueMessage = {
29617
29692
  },
29618
29693
  decode(input, length) {
29619
29694
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
29620
- const end = length === void 0 ? reader.len : reader.pos + length;
29621
- const message = createBaseQueueMessage();
29622
- while (reader.pos < end) {
29623
- const tag = reader.uint32();
29624
- switch (tag >>> 3) {
29625
- case 1:
29626
- if (tag !== 10) break;
29627
- message.id = reader.string();
29628
- continue;
29629
- case 2:
29630
- if (tag !== 18) break;
29631
- message.payload = reader.bytes();
29632
- continue;
29633
- case 3:
29634
- if (tag !== 26) break;
29635
- message.receiptHandle = reader.string();
29636
- continue;
29637
- case 4:
29638
- if (tag !== 34) break;
29639
- message.source = reader.string();
29640
- continue;
29641
- case 5:
29642
- if (tag !== 40) break;
29643
- message.attemptCount = reader.uint32();
29644
- continue;
29645
- case 6:
29646
- if (tag !== 50) break;
29647
- message.timestamp = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
29648
- continue;
29649
- case 7: {
29650
- if (tag !== 58) break;
29651
- const entry7 = QueueMessage_AttributesEntry.decode(reader, reader.uint32());
29652
- if (entry7.value !== void 0) message.attributes[entry7.key] = entry7.value;
29653
- continue;
29695
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
29696
+ if (previousRecursionDepth >= 100) throw new globalThis.Error("protobuf decode recursion limit exceeded");
29697
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
29698
+ try {
29699
+ const end = length === void 0 ? reader.len : reader.pos + length;
29700
+ const message = createBaseQueueMessage();
29701
+ while (reader.pos < end) {
29702
+ const tag = reader.uint32();
29703
+ switch (tag >>> 3) {
29704
+ case 1:
29705
+ if (tag !== 10) break;
29706
+ message.id = reader.string();
29707
+ continue;
29708
+ case 2:
29709
+ if (tag !== 18) break;
29710
+ message.payload = reader.bytes();
29711
+ continue;
29712
+ case 3:
29713
+ if (tag !== 26) break;
29714
+ message.receiptHandle = reader.string();
29715
+ continue;
29716
+ case 4:
29717
+ if (tag !== 34) break;
29718
+ message.source = reader.string();
29719
+ continue;
29720
+ case 5:
29721
+ if (tag !== 40) break;
29722
+ message.attemptCount = reader.uint32();
29723
+ continue;
29724
+ case 6:
29725
+ if (tag !== 50) break;
29726
+ message.timestamp = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
29727
+ continue;
29728
+ case 7: {
29729
+ if (tag !== 58) break;
29730
+ const entry7 = QueueMessage_AttributesEntry.decode(reader, reader.uint32());
29731
+ if (entry7.value !== void 0) message.attributes[entry7.key] = entry7.value;
29732
+ continue;
29733
+ }
29654
29734
  }
29735
+ if ((tag & 7) === 4 || tag === 0) break;
29736
+ reader.skip(tag & 7);
29655
29737
  }
29656
- if ((tag & 7) === 4 || tag === 0) break;
29657
- reader.skip(tag & 7);
29738
+ return message;
29739
+ } finally {
29740
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
29658
29741
  }
29659
- return message;
29660
29742
  },
29661
29743
  fromJSON(object) {
29662
29744
  return {
@@ -29667,7 +29749,12 @@ const QueueMessage = {
29667
29749
  attemptCount: isSet$2(object.attemptCount) ? globalThis.Number(object.attemptCount) : isSet$2(object.attempt_count) ? globalThis.Number(object.attempt_count) : 0,
29668
29750
  timestamp: isSet$2(object.timestamp) ? fromJsonTimestamp(object.timestamp) : void 0,
29669
29751
  attributes: isObject(object.attributes) ? globalThis.Object.entries(object.attributes).reduce((acc, [key, value]) => {
29670
- acc[key] = globalThis.String(value);
29752
+ globalThis.Object.defineProperty(acc, key, {
29753
+ value: globalThis.String(value),
29754
+ enumerable: true,
29755
+ configurable: true,
29756
+ writable: true
29757
+ });
29671
29758
  return acc;
29672
29759
  }, {}) : {}
29673
29760
  };
@@ -29723,24 +29810,31 @@ const QueueMessage_AttributesEntry = {
29723
29810
  },
29724
29811
  decode(input, length) {
29725
29812
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
29726
- const end = length === void 0 ? reader.len : reader.pos + length;
29727
- const message = createBaseQueueMessage_AttributesEntry();
29728
- while (reader.pos < end) {
29729
- const tag = reader.uint32();
29730
- switch (tag >>> 3) {
29731
- case 1:
29732
- if (tag !== 10) break;
29733
- message.key = reader.string();
29734
- continue;
29735
- case 2:
29736
- if (tag !== 18) break;
29737
- message.value = reader.string();
29738
- continue;
29813
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
29814
+ if (previousRecursionDepth >= 100) throw new globalThis.Error("protobuf decode recursion limit exceeded");
29815
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
29816
+ try {
29817
+ const end = length === void 0 ? reader.len : reader.pos + length;
29818
+ const message = createBaseQueueMessage_AttributesEntry();
29819
+ while (reader.pos < end) {
29820
+ const tag = reader.uint32();
29821
+ switch (tag >>> 3) {
29822
+ case 1:
29823
+ if (tag !== 10) break;
29824
+ message.key = reader.string();
29825
+ continue;
29826
+ case 2:
29827
+ if (tag !== 18) break;
29828
+ message.value = reader.string();
29829
+ continue;
29830
+ }
29831
+ if ((tag & 7) === 4 || tag === 0) break;
29832
+ reader.skip(tag & 7);
29739
29833
  }
29740
- if ((tag & 7) === 4 || tag === 0) break;
29741
- reader.skip(tag & 7);
29834
+ return message;
29835
+ } finally {
29836
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
29742
29837
  }
29743
- return message;
29744
29838
  },
29745
29839
  fromJSON(object) {
29746
29840
  return {
@@ -29790,48 +29884,55 @@ const ArcCommand = {
29790
29884
  },
29791
29885
  decode(input, length) {
29792
29886
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
29793
- const end = length === void 0 ? reader.len : reader.pos + length;
29794
- const message = createBaseArcCommand();
29795
- while (reader.pos < end) {
29796
- const tag = reader.uint32();
29797
- switch (tag >>> 3) {
29798
- case 1:
29799
- if (tag !== 10) break;
29800
- message.commandId = reader.string();
29801
- continue;
29802
- case 2:
29803
- if (tag !== 18) break;
29804
- message.commandName = reader.string();
29805
- continue;
29806
- case 3:
29807
- if (tag !== 26) break;
29808
- message.params = reader.bytes();
29809
- continue;
29810
- case 4:
29811
- if (tag !== 32) break;
29812
- message.attempt = reader.uint32();
29813
- continue;
29814
- case 5:
29815
- if (tag !== 42) break;
29816
- message.deadline = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
29817
- continue;
29818
- case 6:
29819
- if (tag !== 50) break;
29820
- message.responseUrl = reader.string();
29821
- continue;
29822
- case 7:
29823
- if (tag !== 58) break;
29824
- message.storageUploadUrl = reader.string();
29825
- continue;
29826
- case 8:
29827
- if (tag !== 64) break;
29828
- message.maxInlineBytes = longToNumber$1(reader.uint64());
29829
- continue;
29887
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
29888
+ if (previousRecursionDepth >= 100) throw new globalThis.Error("protobuf decode recursion limit exceeded");
29889
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
29890
+ try {
29891
+ const end = length === void 0 ? reader.len : reader.pos + length;
29892
+ const message = createBaseArcCommand();
29893
+ while (reader.pos < end) {
29894
+ const tag = reader.uint32();
29895
+ switch (tag >>> 3) {
29896
+ case 1:
29897
+ if (tag !== 10) break;
29898
+ message.commandId = reader.string();
29899
+ continue;
29900
+ case 2:
29901
+ if (tag !== 18) break;
29902
+ message.commandName = reader.string();
29903
+ continue;
29904
+ case 3:
29905
+ if (tag !== 26) break;
29906
+ message.params = reader.bytes();
29907
+ continue;
29908
+ case 4:
29909
+ if (tag !== 32) break;
29910
+ message.attempt = reader.uint32();
29911
+ continue;
29912
+ case 5:
29913
+ if (tag !== 42) break;
29914
+ message.deadline = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
29915
+ continue;
29916
+ case 6:
29917
+ if (tag !== 50) break;
29918
+ message.responseUrl = reader.string();
29919
+ continue;
29920
+ case 7:
29921
+ if (tag !== 58) break;
29922
+ message.storageUploadUrl = reader.string();
29923
+ continue;
29924
+ case 8:
29925
+ if (tag !== 64) break;
29926
+ message.maxInlineBytes = longToNumber$1(reader.uint64());
29927
+ continue;
29928
+ }
29929
+ if ((tag & 7) === 4 || tag === 0) break;
29930
+ reader.skip(tag & 7);
29830
29931
  }
29831
- if ((tag & 7) === 4 || tag === 0) break;
29832
- reader.skip(tag & 7);
29932
+ return message;
29933
+ } finally {
29934
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
29833
29935
  }
29834
- return message;
29835
29936
  },
29836
29937
  fromJSON(object) {
29837
29938
  return {
@@ -29889,28 +29990,35 @@ const SendTaskResultRequest = {
29889
29990
  },
29890
29991
  decode(input, length) {
29891
29992
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
29892
- const end = length === void 0 ? reader.len : reader.pos + length;
29893
- const message = createBaseSendTaskResultRequest();
29894
- while (reader.pos < end) {
29895
- const tag = reader.uint32();
29896
- switch (tag >>> 3) {
29897
- case 1:
29898
- if (tag !== 10) break;
29899
- message.taskId = reader.string();
29900
- continue;
29901
- case 2:
29902
- if (tag !== 18) break;
29903
- message.success = TaskSuccess.decode(reader, reader.uint32());
29904
- continue;
29905
- case 3:
29906
- if (tag !== 26) break;
29907
- message.error = TaskError.decode(reader, reader.uint32());
29908
- continue;
29993
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
29994
+ if (previousRecursionDepth >= 100) throw new globalThis.Error("protobuf decode recursion limit exceeded");
29995
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
29996
+ try {
29997
+ const end = length === void 0 ? reader.len : reader.pos + length;
29998
+ const message = createBaseSendTaskResultRequest();
29999
+ while (reader.pos < end) {
30000
+ const tag = reader.uint32();
30001
+ switch (tag >>> 3) {
30002
+ case 1:
30003
+ if (tag !== 10) break;
30004
+ message.taskId = reader.string();
30005
+ continue;
30006
+ case 2:
30007
+ if (tag !== 18) break;
30008
+ message.success = TaskSuccess.decode(reader, reader.uint32());
30009
+ continue;
30010
+ case 3:
30011
+ if (tag !== 26) break;
30012
+ message.error = TaskError.decode(reader, reader.uint32());
30013
+ continue;
30014
+ }
30015
+ if ((tag & 7) === 4 || tag === 0) break;
30016
+ reader.skip(tag & 7);
29909
30017
  }
29910
- if ((tag & 7) === 4 || tag === 0) break;
29911
- reader.skip(tag & 7);
30018
+ return message;
30019
+ } finally {
30020
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
29912
30021
  }
29913
- return message;
29914
30022
  },
29915
30023
  fromJSON(object) {
29916
30024
  return {
@@ -29947,20 +30055,27 @@ const TaskSuccess = {
29947
30055
  },
29948
30056
  decode(input, length) {
29949
30057
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
29950
- const end = length === void 0 ? reader.len : reader.pos + length;
29951
- const message = createBaseTaskSuccess();
29952
- while (reader.pos < end) {
29953
- const tag = reader.uint32();
29954
- switch (tag >>> 3) {
29955
- case 1:
29956
- if (tag !== 10) break;
29957
- message.responseData = reader.bytes();
29958
- continue;
30058
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
30059
+ if (previousRecursionDepth >= 100) throw new globalThis.Error("protobuf decode recursion limit exceeded");
30060
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
30061
+ try {
30062
+ const end = length === void 0 ? reader.len : reader.pos + length;
30063
+ const message = createBaseTaskSuccess();
30064
+ while (reader.pos < end) {
30065
+ const tag = reader.uint32();
30066
+ switch (tag >>> 3) {
30067
+ case 1:
30068
+ if (tag !== 10) break;
30069
+ message.responseData = reader.bytes();
30070
+ continue;
30071
+ }
30072
+ if ((tag & 7) === 4 || tag === 0) break;
30073
+ reader.skip(tag & 7);
29959
30074
  }
29960
- if ((tag & 7) === 4 || tag === 0) break;
29961
- reader.skip(tag & 7);
30075
+ return message;
30076
+ } finally {
30077
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
29962
30078
  }
29963
- return message;
29964
30079
  },
29965
30080
  fromJSON(object) {
29966
30081
  return { responseData: isSet$2(object.responseData) ? bytesFromBase64(object.responseData) : isSet$2(object.response_data) ? bytesFromBase64(object.response_data) : /* @__PURE__ */ new Uint8Array(0) };
@@ -29993,24 +30108,31 @@ const TaskError = {
29993
30108
  },
29994
30109
  decode(input, length) {
29995
30110
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
29996
- const end = length === void 0 ? reader.len : reader.pos + length;
29997
- const message = createBaseTaskError();
29998
- while (reader.pos < end) {
29999
- const tag = reader.uint32();
30000
- switch (tag >>> 3) {
30001
- case 1:
30002
- if (tag !== 10) break;
30003
- message.code = reader.string();
30004
- continue;
30005
- case 2:
30006
- if (tag !== 18) break;
30007
- message.message = reader.string();
30008
- continue;
30111
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
30112
+ if (previousRecursionDepth >= 100) throw new globalThis.Error("protobuf decode recursion limit exceeded");
30113
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
30114
+ try {
30115
+ const end = length === void 0 ? reader.len : reader.pos + length;
30116
+ const message = createBaseTaskError();
30117
+ while (reader.pos < end) {
30118
+ const tag = reader.uint32();
30119
+ switch (tag >>> 3) {
30120
+ case 1:
30121
+ if (tag !== 10) break;
30122
+ message.code = reader.string();
30123
+ continue;
30124
+ case 2:
30125
+ if (tag !== 18) break;
30126
+ message.message = reader.string();
30127
+ continue;
30128
+ }
30129
+ if ((tag & 7) === 4 || tag === 0) break;
30130
+ reader.skip(tag & 7);
30009
30131
  }
30010
- if ((tag & 7) === 4 || tag === 0) break;
30011
- reader.skip(tag & 7);
30132
+ return message;
30133
+ } finally {
30134
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
30012
30135
  }
30013
- return message;
30014
30136
  },
30015
30137
  fromJSON(object) {
30016
30138
  return {
@@ -30044,20 +30166,27 @@ const SendTaskResultResponse = {
30044
30166
  },
30045
30167
  decode(input, length) {
30046
30168
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
30047
- const end = length === void 0 ? reader.len : reader.pos + length;
30048
- const message = createBaseSendTaskResultResponse();
30049
- while (reader.pos < end) {
30050
- const tag = reader.uint32();
30051
- switch (tag >>> 3) {
30052
- case 1:
30053
- if (tag !== 8) break;
30054
- message.acknowledged = reader.bool();
30055
- continue;
30169
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
30170
+ if (previousRecursionDepth >= 100) throw new globalThis.Error("protobuf decode recursion limit exceeded");
30171
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
30172
+ try {
30173
+ const end = length === void 0 ? reader.len : reader.pos + length;
30174
+ const message = createBaseSendTaskResultResponse();
30175
+ while (reader.pos < end) {
30176
+ const tag = reader.uint32();
30177
+ switch (tag >>> 3) {
30178
+ case 1:
30179
+ if (tag !== 8) break;
30180
+ message.acknowledged = reader.bool();
30181
+ continue;
30182
+ }
30183
+ if ((tag & 7) === 4 || tag === 0) break;
30184
+ reader.skip(tag & 7);
30056
30185
  }
30057
- if ((tag & 7) === 4 || tag === 0) break;
30058
- reader.skip(tag & 7);
30186
+ return message;
30187
+ } finally {
30188
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
30059
30189
  }
30060
- return message;
30061
30190
  },
30062
30191
  fromJSON(object) {
30063
30192
  return { acknowledged: isSet$2(object.acknowledged) ? globalThis.Boolean(object.acknowledged) : false };
@@ -30184,24 +30313,31 @@ const Duration = {
30184
30313
  },
30185
30314
  decode(input, length) {
30186
30315
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
30187
- const end = length === void 0 ? reader.len : reader.pos + length;
30188
- const message = createBaseDuration();
30189
- while (reader.pos < end) {
30190
- const tag = reader.uint32();
30191
- switch (tag >>> 3) {
30192
- case 1:
30193
- if (tag !== 8) break;
30194
- message.seconds = longToNumber(reader.int64());
30195
- continue;
30196
- case 2:
30197
- if (tag !== 16) break;
30198
- message.nanos = reader.int32();
30199
- continue;
30316
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
30317
+ if (previousRecursionDepth >= 100) throw new globalThis.Error("protobuf decode recursion limit exceeded");
30318
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
30319
+ try {
30320
+ const end = length === void 0 ? reader.len : reader.pos + length;
30321
+ const message = createBaseDuration();
30322
+ while (reader.pos < end) {
30323
+ const tag = reader.uint32();
30324
+ switch (tag >>> 3) {
30325
+ case 1:
30326
+ if (tag !== 8) break;
30327
+ message.seconds = longToNumber(reader.int64());
30328
+ continue;
30329
+ case 2:
30330
+ if (tag !== 16) break;
30331
+ message.nanos = reader.int32();
30332
+ continue;
30333
+ }
30334
+ if ((tag & 7) === 4 || tag === 0) break;
30335
+ reader.skip(tag & 7);
30200
30336
  }
30201
- if ((tag & 7) === 4 || tag === 0) break;
30202
- reader.skip(tag & 7);
30337
+ return message;
30338
+ } finally {
30339
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
30203
30340
  }
30204
- return message;
30205
30341
  },
30206
30342
  fromJSON(object) {
30207
30343
  return {
@@ -30250,24 +30386,31 @@ const NotifyTaskRegisteredRequest = {
30250
30386
  },
30251
30387
  decode(input, length) {
30252
30388
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
30253
- const end = length === void 0 ? reader.len : reader.pos + length;
30254
- const message = createBaseNotifyTaskRegisteredRequest();
30255
- while (reader.pos < end) {
30256
- const tag = reader.uint32();
30257
- switch (tag >>> 3) {
30258
- case 1:
30259
- if (tag !== 10) break;
30260
- message.applicationId = reader.string();
30261
- continue;
30262
- case 2:
30263
- if (tag !== 18) break;
30264
- message.taskDescription = reader.string();
30265
- continue;
30389
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
30390
+ if (previousRecursionDepth >= 100) throw new globalThis.Error("protobuf decode recursion limit exceeded");
30391
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
30392
+ try {
30393
+ const end = length === void 0 ? reader.len : reader.pos + length;
30394
+ const message = createBaseNotifyTaskRegisteredRequest();
30395
+ while (reader.pos < end) {
30396
+ const tag = reader.uint32();
30397
+ switch (tag >>> 3) {
30398
+ case 1:
30399
+ if (tag !== 10) break;
30400
+ message.applicationId = reader.string();
30401
+ continue;
30402
+ case 2:
30403
+ if (tag !== 18) break;
30404
+ message.taskDescription = reader.string();
30405
+ continue;
30406
+ }
30407
+ if ((tag & 7) === 4 || tag === 0) break;
30408
+ reader.skip(tag & 7);
30266
30409
  }
30267
- if ((tag & 7) === 4 || tag === 0) break;
30268
- reader.skip(tag & 7);
30410
+ return message;
30411
+ } finally {
30412
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
30269
30413
  }
30270
- return message;
30271
30414
  },
30272
30415
  fromJSON(object) {
30273
30416
  return {
@@ -30301,20 +30444,27 @@ const NotifyTaskRegisteredResponse = {
30301
30444
  },
30302
30445
  decode(input, length) {
30303
30446
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
30304
- const end = length === void 0 ? reader.len : reader.pos + length;
30305
- const message = createBaseNotifyTaskRegisteredResponse();
30306
- while (reader.pos < end) {
30307
- const tag = reader.uint32();
30308
- switch (tag >>> 3) {
30309
- case 1:
30310
- if (tag !== 8) break;
30311
- message.success = reader.bool();
30312
- continue;
30447
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
30448
+ if (previousRecursionDepth >= 100) throw new globalThis.Error("protobuf decode recursion limit exceeded");
30449
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
30450
+ try {
30451
+ const end = length === void 0 ? reader.len : reader.pos + length;
30452
+ const message = createBaseNotifyTaskRegisteredResponse();
30453
+ while (reader.pos < end) {
30454
+ const tag = reader.uint32();
30455
+ switch (tag >>> 3) {
30456
+ case 1:
30457
+ if (tag !== 8) break;
30458
+ message.success = reader.bool();
30459
+ continue;
30460
+ }
30461
+ if ((tag & 7) === 4 || tag === 0) break;
30462
+ reader.skip(tag & 7);
30313
30463
  }
30314
- if ((tag & 7) === 4 || tag === 0) break;
30315
- reader.skip(tag & 7);
30464
+ return message;
30465
+ } finally {
30466
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
30316
30467
  }
30317
- return message;
30318
30468
  },
30319
30469
  fromJSON(object) {
30320
30470
  return { success: isSet(object.success) ? globalThis.Boolean(object.success) : false };
@@ -30347,24 +30497,31 @@ const WaitForDrainSignalRequest = {
30347
30497
  },
30348
30498
  decode(input, length) {
30349
30499
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
30350
- const end = length === void 0 ? reader.len : reader.pos + length;
30351
- const message = createBaseWaitForDrainSignalRequest();
30352
- while (reader.pos < end) {
30353
- const tag = reader.uint32();
30354
- switch (tag >>> 3) {
30355
- case 1:
30356
- if (tag !== 10) break;
30357
- message.applicationId = reader.string();
30358
- continue;
30359
- case 2:
30360
- if (tag !== 18) break;
30361
- message.timeout = Duration.decode(reader, reader.uint32());
30362
- continue;
30500
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
30501
+ if (previousRecursionDepth >= 100) throw new globalThis.Error("protobuf decode recursion limit exceeded");
30502
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
30503
+ try {
30504
+ const end = length === void 0 ? reader.len : reader.pos + length;
30505
+ const message = createBaseWaitForDrainSignalRequest();
30506
+ while (reader.pos < end) {
30507
+ const tag = reader.uint32();
30508
+ switch (tag >>> 3) {
30509
+ case 1:
30510
+ if (tag !== 10) break;
30511
+ message.applicationId = reader.string();
30512
+ continue;
30513
+ case 2:
30514
+ if (tag !== 18) break;
30515
+ message.timeout = Duration.decode(reader, reader.uint32());
30516
+ continue;
30517
+ }
30518
+ if ((tag & 7) === 4 || tag === 0) break;
30519
+ reader.skip(tag & 7);
30363
30520
  }
30364
- if ((tag & 7) === 4 || tag === 0) break;
30365
- reader.skip(tag & 7);
30521
+ return message;
30522
+ } finally {
30523
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
30366
30524
  }
30367
- return message;
30368
30525
  },
30369
30526
  fromJSON(object) {
30370
30527
  return {
@@ -30404,28 +30561,35 @@ const WaitForDrainSignalResponse = {
30404
30561
  },
30405
30562
  decode(input, length) {
30406
30563
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
30407
- const end = length === void 0 ? reader.len : reader.pos + length;
30408
- const message = createBaseWaitForDrainSignalResponse();
30409
- while (reader.pos < end) {
30410
- const tag = reader.uint32();
30411
- switch (tag >>> 3) {
30412
- case 1:
30413
- if (tag !== 8) break;
30414
- message.shouldDrain = reader.bool();
30415
- continue;
30416
- case 2:
30417
- if (tag !== 18) break;
30418
- message.drainTimeout = Duration.decode(reader, reader.uint32());
30419
- continue;
30420
- case 3:
30421
- if (tag !== 26) break;
30422
- message.drainReason = reader.string();
30423
- continue;
30564
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
30565
+ if (previousRecursionDepth >= 100) throw new globalThis.Error("protobuf decode recursion limit exceeded");
30566
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
30567
+ try {
30568
+ const end = length === void 0 ? reader.len : reader.pos + length;
30569
+ const message = createBaseWaitForDrainSignalResponse();
30570
+ while (reader.pos < end) {
30571
+ const tag = reader.uint32();
30572
+ switch (tag >>> 3) {
30573
+ case 1:
30574
+ if (tag !== 8) break;
30575
+ message.shouldDrain = reader.bool();
30576
+ continue;
30577
+ case 2:
30578
+ if (tag !== 18) break;
30579
+ message.drainTimeout = Duration.decode(reader, reader.uint32());
30580
+ continue;
30581
+ case 3:
30582
+ if (tag !== 26) break;
30583
+ message.drainReason = reader.string();
30584
+ continue;
30585
+ }
30586
+ if ((tag & 7) === 4 || tag === 0) break;
30587
+ reader.skip(tag & 7);
30424
30588
  }
30425
- if ((tag & 7) === 4 || tag === 0) break;
30426
- reader.skip(tag & 7);
30589
+ return message;
30590
+ } finally {
30591
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
30427
30592
  }
30428
- return message;
30429
30593
  },
30430
30594
  fromJSON(object) {
30431
30595
  return {
@@ -30470,32 +30634,39 @@ const NotifyDrainCompleteRequest = {
30470
30634
  },
30471
30635
  decode(input, length) {
30472
30636
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
30473
- const end = length === void 0 ? reader.len : reader.pos + length;
30474
- const message = createBaseNotifyDrainCompleteRequest();
30475
- while (reader.pos < end) {
30476
- const tag = reader.uint32();
30477
- switch (tag >>> 3) {
30478
- case 1:
30479
- if (tag !== 10) break;
30480
- message.applicationId = reader.string();
30481
- continue;
30482
- case 2:
30483
- if (tag !== 16) break;
30484
- message.tasksDrained = reader.uint32();
30485
- continue;
30486
- case 3:
30487
- if (tag !== 24) break;
30488
- message.success = reader.bool();
30489
- continue;
30490
- case 4:
30491
- if (tag !== 34) break;
30492
- message.errorMessage = reader.string();
30493
- continue;
30637
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
30638
+ if (previousRecursionDepth >= 100) throw new globalThis.Error("protobuf decode recursion limit exceeded");
30639
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
30640
+ try {
30641
+ const end = length === void 0 ? reader.len : reader.pos + length;
30642
+ const message = createBaseNotifyDrainCompleteRequest();
30643
+ while (reader.pos < end) {
30644
+ const tag = reader.uint32();
30645
+ switch (tag >>> 3) {
30646
+ case 1:
30647
+ if (tag !== 10) break;
30648
+ message.applicationId = reader.string();
30649
+ continue;
30650
+ case 2:
30651
+ if (tag !== 16) break;
30652
+ message.tasksDrained = reader.uint32();
30653
+ continue;
30654
+ case 3:
30655
+ if (tag !== 24) break;
30656
+ message.success = reader.bool();
30657
+ continue;
30658
+ case 4:
30659
+ if (tag !== 34) break;
30660
+ message.errorMessage = reader.string();
30661
+ continue;
30662
+ }
30663
+ if ((tag & 7) === 4 || tag === 0) break;
30664
+ reader.skip(tag & 7);
30494
30665
  }
30495
- if ((tag & 7) === 4 || tag === 0) break;
30496
- reader.skip(tag & 7);
30666
+ return message;
30667
+ } finally {
30668
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
30497
30669
  }
30498
- return message;
30499
30670
  },
30500
30671
  fromJSON(object) {
30501
30672
  return {
@@ -30535,20 +30706,27 @@ const NotifyDrainCompleteResponse = {
30535
30706
  },
30536
30707
  decode(input, length) {
30537
30708
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
30538
- const end = length === void 0 ? reader.len : reader.pos + length;
30539
- const message = createBaseNotifyDrainCompleteResponse();
30540
- while (reader.pos < end) {
30541
- const tag = reader.uint32();
30542
- switch (tag >>> 3) {
30543
- case 1:
30544
- if (tag !== 8) break;
30545
- message.acknowledged = reader.bool();
30546
- continue;
30709
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
30710
+ if (previousRecursionDepth >= 100) throw new globalThis.Error("protobuf decode recursion limit exceeded");
30711
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
30712
+ try {
30713
+ const end = length === void 0 ? reader.len : reader.pos + length;
30714
+ const message = createBaseNotifyDrainCompleteResponse();
30715
+ while (reader.pos < end) {
30716
+ const tag = reader.uint32();
30717
+ switch (tag >>> 3) {
30718
+ case 1:
30719
+ if (tag !== 8) break;
30720
+ message.acknowledged = reader.bool();
30721
+ continue;
30722
+ }
30723
+ if ((tag & 7) === 4 || tag === 0) break;
30724
+ reader.skip(tag & 7);
30547
30725
  }
30548
- if ((tag & 7) === 4 || tag === 0) break;
30549
- reader.skip(tag & 7);
30726
+ return message;
30727
+ } finally {
30728
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
30550
30729
  }
30551
- return message;
30552
30730
  },
30553
30731
  fromJSON(object) {
30554
30732
  return { acknowledged: isSet(object.acknowledged) ? globalThis.Boolean(object.acknowledged) : false };
@@ -30577,20 +30755,27 @@ const GetTaskCountRequest = {
30577
30755
  },
30578
30756
  decode(input, length) {
30579
30757
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
30580
- const end = length === void 0 ? reader.len : reader.pos + length;
30581
- const message = createBaseGetTaskCountRequest();
30582
- while (reader.pos < end) {
30583
- const tag = reader.uint32();
30584
- switch (tag >>> 3) {
30585
- case 1:
30586
- if (tag !== 10) break;
30587
- message.applicationId = reader.string();
30588
- continue;
30758
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
30759
+ if (previousRecursionDepth >= 100) throw new globalThis.Error("protobuf decode recursion limit exceeded");
30760
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
30761
+ try {
30762
+ const end = length === void 0 ? reader.len : reader.pos + length;
30763
+ const message = createBaseGetTaskCountRequest();
30764
+ while (reader.pos < end) {
30765
+ const tag = reader.uint32();
30766
+ switch (tag >>> 3) {
30767
+ case 1:
30768
+ if (tag !== 10) break;
30769
+ message.applicationId = reader.string();
30770
+ continue;
30771
+ }
30772
+ if ((tag & 7) === 4 || tag === 0) break;
30773
+ reader.skip(tag & 7);
30589
30774
  }
30590
- if ((tag & 7) === 4 || tag === 0) break;
30591
- reader.skip(tag & 7);
30775
+ return message;
30776
+ } finally {
30777
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
30592
30778
  }
30593
- return message;
30594
30779
  },
30595
30780
  fromJSON(object) {
30596
30781
  return { applicationId: isSet(object.applicationId) ? globalThis.String(object.applicationId) : isSet(object.application_id) ? globalThis.String(object.application_id) : "" };
@@ -30619,20 +30804,27 @@ const GetTaskCountResponse = {
30619
30804
  },
30620
30805
  decode(input, length) {
30621
30806
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
30622
- const end = length === void 0 ? reader.len : reader.pos + length;
30623
- const message = createBaseGetTaskCountResponse();
30624
- while (reader.pos < end) {
30625
- const tag = reader.uint32();
30626
- switch (tag >>> 3) {
30627
- case 1:
30628
- if (tag !== 8) break;
30629
- message.taskCount = reader.uint32();
30630
- continue;
30807
+ const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
30808
+ if (previousRecursionDepth >= 100) throw new globalThis.Error("protobuf decode recursion limit exceeded");
30809
+ reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
30810
+ try {
30811
+ const end = length === void 0 ? reader.len : reader.pos + length;
30812
+ const message = createBaseGetTaskCountResponse();
30813
+ while (reader.pos < end) {
30814
+ const tag = reader.uint32();
30815
+ switch (tag >>> 3) {
30816
+ case 1:
30817
+ if (tag !== 8) break;
30818
+ message.taskCount = reader.uint32();
30819
+ continue;
30820
+ }
30821
+ if ((tag & 7) === 4 || tag === 0) break;
30822
+ reader.skip(tag & 7);
30631
30823
  }
30632
- if ((tag & 7) === 4 || tag === 0) break;
30633
- reader.skip(tag & 7);
30824
+ return message;
30825
+ } finally {
30826
+ reader.__tsProtoDecodeDepth = previousRecursionDepth;
30634
30827
  }
30635
- return message;
30636
30828
  },
30637
30829
  fromJSON(object) {
30638
30830
  return { taskCount: isSet(object.taskCount) ? globalThis.Number(object.taskCount) : isSet(object.task_count) ? globalThis.Number(object.task_count) : 0 };