@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.
- package/dist/dist.js +216 -0
- package/dist/index.d.ts +4 -3
- package/dist/index.d.ts.map +1 -1
- package/dist/index.js +2 -2
- package/dist/worker-runtime/generated/control.d.ts.map +1 -1
- package/dist/worker-runtime/generated/google/protobuf/duration.d.ts.map +1 -1
- package/dist/worker-runtime/generated/google/protobuf/timestamp.d.ts.map +1 -1
- package/dist/worker-runtime/generated/wait_until.d.ts.map +1 -1
- package/dist/worker-runtime/index.js +680 -488
- package/package.json +4 -4
|
@@ -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
|
|
28968
|
-
|
|
28969
|
-
|
|
28970
|
-
|
|
28971
|
-
|
|
28972
|
-
|
|
28973
|
-
|
|
28974
|
-
|
|
28975
|
-
|
|
28976
|
-
|
|
28977
|
-
|
|
28978
|
-
|
|
28979
|
-
|
|
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
|
-
|
|
28982
|
-
|
|
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
|
|
29030
|
-
|
|
29031
|
-
|
|
29032
|
-
|
|
29033
|
-
|
|
29034
|
-
|
|
29035
|
-
|
|
29036
|
-
|
|
29037
|
-
|
|
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
|
-
|
|
29040
|
-
|
|
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
|
|
29072
|
-
|
|
29073
|
-
|
|
29074
|
-
|
|
29075
|
-
|
|
29076
|
-
|
|
29077
|
-
|
|
29078
|
-
|
|
29079
|
-
|
|
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
|
-
|
|
29082
|
-
|
|
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
|
|
29118
|
-
|
|
29119
|
-
|
|
29120
|
-
|
|
29121
|
-
|
|
29122
|
-
|
|
29123
|
-
|
|
29124
|
-
|
|
29125
|
-
|
|
29126
|
-
|
|
29127
|
-
|
|
29128
|
-
|
|
29129
|
-
|
|
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
|
-
|
|
29132
|
-
|
|
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
|
|
29169
|
-
|
|
29170
|
-
|
|
29171
|
-
|
|
29172
|
-
|
|
29173
|
-
|
|
29174
|
-
|
|
29175
|
-
|
|
29176
|
-
|
|
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
|
-
|
|
29179
|
-
|
|
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
|
|
29211
|
-
|
|
29212
|
-
|
|
29213
|
-
|
|
29214
|
-
|
|
29215
|
-
|
|
29216
|
-
|
|
29217
|
-
|
|
29218
|
-
|
|
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
|
-
|
|
29221
|
-
|
|
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
|
|
29263
|
-
|
|
29264
|
-
|
|
29265
|
-
|
|
29266
|
-
|
|
29267
|
-
|
|
29268
|
-
|
|
29269
|
-
|
|
29270
|
-
|
|
29271
|
-
|
|
29272
|
-
|
|
29273
|
-
|
|
29274
|
-
|
|
29275
|
-
|
|
29276
|
-
|
|
29277
|
-
|
|
29278
|
-
|
|
29279
|
-
|
|
29280
|
-
|
|
29281
|
-
|
|
29282
|
-
|
|
29283
|
-
|
|
29284
|
-
|
|
29285
|
-
|
|
29286
|
-
|
|
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
|
-
|
|
29289
|
-
|
|
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
|
|
29362
|
-
|
|
29363
|
-
|
|
29364
|
-
|
|
29365
|
-
|
|
29366
|
-
|
|
29367
|
-
|
|
29368
|
-
|
|
29369
|
-
|
|
29370
|
-
|
|
29371
|
-
|
|
29372
|
-
|
|
29373
|
-
|
|
29374
|
-
|
|
29375
|
-
|
|
29376
|
-
|
|
29377
|
-
|
|
29378
|
-
|
|
29379
|
-
|
|
29380
|
-
|
|
29381
|
-
|
|
29382
|
-
|
|
29383
|
-
|
|
29384
|
-
|
|
29385
|
-
|
|
29386
|
-
|
|
29387
|
-
|
|
29388
|
-
|
|
29389
|
-
|
|
29390
|
-
|
|
29391
|
-
|
|
29392
|
-
|
|
29393
|
-
|
|
29394
|
-
|
|
29395
|
-
|
|
29396
|
-
|
|
29397
|
-
|
|
29398
|
-
|
|
29399
|
-
|
|
29400
|
-
|
|
29401
|
-
|
|
29402
|
-
|
|
29403
|
-
|
|
29404
|
-
|
|
29405
|
-
|
|
29406
|
-
|
|
29407
|
-
|
|
29408
|
-
|
|
29409
|
-
|
|
29410
|
-
|
|
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
|
-
|
|
29414
|
-
|
|
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
|
|
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
|
|
29496
|
-
|
|
29497
|
-
|
|
29498
|
-
|
|
29499
|
-
|
|
29500
|
-
|
|
29501
|
-
|
|
29502
|
-
|
|
29503
|
-
|
|
29504
|
-
|
|
29505
|
-
|
|
29506
|
-
|
|
29507
|
-
|
|
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
|
-
|
|
29510
|
-
|
|
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
|
|
29551
|
-
|
|
29552
|
-
|
|
29553
|
-
|
|
29554
|
-
|
|
29555
|
-
|
|
29556
|
-
|
|
29557
|
-
|
|
29558
|
-
|
|
29559
|
-
|
|
29560
|
-
|
|
29561
|
-
|
|
29562
|
-
|
|
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
|
-
|
|
29565
|
-
|
|
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
|
|
29621
|
-
|
|
29622
|
-
|
|
29623
|
-
|
|
29624
|
-
|
|
29625
|
-
|
|
29626
|
-
|
|
29627
|
-
|
|
29628
|
-
|
|
29629
|
-
|
|
29630
|
-
|
|
29631
|
-
|
|
29632
|
-
|
|
29633
|
-
|
|
29634
|
-
|
|
29635
|
-
|
|
29636
|
-
|
|
29637
|
-
|
|
29638
|
-
|
|
29639
|
-
|
|
29640
|
-
|
|
29641
|
-
|
|
29642
|
-
|
|
29643
|
-
|
|
29644
|
-
|
|
29645
|
-
|
|
29646
|
-
|
|
29647
|
-
|
|
29648
|
-
|
|
29649
|
-
|
|
29650
|
-
|
|
29651
|
-
|
|
29652
|
-
|
|
29653
|
-
|
|
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
|
-
|
|
29657
|
-
|
|
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
|
|
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
|
|
29727
|
-
|
|
29728
|
-
|
|
29729
|
-
|
|
29730
|
-
|
|
29731
|
-
|
|
29732
|
-
|
|
29733
|
-
|
|
29734
|
-
|
|
29735
|
-
|
|
29736
|
-
|
|
29737
|
-
|
|
29738
|
-
|
|
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
|
-
|
|
29741
|
-
|
|
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
|
|
29794
|
-
|
|
29795
|
-
|
|
29796
|
-
|
|
29797
|
-
|
|
29798
|
-
|
|
29799
|
-
|
|
29800
|
-
|
|
29801
|
-
|
|
29802
|
-
|
|
29803
|
-
|
|
29804
|
-
|
|
29805
|
-
|
|
29806
|
-
|
|
29807
|
-
|
|
29808
|
-
|
|
29809
|
-
|
|
29810
|
-
|
|
29811
|
-
|
|
29812
|
-
|
|
29813
|
-
|
|
29814
|
-
|
|
29815
|
-
|
|
29816
|
-
|
|
29817
|
-
|
|
29818
|
-
|
|
29819
|
-
|
|
29820
|
-
|
|
29821
|
-
|
|
29822
|
-
|
|
29823
|
-
|
|
29824
|
-
|
|
29825
|
-
|
|
29826
|
-
|
|
29827
|
-
|
|
29828
|
-
|
|
29829
|
-
|
|
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
|
-
|
|
29832
|
-
|
|
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
|
|
29893
|
-
|
|
29894
|
-
|
|
29895
|
-
|
|
29896
|
-
|
|
29897
|
-
|
|
29898
|
-
|
|
29899
|
-
|
|
29900
|
-
|
|
29901
|
-
|
|
29902
|
-
|
|
29903
|
-
|
|
29904
|
-
|
|
29905
|
-
|
|
29906
|
-
|
|
29907
|
-
|
|
29908
|
-
|
|
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
|
-
|
|
29911
|
-
|
|
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
|
|
29951
|
-
|
|
29952
|
-
|
|
29953
|
-
|
|
29954
|
-
|
|
29955
|
-
|
|
29956
|
-
|
|
29957
|
-
|
|
29958
|
-
|
|
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
|
-
|
|
29961
|
-
|
|
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
|
|
29997
|
-
|
|
29998
|
-
|
|
29999
|
-
|
|
30000
|
-
|
|
30001
|
-
|
|
30002
|
-
|
|
30003
|
-
|
|
30004
|
-
|
|
30005
|
-
|
|
30006
|
-
|
|
30007
|
-
|
|
30008
|
-
|
|
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
|
-
|
|
30011
|
-
|
|
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
|
|
30048
|
-
|
|
30049
|
-
|
|
30050
|
-
|
|
30051
|
-
|
|
30052
|
-
|
|
30053
|
-
|
|
30054
|
-
|
|
30055
|
-
|
|
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
|
-
|
|
30058
|
-
|
|
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
|
|
30188
|
-
|
|
30189
|
-
|
|
30190
|
-
|
|
30191
|
-
|
|
30192
|
-
|
|
30193
|
-
|
|
30194
|
-
|
|
30195
|
-
|
|
30196
|
-
|
|
30197
|
-
|
|
30198
|
-
|
|
30199
|
-
|
|
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
|
-
|
|
30202
|
-
|
|
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
|
|
30254
|
-
|
|
30255
|
-
|
|
30256
|
-
|
|
30257
|
-
|
|
30258
|
-
|
|
30259
|
-
|
|
30260
|
-
|
|
30261
|
-
|
|
30262
|
-
|
|
30263
|
-
|
|
30264
|
-
|
|
30265
|
-
|
|
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
|
-
|
|
30268
|
-
|
|
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
|
|
30305
|
-
|
|
30306
|
-
|
|
30307
|
-
|
|
30308
|
-
|
|
30309
|
-
|
|
30310
|
-
|
|
30311
|
-
|
|
30312
|
-
|
|
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
|
-
|
|
30315
|
-
|
|
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
|
|
30351
|
-
|
|
30352
|
-
|
|
30353
|
-
|
|
30354
|
-
|
|
30355
|
-
|
|
30356
|
-
|
|
30357
|
-
|
|
30358
|
-
|
|
30359
|
-
|
|
30360
|
-
|
|
30361
|
-
|
|
30362
|
-
|
|
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
|
-
|
|
30365
|
-
|
|
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
|
|
30408
|
-
|
|
30409
|
-
|
|
30410
|
-
|
|
30411
|
-
|
|
30412
|
-
|
|
30413
|
-
|
|
30414
|
-
|
|
30415
|
-
|
|
30416
|
-
|
|
30417
|
-
|
|
30418
|
-
|
|
30419
|
-
|
|
30420
|
-
|
|
30421
|
-
|
|
30422
|
-
|
|
30423
|
-
|
|
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
|
-
|
|
30426
|
-
|
|
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
|
|
30474
|
-
|
|
30475
|
-
|
|
30476
|
-
|
|
30477
|
-
|
|
30478
|
-
|
|
30479
|
-
|
|
30480
|
-
|
|
30481
|
-
|
|
30482
|
-
|
|
30483
|
-
|
|
30484
|
-
|
|
30485
|
-
|
|
30486
|
-
|
|
30487
|
-
|
|
30488
|
-
|
|
30489
|
-
|
|
30490
|
-
|
|
30491
|
-
|
|
30492
|
-
|
|
30493
|
-
|
|
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
|
-
|
|
30496
|
-
|
|
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
|
|
30539
|
-
|
|
30540
|
-
|
|
30541
|
-
|
|
30542
|
-
|
|
30543
|
-
|
|
30544
|
-
|
|
30545
|
-
|
|
30546
|
-
|
|
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
|
-
|
|
30549
|
-
|
|
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
|
|
30581
|
-
|
|
30582
|
-
|
|
30583
|
-
|
|
30584
|
-
|
|
30585
|
-
|
|
30586
|
-
|
|
30587
|
-
|
|
30588
|
-
|
|
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
|
-
|
|
30591
|
-
|
|
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
|
|
30623
|
-
|
|
30624
|
-
|
|
30625
|
-
|
|
30626
|
-
|
|
30627
|
-
|
|
30628
|
-
|
|
30629
|
-
|
|
30630
|
-
|
|
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
|
-
|
|
30633
|
-
|
|
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 };
|