@blueyerobotics/protocol-definitions 3.4.0-8187f91a → 3.4.0-efe27311
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/control.d.ts +28 -0
- package/dist/control.js +159 -0
- package/dist/index.blueye.protocol.d.ts +2 -1
- package/dist/index.blueye.protocol.js +2 -1
- package/dist/message_formats.d.ts +104 -2
- package/dist/message_formats.js +353 -2
- package/dist/mission_planning.d.ts +526 -5
- package/dist/mission_planning.js +3098 -143
- package/dist/req_rep.d.ts +229 -5
- package/dist/req_rep.js +1780 -400
- package/dist/slam.d.ts +512 -0
- package/dist/slam.js +2427 -0
- package/dist/telemetry.d.ts +98 -1
- package/dist/telemetry.js +531 -1
- package/package.json +1 -1
package/dist/req_rep.js
CHANGED
|
@@ -6,8 +6,9 @@
|
|
|
6
6
|
/* eslint-disable */
|
|
7
7
|
import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
|
|
8
8
|
import { Any } from "./google/protobuf/any.js";
|
|
9
|
-
import { Battery, cameraFromJSON, CameraParameters, cameraToJSON, ClientInfo, ConnectedClient, CvModelInfo, headingModeFromJSON, headingModeToJSON, MultibeamColorFilter, OverlayParameters, PersistentStorageSettings, SystemTime, } from "./message_formats.js";
|
|
10
|
-
import { Instruction, Mission } from "./mission_planning.js";
|
|
9
|
+
import { Battery, cameraFromJSON, CameraParameters, cameraToJSON, ClientInfo, ConnectedClient, CvModelInfo, headingModeFromJSON, headingModeToJSON, MultibeamColorFilter, OverlayParameters, PersistentStorageSettings, storageLocationFromJSON, storageLocationToJSON, SystemTime, } from "./message_formats.js";
|
|
10
|
+
import { InsertInstruction, Instruction, Mission, MissionRule } from "./mission_planning.js";
|
|
11
|
+
import { SlamRecordingState, slamRequestErrorFromJSON, slamRequestErrorToJSON, SlamSensorSettings, } from "./slam.js";
|
|
11
12
|
function createBaseSetOverlayParametersReq() {
|
|
12
13
|
return { overlayParameters: undefined };
|
|
13
14
|
}
|
|
@@ -1082,10 +1083,19 @@ export const SetMissionReq = {
|
|
|
1082
1083
|
},
|
|
1083
1084
|
};
|
|
1084
1085
|
function createBaseSetMissionRep() {
|
|
1085
|
-
return {};
|
|
1086
|
+
return { accepted: false, reason: "", loadId: 0 };
|
|
1086
1087
|
}
|
|
1087
1088
|
export const SetMissionRep = {
|
|
1088
|
-
encode(
|
|
1089
|
+
encode(message, writer = new BinaryWriter()) {
|
|
1090
|
+
if (message.accepted !== false) {
|
|
1091
|
+
writer.uint32(8).bool(message.accepted);
|
|
1092
|
+
}
|
|
1093
|
+
if (message.reason !== "") {
|
|
1094
|
+
writer.uint32(18).string(message.reason);
|
|
1095
|
+
}
|
|
1096
|
+
if (message.loadId !== 0) {
|
|
1097
|
+
writer.uint32(24).uint64(message.loadId);
|
|
1098
|
+
}
|
|
1089
1099
|
return writer;
|
|
1090
1100
|
},
|
|
1091
1101
|
decode(input, length) {
|
|
@@ -1095,6 +1105,27 @@ export const SetMissionRep = {
|
|
|
1095
1105
|
while (reader.pos < end) {
|
|
1096
1106
|
const tag = reader.uint32();
|
|
1097
1107
|
switch (tag >>> 3) {
|
|
1108
|
+
case 1: {
|
|
1109
|
+
if (tag !== 8) {
|
|
1110
|
+
break;
|
|
1111
|
+
}
|
|
1112
|
+
message.accepted = reader.bool();
|
|
1113
|
+
continue;
|
|
1114
|
+
}
|
|
1115
|
+
case 2: {
|
|
1116
|
+
if (tag !== 18) {
|
|
1117
|
+
break;
|
|
1118
|
+
}
|
|
1119
|
+
message.reason = reader.string();
|
|
1120
|
+
continue;
|
|
1121
|
+
}
|
|
1122
|
+
case 3: {
|
|
1123
|
+
if (tag !== 24) {
|
|
1124
|
+
break;
|
|
1125
|
+
}
|
|
1126
|
+
message.loadId = longToNumber(reader.uint64());
|
|
1127
|
+
continue;
|
|
1128
|
+
}
|
|
1098
1129
|
}
|
|
1099
1130
|
if ((tag & 7) === 4 || tag === 0) {
|
|
1100
1131
|
break;
|
|
@@ -1103,18 +1134,34 @@ export const SetMissionRep = {
|
|
|
1103
1134
|
}
|
|
1104
1135
|
return message;
|
|
1105
1136
|
},
|
|
1106
|
-
fromJSON(
|
|
1107
|
-
return {
|
|
1137
|
+
fromJSON(object) {
|
|
1138
|
+
return {
|
|
1139
|
+
accepted: isSet(object.accepted) ? gt.Boolean(object.accepted) : false,
|
|
1140
|
+
reason: isSet(object.reason) ? gt.String(object.reason) : "",
|
|
1141
|
+
loadId: isSet(object.loadId) ? gt.Number(object.loadId) : 0,
|
|
1142
|
+
};
|
|
1108
1143
|
},
|
|
1109
|
-
toJSON(
|
|
1144
|
+
toJSON(message) {
|
|
1110
1145
|
const obj = {};
|
|
1146
|
+
if (message.accepted !== false) {
|
|
1147
|
+
obj.accepted = message.accepted;
|
|
1148
|
+
}
|
|
1149
|
+
if (message.reason !== "") {
|
|
1150
|
+
obj.reason = message.reason;
|
|
1151
|
+
}
|
|
1152
|
+
if (message.loadId !== 0) {
|
|
1153
|
+
obj.loadId = Math.round(message.loadId);
|
|
1154
|
+
}
|
|
1111
1155
|
return obj;
|
|
1112
1156
|
},
|
|
1113
1157
|
create(base) {
|
|
1114
1158
|
return SetMissionRep.fromPartial(base ?? {});
|
|
1115
1159
|
},
|
|
1116
|
-
fromPartial(
|
|
1160
|
+
fromPartial(object) {
|
|
1117
1161
|
const message = createBaseSetMissionRep();
|
|
1162
|
+
message.accepted = object.accepted ?? false;
|
|
1163
|
+
message.reason = object.reason ?? "";
|
|
1164
|
+
message.loadId = object.loadId ?? 0;
|
|
1118
1165
|
return message;
|
|
1119
1166
|
},
|
|
1120
1167
|
};
|
|
@@ -1209,12 +1256,24 @@ export const GetMissionRep = {
|
|
|
1209
1256
|
},
|
|
1210
1257
|
};
|
|
1211
1258
|
function createBaseSetInstructionUpdateReq() {
|
|
1212
|
-
return {
|
|
1259
|
+
return { replace: undefined, insert: undefined, removeId: undefined, loadId: 0, revision: 0 };
|
|
1213
1260
|
}
|
|
1214
1261
|
export const SetInstructionUpdateReq = {
|
|
1215
1262
|
encode(message, writer = new BinaryWriter()) {
|
|
1216
|
-
if (message.
|
|
1217
|
-
Instruction.encode(message.
|
|
1263
|
+
if (message.replace !== undefined) {
|
|
1264
|
+
Instruction.encode(message.replace, writer.uint32(10).fork()).join();
|
|
1265
|
+
}
|
|
1266
|
+
if (message.insert !== undefined) {
|
|
1267
|
+
InsertInstruction.encode(message.insert, writer.uint32(18).fork()).join();
|
|
1268
|
+
}
|
|
1269
|
+
if (message.removeId !== undefined) {
|
|
1270
|
+
writer.uint32(24).uint32(message.removeId);
|
|
1271
|
+
}
|
|
1272
|
+
if (message.loadId !== 0) {
|
|
1273
|
+
writer.uint32(32).uint64(message.loadId);
|
|
1274
|
+
}
|
|
1275
|
+
if (message.revision !== 0) {
|
|
1276
|
+
writer.uint32(40).uint32(message.revision);
|
|
1218
1277
|
}
|
|
1219
1278
|
return writer;
|
|
1220
1279
|
},
|
|
@@ -1229,7 +1288,35 @@ export const SetInstructionUpdateReq = {
|
|
|
1229
1288
|
if (tag !== 10) {
|
|
1230
1289
|
break;
|
|
1231
1290
|
}
|
|
1232
|
-
message.
|
|
1291
|
+
message.replace = Instruction.decode(reader, reader.uint32());
|
|
1292
|
+
continue;
|
|
1293
|
+
}
|
|
1294
|
+
case 2: {
|
|
1295
|
+
if (tag !== 18) {
|
|
1296
|
+
break;
|
|
1297
|
+
}
|
|
1298
|
+
message.insert = InsertInstruction.decode(reader, reader.uint32());
|
|
1299
|
+
continue;
|
|
1300
|
+
}
|
|
1301
|
+
case 3: {
|
|
1302
|
+
if (tag !== 24) {
|
|
1303
|
+
break;
|
|
1304
|
+
}
|
|
1305
|
+
message.removeId = reader.uint32();
|
|
1306
|
+
continue;
|
|
1307
|
+
}
|
|
1308
|
+
case 4: {
|
|
1309
|
+
if (tag !== 32) {
|
|
1310
|
+
break;
|
|
1311
|
+
}
|
|
1312
|
+
message.loadId = longToNumber(reader.uint64());
|
|
1313
|
+
continue;
|
|
1314
|
+
}
|
|
1315
|
+
case 5: {
|
|
1316
|
+
if (tag !== 40) {
|
|
1317
|
+
break;
|
|
1318
|
+
}
|
|
1319
|
+
message.revision = reader.uint32();
|
|
1233
1320
|
continue;
|
|
1234
1321
|
}
|
|
1235
1322
|
}
|
|
@@ -1241,12 +1328,30 @@ export const SetInstructionUpdateReq = {
|
|
|
1241
1328
|
return message;
|
|
1242
1329
|
},
|
|
1243
1330
|
fromJSON(object) {
|
|
1244
|
-
return {
|
|
1331
|
+
return {
|
|
1332
|
+
replace: isSet(object.replace) ? Instruction.fromJSON(object.replace) : undefined,
|
|
1333
|
+
insert: isSet(object.insert) ? InsertInstruction.fromJSON(object.insert) : undefined,
|
|
1334
|
+
removeId: isSet(object.removeId) ? gt.Number(object.removeId) : undefined,
|
|
1335
|
+
loadId: isSet(object.loadId) ? gt.Number(object.loadId) : 0,
|
|
1336
|
+
revision: isSet(object.revision) ? gt.Number(object.revision) : 0,
|
|
1337
|
+
};
|
|
1245
1338
|
},
|
|
1246
1339
|
toJSON(message) {
|
|
1247
1340
|
const obj = {};
|
|
1248
|
-
if (message.
|
|
1249
|
-
obj.
|
|
1341
|
+
if (message.replace !== undefined) {
|
|
1342
|
+
obj.replace = Instruction.toJSON(message.replace);
|
|
1343
|
+
}
|
|
1344
|
+
if (message.insert !== undefined) {
|
|
1345
|
+
obj.insert = InsertInstruction.toJSON(message.insert);
|
|
1346
|
+
}
|
|
1347
|
+
if (message.removeId !== undefined) {
|
|
1348
|
+
obj.removeId = Math.round(message.removeId);
|
|
1349
|
+
}
|
|
1350
|
+
if (message.loadId !== 0) {
|
|
1351
|
+
obj.loadId = Math.round(message.loadId);
|
|
1352
|
+
}
|
|
1353
|
+
if (message.revision !== 0) {
|
|
1354
|
+
obj.revision = Math.round(message.revision);
|
|
1250
1355
|
}
|
|
1251
1356
|
return obj;
|
|
1252
1357
|
},
|
|
@@ -1255,17 +1360,32 @@ export const SetInstructionUpdateReq = {
|
|
|
1255
1360
|
},
|
|
1256
1361
|
fromPartial(object) {
|
|
1257
1362
|
const message = createBaseSetInstructionUpdateReq();
|
|
1258
|
-
message.
|
|
1259
|
-
? Instruction.fromPartial(object.
|
|
1363
|
+
message.replace = (object.replace !== undefined && object.replace !== null)
|
|
1364
|
+
? Instruction.fromPartial(object.replace)
|
|
1260
1365
|
: undefined;
|
|
1366
|
+
message.insert = (object.insert !== undefined && object.insert !== null)
|
|
1367
|
+
? InsertInstruction.fromPartial(object.insert)
|
|
1368
|
+
: undefined;
|
|
1369
|
+
message.removeId = object.removeId ?? undefined;
|
|
1370
|
+
message.loadId = object.loadId ?? 0;
|
|
1371
|
+
message.revision = object.revision ?? 0;
|
|
1261
1372
|
return message;
|
|
1262
1373
|
},
|
|
1263
1374
|
};
|
|
1264
1375
|
function createBaseSetInstructionUpdateRep() {
|
|
1265
|
-
return {};
|
|
1376
|
+
return { accepted: false, reason: "", revision: 0 };
|
|
1266
1377
|
}
|
|
1267
1378
|
export const SetInstructionUpdateRep = {
|
|
1268
|
-
encode(
|
|
1379
|
+
encode(message, writer = new BinaryWriter()) {
|
|
1380
|
+
if (message.accepted !== false) {
|
|
1381
|
+
writer.uint32(8).bool(message.accepted);
|
|
1382
|
+
}
|
|
1383
|
+
if (message.reason !== "") {
|
|
1384
|
+
writer.uint32(18).string(message.reason);
|
|
1385
|
+
}
|
|
1386
|
+
if (message.revision !== 0) {
|
|
1387
|
+
writer.uint32(24).uint32(message.revision);
|
|
1388
|
+
}
|
|
1269
1389
|
return writer;
|
|
1270
1390
|
},
|
|
1271
1391
|
decode(input, length) {
|
|
@@ -1275,6 +1395,27 @@ export const SetInstructionUpdateRep = {
|
|
|
1275
1395
|
while (reader.pos < end) {
|
|
1276
1396
|
const tag = reader.uint32();
|
|
1277
1397
|
switch (tag >>> 3) {
|
|
1398
|
+
case 1: {
|
|
1399
|
+
if (tag !== 8) {
|
|
1400
|
+
break;
|
|
1401
|
+
}
|
|
1402
|
+
message.accepted = reader.bool();
|
|
1403
|
+
continue;
|
|
1404
|
+
}
|
|
1405
|
+
case 2: {
|
|
1406
|
+
if (tag !== 18) {
|
|
1407
|
+
break;
|
|
1408
|
+
}
|
|
1409
|
+
message.reason = reader.string();
|
|
1410
|
+
continue;
|
|
1411
|
+
}
|
|
1412
|
+
case 3: {
|
|
1413
|
+
if (tag !== 24) {
|
|
1414
|
+
break;
|
|
1415
|
+
}
|
|
1416
|
+
message.revision = reader.uint32();
|
|
1417
|
+
continue;
|
|
1418
|
+
}
|
|
1278
1419
|
}
|
|
1279
1420
|
if ((tag & 7) === 4 || tag === 0) {
|
|
1280
1421
|
break;
|
|
@@ -1283,35 +1424,105 @@ export const SetInstructionUpdateRep = {
|
|
|
1283
1424
|
}
|
|
1284
1425
|
return message;
|
|
1285
1426
|
},
|
|
1286
|
-
fromJSON(
|
|
1287
|
-
return {
|
|
1427
|
+
fromJSON(object) {
|
|
1428
|
+
return {
|
|
1429
|
+
accepted: isSet(object.accepted) ? gt.Boolean(object.accepted) : false,
|
|
1430
|
+
reason: isSet(object.reason) ? gt.String(object.reason) : "",
|
|
1431
|
+
revision: isSet(object.revision) ? gt.Number(object.revision) : 0,
|
|
1432
|
+
};
|
|
1288
1433
|
},
|
|
1289
|
-
toJSON(
|
|
1434
|
+
toJSON(message) {
|
|
1290
1435
|
const obj = {};
|
|
1436
|
+
if (message.accepted !== false) {
|
|
1437
|
+
obj.accepted = message.accepted;
|
|
1438
|
+
}
|
|
1439
|
+
if (message.reason !== "") {
|
|
1440
|
+
obj.reason = message.reason;
|
|
1441
|
+
}
|
|
1442
|
+
if (message.revision !== 0) {
|
|
1443
|
+
obj.revision = Math.round(message.revision);
|
|
1444
|
+
}
|
|
1291
1445
|
return obj;
|
|
1292
1446
|
},
|
|
1293
1447
|
create(base) {
|
|
1294
1448
|
return SetInstructionUpdateRep.fromPartial(base ?? {});
|
|
1295
1449
|
},
|
|
1296
|
-
fromPartial(
|
|
1450
|
+
fromPartial(object) {
|
|
1297
1451
|
const message = createBaseSetInstructionUpdateRep();
|
|
1452
|
+
message.accepted = object.accepted ?? false;
|
|
1453
|
+
message.reason = object.reason ?? "";
|
|
1454
|
+
message.revision = object.revision ?? 0;
|
|
1298
1455
|
return message;
|
|
1299
1456
|
},
|
|
1300
1457
|
};
|
|
1301
|
-
function
|
|
1302
|
-
return {
|
|
1458
|
+
function createBaseSetMissionRulesReq() {
|
|
1459
|
+
return { rules: [] };
|
|
1303
1460
|
}
|
|
1304
|
-
export const
|
|
1461
|
+
export const SetMissionRulesReq = {
|
|
1305
1462
|
encode(message, writer = new BinaryWriter()) {
|
|
1306
|
-
|
|
1307
|
-
writer.uint32(
|
|
1463
|
+
for (const v of message.rules) {
|
|
1464
|
+
MissionRule.encode(v, writer.uint32(10).fork()).join();
|
|
1308
1465
|
}
|
|
1309
1466
|
return writer;
|
|
1310
1467
|
},
|
|
1311
1468
|
decode(input, length) {
|
|
1312
1469
|
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
1313
1470
|
const end = length === undefined ? reader.len : reader.pos + length;
|
|
1314
|
-
const message =
|
|
1471
|
+
const message = createBaseSetMissionRulesReq();
|
|
1472
|
+
while (reader.pos < end) {
|
|
1473
|
+
const tag = reader.uint32();
|
|
1474
|
+
switch (tag >>> 3) {
|
|
1475
|
+
case 1: {
|
|
1476
|
+
if (tag !== 10) {
|
|
1477
|
+
break;
|
|
1478
|
+
}
|
|
1479
|
+
message.rules.push(MissionRule.decode(reader, reader.uint32()));
|
|
1480
|
+
continue;
|
|
1481
|
+
}
|
|
1482
|
+
}
|
|
1483
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
1484
|
+
break;
|
|
1485
|
+
}
|
|
1486
|
+
reader.skip(tag & 7);
|
|
1487
|
+
}
|
|
1488
|
+
return message;
|
|
1489
|
+
},
|
|
1490
|
+
fromJSON(object) {
|
|
1491
|
+
return { rules: gt.Array.isArray(object?.rules) ? object.rules.map((e) => MissionRule.fromJSON(e)) : [] };
|
|
1492
|
+
},
|
|
1493
|
+
toJSON(message) {
|
|
1494
|
+
const obj = {};
|
|
1495
|
+
if (message.rules?.length) {
|
|
1496
|
+
obj.rules = message.rules.map((e) => MissionRule.toJSON(e));
|
|
1497
|
+
}
|
|
1498
|
+
return obj;
|
|
1499
|
+
},
|
|
1500
|
+
create(base) {
|
|
1501
|
+
return SetMissionRulesReq.fromPartial(base ?? {});
|
|
1502
|
+
},
|
|
1503
|
+
fromPartial(object) {
|
|
1504
|
+
const message = createBaseSetMissionRulesReq();
|
|
1505
|
+
message.rules = object.rules?.map((e) => MissionRule.fromPartial(e)) || [];
|
|
1506
|
+
return message;
|
|
1507
|
+
},
|
|
1508
|
+
};
|
|
1509
|
+
function createBaseSetMissionRulesRep() {
|
|
1510
|
+
return { accepted: false, reason: "" };
|
|
1511
|
+
}
|
|
1512
|
+
export const SetMissionRulesRep = {
|
|
1513
|
+
encode(message, writer = new BinaryWriter()) {
|
|
1514
|
+
if (message.accepted !== false) {
|
|
1515
|
+
writer.uint32(8).bool(message.accepted);
|
|
1516
|
+
}
|
|
1517
|
+
if (message.reason !== "") {
|
|
1518
|
+
writer.uint32(18).string(message.reason);
|
|
1519
|
+
}
|
|
1520
|
+
return writer;
|
|
1521
|
+
},
|
|
1522
|
+
decode(input, length) {
|
|
1523
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
1524
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
1525
|
+
const message = createBaseSetMissionRulesRep();
|
|
1315
1526
|
while (reader.pos < end) {
|
|
1316
1527
|
const tag = reader.uint32();
|
|
1317
1528
|
switch (tag >>> 3) {
|
|
@@ -1319,7 +1530,14 @@ export const SetHeadingModeReq = {
|
|
|
1319
1530
|
if (tag !== 8) {
|
|
1320
1531
|
break;
|
|
1321
1532
|
}
|
|
1322
|
-
message.
|
|
1533
|
+
message.accepted = reader.bool();
|
|
1534
|
+
continue;
|
|
1535
|
+
}
|
|
1536
|
+
case 2: {
|
|
1537
|
+
if (tag !== 18) {
|
|
1538
|
+
break;
|
|
1539
|
+
}
|
|
1540
|
+
message.reason = reader.string();
|
|
1323
1541
|
continue;
|
|
1324
1542
|
}
|
|
1325
1543
|
}
|
|
@@ -1331,35 +1549,42 @@ export const SetHeadingModeReq = {
|
|
|
1331
1549
|
return message;
|
|
1332
1550
|
},
|
|
1333
1551
|
fromJSON(object) {
|
|
1334
|
-
return {
|
|
1552
|
+
return {
|
|
1553
|
+
accepted: isSet(object.accepted) ? gt.Boolean(object.accepted) : false,
|
|
1554
|
+
reason: isSet(object.reason) ? gt.String(object.reason) : "",
|
|
1555
|
+
};
|
|
1335
1556
|
},
|
|
1336
1557
|
toJSON(message) {
|
|
1337
1558
|
const obj = {};
|
|
1338
|
-
if (message.
|
|
1339
|
-
obj.
|
|
1559
|
+
if (message.accepted !== false) {
|
|
1560
|
+
obj.accepted = message.accepted;
|
|
1561
|
+
}
|
|
1562
|
+
if (message.reason !== "") {
|
|
1563
|
+
obj.reason = message.reason;
|
|
1340
1564
|
}
|
|
1341
1565
|
return obj;
|
|
1342
1566
|
},
|
|
1343
1567
|
create(base) {
|
|
1344
|
-
return
|
|
1568
|
+
return SetMissionRulesRep.fromPartial(base ?? {});
|
|
1345
1569
|
},
|
|
1346
1570
|
fromPartial(object) {
|
|
1347
|
-
const message =
|
|
1348
|
-
message.
|
|
1571
|
+
const message = createBaseSetMissionRulesRep();
|
|
1572
|
+
message.accepted = object.accepted ?? false;
|
|
1573
|
+
message.reason = object.reason ?? "";
|
|
1349
1574
|
return message;
|
|
1350
1575
|
},
|
|
1351
1576
|
};
|
|
1352
|
-
function
|
|
1577
|
+
function createBaseGetMissionRulesReq() {
|
|
1353
1578
|
return {};
|
|
1354
1579
|
}
|
|
1355
|
-
export const
|
|
1580
|
+
export const GetMissionRulesReq = {
|
|
1356
1581
|
encode(_, writer = new BinaryWriter()) {
|
|
1357
1582
|
return writer;
|
|
1358
1583
|
},
|
|
1359
1584
|
decode(input, length) {
|
|
1360
1585
|
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
1361
1586
|
const end = length === undefined ? reader.len : reader.pos + length;
|
|
1362
|
-
const message =
|
|
1587
|
+
const message = createBaseGetMissionRulesReq();
|
|
1363
1588
|
while (reader.pos < end) {
|
|
1364
1589
|
const tag = reader.uint32();
|
|
1365
1590
|
switch (tag >>> 3) {
|
|
@@ -1379,30 +1604,27 @@ export const SetHeadingModeRep = {
|
|
|
1379
1604
|
return obj;
|
|
1380
1605
|
},
|
|
1381
1606
|
create(base) {
|
|
1382
|
-
return
|
|
1607
|
+
return GetMissionRulesReq.fromPartial(base ?? {});
|
|
1383
1608
|
},
|
|
1384
1609
|
fromPartial(_) {
|
|
1385
|
-
const message =
|
|
1610
|
+
const message = createBaseGetMissionRulesReq();
|
|
1386
1611
|
return message;
|
|
1387
1612
|
},
|
|
1388
1613
|
};
|
|
1389
|
-
function
|
|
1390
|
-
return {
|
|
1614
|
+
function createBaseGetMissionRulesRep() {
|
|
1615
|
+
return { rules: [] };
|
|
1391
1616
|
}
|
|
1392
|
-
export const
|
|
1617
|
+
export const GetMissionRulesRep = {
|
|
1393
1618
|
encode(message, writer = new BinaryWriter()) {
|
|
1394
|
-
|
|
1395
|
-
writer.uint32(10).
|
|
1396
|
-
}
|
|
1397
|
-
if (message.frequency !== 0) {
|
|
1398
|
-
writer.uint32(21).float(message.frequency);
|
|
1619
|
+
for (const v of message.rules) {
|
|
1620
|
+
MissionRule.encode(v, writer.uint32(10).fork()).join();
|
|
1399
1621
|
}
|
|
1400
1622
|
return writer;
|
|
1401
1623
|
},
|
|
1402
1624
|
decode(input, length) {
|
|
1403
1625
|
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
1404
1626
|
const end = length === undefined ? reader.len : reader.pos + length;
|
|
1405
|
-
const message =
|
|
1627
|
+
const message = createBaseGetMissionRulesRep();
|
|
1406
1628
|
while (reader.pos < end) {
|
|
1407
1629
|
const tag = reader.uint32();
|
|
1408
1630
|
switch (tag >>> 3) {
|
|
@@ -1410,14 +1632,7 @@ export const SetPubFrequencyReq = {
|
|
|
1410
1632
|
if (tag !== 10) {
|
|
1411
1633
|
break;
|
|
1412
1634
|
}
|
|
1413
|
-
message.
|
|
1414
|
-
continue;
|
|
1415
|
-
}
|
|
1416
|
-
case 2: {
|
|
1417
|
-
if (tag !== 21) {
|
|
1418
|
-
break;
|
|
1419
|
-
}
|
|
1420
|
-
message.frequency = reader.float();
|
|
1635
|
+
message.rules.push(MissionRule.decode(reader, reader.uint32()));
|
|
1421
1636
|
continue;
|
|
1422
1637
|
}
|
|
1423
1638
|
}
|
|
@@ -1429,45 +1644,38 @@ export const SetPubFrequencyReq = {
|
|
|
1429
1644
|
return message;
|
|
1430
1645
|
},
|
|
1431
1646
|
fromJSON(object) {
|
|
1432
|
-
return {
|
|
1433
|
-
messageType: isSet(object.messageType) ? gt.String(object.messageType) : "",
|
|
1434
|
-
frequency: isSet(object.frequency) ? gt.Number(object.frequency) : 0,
|
|
1435
|
-
};
|
|
1647
|
+
return { rules: gt.Array.isArray(object?.rules) ? object.rules.map((e) => MissionRule.fromJSON(e)) : [] };
|
|
1436
1648
|
},
|
|
1437
1649
|
toJSON(message) {
|
|
1438
1650
|
const obj = {};
|
|
1439
|
-
if (message.
|
|
1440
|
-
obj.
|
|
1441
|
-
}
|
|
1442
|
-
if (message.frequency !== 0) {
|
|
1443
|
-
obj.frequency = message.frequency;
|
|
1651
|
+
if (message.rules?.length) {
|
|
1652
|
+
obj.rules = message.rules.map((e) => MissionRule.toJSON(e));
|
|
1444
1653
|
}
|
|
1445
1654
|
return obj;
|
|
1446
1655
|
},
|
|
1447
1656
|
create(base) {
|
|
1448
|
-
return
|
|
1657
|
+
return GetMissionRulesRep.fromPartial(base ?? {});
|
|
1449
1658
|
},
|
|
1450
1659
|
fromPartial(object) {
|
|
1451
|
-
const message =
|
|
1452
|
-
message.
|
|
1453
|
-
message.frequency = object.frequency ?? 0;
|
|
1660
|
+
const message = createBaseGetMissionRulesRep();
|
|
1661
|
+
message.rules = object.rules?.map((e) => MissionRule.fromPartial(e)) || [];
|
|
1454
1662
|
return message;
|
|
1455
1663
|
},
|
|
1456
1664
|
};
|
|
1457
|
-
function
|
|
1458
|
-
return {
|
|
1665
|
+
function createBaseSetHeadingModeReq() {
|
|
1666
|
+
return { headingMode: 0 };
|
|
1459
1667
|
}
|
|
1460
|
-
export const
|
|
1668
|
+
export const SetHeadingModeReq = {
|
|
1461
1669
|
encode(message, writer = new BinaryWriter()) {
|
|
1462
|
-
if (message.
|
|
1463
|
-
writer.uint32(8).
|
|
1670
|
+
if (message.headingMode !== 0) {
|
|
1671
|
+
writer.uint32(8).int32(message.headingMode);
|
|
1464
1672
|
}
|
|
1465
1673
|
return writer;
|
|
1466
1674
|
},
|
|
1467
1675
|
decode(input, length) {
|
|
1468
1676
|
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
1469
1677
|
const end = length === undefined ? reader.len : reader.pos + length;
|
|
1470
|
-
const message =
|
|
1678
|
+
const message = createBaseSetHeadingModeReq();
|
|
1471
1679
|
while (reader.pos < end) {
|
|
1472
1680
|
const tag = reader.uint32();
|
|
1473
1681
|
switch (tag >>> 3) {
|
|
@@ -1475,7 +1683,7 @@ export const SetPubFrequencyRep = {
|
|
|
1475
1683
|
if (tag !== 8) {
|
|
1476
1684
|
break;
|
|
1477
1685
|
}
|
|
1478
|
-
message.
|
|
1686
|
+
message.headingMode = reader.int32();
|
|
1479
1687
|
continue;
|
|
1480
1688
|
}
|
|
1481
1689
|
}
|
|
@@ -1487,41 +1695,78 @@ export const SetPubFrequencyRep = {
|
|
|
1487
1695
|
return message;
|
|
1488
1696
|
},
|
|
1489
1697
|
fromJSON(object) {
|
|
1490
|
-
return {
|
|
1698
|
+
return { headingMode: isSet(object.headingMode) ? headingModeFromJSON(object.headingMode) : 0 };
|
|
1491
1699
|
},
|
|
1492
1700
|
toJSON(message) {
|
|
1493
1701
|
const obj = {};
|
|
1494
|
-
if (message.
|
|
1495
|
-
obj.
|
|
1702
|
+
if (message.headingMode !== 0) {
|
|
1703
|
+
obj.headingMode = headingModeToJSON(message.headingMode);
|
|
1496
1704
|
}
|
|
1497
1705
|
return obj;
|
|
1498
1706
|
},
|
|
1499
1707
|
create(base) {
|
|
1500
|
-
return
|
|
1708
|
+
return SetHeadingModeReq.fromPartial(base ?? {});
|
|
1501
1709
|
},
|
|
1502
1710
|
fromPartial(object) {
|
|
1503
|
-
const message =
|
|
1504
|
-
message.
|
|
1711
|
+
const message = createBaseSetHeadingModeReq();
|
|
1712
|
+
message.headingMode = object.headingMode ?? 0;
|
|
1505
1713
|
return message;
|
|
1506
1714
|
},
|
|
1507
1715
|
};
|
|
1508
|
-
function
|
|
1509
|
-
return {
|
|
1716
|
+
function createBaseSetHeadingModeRep() {
|
|
1717
|
+
return {};
|
|
1510
1718
|
}
|
|
1511
|
-
export const
|
|
1512
|
-
encode(
|
|
1513
|
-
if (message.messageType !== "") {
|
|
1514
|
-
writer.uint32(10).string(message.messageType);
|
|
1515
|
-
}
|
|
1516
|
-
if (message.frequency !== 0) {
|
|
1517
|
-
writer.uint32(21).float(message.frequency);
|
|
1518
|
-
}
|
|
1719
|
+
export const SetHeadingModeRep = {
|
|
1720
|
+
encode(_, writer = new BinaryWriter()) {
|
|
1519
1721
|
return writer;
|
|
1520
1722
|
},
|
|
1521
1723
|
decode(input, length) {
|
|
1522
1724
|
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
1523
1725
|
const end = length === undefined ? reader.len : reader.pos + length;
|
|
1524
|
-
const message =
|
|
1726
|
+
const message = createBaseSetHeadingModeRep();
|
|
1727
|
+
while (reader.pos < end) {
|
|
1728
|
+
const tag = reader.uint32();
|
|
1729
|
+
switch (tag >>> 3) {
|
|
1730
|
+
}
|
|
1731
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
1732
|
+
break;
|
|
1733
|
+
}
|
|
1734
|
+
reader.skip(tag & 7);
|
|
1735
|
+
}
|
|
1736
|
+
return message;
|
|
1737
|
+
},
|
|
1738
|
+
fromJSON(_) {
|
|
1739
|
+
return {};
|
|
1740
|
+
},
|
|
1741
|
+
toJSON(_) {
|
|
1742
|
+
const obj = {};
|
|
1743
|
+
return obj;
|
|
1744
|
+
},
|
|
1745
|
+
create(base) {
|
|
1746
|
+
return SetHeadingModeRep.fromPartial(base ?? {});
|
|
1747
|
+
},
|
|
1748
|
+
fromPartial(_) {
|
|
1749
|
+
const message = createBaseSetHeadingModeRep();
|
|
1750
|
+
return message;
|
|
1751
|
+
},
|
|
1752
|
+
};
|
|
1753
|
+
function createBaseSetPubFrequencyReq() {
|
|
1754
|
+
return { messageType: "", frequency: 0 };
|
|
1755
|
+
}
|
|
1756
|
+
export const SetPubFrequencyReq = {
|
|
1757
|
+
encode(message, writer = new BinaryWriter()) {
|
|
1758
|
+
if (message.messageType !== "") {
|
|
1759
|
+
writer.uint32(10).string(message.messageType);
|
|
1760
|
+
}
|
|
1761
|
+
if (message.frequency !== 0) {
|
|
1762
|
+
writer.uint32(21).float(message.frequency);
|
|
1763
|
+
}
|
|
1764
|
+
return writer;
|
|
1765
|
+
},
|
|
1766
|
+
decode(input, length) {
|
|
1767
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
1768
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
1769
|
+
const message = createBaseSetPubFrequencyReq();
|
|
1525
1770
|
while (reader.pos < end) {
|
|
1526
1771
|
const tag = reader.uint32();
|
|
1527
1772
|
switch (tag >>> 3) {
|
|
@@ -1564,19 +1809,19 @@ export const SetLogFrequencyReq = {
|
|
|
1564
1809
|
return obj;
|
|
1565
1810
|
},
|
|
1566
1811
|
create(base) {
|
|
1567
|
-
return
|
|
1812
|
+
return SetPubFrequencyReq.fromPartial(base ?? {});
|
|
1568
1813
|
},
|
|
1569
1814
|
fromPartial(object) {
|
|
1570
|
-
const message =
|
|
1815
|
+
const message = createBaseSetPubFrequencyReq();
|
|
1571
1816
|
message.messageType = object.messageType ?? "";
|
|
1572
1817
|
message.frequency = object.frequency ?? 0;
|
|
1573
1818
|
return message;
|
|
1574
1819
|
},
|
|
1575
1820
|
};
|
|
1576
|
-
function
|
|
1821
|
+
function createBaseSetPubFrequencyRep() {
|
|
1577
1822
|
return { success: false };
|
|
1578
1823
|
}
|
|
1579
|
-
export const
|
|
1824
|
+
export const SetPubFrequencyRep = {
|
|
1580
1825
|
encode(message, writer = new BinaryWriter()) {
|
|
1581
1826
|
if (message.success !== false) {
|
|
1582
1827
|
writer.uint32(8).bool(message.success);
|
|
@@ -1586,7 +1831,7 @@ export const SetLogFrequencyRep = {
|
|
|
1586
1831
|
decode(input, length) {
|
|
1587
1832
|
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
1588
1833
|
const end = length === undefined ? reader.len : reader.pos + length;
|
|
1589
|
-
const message =
|
|
1834
|
+
const message = createBaseSetPubFrequencyRep();
|
|
1590
1835
|
while (reader.pos < end) {
|
|
1591
1836
|
const tag = reader.uint32();
|
|
1592
1837
|
switch (tag >>> 3) {
|
|
@@ -1616,28 +1861,31 @@ export const SetLogFrequencyRep = {
|
|
|
1616
1861
|
return obj;
|
|
1617
1862
|
},
|
|
1618
1863
|
create(base) {
|
|
1619
|
-
return
|
|
1864
|
+
return SetPubFrequencyRep.fromPartial(base ?? {});
|
|
1620
1865
|
},
|
|
1621
1866
|
fromPartial(object) {
|
|
1622
|
-
const message =
|
|
1867
|
+
const message = createBaseSetPubFrequencyRep();
|
|
1623
1868
|
message.success = object.success ?? false;
|
|
1624
1869
|
return message;
|
|
1625
1870
|
},
|
|
1626
1871
|
};
|
|
1627
|
-
function
|
|
1628
|
-
return { messageType: "" };
|
|
1872
|
+
function createBaseSetLogFrequencyReq() {
|
|
1873
|
+
return { messageType: "", frequency: 0 };
|
|
1629
1874
|
}
|
|
1630
|
-
export const
|
|
1875
|
+
export const SetLogFrequencyReq = {
|
|
1631
1876
|
encode(message, writer = new BinaryWriter()) {
|
|
1632
1877
|
if (message.messageType !== "") {
|
|
1633
1878
|
writer.uint32(10).string(message.messageType);
|
|
1634
1879
|
}
|
|
1880
|
+
if (message.frequency !== 0) {
|
|
1881
|
+
writer.uint32(21).float(message.frequency);
|
|
1882
|
+
}
|
|
1635
1883
|
return writer;
|
|
1636
1884
|
},
|
|
1637
1885
|
decode(input, length) {
|
|
1638
1886
|
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
1639
1887
|
const end = length === undefined ? reader.len : reader.pos + length;
|
|
1640
|
-
const message =
|
|
1888
|
+
const message = createBaseSetLogFrequencyReq();
|
|
1641
1889
|
while (reader.pos < end) {
|
|
1642
1890
|
const tag = reader.uint32();
|
|
1643
1891
|
switch (tag >>> 3) {
|
|
@@ -1648,6 +1896,13 @@ export const GetTelemetryReq = {
|
|
|
1648
1896
|
message.messageType = reader.string();
|
|
1649
1897
|
continue;
|
|
1650
1898
|
}
|
|
1899
|
+
case 2: {
|
|
1900
|
+
if (tag !== 21) {
|
|
1901
|
+
break;
|
|
1902
|
+
}
|
|
1903
|
+
message.frequency = reader.float();
|
|
1904
|
+
continue;
|
|
1905
|
+
}
|
|
1651
1906
|
}
|
|
1652
1907
|
if ((tag & 7) === 4 || tag === 0) {
|
|
1653
1908
|
break;
|
|
@@ -1657,46 +1912,53 @@ export const GetTelemetryReq = {
|
|
|
1657
1912
|
return message;
|
|
1658
1913
|
},
|
|
1659
1914
|
fromJSON(object) {
|
|
1660
|
-
return {
|
|
1915
|
+
return {
|
|
1916
|
+
messageType: isSet(object.messageType) ? gt.String(object.messageType) : "",
|
|
1917
|
+
frequency: isSet(object.frequency) ? gt.Number(object.frequency) : 0,
|
|
1918
|
+
};
|
|
1661
1919
|
},
|
|
1662
1920
|
toJSON(message) {
|
|
1663
1921
|
const obj = {};
|
|
1664
1922
|
if (message.messageType !== "") {
|
|
1665
1923
|
obj.messageType = message.messageType;
|
|
1666
1924
|
}
|
|
1925
|
+
if (message.frequency !== 0) {
|
|
1926
|
+
obj.frequency = message.frequency;
|
|
1927
|
+
}
|
|
1667
1928
|
return obj;
|
|
1668
1929
|
},
|
|
1669
1930
|
create(base) {
|
|
1670
|
-
return
|
|
1931
|
+
return SetLogFrequencyReq.fromPartial(base ?? {});
|
|
1671
1932
|
},
|
|
1672
1933
|
fromPartial(object) {
|
|
1673
|
-
const message =
|
|
1934
|
+
const message = createBaseSetLogFrequencyReq();
|
|
1674
1935
|
message.messageType = object.messageType ?? "";
|
|
1936
|
+
message.frequency = object.frequency ?? 0;
|
|
1675
1937
|
return message;
|
|
1676
1938
|
},
|
|
1677
1939
|
};
|
|
1678
|
-
function
|
|
1679
|
-
return {
|
|
1940
|
+
function createBaseSetLogFrequencyRep() {
|
|
1941
|
+
return { success: false };
|
|
1680
1942
|
}
|
|
1681
|
-
export const
|
|
1943
|
+
export const SetLogFrequencyRep = {
|
|
1682
1944
|
encode(message, writer = new BinaryWriter()) {
|
|
1683
|
-
if (message.
|
|
1684
|
-
|
|
1945
|
+
if (message.success !== false) {
|
|
1946
|
+
writer.uint32(8).bool(message.success);
|
|
1685
1947
|
}
|
|
1686
1948
|
return writer;
|
|
1687
1949
|
},
|
|
1688
1950
|
decode(input, length) {
|
|
1689
1951
|
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
1690
1952
|
const end = length === undefined ? reader.len : reader.pos + length;
|
|
1691
|
-
const message =
|
|
1953
|
+
const message = createBaseSetLogFrequencyRep();
|
|
1692
1954
|
while (reader.pos < end) {
|
|
1693
1955
|
const tag = reader.uint32();
|
|
1694
1956
|
switch (tag >>> 3) {
|
|
1695
1957
|
case 1: {
|
|
1696
|
-
if (tag !==
|
|
1958
|
+
if (tag !== 8) {
|
|
1697
1959
|
break;
|
|
1698
1960
|
}
|
|
1699
|
-
message.
|
|
1961
|
+
message.success = reader.bool();
|
|
1700
1962
|
continue;
|
|
1701
1963
|
}
|
|
1702
1964
|
}
|
|
@@ -1708,40 +1970,38 @@ export const GetTelemetryRep = {
|
|
|
1708
1970
|
return message;
|
|
1709
1971
|
},
|
|
1710
1972
|
fromJSON(object) {
|
|
1711
|
-
return {
|
|
1973
|
+
return { success: isSet(object.success) ? gt.Boolean(object.success) : false };
|
|
1712
1974
|
},
|
|
1713
1975
|
toJSON(message) {
|
|
1714
1976
|
const obj = {};
|
|
1715
|
-
if (message.
|
|
1716
|
-
obj.
|
|
1977
|
+
if (message.success !== false) {
|
|
1978
|
+
obj.success = message.success;
|
|
1717
1979
|
}
|
|
1718
1980
|
return obj;
|
|
1719
1981
|
},
|
|
1720
1982
|
create(base) {
|
|
1721
|
-
return
|
|
1983
|
+
return SetLogFrequencyRep.fromPartial(base ?? {});
|
|
1722
1984
|
},
|
|
1723
1985
|
fromPartial(object) {
|
|
1724
|
-
const message =
|
|
1725
|
-
message.
|
|
1726
|
-
? Any.fromPartial(object.payload)
|
|
1727
|
-
: undefined;
|
|
1986
|
+
const message = createBaseSetLogFrequencyRep();
|
|
1987
|
+
message.success = object.success ?? false;
|
|
1728
1988
|
return message;
|
|
1729
1989
|
},
|
|
1730
1990
|
};
|
|
1731
|
-
function
|
|
1732
|
-
return {
|
|
1991
|
+
function createBaseResetPubFrequencyReq() {
|
|
1992
|
+
return { messageType: "" };
|
|
1733
1993
|
}
|
|
1734
|
-
export const
|
|
1994
|
+
export const ResetPubFrequencyReq = {
|
|
1735
1995
|
encode(message, writer = new BinaryWriter()) {
|
|
1736
|
-
if (message.
|
|
1737
|
-
|
|
1996
|
+
if (message.messageType !== "") {
|
|
1997
|
+
writer.uint32(10).string(message.messageType);
|
|
1738
1998
|
}
|
|
1739
1999
|
return writer;
|
|
1740
2000
|
},
|
|
1741
2001
|
decode(input, length) {
|
|
1742
2002
|
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
1743
2003
|
const end = length === undefined ? reader.len : reader.pos + length;
|
|
1744
|
-
const message =
|
|
2004
|
+
const message = createBaseResetPubFrequencyReq();
|
|
1745
2005
|
while (reader.pos < end) {
|
|
1746
2006
|
const tag = reader.uint32();
|
|
1747
2007
|
switch (tag >>> 3) {
|
|
@@ -1749,7 +2009,7 @@ export const SetPersistentStorageSettingsReq = {
|
|
|
1749
2009
|
if (tag !== 10) {
|
|
1750
2010
|
break;
|
|
1751
2011
|
}
|
|
1752
|
-
message.
|
|
2012
|
+
message.messageType = reader.string();
|
|
1753
2013
|
continue;
|
|
1754
2014
|
}
|
|
1755
2015
|
}
|
|
@@ -1761,35 +2021,28 @@ export const SetPersistentStorageSettingsReq = {
|
|
|
1761
2021
|
return message;
|
|
1762
2022
|
},
|
|
1763
2023
|
fromJSON(object) {
|
|
1764
|
-
return {
|
|
1765
|
-
persistentStorageSettings: isSet(object.persistentStorageSettings)
|
|
1766
|
-
? PersistentStorageSettings.fromJSON(object.persistentStorageSettings)
|
|
1767
|
-
: undefined,
|
|
1768
|
-
};
|
|
2024
|
+
return { messageType: isSet(object.messageType) ? gt.String(object.messageType) : "" };
|
|
1769
2025
|
},
|
|
1770
2026
|
toJSON(message) {
|
|
1771
2027
|
const obj = {};
|
|
1772
|
-
if (message.
|
|
1773
|
-
obj.
|
|
2028
|
+
if (message.messageType !== "") {
|
|
2029
|
+
obj.messageType = message.messageType;
|
|
1774
2030
|
}
|
|
1775
2031
|
return obj;
|
|
1776
2032
|
},
|
|
1777
2033
|
create(base) {
|
|
1778
|
-
return
|
|
2034
|
+
return ResetPubFrequencyReq.fromPartial(base ?? {});
|
|
1779
2035
|
},
|
|
1780
2036
|
fromPartial(object) {
|
|
1781
|
-
const message =
|
|
1782
|
-
message.
|
|
1783
|
-
(object.persistentStorageSettings !== undefined && object.persistentStorageSettings !== null)
|
|
1784
|
-
? PersistentStorageSettings.fromPartial(object.persistentStorageSettings)
|
|
1785
|
-
: undefined;
|
|
2037
|
+
const message = createBaseResetPubFrequencyReq();
|
|
2038
|
+
message.messageType = object.messageType ?? "";
|
|
1786
2039
|
return message;
|
|
1787
2040
|
},
|
|
1788
2041
|
};
|
|
1789
|
-
function
|
|
2042
|
+
function createBaseResetPubFrequencyRep() {
|
|
1790
2043
|
return { success: false };
|
|
1791
2044
|
}
|
|
1792
|
-
export const
|
|
2045
|
+
export const ResetPubFrequencyRep = {
|
|
1793
2046
|
encode(message, writer = new BinaryWriter()) {
|
|
1794
2047
|
if (message.success !== false) {
|
|
1795
2048
|
writer.uint32(8).bool(message.success);
|
|
@@ -1799,7 +2052,7 @@ export const SetPersistentStorageSettingsRep = {
|
|
|
1799
2052
|
decode(input, length) {
|
|
1800
2053
|
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
1801
2054
|
const end = length === undefined ? reader.len : reader.pos + length;
|
|
1802
|
-
const message =
|
|
2055
|
+
const message = createBaseResetPubFrequencyRep();
|
|
1803
2056
|
while (reader.pos < end) {
|
|
1804
2057
|
const tag = reader.uint32();
|
|
1805
2058
|
switch (tag >>> 3) {
|
|
@@ -1829,28 +2082,38 @@ export const SetPersistentStorageSettingsRep = {
|
|
|
1829
2082
|
return obj;
|
|
1830
2083
|
},
|
|
1831
2084
|
create(base) {
|
|
1832
|
-
return
|
|
2085
|
+
return ResetPubFrequencyRep.fromPartial(base ?? {});
|
|
1833
2086
|
},
|
|
1834
2087
|
fromPartial(object) {
|
|
1835
|
-
const message =
|
|
2088
|
+
const message = createBaseResetPubFrequencyRep();
|
|
1836
2089
|
message.success = object.success ?? false;
|
|
1837
2090
|
return message;
|
|
1838
2091
|
},
|
|
1839
2092
|
};
|
|
1840
|
-
function
|
|
1841
|
-
return {};
|
|
2093
|
+
function createBaseResetLogFrequencyReq() {
|
|
2094
|
+
return { messageType: "" };
|
|
1842
2095
|
}
|
|
1843
|
-
export const
|
|
1844
|
-
encode(
|
|
2096
|
+
export const ResetLogFrequencyReq = {
|
|
2097
|
+
encode(message, writer = new BinaryWriter()) {
|
|
2098
|
+
if (message.messageType !== "") {
|
|
2099
|
+
writer.uint32(10).string(message.messageType);
|
|
2100
|
+
}
|
|
1845
2101
|
return writer;
|
|
1846
2102
|
},
|
|
1847
2103
|
decode(input, length) {
|
|
1848
2104
|
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
1849
2105
|
const end = length === undefined ? reader.len : reader.pos + length;
|
|
1850
|
-
const message =
|
|
2106
|
+
const message = createBaseResetLogFrequencyReq();
|
|
1851
2107
|
while (reader.pos < end) {
|
|
1852
2108
|
const tag = reader.uint32();
|
|
1853
2109
|
switch (tag >>> 3) {
|
|
2110
|
+
case 1: {
|
|
2111
|
+
if (tag !== 10) {
|
|
2112
|
+
break;
|
|
2113
|
+
}
|
|
2114
|
+
message.messageType = reader.string();
|
|
2115
|
+
continue;
|
|
2116
|
+
}
|
|
1854
2117
|
}
|
|
1855
2118
|
if ((tag & 7) === 4 || tag === 0) {
|
|
1856
2119
|
break;
|
|
@@ -1859,43 +2122,47 @@ export const GetPersistentStorageSettingsReq = {
|
|
|
1859
2122
|
}
|
|
1860
2123
|
return message;
|
|
1861
2124
|
},
|
|
1862
|
-
fromJSON(
|
|
1863
|
-
return {};
|
|
2125
|
+
fromJSON(object) {
|
|
2126
|
+
return { messageType: isSet(object.messageType) ? gt.String(object.messageType) : "" };
|
|
1864
2127
|
},
|
|
1865
|
-
toJSON(
|
|
2128
|
+
toJSON(message) {
|
|
1866
2129
|
const obj = {};
|
|
2130
|
+
if (message.messageType !== "") {
|
|
2131
|
+
obj.messageType = message.messageType;
|
|
2132
|
+
}
|
|
1867
2133
|
return obj;
|
|
1868
2134
|
},
|
|
1869
2135
|
create(base) {
|
|
1870
|
-
return
|
|
2136
|
+
return ResetLogFrequencyReq.fromPartial(base ?? {});
|
|
1871
2137
|
},
|
|
1872
|
-
fromPartial(
|
|
1873
|
-
const message =
|
|
2138
|
+
fromPartial(object) {
|
|
2139
|
+
const message = createBaseResetLogFrequencyReq();
|
|
2140
|
+
message.messageType = object.messageType ?? "";
|
|
1874
2141
|
return message;
|
|
1875
2142
|
},
|
|
1876
2143
|
};
|
|
1877
|
-
function
|
|
1878
|
-
return {
|
|
2144
|
+
function createBaseResetLogFrequencyRep() {
|
|
2145
|
+
return { success: false };
|
|
1879
2146
|
}
|
|
1880
|
-
export const
|
|
2147
|
+
export const ResetLogFrequencyRep = {
|
|
1881
2148
|
encode(message, writer = new BinaryWriter()) {
|
|
1882
|
-
if (message.
|
|
1883
|
-
|
|
2149
|
+
if (message.success !== false) {
|
|
2150
|
+
writer.uint32(8).bool(message.success);
|
|
1884
2151
|
}
|
|
1885
2152
|
return writer;
|
|
1886
2153
|
},
|
|
1887
2154
|
decode(input, length) {
|
|
1888
2155
|
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
1889
2156
|
const end = length === undefined ? reader.len : reader.pos + length;
|
|
1890
|
-
const message =
|
|
2157
|
+
const message = createBaseResetLogFrequencyRep();
|
|
1891
2158
|
while (reader.pos < end) {
|
|
1892
2159
|
const tag = reader.uint32();
|
|
1893
2160
|
switch (tag >>> 3) {
|
|
1894
2161
|
case 1: {
|
|
1895
|
-
if (tag !==
|
|
2162
|
+
if (tag !== 8) {
|
|
1896
2163
|
break;
|
|
1897
2164
|
}
|
|
1898
|
-
message.
|
|
2165
|
+
message.success = reader.bool();
|
|
1899
2166
|
continue;
|
|
1900
2167
|
}
|
|
1901
2168
|
}
|
|
@@ -1907,53 +2174,46 @@ export const GetPersistentStorageSettingsRep = {
|
|
|
1907
2174
|
return message;
|
|
1908
2175
|
},
|
|
1909
2176
|
fromJSON(object) {
|
|
1910
|
-
return {
|
|
1911
|
-
persistentStorageSettings: isSet(object.persistentStorageSettings)
|
|
1912
|
-
? PersistentStorageSettings.fromJSON(object.persistentStorageSettings)
|
|
1913
|
-
: undefined,
|
|
1914
|
-
};
|
|
2177
|
+
return { success: isSet(object.success) ? gt.Boolean(object.success) : false };
|
|
1915
2178
|
},
|
|
1916
2179
|
toJSON(message) {
|
|
1917
2180
|
const obj = {};
|
|
1918
|
-
if (message.
|
|
1919
|
-
obj.
|
|
2181
|
+
if (message.success !== false) {
|
|
2182
|
+
obj.success = message.success;
|
|
1920
2183
|
}
|
|
1921
2184
|
return obj;
|
|
1922
2185
|
},
|
|
1923
2186
|
create(base) {
|
|
1924
|
-
return
|
|
2187
|
+
return ResetLogFrequencyRep.fromPartial(base ?? {});
|
|
1925
2188
|
},
|
|
1926
2189
|
fromPartial(object) {
|
|
1927
|
-
const message =
|
|
1928
|
-
message.
|
|
1929
|
-
(object.persistentStorageSettings !== undefined && object.persistentStorageSettings !== null)
|
|
1930
|
-
? PersistentStorageSettings.fromPartial(object.persistentStorageSettings)
|
|
1931
|
-
: undefined;
|
|
2190
|
+
const message = createBaseResetLogFrequencyRep();
|
|
2191
|
+
message.success = object.success ?? false;
|
|
1932
2192
|
return message;
|
|
1933
2193
|
},
|
|
1934
2194
|
};
|
|
1935
|
-
function
|
|
1936
|
-
return {
|
|
2195
|
+
function createBaseGetTelemetryReq() {
|
|
2196
|
+
return { messageType: "" };
|
|
1937
2197
|
}
|
|
1938
|
-
export const
|
|
2198
|
+
export const GetTelemetryReq = {
|
|
1939
2199
|
encode(message, writer = new BinaryWriter()) {
|
|
1940
|
-
if (message.
|
|
1941
|
-
writer.uint32(
|
|
2200
|
+
if (message.messageType !== "") {
|
|
2201
|
+
writer.uint32(10).string(message.messageType);
|
|
1942
2202
|
}
|
|
1943
2203
|
return writer;
|
|
1944
2204
|
},
|
|
1945
2205
|
decode(input, length) {
|
|
1946
2206
|
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
1947
2207
|
const end = length === undefined ? reader.len : reader.pos + length;
|
|
1948
|
-
const message =
|
|
2208
|
+
const message = createBaseGetTelemetryReq();
|
|
1949
2209
|
while (reader.pos < end) {
|
|
1950
2210
|
const tag = reader.uint32();
|
|
1951
2211
|
switch (tag >>> 3) {
|
|
1952
2212
|
case 1: {
|
|
1953
|
-
if (tag !==
|
|
2213
|
+
if (tag !== 10) {
|
|
1954
2214
|
break;
|
|
1955
2215
|
}
|
|
1956
|
-
message.
|
|
2216
|
+
message.messageType = reader.string();
|
|
1957
2217
|
continue;
|
|
1958
2218
|
}
|
|
1959
2219
|
}
|
|
@@ -1965,46 +2225,46 @@ export const FlashEscSettingsReq = {
|
|
|
1965
2225
|
return message;
|
|
1966
2226
|
},
|
|
1967
2227
|
fromJSON(object) {
|
|
1968
|
-
return {
|
|
2228
|
+
return { messageType: isSet(object.messageType) ? gt.String(object.messageType) : "" };
|
|
1969
2229
|
},
|
|
1970
2230
|
toJSON(message) {
|
|
1971
2231
|
const obj = {};
|
|
1972
|
-
if (message.
|
|
1973
|
-
obj.
|
|
2232
|
+
if (message.messageType !== "") {
|
|
2233
|
+
obj.messageType = message.messageType;
|
|
1974
2234
|
}
|
|
1975
2235
|
return obj;
|
|
1976
2236
|
},
|
|
1977
2237
|
create(base) {
|
|
1978
|
-
return
|
|
2238
|
+
return GetTelemetryReq.fromPartial(base ?? {});
|
|
1979
2239
|
},
|
|
1980
2240
|
fromPartial(object) {
|
|
1981
|
-
const message =
|
|
1982
|
-
message.
|
|
2241
|
+
const message = createBaseGetTelemetryReq();
|
|
2242
|
+
message.messageType = object.messageType ?? "";
|
|
1983
2243
|
return message;
|
|
1984
2244
|
},
|
|
1985
2245
|
};
|
|
1986
|
-
function
|
|
1987
|
-
return {
|
|
2246
|
+
function createBaseGetTelemetryRep() {
|
|
2247
|
+
return { payload: undefined };
|
|
1988
2248
|
}
|
|
1989
|
-
export const
|
|
2249
|
+
export const GetTelemetryRep = {
|
|
1990
2250
|
encode(message, writer = new BinaryWriter()) {
|
|
1991
|
-
if (message.
|
|
1992
|
-
writer.uint32(
|
|
2251
|
+
if (message.payload !== undefined) {
|
|
2252
|
+
Any.encode(message.payload, writer.uint32(10).fork()).join();
|
|
1993
2253
|
}
|
|
1994
2254
|
return writer;
|
|
1995
2255
|
},
|
|
1996
2256
|
decode(input, length) {
|
|
1997
2257
|
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
1998
2258
|
const end = length === undefined ? reader.len : reader.pos + length;
|
|
1999
|
-
const message =
|
|
2259
|
+
const message = createBaseGetTelemetryRep();
|
|
2000
2260
|
while (reader.pos < end) {
|
|
2001
2261
|
const tag = reader.uint32();
|
|
2002
2262
|
switch (tag >>> 3) {
|
|
2003
2263
|
case 1: {
|
|
2004
|
-
if (tag !==
|
|
2264
|
+
if (tag !== 10) {
|
|
2005
2265
|
break;
|
|
2006
2266
|
}
|
|
2007
|
-
message.
|
|
2267
|
+
message.payload = Any.decode(reader, reader.uint32());
|
|
2008
2268
|
continue;
|
|
2009
2269
|
}
|
|
2010
2270
|
}
|
|
@@ -2016,46 +2276,48 @@ export const FlashEscSettingsRep = {
|
|
|
2016
2276
|
return message;
|
|
2017
2277
|
},
|
|
2018
2278
|
fromJSON(object) {
|
|
2019
|
-
return {
|
|
2279
|
+
return { payload: isSet(object.payload) ? Any.fromJSON(object.payload) : undefined };
|
|
2020
2280
|
},
|
|
2021
2281
|
toJSON(message) {
|
|
2022
2282
|
const obj = {};
|
|
2023
|
-
if (message.
|
|
2024
|
-
obj.
|
|
2283
|
+
if (message.payload !== undefined) {
|
|
2284
|
+
obj.payload = Any.toJSON(message.payload);
|
|
2025
2285
|
}
|
|
2026
2286
|
return obj;
|
|
2027
2287
|
},
|
|
2028
2288
|
create(base) {
|
|
2029
|
-
return
|
|
2289
|
+
return GetTelemetryRep.fromPartial(base ?? {});
|
|
2030
2290
|
},
|
|
2031
2291
|
fromPartial(object) {
|
|
2032
|
-
const message =
|
|
2033
|
-
message.
|
|
2292
|
+
const message = createBaseGetTelemetryRep();
|
|
2293
|
+
message.payload = (object.payload !== undefined && object.payload !== null)
|
|
2294
|
+
? Any.fromPartial(object.payload)
|
|
2295
|
+
: undefined;
|
|
2034
2296
|
return message;
|
|
2035
2297
|
},
|
|
2036
2298
|
};
|
|
2037
|
-
function
|
|
2038
|
-
return {
|
|
2299
|
+
function createBaseSetPersistentStorageSettingsReq() {
|
|
2300
|
+
return { persistentStorageSettings: undefined };
|
|
2039
2301
|
}
|
|
2040
|
-
export const
|
|
2302
|
+
export const SetPersistentStorageSettingsReq = {
|
|
2041
2303
|
encode(message, writer = new BinaryWriter()) {
|
|
2042
|
-
if (message.
|
|
2043
|
-
writer.uint32(
|
|
2304
|
+
if (message.persistentStorageSettings !== undefined) {
|
|
2305
|
+
PersistentStorageSettings.encode(message.persistentStorageSettings, writer.uint32(10).fork()).join();
|
|
2044
2306
|
}
|
|
2045
2307
|
return writer;
|
|
2046
2308
|
},
|
|
2047
2309
|
decode(input, length) {
|
|
2048
2310
|
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
2049
2311
|
const end = length === undefined ? reader.len : reader.pos + length;
|
|
2050
|
-
const message =
|
|
2312
|
+
const message = createBaseSetPersistentStorageSettingsReq();
|
|
2051
2313
|
while (reader.pos < end) {
|
|
2052
2314
|
const tag = reader.uint32();
|
|
2053
2315
|
switch (tag >>> 3) {
|
|
2054
2316
|
case 1: {
|
|
2055
|
-
if (tag !==
|
|
2317
|
+
if (tag !== 10) {
|
|
2056
2318
|
break;
|
|
2057
2319
|
}
|
|
2058
|
-
message.
|
|
2320
|
+
message.persistentStorageSettings = PersistentStorageSettings.decode(reader, reader.uint32());
|
|
2059
2321
|
continue;
|
|
2060
2322
|
}
|
|
2061
2323
|
}
|
|
@@ -2067,38 +2329,45 @@ export const SetIperfStatusReq = {
|
|
|
2067
2329
|
return message;
|
|
2068
2330
|
},
|
|
2069
2331
|
fromJSON(object) {
|
|
2070
|
-
return {
|
|
2332
|
+
return {
|
|
2333
|
+
persistentStorageSettings: isSet(object.persistentStorageSettings)
|
|
2334
|
+
? PersistentStorageSettings.fromJSON(object.persistentStorageSettings)
|
|
2335
|
+
: undefined,
|
|
2336
|
+
};
|
|
2071
2337
|
},
|
|
2072
2338
|
toJSON(message) {
|
|
2073
2339
|
const obj = {};
|
|
2074
|
-
if (message.
|
|
2075
|
-
obj.
|
|
2340
|
+
if (message.persistentStorageSettings !== undefined) {
|
|
2341
|
+
obj.persistentStorageSettings = PersistentStorageSettings.toJSON(message.persistentStorageSettings);
|
|
2076
2342
|
}
|
|
2077
2343
|
return obj;
|
|
2078
2344
|
},
|
|
2079
2345
|
create(base) {
|
|
2080
|
-
return
|
|
2346
|
+
return SetPersistentStorageSettingsReq.fromPartial(base ?? {});
|
|
2081
2347
|
},
|
|
2082
2348
|
fromPartial(object) {
|
|
2083
|
-
const message =
|
|
2084
|
-
message.
|
|
2349
|
+
const message = createBaseSetPersistentStorageSettingsReq();
|
|
2350
|
+
message.persistentStorageSettings =
|
|
2351
|
+
(object.persistentStorageSettings !== undefined && object.persistentStorageSettings !== null)
|
|
2352
|
+
? PersistentStorageSettings.fromPartial(object.persistentStorageSettings)
|
|
2353
|
+
: undefined;
|
|
2085
2354
|
return message;
|
|
2086
2355
|
},
|
|
2087
2356
|
};
|
|
2088
|
-
function
|
|
2089
|
-
return {
|
|
2357
|
+
function createBaseSetPersistentStorageSettingsRep() {
|
|
2358
|
+
return { success: false };
|
|
2090
2359
|
}
|
|
2091
|
-
export const
|
|
2360
|
+
export const SetPersistentStorageSettingsRep = {
|
|
2092
2361
|
encode(message, writer = new BinaryWriter()) {
|
|
2093
|
-
if (message.
|
|
2094
|
-
writer.uint32(8).bool(message.
|
|
2362
|
+
if (message.success !== false) {
|
|
2363
|
+
writer.uint32(8).bool(message.success);
|
|
2095
2364
|
}
|
|
2096
2365
|
return writer;
|
|
2097
2366
|
},
|
|
2098
2367
|
decode(input, length) {
|
|
2099
2368
|
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
2100
2369
|
const end = length === undefined ? reader.len : reader.pos + length;
|
|
2101
|
-
const message =
|
|
2370
|
+
const message = createBaseSetPersistentStorageSettingsRep();
|
|
2102
2371
|
while (reader.pos < end) {
|
|
2103
2372
|
const tag = reader.uint32();
|
|
2104
2373
|
switch (tag >>> 3) {
|
|
@@ -2106,7 +2375,7 @@ export const SetIperfStatusRep = {
|
|
|
2106
2375
|
if (tag !== 8) {
|
|
2107
2376
|
break;
|
|
2108
2377
|
}
|
|
2109
|
-
message.
|
|
2378
|
+
message.success = reader.bool();
|
|
2110
2379
|
continue;
|
|
2111
2380
|
}
|
|
2112
2381
|
}
|
|
@@ -2118,35 +2387,35 @@ export const SetIperfStatusRep = {
|
|
|
2118
2387
|
return message;
|
|
2119
2388
|
},
|
|
2120
2389
|
fromJSON(object) {
|
|
2121
|
-
return {
|
|
2390
|
+
return { success: isSet(object.success) ? gt.Boolean(object.success) : false };
|
|
2122
2391
|
},
|
|
2123
2392
|
toJSON(message) {
|
|
2124
2393
|
const obj = {};
|
|
2125
|
-
if (message.
|
|
2126
|
-
obj.
|
|
2394
|
+
if (message.success !== false) {
|
|
2395
|
+
obj.success = message.success;
|
|
2127
2396
|
}
|
|
2128
2397
|
return obj;
|
|
2129
2398
|
},
|
|
2130
2399
|
create(base) {
|
|
2131
|
-
return
|
|
2400
|
+
return SetPersistentStorageSettingsRep.fromPartial(base ?? {});
|
|
2132
2401
|
},
|
|
2133
2402
|
fromPartial(object) {
|
|
2134
|
-
const message =
|
|
2135
|
-
message.
|
|
2403
|
+
const message = createBaseSetPersistentStorageSettingsRep();
|
|
2404
|
+
message.success = object.success ?? false;
|
|
2136
2405
|
return message;
|
|
2137
2406
|
},
|
|
2138
2407
|
};
|
|
2139
|
-
function
|
|
2408
|
+
function createBaseGetPersistentStorageSettingsReq() {
|
|
2140
2409
|
return {};
|
|
2141
2410
|
}
|
|
2142
|
-
export const
|
|
2411
|
+
export const GetPersistentStorageSettingsReq = {
|
|
2143
2412
|
encode(_, writer = new BinaryWriter()) {
|
|
2144
2413
|
return writer;
|
|
2145
2414
|
},
|
|
2146
2415
|
decode(input, length) {
|
|
2147
2416
|
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
2148
2417
|
const end = length === undefined ? reader.len : reader.pos + length;
|
|
2149
|
-
const message =
|
|
2418
|
+
const message = createBaseGetPersistentStorageSettingsReq();
|
|
2150
2419
|
while (reader.pos < end) {
|
|
2151
2420
|
const tag = reader.uint32();
|
|
2152
2421
|
switch (tag >>> 3) {
|
|
@@ -2166,35 +2435,35 @@ export const GetIperfStatusReq = {
|
|
|
2166
2435
|
return obj;
|
|
2167
2436
|
},
|
|
2168
2437
|
create(base) {
|
|
2169
|
-
return
|
|
2438
|
+
return GetPersistentStorageSettingsReq.fromPartial(base ?? {});
|
|
2170
2439
|
},
|
|
2171
2440
|
fromPartial(_) {
|
|
2172
|
-
const message =
|
|
2441
|
+
const message = createBaseGetPersistentStorageSettingsReq();
|
|
2173
2442
|
return message;
|
|
2174
2443
|
},
|
|
2175
2444
|
};
|
|
2176
|
-
function
|
|
2177
|
-
return {
|
|
2445
|
+
function createBaseGetPersistentStorageSettingsRep() {
|
|
2446
|
+
return { persistentStorageSettings: undefined };
|
|
2178
2447
|
}
|
|
2179
|
-
export const
|
|
2448
|
+
export const GetPersistentStorageSettingsRep = {
|
|
2180
2449
|
encode(message, writer = new BinaryWriter()) {
|
|
2181
|
-
if (message.
|
|
2182
|
-
writer.uint32(
|
|
2450
|
+
if (message.persistentStorageSettings !== undefined) {
|
|
2451
|
+
PersistentStorageSettings.encode(message.persistentStorageSettings, writer.uint32(10).fork()).join();
|
|
2183
2452
|
}
|
|
2184
2453
|
return writer;
|
|
2185
2454
|
},
|
|
2186
2455
|
decode(input, length) {
|
|
2187
2456
|
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
2188
2457
|
const end = length === undefined ? reader.len : reader.pos + length;
|
|
2189
|
-
const message =
|
|
2458
|
+
const message = createBaseGetPersistentStorageSettingsRep();
|
|
2190
2459
|
while (reader.pos < end) {
|
|
2191
2460
|
const tag = reader.uint32();
|
|
2192
2461
|
switch (tag >>> 3) {
|
|
2193
2462
|
case 1: {
|
|
2194
|
-
if (tag !==
|
|
2463
|
+
if (tag !== 10) {
|
|
2195
2464
|
break;
|
|
2196
2465
|
}
|
|
2197
|
-
message.
|
|
2466
|
+
message.persistentStorageSettings = PersistentStorageSettings.decode(reader, reader.uint32());
|
|
2198
2467
|
continue;
|
|
2199
2468
|
}
|
|
2200
2469
|
}
|
|
@@ -2206,38 +2475,55 @@ export const GetIperfStatusRep = {
|
|
|
2206
2475
|
return message;
|
|
2207
2476
|
},
|
|
2208
2477
|
fromJSON(object) {
|
|
2209
|
-
return {
|
|
2478
|
+
return {
|
|
2479
|
+
persistentStorageSettings: isSet(object.persistentStorageSettings)
|
|
2480
|
+
? PersistentStorageSettings.fromJSON(object.persistentStorageSettings)
|
|
2481
|
+
: undefined,
|
|
2482
|
+
};
|
|
2210
2483
|
},
|
|
2211
2484
|
toJSON(message) {
|
|
2212
2485
|
const obj = {};
|
|
2213
|
-
if (message.
|
|
2214
|
-
obj.
|
|
2486
|
+
if (message.persistentStorageSettings !== undefined) {
|
|
2487
|
+
obj.persistentStorageSettings = PersistentStorageSettings.toJSON(message.persistentStorageSettings);
|
|
2215
2488
|
}
|
|
2216
2489
|
return obj;
|
|
2217
2490
|
},
|
|
2218
2491
|
create(base) {
|
|
2219
|
-
return
|
|
2492
|
+
return GetPersistentStorageSettingsRep.fromPartial(base ?? {});
|
|
2220
2493
|
},
|
|
2221
2494
|
fromPartial(object) {
|
|
2222
|
-
const message =
|
|
2223
|
-
message.
|
|
2495
|
+
const message = createBaseGetPersistentStorageSettingsRep();
|
|
2496
|
+
message.persistentStorageSettings =
|
|
2497
|
+
(object.persistentStorageSettings !== undefined && object.persistentStorageSettings !== null)
|
|
2498
|
+
? PersistentStorageSettings.fromPartial(object.persistentStorageSettings)
|
|
2499
|
+
: undefined;
|
|
2224
2500
|
return message;
|
|
2225
2501
|
},
|
|
2226
2502
|
};
|
|
2227
|
-
function
|
|
2228
|
-
return {};
|
|
2503
|
+
function createBaseFlashEscSettingsReq() {
|
|
2504
|
+
return { silent: false };
|
|
2229
2505
|
}
|
|
2230
|
-
export const
|
|
2231
|
-
encode(
|
|
2506
|
+
export const FlashEscSettingsReq = {
|
|
2507
|
+
encode(message, writer = new BinaryWriter()) {
|
|
2508
|
+
if (message.silent !== false) {
|
|
2509
|
+
writer.uint32(8).bool(message.silent);
|
|
2510
|
+
}
|
|
2232
2511
|
return writer;
|
|
2233
2512
|
},
|
|
2234
2513
|
decode(input, length) {
|
|
2235
2514
|
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
2236
2515
|
const end = length === undefined ? reader.len : reader.pos + length;
|
|
2237
|
-
const message =
|
|
2516
|
+
const message = createBaseFlashEscSettingsReq();
|
|
2238
2517
|
while (reader.pos < end) {
|
|
2239
2518
|
const tag = reader.uint32();
|
|
2240
2519
|
switch (tag >>> 3) {
|
|
2520
|
+
case 1: {
|
|
2521
|
+
if (tag !== 8) {
|
|
2522
|
+
break;
|
|
2523
|
+
}
|
|
2524
|
+
message.silent = reader.bool();
|
|
2525
|
+
continue;
|
|
2526
|
+
}
|
|
2241
2527
|
}
|
|
2242
2528
|
if ((tag & 7) === 4 || tag === 0) {
|
|
2243
2529
|
break;
|
|
@@ -2246,35 +2532,39 @@ export const GetLogStreamingStatusReq = {
|
|
|
2246
2532
|
}
|
|
2247
2533
|
return message;
|
|
2248
2534
|
},
|
|
2249
|
-
fromJSON(
|
|
2250
|
-
return {};
|
|
2535
|
+
fromJSON(object) {
|
|
2536
|
+
return { silent: isSet(object.silent) ? gt.Boolean(object.silent) : false };
|
|
2251
2537
|
},
|
|
2252
|
-
toJSON(
|
|
2538
|
+
toJSON(message) {
|
|
2253
2539
|
const obj = {};
|
|
2540
|
+
if (message.silent !== false) {
|
|
2541
|
+
obj.silent = message.silent;
|
|
2542
|
+
}
|
|
2254
2543
|
return obj;
|
|
2255
2544
|
},
|
|
2256
2545
|
create(base) {
|
|
2257
|
-
return
|
|
2546
|
+
return FlashEscSettingsReq.fromPartial(base ?? {});
|
|
2258
2547
|
},
|
|
2259
|
-
fromPartial(
|
|
2260
|
-
const message =
|
|
2548
|
+
fromPartial(object) {
|
|
2549
|
+
const message = createBaseFlashEscSettingsReq();
|
|
2550
|
+
message.silent = object.silent ?? false;
|
|
2261
2551
|
return message;
|
|
2262
2552
|
},
|
|
2263
2553
|
};
|
|
2264
|
-
function
|
|
2265
|
-
return {
|
|
2554
|
+
function createBaseFlashEscSettingsRep() {
|
|
2555
|
+
return { success: false };
|
|
2266
2556
|
}
|
|
2267
|
-
export const
|
|
2557
|
+
export const FlashEscSettingsRep = {
|
|
2268
2558
|
encode(message, writer = new BinaryWriter()) {
|
|
2269
|
-
if (message.
|
|
2270
|
-
writer.uint32(8).bool(message.
|
|
2559
|
+
if (message.success !== false) {
|
|
2560
|
+
writer.uint32(8).bool(message.success);
|
|
2271
2561
|
}
|
|
2272
2562
|
return writer;
|
|
2273
2563
|
},
|
|
2274
2564
|
decode(input, length) {
|
|
2275
2565
|
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
2276
2566
|
const end = length === undefined ? reader.len : reader.pos + length;
|
|
2277
|
-
const message =
|
|
2567
|
+
const message = createBaseFlashEscSettingsRep();
|
|
2278
2568
|
while (reader.pos < end) {
|
|
2279
2569
|
const tag = reader.uint32();
|
|
2280
2570
|
switch (tag >>> 3) {
|
|
@@ -2282,7 +2572,7 @@ export const GetLogStreamingStatusRep = {
|
|
|
2282
2572
|
if (tag !== 8) {
|
|
2283
2573
|
break;
|
|
2284
2574
|
}
|
|
2285
|
-
message.
|
|
2575
|
+
message.success = reader.bool();
|
|
2286
2576
|
continue;
|
|
2287
2577
|
}
|
|
2288
2578
|
}
|
|
@@ -2294,56 +2584,46 @@ export const GetLogStreamingStatusRep = {
|
|
|
2294
2584
|
return message;
|
|
2295
2585
|
},
|
|
2296
2586
|
fromJSON(object) {
|
|
2297
|
-
return {
|
|
2587
|
+
return { success: isSet(object.success) ? gt.Boolean(object.success) : false };
|
|
2298
2588
|
},
|
|
2299
2589
|
toJSON(message) {
|
|
2300
2590
|
const obj = {};
|
|
2301
|
-
if (message.
|
|
2302
|
-
obj.
|
|
2591
|
+
if (message.success !== false) {
|
|
2592
|
+
obj.success = message.success;
|
|
2303
2593
|
}
|
|
2304
2594
|
return obj;
|
|
2305
2595
|
},
|
|
2306
2596
|
create(base) {
|
|
2307
|
-
return
|
|
2597
|
+
return FlashEscSettingsRep.fromPartial(base ?? {});
|
|
2308
2598
|
},
|
|
2309
2599
|
fromPartial(object) {
|
|
2310
|
-
const message =
|
|
2311
|
-
message.
|
|
2600
|
+
const message = createBaseFlashEscSettingsRep();
|
|
2601
|
+
message.success = object.success ?? false;
|
|
2312
2602
|
return message;
|
|
2313
2603
|
},
|
|
2314
2604
|
};
|
|
2315
|
-
function
|
|
2316
|
-
return {
|
|
2605
|
+
function createBaseSetIperfStatusReq() {
|
|
2606
|
+
return { enabled: false };
|
|
2317
2607
|
}
|
|
2318
|
-
export const
|
|
2608
|
+
export const SetIperfStatusReq = {
|
|
2319
2609
|
encode(message, writer = new BinaryWriter()) {
|
|
2320
|
-
if (message.
|
|
2321
|
-
writer.uint32(
|
|
2322
|
-
}
|
|
2323
|
-
if (message.running !== false) {
|
|
2324
|
-
writer.uint32(16).bool(message.running);
|
|
2610
|
+
if (message.enabled !== false) {
|
|
2611
|
+
writer.uint32(8).bool(message.enabled);
|
|
2325
2612
|
}
|
|
2326
2613
|
return writer;
|
|
2327
2614
|
},
|
|
2328
2615
|
decode(input, length) {
|
|
2329
2616
|
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
2330
2617
|
const end = length === undefined ? reader.len : reader.pos + length;
|
|
2331
|
-
const message =
|
|
2618
|
+
const message = createBaseSetIperfStatusReq();
|
|
2332
2619
|
while (reader.pos < end) {
|
|
2333
2620
|
const tag = reader.uint32();
|
|
2334
2621
|
switch (tag >>> 3) {
|
|
2335
2622
|
case 1: {
|
|
2336
|
-
if (tag !==
|
|
2337
|
-
break;
|
|
2338
|
-
}
|
|
2339
|
-
message.packageId = reader.string();
|
|
2340
|
-
continue;
|
|
2341
|
-
}
|
|
2342
|
-
case 2: {
|
|
2343
|
-
if (tag !== 16) {
|
|
2623
|
+
if (tag !== 8) {
|
|
2344
2624
|
break;
|
|
2345
2625
|
}
|
|
2346
|
-
message.
|
|
2626
|
+
message.enabled = reader.bool();
|
|
2347
2627
|
continue;
|
|
2348
2628
|
}
|
|
2349
2629
|
}
|
|
@@ -2355,45 +2635,38 @@ export const SetCvModelStateReq = {
|
|
|
2355
2635
|
return message;
|
|
2356
2636
|
},
|
|
2357
2637
|
fromJSON(object) {
|
|
2358
|
-
return {
|
|
2359
|
-
packageId: isSet(object.packageId) ? gt.String(object.packageId) : "",
|
|
2360
|
-
running: isSet(object.running) ? gt.Boolean(object.running) : false,
|
|
2361
|
-
};
|
|
2638
|
+
return { enabled: isSet(object.enabled) ? gt.Boolean(object.enabled) : false };
|
|
2362
2639
|
},
|
|
2363
2640
|
toJSON(message) {
|
|
2364
2641
|
const obj = {};
|
|
2365
|
-
if (message.
|
|
2366
|
-
obj.
|
|
2367
|
-
}
|
|
2368
|
-
if (message.running !== false) {
|
|
2369
|
-
obj.running = message.running;
|
|
2642
|
+
if (message.enabled !== false) {
|
|
2643
|
+
obj.enabled = message.enabled;
|
|
2370
2644
|
}
|
|
2371
2645
|
return obj;
|
|
2372
2646
|
},
|
|
2373
2647
|
create(base) {
|
|
2374
|
-
return
|
|
2648
|
+
return SetIperfStatusReq.fromPartial(base ?? {});
|
|
2375
2649
|
},
|
|
2376
2650
|
fromPartial(object) {
|
|
2377
|
-
const message =
|
|
2378
|
-
message.
|
|
2379
|
-
message.running = object.running ?? false;
|
|
2651
|
+
const message = createBaseSetIperfStatusReq();
|
|
2652
|
+
message.enabled = object.enabled ?? false;
|
|
2380
2653
|
return message;
|
|
2381
2654
|
},
|
|
2382
2655
|
};
|
|
2383
|
-
function
|
|
2384
|
-
return {
|
|
2656
|
+
function createBaseSetIperfStatusRep() {
|
|
2657
|
+
return { enabled: false };
|
|
2385
2658
|
}
|
|
2386
|
-
export const
|
|
2659
|
+
export const SetIperfStatusRep = {
|
|
2387
2660
|
encode(message, writer = new BinaryWriter()) {
|
|
2388
|
-
if (message.
|
|
2389
|
-
writer.uint32(8).bool(message.
|
|
2661
|
+
if (message.enabled !== false) {
|
|
2662
|
+
writer.uint32(8).bool(message.enabled);
|
|
2390
2663
|
}
|
|
2391
2664
|
return writer;
|
|
2392
2665
|
},
|
|
2393
2666
|
decode(input, length) {
|
|
2394
2667
|
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
2395
2668
|
const end = length === undefined ? reader.len : reader.pos + length;
|
|
2396
|
-
const message =
|
|
2669
|
+
const message = createBaseSetIperfStatusRep();
|
|
2397
2670
|
while (reader.pos < end) {
|
|
2398
2671
|
const tag = reader.uint32();
|
|
2399
2672
|
switch (tag >>> 3) {
|
|
@@ -2401,7 +2674,7 @@ export const SetCvModelStateRep = {
|
|
|
2401
2674
|
if (tag !== 8) {
|
|
2402
2675
|
break;
|
|
2403
2676
|
}
|
|
2404
|
-
message.
|
|
2677
|
+
message.enabled = reader.bool();
|
|
2405
2678
|
continue;
|
|
2406
2679
|
}
|
|
2407
2680
|
}
|
|
@@ -2413,38 +2686,943 @@ export const SetCvModelStateRep = {
|
|
|
2413
2686
|
return message;
|
|
2414
2687
|
},
|
|
2415
2688
|
fromJSON(object) {
|
|
2416
|
-
return {
|
|
2689
|
+
return { enabled: isSet(object.enabled) ? gt.Boolean(object.enabled) : false };
|
|
2417
2690
|
},
|
|
2418
2691
|
toJSON(message) {
|
|
2419
2692
|
const obj = {};
|
|
2420
|
-
if (message.
|
|
2421
|
-
obj.
|
|
2693
|
+
if (message.enabled !== false) {
|
|
2694
|
+
obj.enabled = message.enabled;
|
|
2422
2695
|
}
|
|
2423
2696
|
return obj;
|
|
2424
2697
|
},
|
|
2425
2698
|
create(base) {
|
|
2426
|
-
return
|
|
2699
|
+
return SetIperfStatusRep.fromPartial(base ?? {});
|
|
2427
2700
|
},
|
|
2428
2701
|
fromPartial(object) {
|
|
2429
|
-
const message =
|
|
2430
|
-
message.
|
|
2702
|
+
const message = createBaseSetIperfStatusRep();
|
|
2703
|
+
message.enabled = object.enabled ?? false;
|
|
2431
2704
|
return message;
|
|
2432
2705
|
},
|
|
2433
2706
|
};
|
|
2434
|
-
function
|
|
2707
|
+
function createBaseGetIperfStatusReq() {
|
|
2435
2708
|
return {};
|
|
2436
2709
|
}
|
|
2437
|
-
export const
|
|
2710
|
+
export const GetIperfStatusReq = {
|
|
2711
|
+
encode(_, writer = new BinaryWriter()) {
|
|
2712
|
+
return writer;
|
|
2713
|
+
},
|
|
2714
|
+
decode(input, length) {
|
|
2715
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
2716
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
2717
|
+
const message = createBaseGetIperfStatusReq();
|
|
2718
|
+
while (reader.pos < end) {
|
|
2719
|
+
const tag = reader.uint32();
|
|
2720
|
+
switch (tag >>> 3) {
|
|
2721
|
+
}
|
|
2722
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
2723
|
+
break;
|
|
2724
|
+
}
|
|
2725
|
+
reader.skip(tag & 7);
|
|
2726
|
+
}
|
|
2727
|
+
return message;
|
|
2728
|
+
},
|
|
2729
|
+
fromJSON(_) {
|
|
2730
|
+
return {};
|
|
2731
|
+
},
|
|
2732
|
+
toJSON(_) {
|
|
2733
|
+
const obj = {};
|
|
2734
|
+
return obj;
|
|
2735
|
+
},
|
|
2736
|
+
create(base) {
|
|
2737
|
+
return GetIperfStatusReq.fromPartial(base ?? {});
|
|
2738
|
+
},
|
|
2739
|
+
fromPartial(_) {
|
|
2740
|
+
const message = createBaseGetIperfStatusReq();
|
|
2741
|
+
return message;
|
|
2742
|
+
},
|
|
2743
|
+
};
|
|
2744
|
+
function createBaseGetIperfStatusRep() {
|
|
2745
|
+
return { enabled: false };
|
|
2746
|
+
}
|
|
2747
|
+
export const GetIperfStatusRep = {
|
|
2748
|
+
encode(message, writer = new BinaryWriter()) {
|
|
2749
|
+
if (message.enabled !== false) {
|
|
2750
|
+
writer.uint32(8).bool(message.enabled);
|
|
2751
|
+
}
|
|
2752
|
+
return writer;
|
|
2753
|
+
},
|
|
2754
|
+
decode(input, length) {
|
|
2755
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
2756
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
2757
|
+
const message = createBaseGetIperfStatusRep();
|
|
2758
|
+
while (reader.pos < end) {
|
|
2759
|
+
const tag = reader.uint32();
|
|
2760
|
+
switch (tag >>> 3) {
|
|
2761
|
+
case 1: {
|
|
2762
|
+
if (tag !== 8) {
|
|
2763
|
+
break;
|
|
2764
|
+
}
|
|
2765
|
+
message.enabled = reader.bool();
|
|
2766
|
+
continue;
|
|
2767
|
+
}
|
|
2768
|
+
}
|
|
2769
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
2770
|
+
break;
|
|
2771
|
+
}
|
|
2772
|
+
reader.skip(tag & 7);
|
|
2773
|
+
}
|
|
2774
|
+
return message;
|
|
2775
|
+
},
|
|
2776
|
+
fromJSON(object) {
|
|
2777
|
+
return { enabled: isSet(object.enabled) ? gt.Boolean(object.enabled) : false };
|
|
2778
|
+
},
|
|
2779
|
+
toJSON(message) {
|
|
2780
|
+
const obj = {};
|
|
2781
|
+
if (message.enabled !== false) {
|
|
2782
|
+
obj.enabled = message.enabled;
|
|
2783
|
+
}
|
|
2784
|
+
return obj;
|
|
2785
|
+
},
|
|
2786
|
+
create(base) {
|
|
2787
|
+
return GetIperfStatusRep.fromPartial(base ?? {});
|
|
2788
|
+
},
|
|
2789
|
+
fromPartial(object) {
|
|
2790
|
+
const message = createBaseGetIperfStatusRep();
|
|
2791
|
+
message.enabled = object.enabled ?? false;
|
|
2792
|
+
return message;
|
|
2793
|
+
},
|
|
2794
|
+
};
|
|
2795
|
+
function createBaseGetLogStreamingStatusReq() {
|
|
2796
|
+
return {};
|
|
2797
|
+
}
|
|
2798
|
+
export const GetLogStreamingStatusReq = {
|
|
2799
|
+
encode(_, writer = new BinaryWriter()) {
|
|
2800
|
+
return writer;
|
|
2801
|
+
},
|
|
2802
|
+
decode(input, length) {
|
|
2803
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
2804
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
2805
|
+
const message = createBaseGetLogStreamingStatusReq();
|
|
2806
|
+
while (reader.pos < end) {
|
|
2807
|
+
const tag = reader.uint32();
|
|
2808
|
+
switch (tag >>> 3) {
|
|
2809
|
+
}
|
|
2810
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
2811
|
+
break;
|
|
2812
|
+
}
|
|
2813
|
+
reader.skip(tag & 7);
|
|
2814
|
+
}
|
|
2815
|
+
return message;
|
|
2816
|
+
},
|
|
2817
|
+
fromJSON(_) {
|
|
2818
|
+
return {};
|
|
2819
|
+
},
|
|
2820
|
+
toJSON(_) {
|
|
2821
|
+
const obj = {};
|
|
2822
|
+
return obj;
|
|
2823
|
+
},
|
|
2824
|
+
create(base) {
|
|
2825
|
+
return GetLogStreamingStatusReq.fromPartial(base ?? {});
|
|
2826
|
+
},
|
|
2827
|
+
fromPartial(_) {
|
|
2828
|
+
const message = createBaseGetLogStreamingStatusReq();
|
|
2829
|
+
return message;
|
|
2830
|
+
},
|
|
2831
|
+
};
|
|
2832
|
+
function createBaseGetLogStreamingStatusRep() {
|
|
2833
|
+
return { enabled: false };
|
|
2834
|
+
}
|
|
2835
|
+
export const GetLogStreamingStatusRep = {
|
|
2836
|
+
encode(message, writer = new BinaryWriter()) {
|
|
2837
|
+
if (message.enabled !== false) {
|
|
2838
|
+
writer.uint32(8).bool(message.enabled);
|
|
2839
|
+
}
|
|
2840
|
+
return writer;
|
|
2841
|
+
},
|
|
2842
|
+
decode(input, length) {
|
|
2843
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
2844
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
2845
|
+
const message = createBaseGetLogStreamingStatusRep();
|
|
2846
|
+
while (reader.pos < end) {
|
|
2847
|
+
const tag = reader.uint32();
|
|
2848
|
+
switch (tag >>> 3) {
|
|
2849
|
+
case 1: {
|
|
2850
|
+
if (tag !== 8) {
|
|
2851
|
+
break;
|
|
2852
|
+
}
|
|
2853
|
+
message.enabled = reader.bool();
|
|
2854
|
+
continue;
|
|
2855
|
+
}
|
|
2856
|
+
}
|
|
2857
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
2858
|
+
break;
|
|
2859
|
+
}
|
|
2860
|
+
reader.skip(tag & 7);
|
|
2861
|
+
}
|
|
2862
|
+
return message;
|
|
2863
|
+
},
|
|
2864
|
+
fromJSON(object) {
|
|
2865
|
+
return { enabled: isSet(object.enabled) ? gt.Boolean(object.enabled) : false };
|
|
2866
|
+
},
|
|
2867
|
+
toJSON(message) {
|
|
2868
|
+
const obj = {};
|
|
2869
|
+
if (message.enabled !== false) {
|
|
2870
|
+
obj.enabled = message.enabled;
|
|
2871
|
+
}
|
|
2872
|
+
return obj;
|
|
2873
|
+
},
|
|
2874
|
+
create(base) {
|
|
2875
|
+
return GetLogStreamingStatusRep.fromPartial(base ?? {});
|
|
2876
|
+
},
|
|
2877
|
+
fromPartial(object) {
|
|
2878
|
+
const message = createBaseGetLogStreamingStatusRep();
|
|
2879
|
+
message.enabled = object.enabled ?? false;
|
|
2880
|
+
return message;
|
|
2881
|
+
},
|
|
2882
|
+
};
|
|
2883
|
+
function createBaseSetCvModelStateReq() {
|
|
2884
|
+
return { packageId: "", running: false };
|
|
2885
|
+
}
|
|
2886
|
+
export const SetCvModelStateReq = {
|
|
2887
|
+
encode(message, writer = new BinaryWriter()) {
|
|
2888
|
+
if (message.packageId !== "") {
|
|
2889
|
+
writer.uint32(10).string(message.packageId);
|
|
2890
|
+
}
|
|
2891
|
+
if (message.running !== false) {
|
|
2892
|
+
writer.uint32(16).bool(message.running);
|
|
2893
|
+
}
|
|
2894
|
+
return writer;
|
|
2895
|
+
},
|
|
2896
|
+
decode(input, length) {
|
|
2897
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
2898
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
2899
|
+
const message = createBaseSetCvModelStateReq();
|
|
2900
|
+
while (reader.pos < end) {
|
|
2901
|
+
const tag = reader.uint32();
|
|
2902
|
+
switch (tag >>> 3) {
|
|
2903
|
+
case 1: {
|
|
2904
|
+
if (tag !== 10) {
|
|
2905
|
+
break;
|
|
2906
|
+
}
|
|
2907
|
+
message.packageId = reader.string();
|
|
2908
|
+
continue;
|
|
2909
|
+
}
|
|
2910
|
+
case 2: {
|
|
2911
|
+
if (tag !== 16) {
|
|
2912
|
+
break;
|
|
2913
|
+
}
|
|
2914
|
+
message.running = reader.bool();
|
|
2915
|
+
continue;
|
|
2916
|
+
}
|
|
2917
|
+
}
|
|
2918
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
2919
|
+
break;
|
|
2920
|
+
}
|
|
2921
|
+
reader.skip(tag & 7);
|
|
2922
|
+
}
|
|
2923
|
+
return message;
|
|
2924
|
+
},
|
|
2925
|
+
fromJSON(object) {
|
|
2926
|
+
return {
|
|
2927
|
+
packageId: isSet(object.packageId) ? gt.String(object.packageId) : "",
|
|
2928
|
+
running: isSet(object.running) ? gt.Boolean(object.running) : false,
|
|
2929
|
+
};
|
|
2930
|
+
},
|
|
2931
|
+
toJSON(message) {
|
|
2932
|
+
const obj = {};
|
|
2933
|
+
if (message.packageId !== "") {
|
|
2934
|
+
obj.packageId = message.packageId;
|
|
2935
|
+
}
|
|
2936
|
+
if (message.running !== false) {
|
|
2937
|
+
obj.running = message.running;
|
|
2938
|
+
}
|
|
2939
|
+
return obj;
|
|
2940
|
+
},
|
|
2941
|
+
create(base) {
|
|
2942
|
+
return SetCvModelStateReq.fromPartial(base ?? {});
|
|
2943
|
+
},
|
|
2944
|
+
fromPartial(object) {
|
|
2945
|
+
const message = createBaseSetCvModelStateReq();
|
|
2946
|
+
message.packageId = object.packageId ?? "";
|
|
2947
|
+
message.running = object.running ?? false;
|
|
2948
|
+
return message;
|
|
2949
|
+
},
|
|
2950
|
+
};
|
|
2951
|
+
function createBaseSetCvModelStateRep() {
|
|
2952
|
+
return { accepted: false };
|
|
2953
|
+
}
|
|
2954
|
+
export const SetCvModelStateRep = {
|
|
2955
|
+
encode(message, writer = new BinaryWriter()) {
|
|
2956
|
+
if (message.accepted !== false) {
|
|
2957
|
+
writer.uint32(8).bool(message.accepted);
|
|
2958
|
+
}
|
|
2959
|
+
return writer;
|
|
2960
|
+
},
|
|
2961
|
+
decode(input, length) {
|
|
2962
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
2963
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
2964
|
+
const message = createBaseSetCvModelStateRep();
|
|
2965
|
+
while (reader.pos < end) {
|
|
2966
|
+
const tag = reader.uint32();
|
|
2967
|
+
switch (tag >>> 3) {
|
|
2968
|
+
case 1: {
|
|
2969
|
+
if (tag !== 8) {
|
|
2970
|
+
break;
|
|
2971
|
+
}
|
|
2972
|
+
message.accepted = reader.bool();
|
|
2973
|
+
continue;
|
|
2974
|
+
}
|
|
2975
|
+
}
|
|
2976
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
2977
|
+
break;
|
|
2978
|
+
}
|
|
2979
|
+
reader.skip(tag & 7);
|
|
2980
|
+
}
|
|
2981
|
+
return message;
|
|
2982
|
+
},
|
|
2983
|
+
fromJSON(object) {
|
|
2984
|
+
return { accepted: isSet(object.accepted) ? gt.Boolean(object.accepted) : false };
|
|
2985
|
+
},
|
|
2986
|
+
toJSON(message) {
|
|
2987
|
+
const obj = {};
|
|
2988
|
+
if (message.accepted !== false) {
|
|
2989
|
+
obj.accepted = message.accepted;
|
|
2990
|
+
}
|
|
2991
|
+
return obj;
|
|
2992
|
+
},
|
|
2993
|
+
create(base) {
|
|
2994
|
+
return SetCvModelStateRep.fromPartial(base ?? {});
|
|
2995
|
+
},
|
|
2996
|
+
fromPartial(object) {
|
|
2997
|
+
const message = createBaseSetCvModelStateRep();
|
|
2998
|
+
message.accepted = object.accepted ?? false;
|
|
2999
|
+
return message;
|
|
3000
|
+
},
|
|
3001
|
+
};
|
|
3002
|
+
function createBaseGetCvModelsReq() {
|
|
3003
|
+
return {};
|
|
3004
|
+
}
|
|
3005
|
+
export const GetCvModelsReq = {
|
|
3006
|
+
encode(_, writer = new BinaryWriter()) {
|
|
3007
|
+
return writer;
|
|
3008
|
+
},
|
|
3009
|
+
decode(input, length) {
|
|
3010
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
3011
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
3012
|
+
const message = createBaseGetCvModelsReq();
|
|
3013
|
+
while (reader.pos < end) {
|
|
3014
|
+
const tag = reader.uint32();
|
|
3015
|
+
switch (tag >>> 3) {
|
|
3016
|
+
}
|
|
3017
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
3018
|
+
break;
|
|
3019
|
+
}
|
|
3020
|
+
reader.skip(tag & 7);
|
|
3021
|
+
}
|
|
3022
|
+
return message;
|
|
3023
|
+
},
|
|
3024
|
+
fromJSON(_) {
|
|
3025
|
+
return {};
|
|
3026
|
+
},
|
|
3027
|
+
toJSON(_) {
|
|
3028
|
+
const obj = {};
|
|
3029
|
+
return obj;
|
|
3030
|
+
},
|
|
3031
|
+
create(base) {
|
|
3032
|
+
return GetCvModelsReq.fromPartial(base ?? {});
|
|
3033
|
+
},
|
|
3034
|
+
fromPartial(_) {
|
|
3035
|
+
const message = createBaseGetCvModelsReq();
|
|
3036
|
+
return message;
|
|
3037
|
+
},
|
|
3038
|
+
};
|
|
3039
|
+
function createBaseGetCvModelsRep() {
|
|
3040
|
+
return { cvModels: [] };
|
|
3041
|
+
}
|
|
3042
|
+
export const GetCvModelsRep = {
|
|
3043
|
+
encode(message, writer = new BinaryWriter()) {
|
|
3044
|
+
for (const v of message.cvModels) {
|
|
3045
|
+
CvModelInfo.encode(v, writer.uint32(10).fork()).join();
|
|
3046
|
+
}
|
|
3047
|
+
return writer;
|
|
3048
|
+
},
|
|
3049
|
+
decode(input, length) {
|
|
3050
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
3051
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
3052
|
+
const message = createBaseGetCvModelsRep();
|
|
3053
|
+
while (reader.pos < end) {
|
|
3054
|
+
const tag = reader.uint32();
|
|
3055
|
+
switch (tag >>> 3) {
|
|
3056
|
+
case 1: {
|
|
3057
|
+
if (tag !== 10) {
|
|
3058
|
+
break;
|
|
3059
|
+
}
|
|
3060
|
+
message.cvModels.push(CvModelInfo.decode(reader, reader.uint32()));
|
|
3061
|
+
continue;
|
|
3062
|
+
}
|
|
3063
|
+
}
|
|
3064
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
3065
|
+
break;
|
|
3066
|
+
}
|
|
3067
|
+
reader.skip(tag & 7);
|
|
3068
|
+
}
|
|
3069
|
+
return message;
|
|
3070
|
+
},
|
|
3071
|
+
fromJSON(object) {
|
|
3072
|
+
return {
|
|
3073
|
+
cvModels: gt.Array.isArray(object?.cvModels) ? object.cvModels.map((e) => CvModelInfo.fromJSON(e)) : [],
|
|
3074
|
+
};
|
|
3075
|
+
},
|
|
3076
|
+
toJSON(message) {
|
|
3077
|
+
const obj = {};
|
|
3078
|
+
if (message.cvModels?.length) {
|
|
3079
|
+
obj.cvModels = message.cvModels.map((e) => CvModelInfo.toJSON(e));
|
|
3080
|
+
}
|
|
3081
|
+
return obj;
|
|
3082
|
+
},
|
|
3083
|
+
create(base) {
|
|
3084
|
+
return GetCvModelsRep.fromPartial(base ?? {});
|
|
3085
|
+
},
|
|
3086
|
+
fromPartial(object) {
|
|
3087
|
+
const message = createBaseGetCvModelsRep();
|
|
3088
|
+
message.cvModels = object.cvModels?.map((e) => CvModelInfo.fromPartial(e)) || [];
|
|
3089
|
+
return message;
|
|
3090
|
+
},
|
|
3091
|
+
};
|
|
3092
|
+
function createBaseSetMultibeamColorFilterReq() {
|
|
3093
|
+
return { colorFilter: undefined };
|
|
3094
|
+
}
|
|
3095
|
+
export const SetMultibeamColorFilterReq = {
|
|
3096
|
+
encode(message, writer = new BinaryWriter()) {
|
|
3097
|
+
if (message.colorFilter !== undefined) {
|
|
3098
|
+
MultibeamColorFilter.encode(message.colorFilter, writer.uint32(10).fork()).join();
|
|
3099
|
+
}
|
|
3100
|
+
return writer;
|
|
3101
|
+
},
|
|
3102
|
+
decode(input, length) {
|
|
3103
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
3104
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
3105
|
+
const message = createBaseSetMultibeamColorFilterReq();
|
|
3106
|
+
while (reader.pos < end) {
|
|
3107
|
+
const tag = reader.uint32();
|
|
3108
|
+
switch (tag >>> 3) {
|
|
3109
|
+
case 1: {
|
|
3110
|
+
if (tag !== 10) {
|
|
3111
|
+
break;
|
|
3112
|
+
}
|
|
3113
|
+
message.colorFilter = MultibeamColorFilter.decode(reader, reader.uint32());
|
|
3114
|
+
continue;
|
|
3115
|
+
}
|
|
3116
|
+
}
|
|
3117
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
3118
|
+
break;
|
|
3119
|
+
}
|
|
3120
|
+
reader.skip(tag & 7);
|
|
3121
|
+
}
|
|
3122
|
+
return message;
|
|
3123
|
+
},
|
|
3124
|
+
fromJSON(object) {
|
|
3125
|
+
return { colorFilter: isSet(object.colorFilter) ? MultibeamColorFilter.fromJSON(object.colorFilter) : undefined };
|
|
3126
|
+
},
|
|
3127
|
+
toJSON(message) {
|
|
3128
|
+
const obj = {};
|
|
3129
|
+
if (message.colorFilter !== undefined) {
|
|
3130
|
+
obj.colorFilter = MultibeamColorFilter.toJSON(message.colorFilter);
|
|
3131
|
+
}
|
|
3132
|
+
return obj;
|
|
3133
|
+
},
|
|
3134
|
+
create(base) {
|
|
3135
|
+
return SetMultibeamColorFilterReq.fromPartial(base ?? {});
|
|
3136
|
+
},
|
|
3137
|
+
fromPartial(object) {
|
|
3138
|
+
const message = createBaseSetMultibeamColorFilterReq();
|
|
3139
|
+
message.colorFilter = (object.colorFilter !== undefined && object.colorFilter !== null)
|
|
3140
|
+
? MultibeamColorFilter.fromPartial(object.colorFilter)
|
|
3141
|
+
: undefined;
|
|
3142
|
+
return message;
|
|
3143
|
+
},
|
|
3144
|
+
};
|
|
3145
|
+
function createBaseSetMultibeamColorFilterRep() {
|
|
3146
|
+
return {};
|
|
3147
|
+
}
|
|
3148
|
+
export const SetMultibeamColorFilterRep = {
|
|
3149
|
+
encode(_, writer = new BinaryWriter()) {
|
|
3150
|
+
return writer;
|
|
3151
|
+
},
|
|
3152
|
+
decode(input, length) {
|
|
3153
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
3154
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
3155
|
+
const message = createBaseSetMultibeamColorFilterRep();
|
|
3156
|
+
while (reader.pos < end) {
|
|
3157
|
+
const tag = reader.uint32();
|
|
3158
|
+
switch (tag >>> 3) {
|
|
3159
|
+
}
|
|
3160
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
3161
|
+
break;
|
|
3162
|
+
}
|
|
3163
|
+
reader.skip(tag & 7);
|
|
3164
|
+
}
|
|
3165
|
+
return message;
|
|
3166
|
+
},
|
|
3167
|
+
fromJSON(_) {
|
|
3168
|
+
return {};
|
|
3169
|
+
},
|
|
3170
|
+
toJSON(_) {
|
|
3171
|
+
const obj = {};
|
|
3172
|
+
return obj;
|
|
3173
|
+
},
|
|
3174
|
+
create(base) {
|
|
3175
|
+
return SetMultibeamColorFilterRep.fromPartial(base ?? {});
|
|
3176
|
+
},
|
|
3177
|
+
fromPartial(_) {
|
|
3178
|
+
const message = createBaseSetMultibeamColorFilterRep();
|
|
3179
|
+
return message;
|
|
3180
|
+
},
|
|
3181
|
+
};
|
|
3182
|
+
function createBaseGetMultibeamColorFilterReq() {
|
|
3183
|
+
return {};
|
|
3184
|
+
}
|
|
3185
|
+
export const GetMultibeamColorFilterReq = {
|
|
2438
3186
|
encode(_, writer = new BinaryWriter()) {
|
|
2439
3187
|
return writer;
|
|
2440
3188
|
},
|
|
2441
3189
|
decode(input, length) {
|
|
2442
3190
|
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
2443
3191
|
const end = length === undefined ? reader.len : reader.pos + length;
|
|
2444
|
-
const message =
|
|
3192
|
+
const message = createBaseGetMultibeamColorFilterReq();
|
|
3193
|
+
while (reader.pos < end) {
|
|
3194
|
+
const tag = reader.uint32();
|
|
3195
|
+
switch (tag >>> 3) {
|
|
3196
|
+
}
|
|
3197
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
3198
|
+
break;
|
|
3199
|
+
}
|
|
3200
|
+
reader.skip(tag & 7);
|
|
3201
|
+
}
|
|
3202
|
+
return message;
|
|
3203
|
+
},
|
|
3204
|
+
fromJSON(_) {
|
|
3205
|
+
return {};
|
|
3206
|
+
},
|
|
3207
|
+
toJSON(_) {
|
|
3208
|
+
const obj = {};
|
|
3209
|
+
return obj;
|
|
3210
|
+
},
|
|
3211
|
+
create(base) {
|
|
3212
|
+
return GetMultibeamColorFilterReq.fromPartial(base ?? {});
|
|
3213
|
+
},
|
|
3214
|
+
fromPartial(_) {
|
|
3215
|
+
const message = createBaseGetMultibeamColorFilterReq();
|
|
3216
|
+
return message;
|
|
3217
|
+
},
|
|
3218
|
+
};
|
|
3219
|
+
function createBaseGetMultibeamColorFilterRep() {
|
|
3220
|
+
return { colorFilter: undefined };
|
|
3221
|
+
}
|
|
3222
|
+
export const GetMultibeamColorFilterRep = {
|
|
3223
|
+
encode(message, writer = new BinaryWriter()) {
|
|
3224
|
+
if (message.colorFilter !== undefined) {
|
|
3225
|
+
MultibeamColorFilter.encode(message.colorFilter, writer.uint32(10).fork()).join();
|
|
3226
|
+
}
|
|
3227
|
+
return writer;
|
|
3228
|
+
},
|
|
3229
|
+
decode(input, length) {
|
|
3230
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
3231
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
3232
|
+
const message = createBaseGetMultibeamColorFilterRep();
|
|
3233
|
+
while (reader.pos < end) {
|
|
3234
|
+
const tag = reader.uint32();
|
|
3235
|
+
switch (tag >>> 3) {
|
|
3236
|
+
case 1: {
|
|
3237
|
+
if (tag !== 10) {
|
|
3238
|
+
break;
|
|
3239
|
+
}
|
|
3240
|
+
message.colorFilter = MultibeamColorFilter.decode(reader, reader.uint32());
|
|
3241
|
+
continue;
|
|
3242
|
+
}
|
|
3243
|
+
}
|
|
3244
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
3245
|
+
break;
|
|
3246
|
+
}
|
|
3247
|
+
reader.skip(tag & 7);
|
|
3248
|
+
}
|
|
3249
|
+
return message;
|
|
3250
|
+
},
|
|
3251
|
+
fromJSON(object) {
|
|
3252
|
+
return { colorFilter: isSet(object.colorFilter) ? MultibeamColorFilter.fromJSON(object.colorFilter) : undefined };
|
|
3253
|
+
},
|
|
3254
|
+
toJSON(message) {
|
|
3255
|
+
const obj = {};
|
|
3256
|
+
if (message.colorFilter !== undefined) {
|
|
3257
|
+
obj.colorFilter = MultibeamColorFilter.toJSON(message.colorFilter);
|
|
3258
|
+
}
|
|
3259
|
+
return obj;
|
|
3260
|
+
},
|
|
3261
|
+
create(base) {
|
|
3262
|
+
return GetMultibeamColorFilterRep.fromPartial(base ?? {});
|
|
3263
|
+
},
|
|
3264
|
+
fromPartial(object) {
|
|
3265
|
+
const message = createBaseGetMultibeamColorFilterRep();
|
|
3266
|
+
message.colorFilter = (object.colorFilter !== undefined && object.colorFilter !== null)
|
|
3267
|
+
? MultibeamColorFilter.fromPartial(object.colorFilter)
|
|
3268
|
+
: undefined;
|
|
3269
|
+
return message;
|
|
3270
|
+
},
|
|
3271
|
+
};
|
|
3272
|
+
function createBaseGetSlamMapReq() {
|
|
3273
|
+
return { mapId: 0, haveSequence: 0 };
|
|
3274
|
+
}
|
|
3275
|
+
export const GetSlamMapReq = {
|
|
3276
|
+
encode(message, writer = new BinaryWriter()) {
|
|
3277
|
+
if (message.mapId !== 0) {
|
|
3278
|
+
writer.uint32(8).uint32(message.mapId);
|
|
3279
|
+
}
|
|
3280
|
+
if (message.haveSequence !== 0) {
|
|
3281
|
+
writer.uint32(16).uint64(message.haveSequence);
|
|
3282
|
+
}
|
|
3283
|
+
return writer;
|
|
3284
|
+
},
|
|
3285
|
+
decode(input, length) {
|
|
3286
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
3287
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
3288
|
+
const message = createBaseGetSlamMapReq();
|
|
3289
|
+
while (reader.pos < end) {
|
|
3290
|
+
const tag = reader.uint32();
|
|
3291
|
+
switch (tag >>> 3) {
|
|
3292
|
+
case 1: {
|
|
3293
|
+
if (tag !== 8) {
|
|
3294
|
+
break;
|
|
3295
|
+
}
|
|
3296
|
+
message.mapId = reader.uint32();
|
|
3297
|
+
continue;
|
|
3298
|
+
}
|
|
3299
|
+
case 2: {
|
|
3300
|
+
if (tag !== 16) {
|
|
3301
|
+
break;
|
|
3302
|
+
}
|
|
3303
|
+
message.haveSequence = longToNumber(reader.uint64());
|
|
3304
|
+
continue;
|
|
3305
|
+
}
|
|
3306
|
+
}
|
|
3307
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
3308
|
+
break;
|
|
3309
|
+
}
|
|
3310
|
+
reader.skip(tag & 7);
|
|
3311
|
+
}
|
|
3312
|
+
return message;
|
|
3313
|
+
},
|
|
3314
|
+
fromJSON(object) {
|
|
3315
|
+
return {
|
|
3316
|
+
mapId: isSet(object.mapId) ? gt.Number(object.mapId) : 0,
|
|
3317
|
+
haveSequence: isSet(object.haveSequence) ? gt.Number(object.haveSequence) : 0,
|
|
3318
|
+
};
|
|
3319
|
+
},
|
|
3320
|
+
toJSON(message) {
|
|
3321
|
+
const obj = {};
|
|
3322
|
+
if (message.mapId !== 0) {
|
|
3323
|
+
obj.mapId = Math.round(message.mapId);
|
|
3324
|
+
}
|
|
3325
|
+
if (message.haveSequence !== 0) {
|
|
3326
|
+
obj.haveSequence = Math.round(message.haveSequence);
|
|
3327
|
+
}
|
|
3328
|
+
return obj;
|
|
3329
|
+
},
|
|
3330
|
+
create(base) {
|
|
3331
|
+
return GetSlamMapReq.fromPartial(base ?? {});
|
|
3332
|
+
},
|
|
3333
|
+
fromPartial(object) {
|
|
3334
|
+
const message = createBaseGetSlamMapReq();
|
|
3335
|
+
message.mapId = object.mapId ?? 0;
|
|
3336
|
+
message.haveSequence = object.haveSequence ?? 0;
|
|
3337
|
+
return message;
|
|
3338
|
+
},
|
|
3339
|
+
};
|
|
3340
|
+
function createBaseGetSlamMapRep() {
|
|
3341
|
+
return { available: false, mapId: 0, sequence: 0, fromSequence: undefined, partCount: undefined };
|
|
3342
|
+
}
|
|
3343
|
+
export const GetSlamMapRep = {
|
|
3344
|
+
encode(message, writer = new BinaryWriter()) {
|
|
3345
|
+
if (message.available !== false) {
|
|
3346
|
+
writer.uint32(8).bool(message.available);
|
|
3347
|
+
}
|
|
3348
|
+
if (message.mapId !== 0) {
|
|
3349
|
+
writer.uint32(16).uint32(message.mapId);
|
|
3350
|
+
}
|
|
3351
|
+
if (message.sequence !== 0) {
|
|
3352
|
+
writer.uint32(24).uint64(message.sequence);
|
|
3353
|
+
}
|
|
3354
|
+
if (message.fromSequence !== undefined) {
|
|
3355
|
+
writer.uint32(32).uint64(message.fromSequence);
|
|
3356
|
+
}
|
|
3357
|
+
if (message.partCount !== undefined) {
|
|
3358
|
+
writer.uint32(40).uint32(message.partCount);
|
|
3359
|
+
}
|
|
3360
|
+
return writer;
|
|
3361
|
+
},
|
|
3362
|
+
decode(input, length) {
|
|
3363
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
3364
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
3365
|
+
const message = createBaseGetSlamMapRep();
|
|
3366
|
+
while (reader.pos < end) {
|
|
3367
|
+
const tag = reader.uint32();
|
|
3368
|
+
switch (tag >>> 3) {
|
|
3369
|
+
case 1: {
|
|
3370
|
+
if (tag !== 8) {
|
|
3371
|
+
break;
|
|
3372
|
+
}
|
|
3373
|
+
message.available = reader.bool();
|
|
3374
|
+
continue;
|
|
3375
|
+
}
|
|
3376
|
+
case 2: {
|
|
3377
|
+
if (tag !== 16) {
|
|
3378
|
+
break;
|
|
3379
|
+
}
|
|
3380
|
+
message.mapId = reader.uint32();
|
|
3381
|
+
continue;
|
|
3382
|
+
}
|
|
3383
|
+
case 3: {
|
|
3384
|
+
if (tag !== 24) {
|
|
3385
|
+
break;
|
|
3386
|
+
}
|
|
3387
|
+
message.sequence = longToNumber(reader.uint64());
|
|
3388
|
+
continue;
|
|
3389
|
+
}
|
|
3390
|
+
case 4: {
|
|
3391
|
+
if (tag !== 32) {
|
|
3392
|
+
break;
|
|
3393
|
+
}
|
|
3394
|
+
message.fromSequence = longToNumber(reader.uint64());
|
|
3395
|
+
continue;
|
|
3396
|
+
}
|
|
3397
|
+
case 5: {
|
|
3398
|
+
if (tag !== 40) {
|
|
3399
|
+
break;
|
|
3400
|
+
}
|
|
3401
|
+
message.partCount = reader.uint32();
|
|
3402
|
+
continue;
|
|
3403
|
+
}
|
|
3404
|
+
}
|
|
3405
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
3406
|
+
break;
|
|
3407
|
+
}
|
|
3408
|
+
reader.skip(tag & 7);
|
|
3409
|
+
}
|
|
3410
|
+
return message;
|
|
3411
|
+
},
|
|
3412
|
+
fromJSON(object) {
|
|
3413
|
+
return {
|
|
3414
|
+
available: isSet(object.available) ? gt.Boolean(object.available) : false,
|
|
3415
|
+
mapId: isSet(object.mapId) ? gt.Number(object.mapId) : 0,
|
|
3416
|
+
sequence: isSet(object.sequence) ? gt.Number(object.sequence) : 0,
|
|
3417
|
+
fromSequence: isSet(object.fromSequence) ? gt.Number(object.fromSequence) : undefined,
|
|
3418
|
+
partCount: isSet(object.partCount) ? gt.Number(object.partCount) : undefined,
|
|
3419
|
+
};
|
|
3420
|
+
},
|
|
3421
|
+
toJSON(message) {
|
|
3422
|
+
const obj = {};
|
|
3423
|
+
if (message.available !== false) {
|
|
3424
|
+
obj.available = message.available;
|
|
3425
|
+
}
|
|
3426
|
+
if (message.mapId !== 0) {
|
|
3427
|
+
obj.mapId = Math.round(message.mapId);
|
|
3428
|
+
}
|
|
3429
|
+
if (message.sequence !== 0) {
|
|
3430
|
+
obj.sequence = Math.round(message.sequence);
|
|
3431
|
+
}
|
|
3432
|
+
if (message.fromSequence !== undefined) {
|
|
3433
|
+
obj.fromSequence = Math.round(message.fromSequence);
|
|
3434
|
+
}
|
|
3435
|
+
if (message.partCount !== undefined) {
|
|
3436
|
+
obj.partCount = Math.round(message.partCount);
|
|
3437
|
+
}
|
|
3438
|
+
return obj;
|
|
3439
|
+
},
|
|
3440
|
+
create(base) {
|
|
3441
|
+
return GetSlamMapRep.fromPartial(base ?? {});
|
|
3442
|
+
},
|
|
3443
|
+
fromPartial(object) {
|
|
3444
|
+
const message = createBaseGetSlamMapRep();
|
|
3445
|
+
message.available = object.available ?? false;
|
|
3446
|
+
message.mapId = object.mapId ?? 0;
|
|
3447
|
+
message.sequence = object.sequence ?? 0;
|
|
3448
|
+
message.fromSequence = object.fromSequence ?? undefined;
|
|
3449
|
+
message.partCount = object.partCount ?? undefined;
|
|
3450
|
+
return message;
|
|
3451
|
+
},
|
|
3452
|
+
};
|
|
3453
|
+
function createBaseResetSlamReq() {
|
|
3454
|
+
return { mapId: 0 };
|
|
3455
|
+
}
|
|
3456
|
+
export const ResetSlamReq = {
|
|
3457
|
+
encode(message, writer = new BinaryWriter()) {
|
|
3458
|
+
if (message.mapId !== 0) {
|
|
3459
|
+
writer.uint32(8).uint32(message.mapId);
|
|
3460
|
+
}
|
|
3461
|
+
return writer;
|
|
3462
|
+
},
|
|
3463
|
+
decode(input, length) {
|
|
3464
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
3465
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
3466
|
+
const message = createBaseResetSlamReq();
|
|
3467
|
+
while (reader.pos < end) {
|
|
3468
|
+
const tag = reader.uint32();
|
|
3469
|
+
switch (tag >>> 3) {
|
|
3470
|
+
case 1: {
|
|
3471
|
+
if (tag !== 8) {
|
|
3472
|
+
break;
|
|
3473
|
+
}
|
|
3474
|
+
message.mapId = reader.uint32();
|
|
3475
|
+
continue;
|
|
3476
|
+
}
|
|
3477
|
+
}
|
|
3478
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
3479
|
+
break;
|
|
3480
|
+
}
|
|
3481
|
+
reader.skip(tag & 7);
|
|
3482
|
+
}
|
|
3483
|
+
return message;
|
|
3484
|
+
},
|
|
3485
|
+
fromJSON(object) {
|
|
3486
|
+
return { mapId: isSet(object.mapId) ? gt.Number(object.mapId) : 0 };
|
|
3487
|
+
},
|
|
3488
|
+
toJSON(message) {
|
|
3489
|
+
const obj = {};
|
|
3490
|
+
if (message.mapId !== 0) {
|
|
3491
|
+
obj.mapId = Math.round(message.mapId);
|
|
3492
|
+
}
|
|
3493
|
+
return obj;
|
|
3494
|
+
},
|
|
3495
|
+
create(base) {
|
|
3496
|
+
return ResetSlamReq.fromPartial(base ?? {});
|
|
3497
|
+
},
|
|
3498
|
+
fromPartial(object) {
|
|
3499
|
+
const message = createBaseResetSlamReq();
|
|
3500
|
+
message.mapId = object.mapId ?? 0;
|
|
3501
|
+
return message;
|
|
3502
|
+
},
|
|
3503
|
+
};
|
|
3504
|
+
function createBaseResetSlamRep() {
|
|
3505
|
+
return { available: false, mapId: 0, reset: false, error: 0 };
|
|
3506
|
+
}
|
|
3507
|
+
export const ResetSlamRep = {
|
|
3508
|
+
encode(message, writer = new BinaryWriter()) {
|
|
3509
|
+
if (message.available !== false) {
|
|
3510
|
+
writer.uint32(8).bool(message.available);
|
|
3511
|
+
}
|
|
3512
|
+
if (message.mapId !== 0) {
|
|
3513
|
+
writer.uint32(16).uint32(message.mapId);
|
|
3514
|
+
}
|
|
3515
|
+
if (message.reset !== false) {
|
|
3516
|
+
writer.uint32(24).bool(message.reset);
|
|
3517
|
+
}
|
|
3518
|
+
if (message.error !== 0) {
|
|
3519
|
+
writer.uint32(32).int32(message.error);
|
|
3520
|
+
}
|
|
3521
|
+
return writer;
|
|
3522
|
+
},
|
|
3523
|
+
decode(input, length) {
|
|
3524
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
3525
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
3526
|
+
const message = createBaseResetSlamRep();
|
|
3527
|
+
while (reader.pos < end) {
|
|
3528
|
+
const tag = reader.uint32();
|
|
3529
|
+
switch (tag >>> 3) {
|
|
3530
|
+
case 1: {
|
|
3531
|
+
if (tag !== 8) {
|
|
3532
|
+
break;
|
|
3533
|
+
}
|
|
3534
|
+
message.available = reader.bool();
|
|
3535
|
+
continue;
|
|
3536
|
+
}
|
|
3537
|
+
case 2: {
|
|
3538
|
+
if (tag !== 16) {
|
|
3539
|
+
break;
|
|
3540
|
+
}
|
|
3541
|
+
message.mapId = reader.uint32();
|
|
3542
|
+
continue;
|
|
3543
|
+
}
|
|
3544
|
+
case 3: {
|
|
3545
|
+
if (tag !== 24) {
|
|
3546
|
+
break;
|
|
3547
|
+
}
|
|
3548
|
+
message.reset = reader.bool();
|
|
3549
|
+
continue;
|
|
3550
|
+
}
|
|
3551
|
+
case 4: {
|
|
3552
|
+
if (tag !== 32) {
|
|
3553
|
+
break;
|
|
3554
|
+
}
|
|
3555
|
+
message.error = reader.int32();
|
|
3556
|
+
continue;
|
|
3557
|
+
}
|
|
3558
|
+
}
|
|
3559
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
3560
|
+
break;
|
|
3561
|
+
}
|
|
3562
|
+
reader.skip(tag & 7);
|
|
3563
|
+
}
|
|
3564
|
+
return message;
|
|
3565
|
+
},
|
|
3566
|
+
fromJSON(object) {
|
|
3567
|
+
return {
|
|
3568
|
+
available: isSet(object.available) ? gt.Boolean(object.available) : false,
|
|
3569
|
+
mapId: isSet(object.mapId) ? gt.Number(object.mapId) : 0,
|
|
3570
|
+
reset: isSet(object.reset) ? gt.Boolean(object.reset) : false,
|
|
3571
|
+
error: isSet(object.error) ? slamRequestErrorFromJSON(object.error) : 0,
|
|
3572
|
+
};
|
|
3573
|
+
},
|
|
3574
|
+
toJSON(message) {
|
|
3575
|
+
const obj = {};
|
|
3576
|
+
if (message.available !== false) {
|
|
3577
|
+
obj.available = message.available;
|
|
3578
|
+
}
|
|
3579
|
+
if (message.mapId !== 0) {
|
|
3580
|
+
obj.mapId = Math.round(message.mapId);
|
|
3581
|
+
}
|
|
3582
|
+
if (message.reset !== false) {
|
|
3583
|
+
obj.reset = message.reset;
|
|
3584
|
+
}
|
|
3585
|
+
if (message.error !== 0) {
|
|
3586
|
+
obj.error = slamRequestErrorToJSON(message.error);
|
|
3587
|
+
}
|
|
3588
|
+
return obj;
|
|
3589
|
+
},
|
|
3590
|
+
create(base) {
|
|
3591
|
+
return ResetSlamRep.fromPartial(base ?? {});
|
|
3592
|
+
},
|
|
3593
|
+
fromPartial(object) {
|
|
3594
|
+
const message = createBaseResetSlamRep();
|
|
3595
|
+
message.available = object.available ?? false;
|
|
3596
|
+
message.mapId = object.mapId ?? 0;
|
|
3597
|
+
message.reset = object.reset ?? false;
|
|
3598
|
+
message.error = object.error ?? 0;
|
|
3599
|
+
return message;
|
|
3600
|
+
},
|
|
3601
|
+
};
|
|
3602
|
+
function createBaseSetSlamActiveReq() {
|
|
3603
|
+
return { active: false };
|
|
3604
|
+
}
|
|
3605
|
+
export const SetSlamActiveReq = {
|
|
3606
|
+
encode(message, writer = new BinaryWriter()) {
|
|
3607
|
+
if (message.active !== false) {
|
|
3608
|
+
writer.uint32(8).bool(message.active);
|
|
3609
|
+
}
|
|
3610
|
+
return writer;
|
|
3611
|
+
},
|
|
3612
|
+
decode(input, length) {
|
|
3613
|
+
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
3614
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
3615
|
+
const message = createBaseSetSlamActiveReq();
|
|
2445
3616
|
while (reader.pos < end) {
|
|
2446
3617
|
const tag = reader.uint32();
|
|
2447
3618
|
switch (tag >>> 3) {
|
|
3619
|
+
case 1: {
|
|
3620
|
+
if (tag !== 8) {
|
|
3621
|
+
break;
|
|
3622
|
+
}
|
|
3623
|
+
message.active = reader.bool();
|
|
3624
|
+
continue;
|
|
3625
|
+
}
|
|
2448
3626
|
}
|
|
2449
3627
|
if ((tag & 7) === 4 || tag === 0) {
|
|
2450
3628
|
break;
|
|
@@ -2453,43 +3631,67 @@ export const GetCvModelsReq = {
|
|
|
2453
3631
|
}
|
|
2454
3632
|
return message;
|
|
2455
3633
|
},
|
|
2456
|
-
fromJSON(
|
|
2457
|
-
return {};
|
|
3634
|
+
fromJSON(object) {
|
|
3635
|
+
return { active: isSet(object.active) ? gt.Boolean(object.active) : false };
|
|
2458
3636
|
},
|
|
2459
|
-
toJSON(
|
|
3637
|
+
toJSON(message) {
|
|
2460
3638
|
const obj = {};
|
|
3639
|
+
if (message.active !== false) {
|
|
3640
|
+
obj.active = message.active;
|
|
3641
|
+
}
|
|
2461
3642
|
return obj;
|
|
2462
3643
|
},
|
|
2463
3644
|
create(base) {
|
|
2464
|
-
return
|
|
3645
|
+
return SetSlamActiveReq.fromPartial(base ?? {});
|
|
2465
3646
|
},
|
|
2466
|
-
fromPartial(
|
|
2467
|
-
const message =
|
|
3647
|
+
fromPartial(object) {
|
|
3648
|
+
const message = createBaseSetSlamActiveReq();
|
|
3649
|
+
message.active = object.active ?? false;
|
|
2468
3650
|
return message;
|
|
2469
3651
|
},
|
|
2470
3652
|
};
|
|
2471
|
-
function
|
|
2472
|
-
return {
|
|
3653
|
+
function createBaseSetSlamActiveRep() {
|
|
3654
|
+
return { available: false, active: false, error: 0 };
|
|
2473
3655
|
}
|
|
2474
|
-
export const
|
|
3656
|
+
export const SetSlamActiveRep = {
|
|
2475
3657
|
encode(message, writer = new BinaryWriter()) {
|
|
2476
|
-
|
|
2477
|
-
|
|
3658
|
+
if (message.available !== false) {
|
|
3659
|
+
writer.uint32(8).bool(message.available);
|
|
3660
|
+
}
|
|
3661
|
+
if (message.active !== false) {
|
|
3662
|
+
writer.uint32(16).bool(message.active);
|
|
3663
|
+
}
|
|
3664
|
+
if (message.error !== 0) {
|
|
3665
|
+
writer.uint32(24).int32(message.error);
|
|
2478
3666
|
}
|
|
2479
3667
|
return writer;
|
|
2480
3668
|
},
|
|
2481
3669
|
decode(input, length) {
|
|
2482
3670
|
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
2483
3671
|
const end = length === undefined ? reader.len : reader.pos + length;
|
|
2484
|
-
const message =
|
|
3672
|
+
const message = createBaseSetSlamActiveRep();
|
|
2485
3673
|
while (reader.pos < end) {
|
|
2486
3674
|
const tag = reader.uint32();
|
|
2487
3675
|
switch (tag >>> 3) {
|
|
2488
3676
|
case 1: {
|
|
2489
|
-
if (tag !==
|
|
3677
|
+
if (tag !== 8) {
|
|
2490
3678
|
break;
|
|
2491
3679
|
}
|
|
2492
|
-
message.
|
|
3680
|
+
message.available = reader.bool();
|
|
3681
|
+
continue;
|
|
3682
|
+
}
|
|
3683
|
+
case 2: {
|
|
3684
|
+
if (tag !== 16) {
|
|
3685
|
+
break;
|
|
3686
|
+
}
|
|
3687
|
+
message.active = reader.bool();
|
|
3688
|
+
continue;
|
|
3689
|
+
}
|
|
3690
|
+
case 3: {
|
|
3691
|
+
if (tag !== 24) {
|
|
3692
|
+
break;
|
|
3693
|
+
}
|
|
3694
|
+
message.error = reader.int32();
|
|
2493
3695
|
continue;
|
|
2494
3696
|
}
|
|
2495
3697
|
}
|
|
@@ -2502,47 +3704,77 @@ export const GetCvModelsRep = {
|
|
|
2502
3704
|
},
|
|
2503
3705
|
fromJSON(object) {
|
|
2504
3706
|
return {
|
|
2505
|
-
|
|
3707
|
+
available: isSet(object.available) ? gt.Boolean(object.available) : false,
|
|
3708
|
+
active: isSet(object.active) ? gt.Boolean(object.active) : false,
|
|
3709
|
+
error: isSet(object.error) ? slamRequestErrorFromJSON(object.error) : 0,
|
|
2506
3710
|
};
|
|
2507
3711
|
},
|
|
2508
3712
|
toJSON(message) {
|
|
2509
3713
|
const obj = {};
|
|
2510
|
-
if (message.
|
|
2511
|
-
obj.
|
|
3714
|
+
if (message.available !== false) {
|
|
3715
|
+
obj.available = message.available;
|
|
3716
|
+
}
|
|
3717
|
+
if (message.active !== false) {
|
|
3718
|
+
obj.active = message.active;
|
|
3719
|
+
}
|
|
3720
|
+
if (message.error !== 0) {
|
|
3721
|
+
obj.error = slamRequestErrorToJSON(message.error);
|
|
2512
3722
|
}
|
|
2513
3723
|
return obj;
|
|
2514
3724
|
},
|
|
2515
3725
|
create(base) {
|
|
2516
|
-
return
|
|
3726
|
+
return SetSlamActiveRep.fromPartial(base ?? {});
|
|
2517
3727
|
},
|
|
2518
3728
|
fromPartial(object) {
|
|
2519
|
-
const message =
|
|
2520
|
-
message.
|
|
3729
|
+
const message = createBaseSetSlamActiveRep();
|
|
3730
|
+
message.available = object.available ?? false;
|
|
3731
|
+
message.active = object.active ?? false;
|
|
3732
|
+
message.error = object.error ?? 0;
|
|
2521
3733
|
return message;
|
|
2522
3734
|
},
|
|
2523
3735
|
};
|
|
2524
|
-
function
|
|
2525
|
-
return {
|
|
3736
|
+
function createBaseSetSlamRecordingReq() {
|
|
3737
|
+
return { record: false, sensorData: false, storageLocation: 0 };
|
|
2526
3738
|
}
|
|
2527
|
-
export const
|
|
3739
|
+
export const SetSlamRecordingReq = {
|
|
2528
3740
|
encode(message, writer = new BinaryWriter()) {
|
|
2529
|
-
if (message.
|
|
2530
|
-
|
|
3741
|
+
if (message.record !== false) {
|
|
3742
|
+
writer.uint32(8).bool(message.record);
|
|
3743
|
+
}
|
|
3744
|
+
if (message.sensorData !== false) {
|
|
3745
|
+
writer.uint32(16).bool(message.sensorData);
|
|
3746
|
+
}
|
|
3747
|
+
if (message.storageLocation !== 0) {
|
|
3748
|
+
writer.uint32(24).int32(message.storageLocation);
|
|
2531
3749
|
}
|
|
2532
3750
|
return writer;
|
|
2533
3751
|
},
|
|
2534
3752
|
decode(input, length) {
|
|
2535
3753
|
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
2536
3754
|
const end = length === undefined ? reader.len : reader.pos + length;
|
|
2537
|
-
const message =
|
|
3755
|
+
const message = createBaseSetSlamRecordingReq();
|
|
2538
3756
|
while (reader.pos < end) {
|
|
2539
3757
|
const tag = reader.uint32();
|
|
2540
3758
|
switch (tag >>> 3) {
|
|
2541
3759
|
case 1: {
|
|
2542
|
-
if (tag !==
|
|
3760
|
+
if (tag !== 8) {
|
|
2543
3761
|
break;
|
|
2544
3762
|
}
|
|
2545
|
-
message.
|
|
3763
|
+
message.record = reader.bool();
|
|
3764
|
+
continue;
|
|
3765
|
+
}
|
|
3766
|
+
case 2: {
|
|
3767
|
+
if (tag !== 16) {
|
|
3768
|
+
break;
|
|
3769
|
+
}
|
|
3770
|
+
message.sensorData = reader.bool();
|
|
3771
|
+
continue;
|
|
3772
|
+
}
|
|
3773
|
+
case 3: {
|
|
3774
|
+
if (tag !== 24) {
|
|
3775
|
+
break;
|
|
3776
|
+
}
|
|
3777
|
+
message.storageLocation = reader.int32();
|
|
2546
3778
|
continue;
|
|
2547
3779
|
}
|
|
2548
3780
|
}
|
|
@@ -2554,40 +3786,80 @@ export const SetMultibeamColorFilterReq = {
|
|
|
2554
3786
|
return message;
|
|
2555
3787
|
},
|
|
2556
3788
|
fromJSON(object) {
|
|
2557
|
-
return {
|
|
3789
|
+
return {
|
|
3790
|
+
record: isSet(object.record) ? gt.Boolean(object.record) : false,
|
|
3791
|
+
sensorData: isSet(object.sensorData) ? gt.Boolean(object.sensorData) : false,
|
|
3792
|
+
storageLocation: isSet(object.storageLocation) ? storageLocationFromJSON(object.storageLocation) : 0,
|
|
3793
|
+
};
|
|
2558
3794
|
},
|
|
2559
3795
|
toJSON(message) {
|
|
2560
3796
|
const obj = {};
|
|
2561
|
-
if (message.
|
|
2562
|
-
obj.
|
|
3797
|
+
if (message.record !== false) {
|
|
3798
|
+
obj.record = message.record;
|
|
3799
|
+
}
|
|
3800
|
+
if (message.sensorData !== false) {
|
|
3801
|
+
obj.sensorData = message.sensorData;
|
|
3802
|
+
}
|
|
3803
|
+
if (message.storageLocation !== 0) {
|
|
3804
|
+
obj.storageLocation = storageLocationToJSON(message.storageLocation);
|
|
2563
3805
|
}
|
|
2564
3806
|
return obj;
|
|
2565
3807
|
},
|
|
2566
3808
|
create(base) {
|
|
2567
|
-
return
|
|
3809
|
+
return SetSlamRecordingReq.fromPartial(base ?? {});
|
|
2568
3810
|
},
|
|
2569
3811
|
fromPartial(object) {
|
|
2570
|
-
const message =
|
|
2571
|
-
message.
|
|
2572
|
-
|
|
2573
|
-
|
|
3812
|
+
const message = createBaseSetSlamRecordingReq();
|
|
3813
|
+
message.record = object.record ?? false;
|
|
3814
|
+
message.sensorData = object.sensorData ?? false;
|
|
3815
|
+
message.storageLocation = object.storageLocation ?? 0;
|
|
2574
3816
|
return message;
|
|
2575
3817
|
},
|
|
2576
3818
|
};
|
|
2577
|
-
function
|
|
2578
|
-
return {};
|
|
3819
|
+
function createBaseSetSlamRecordingRep() {
|
|
3820
|
+
return { available: false, recording: undefined, error: 0 };
|
|
2579
3821
|
}
|
|
2580
|
-
export const
|
|
2581
|
-
encode(
|
|
3822
|
+
export const SetSlamRecordingRep = {
|
|
3823
|
+
encode(message, writer = new BinaryWriter()) {
|
|
3824
|
+
if (message.available !== false) {
|
|
3825
|
+
writer.uint32(8).bool(message.available);
|
|
3826
|
+
}
|
|
3827
|
+
if (message.recording !== undefined) {
|
|
3828
|
+
SlamRecordingState.encode(message.recording, writer.uint32(18).fork()).join();
|
|
3829
|
+
}
|
|
3830
|
+
if (message.error !== 0) {
|
|
3831
|
+
writer.uint32(24).int32(message.error);
|
|
3832
|
+
}
|
|
2582
3833
|
return writer;
|
|
2583
3834
|
},
|
|
2584
3835
|
decode(input, length) {
|
|
2585
3836
|
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
2586
3837
|
const end = length === undefined ? reader.len : reader.pos + length;
|
|
2587
|
-
const message =
|
|
3838
|
+
const message = createBaseSetSlamRecordingRep();
|
|
2588
3839
|
while (reader.pos < end) {
|
|
2589
3840
|
const tag = reader.uint32();
|
|
2590
3841
|
switch (tag >>> 3) {
|
|
3842
|
+
case 1: {
|
|
3843
|
+
if (tag !== 8) {
|
|
3844
|
+
break;
|
|
3845
|
+
}
|
|
3846
|
+
message.available = reader.bool();
|
|
3847
|
+
continue;
|
|
3848
|
+
}
|
|
3849
|
+
case 2: {
|
|
3850
|
+
if (tag !== 18) {
|
|
3851
|
+
break;
|
|
3852
|
+
}
|
|
3853
|
+
message.recording = SlamRecordingState.decode(reader, reader.uint32());
|
|
3854
|
+
continue;
|
|
3855
|
+
}
|
|
3856
|
+
case 3: {
|
|
3857
|
+
if (tag !== 24) {
|
|
3858
|
+
break;
|
|
3859
|
+
}
|
|
3860
|
+
message.error = reader.int32();
|
|
3861
|
+
continue;
|
|
3862
|
+
}
|
|
2591
3863
|
}
|
|
2592
3864
|
if ((tag & 7) === 4 || tag === 0) {
|
|
2593
3865
|
break;
|
|
@@ -2596,35 +3868,73 @@ export const SetMultibeamColorFilterRep = {
|
|
|
2596
3868
|
}
|
|
2597
3869
|
return message;
|
|
2598
3870
|
},
|
|
2599
|
-
fromJSON(
|
|
2600
|
-
return {
|
|
3871
|
+
fromJSON(object) {
|
|
3872
|
+
return {
|
|
3873
|
+
available: isSet(object.available) ? gt.Boolean(object.available) : false,
|
|
3874
|
+
recording: isSet(object.recording) ? SlamRecordingState.fromJSON(object.recording) : undefined,
|
|
3875
|
+
error: isSet(object.error) ? slamRequestErrorFromJSON(object.error) : 0,
|
|
3876
|
+
};
|
|
2601
3877
|
},
|
|
2602
|
-
toJSON(
|
|
3878
|
+
toJSON(message) {
|
|
2603
3879
|
const obj = {};
|
|
3880
|
+
if (message.available !== false) {
|
|
3881
|
+
obj.available = message.available;
|
|
3882
|
+
}
|
|
3883
|
+
if (message.recording !== undefined) {
|
|
3884
|
+
obj.recording = SlamRecordingState.toJSON(message.recording);
|
|
3885
|
+
}
|
|
3886
|
+
if (message.error !== 0) {
|
|
3887
|
+
obj.error = slamRequestErrorToJSON(message.error);
|
|
3888
|
+
}
|
|
2604
3889
|
return obj;
|
|
2605
3890
|
},
|
|
2606
3891
|
create(base) {
|
|
2607
|
-
return
|
|
3892
|
+
return SetSlamRecordingRep.fromPartial(base ?? {});
|
|
2608
3893
|
},
|
|
2609
|
-
fromPartial(
|
|
2610
|
-
const message =
|
|
3894
|
+
fromPartial(object) {
|
|
3895
|
+
const message = createBaseSetSlamRecordingRep();
|
|
3896
|
+
message.available = object.available ?? false;
|
|
3897
|
+
message.recording = (object.recording !== undefined && object.recording !== null)
|
|
3898
|
+
? SlamRecordingState.fromPartial(object.recording)
|
|
3899
|
+
: undefined;
|
|
3900
|
+
message.error = object.error ?? 0;
|
|
2611
3901
|
return message;
|
|
2612
3902
|
},
|
|
2613
3903
|
};
|
|
2614
|
-
function
|
|
2615
|
-
return {};
|
|
3904
|
+
function createBaseSetSlamSensorSettingsReq() {
|
|
3905
|
+
return { settings: undefined, sensorId: "" };
|
|
2616
3906
|
}
|
|
2617
|
-
export const
|
|
2618
|
-
encode(
|
|
3907
|
+
export const SetSlamSensorSettingsReq = {
|
|
3908
|
+
encode(message, writer = new BinaryWriter()) {
|
|
3909
|
+
if (message.settings !== undefined) {
|
|
3910
|
+
SlamSensorSettings.encode(message.settings, writer.uint32(10).fork()).join();
|
|
3911
|
+
}
|
|
3912
|
+
if (message.sensorId !== "") {
|
|
3913
|
+
writer.uint32(18).string(message.sensorId);
|
|
3914
|
+
}
|
|
2619
3915
|
return writer;
|
|
2620
3916
|
},
|
|
2621
3917
|
decode(input, length) {
|
|
2622
3918
|
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
2623
3919
|
const end = length === undefined ? reader.len : reader.pos + length;
|
|
2624
|
-
const message =
|
|
3920
|
+
const message = createBaseSetSlamSensorSettingsReq();
|
|
2625
3921
|
while (reader.pos < end) {
|
|
2626
3922
|
const tag = reader.uint32();
|
|
2627
3923
|
switch (tag >>> 3) {
|
|
3924
|
+
case 1: {
|
|
3925
|
+
if (tag !== 10) {
|
|
3926
|
+
break;
|
|
3927
|
+
}
|
|
3928
|
+
message.settings = SlamSensorSettings.decode(reader, reader.uint32());
|
|
3929
|
+
continue;
|
|
3930
|
+
}
|
|
3931
|
+
case 2: {
|
|
3932
|
+
if (tag !== 18) {
|
|
3933
|
+
break;
|
|
3934
|
+
}
|
|
3935
|
+
message.sensorId = reader.string();
|
|
3936
|
+
continue;
|
|
3937
|
+
}
|
|
2628
3938
|
}
|
|
2629
3939
|
if ((tag & 7) === 4 || tag === 0) {
|
|
2630
3940
|
break;
|
|
@@ -2633,43 +3943,86 @@ export const GetMultibeamColorFilterReq = {
|
|
|
2633
3943
|
}
|
|
2634
3944
|
return message;
|
|
2635
3945
|
},
|
|
2636
|
-
fromJSON(
|
|
2637
|
-
return {
|
|
3946
|
+
fromJSON(object) {
|
|
3947
|
+
return {
|
|
3948
|
+
settings: isSet(object.settings) ? SlamSensorSettings.fromJSON(object.settings) : undefined,
|
|
3949
|
+
sensorId: isSet(object.sensorId) ? gt.String(object.sensorId) : "",
|
|
3950
|
+
};
|
|
2638
3951
|
},
|
|
2639
|
-
toJSON(
|
|
3952
|
+
toJSON(message) {
|
|
2640
3953
|
const obj = {};
|
|
3954
|
+
if (message.settings !== undefined) {
|
|
3955
|
+
obj.settings = SlamSensorSettings.toJSON(message.settings);
|
|
3956
|
+
}
|
|
3957
|
+
if (message.sensorId !== "") {
|
|
3958
|
+
obj.sensorId = message.sensorId;
|
|
3959
|
+
}
|
|
2641
3960
|
return obj;
|
|
2642
3961
|
},
|
|
2643
3962
|
create(base) {
|
|
2644
|
-
return
|
|
3963
|
+
return SetSlamSensorSettingsReq.fromPartial(base ?? {});
|
|
2645
3964
|
},
|
|
2646
|
-
fromPartial(
|
|
2647
|
-
const message =
|
|
3965
|
+
fromPartial(object) {
|
|
3966
|
+
const message = createBaseSetSlamSensorSettingsReq();
|
|
3967
|
+
message.settings = (object.settings !== undefined && object.settings !== null)
|
|
3968
|
+
? SlamSensorSettings.fromPartial(object.settings)
|
|
3969
|
+
: undefined;
|
|
3970
|
+
message.sensorId = object.sensorId ?? "";
|
|
2648
3971
|
return message;
|
|
2649
3972
|
},
|
|
2650
3973
|
};
|
|
2651
|
-
function
|
|
2652
|
-
return {
|
|
3974
|
+
function createBaseSetSlamSensorSettingsRep() {
|
|
3975
|
+
return { available: false, applied: false, settings: undefined, error: 0 };
|
|
2653
3976
|
}
|
|
2654
|
-
export const
|
|
3977
|
+
export const SetSlamSensorSettingsRep = {
|
|
2655
3978
|
encode(message, writer = new BinaryWriter()) {
|
|
2656
|
-
if (message.
|
|
2657
|
-
|
|
3979
|
+
if (message.available !== false) {
|
|
3980
|
+
writer.uint32(8).bool(message.available);
|
|
3981
|
+
}
|
|
3982
|
+
if (message.applied !== false) {
|
|
3983
|
+
writer.uint32(16).bool(message.applied);
|
|
3984
|
+
}
|
|
3985
|
+
if (message.settings !== undefined) {
|
|
3986
|
+
SlamSensorSettings.encode(message.settings, writer.uint32(26).fork()).join();
|
|
3987
|
+
}
|
|
3988
|
+
if (message.error !== 0) {
|
|
3989
|
+
writer.uint32(32).int32(message.error);
|
|
2658
3990
|
}
|
|
2659
3991
|
return writer;
|
|
2660
3992
|
},
|
|
2661
3993
|
decode(input, length) {
|
|
2662
3994
|
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
|
|
2663
3995
|
const end = length === undefined ? reader.len : reader.pos + length;
|
|
2664
|
-
const message =
|
|
3996
|
+
const message = createBaseSetSlamSensorSettingsRep();
|
|
2665
3997
|
while (reader.pos < end) {
|
|
2666
3998
|
const tag = reader.uint32();
|
|
2667
3999
|
switch (tag >>> 3) {
|
|
2668
4000
|
case 1: {
|
|
2669
|
-
if (tag !==
|
|
4001
|
+
if (tag !== 8) {
|
|
2670
4002
|
break;
|
|
2671
4003
|
}
|
|
2672
|
-
message.
|
|
4004
|
+
message.available = reader.bool();
|
|
4005
|
+
continue;
|
|
4006
|
+
}
|
|
4007
|
+
case 2: {
|
|
4008
|
+
if (tag !== 16) {
|
|
4009
|
+
break;
|
|
4010
|
+
}
|
|
4011
|
+
message.applied = reader.bool();
|
|
4012
|
+
continue;
|
|
4013
|
+
}
|
|
4014
|
+
case 3: {
|
|
4015
|
+
if (tag !== 26) {
|
|
4016
|
+
break;
|
|
4017
|
+
}
|
|
4018
|
+
message.settings = SlamSensorSettings.decode(reader, reader.uint32());
|
|
4019
|
+
continue;
|
|
4020
|
+
}
|
|
4021
|
+
case 4: {
|
|
4022
|
+
if (tag !== 32) {
|
|
4023
|
+
break;
|
|
4024
|
+
}
|
|
4025
|
+
message.error = reader.int32();
|
|
2673
4026
|
continue;
|
|
2674
4027
|
}
|
|
2675
4028
|
}
|
|
@@ -2681,23 +4034,40 @@ export const GetMultibeamColorFilterRep = {
|
|
|
2681
4034
|
return message;
|
|
2682
4035
|
},
|
|
2683
4036
|
fromJSON(object) {
|
|
2684
|
-
return {
|
|
4037
|
+
return {
|
|
4038
|
+
available: isSet(object.available) ? gt.Boolean(object.available) : false,
|
|
4039
|
+
applied: isSet(object.applied) ? gt.Boolean(object.applied) : false,
|
|
4040
|
+
settings: isSet(object.settings) ? SlamSensorSettings.fromJSON(object.settings) : undefined,
|
|
4041
|
+
error: isSet(object.error) ? slamRequestErrorFromJSON(object.error) : 0,
|
|
4042
|
+
};
|
|
2685
4043
|
},
|
|
2686
4044
|
toJSON(message) {
|
|
2687
4045
|
const obj = {};
|
|
2688
|
-
if (message.
|
|
2689
|
-
obj.
|
|
4046
|
+
if (message.available !== false) {
|
|
4047
|
+
obj.available = message.available;
|
|
4048
|
+
}
|
|
4049
|
+
if (message.applied !== false) {
|
|
4050
|
+
obj.applied = message.applied;
|
|
4051
|
+
}
|
|
4052
|
+
if (message.settings !== undefined) {
|
|
4053
|
+
obj.settings = SlamSensorSettings.toJSON(message.settings);
|
|
4054
|
+
}
|
|
4055
|
+
if (message.error !== 0) {
|
|
4056
|
+
obj.error = slamRequestErrorToJSON(message.error);
|
|
2690
4057
|
}
|
|
2691
4058
|
return obj;
|
|
2692
4059
|
},
|
|
2693
4060
|
create(base) {
|
|
2694
|
-
return
|
|
4061
|
+
return SetSlamSensorSettingsRep.fromPartial(base ?? {});
|
|
2695
4062
|
},
|
|
2696
4063
|
fromPartial(object) {
|
|
2697
|
-
const message =
|
|
2698
|
-
message.
|
|
2699
|
-
|
|
4064
|
+
const message = createBaseSetSlamSensorSettingsRep();
|
|
4065
|
+
message.available = object.available ?? false;
|
|
4066
|
+
message.applied = object.applied ?? false;
|
|
4067
|
+
message.settings = (object.settings !== undefined && object.settings !== null)
|
|
4068
|
+
? SlamSensorSettings.fromPartial(object.settings)
|
|
2700
4069
|
: undefined;
|
|
4070
|
+
message.error = object.error ?? 0;
|
|
2701
4071
|
return message;
|
|
2702
4072
|
},
|
|
2703
4073
|
};
|
|
@@ -2716,6 +4086,16 @@ const gt = (() => {
|
|
|
2716
4086
|
}
|
|
2717
4087
|
throw "Unable to locate global object";
|
|
2718
4088
|
})();
|
|
4089
|
+
function longToNumber(int64) {
|
|
4090
|
+
const num = gt.Number(int64.toString());
|
|
4091
|
+
if (num > gt.Number.MAX_SAFE_INTEGER) {
|
|
4092
|
+
throw new gt.Error("Value is larger than Number.MAX_SAFE_INTEGER");
|
|
4093
|
+
}
|
|
4094
|
+
if (num < gt.Number.MIN_SAFE_INTEGER) {
|
|
4095
|
+
throw new gt.Error("Value is smaller than Number.MIN_SAFE_INTEGER");
|
|
4096
|
+
}
|
|
4097
|
+
return num;
|
|
4098
|
+
}
|
|
2719
4099
|
function isSet(value) {
|
|
2720
4100
|
return value !== null && value !== undefined;
|
|
2721
4101
|
}
|