@blueyerobotics/protocol-definitions 3.4.0-8187f91a → 3.4.0-eddb8a5e

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/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";
9
+ import { Battery, cameraFromJSON, CameraParameters, cameraToJSON, ClientInfo, ConnectedClient, CvModelInfo, headingModeFromJSON, headingModeToJSON, MultibeamColorFilter, OverlayParameters, PersistentStorageSettings, storageLocationFromJSON, storageLocationToJSON, SystemTime, } from "./message_formats.js";
10
10
  import { Instruction, Mission } from "./mission_planning.js";
11
+ import { SlamRecordingState, slamRequestErrorFromJSON, slamRequestErrorToJSON, SlamSensorSettings, } from "./slam.js";
11
12
  function createBaseSetOverlayParametersReq() {
12
13
  return { overlayParameters: undefined };
13
14
  }
@@ -1624,6 +1625,210 @@ export const SetLogFrequencyRep = {
1624
1625
  return message;
1625
1626
  },
1626
1627
  };
1628
+ function createBaseResetPubFrequencyReq() {
1629
+ return { messageType: "" };
1630
+ }
1631
+ export const ResetPubFrequencyReq = {
1632
+ encode(message, writer = new BinaryWriter()) {
1633
+ if (message.messageType !== "") {
1634
+ writer.uint32(10).string(message.messageType);
1635
+ }
1636
+ return writer;
1637
+ },
1638
+ decode(input, length) {
1639
+ const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
1640
+ const end = length === undefined ? reader.len : reader.pos + length;
1641
+ const message = createBaseResetPubFrequencyReq();
1642
+ while (reader.pos < end) {
1643
+ const tag = reader.uint32();
1644
+ switch (tag >>> 3) {
1645
+ case 1: {
1646
+ if (tag !== 10) {
1647
+ break;
1648
+ }
1649
+ message.messageType = reader.string();
1650
+ continue;
1651
+ }
1652
+ }
1653
+ if ((tag & 7) === 4 || tag === 0) {
1654
+ break;
1655
+ }
1656
+ reader.skip(tag & 7);
1657
+ }
1658
+ return message;
1659
+ },
1660
+ fromJSON(object) {
1661
+ return { messageType: isSet(object.messageType) ? gt.String(object.messageType) : "" };
1662
+ },
1663
+ toJSON(message) {
1664
+ const obj = {};
1665
+ if (message.messageType !== "") {
1666
+ obj.messageType = message.messageType;
1667
+ }
1668
+ return obj;
1669
+ },
1670
+ create(base) {
1671
+ return ResetPubFrequencyReq.fromPartial(base ?? {});
1672
+ },
1673
+ fromPartial(object) {
1674
+ const message = createBaseResetPubFrequencyReq();
1675
+ message.messageType = object.messageType ?? "";
1676
+ return message;
1677
+ },
1678
+ };
1679
+ function createBaseResetPubFrequencyRep() {
1680
+ return { success: false };
1681
+ }
1682
+ export const ResetPubFrequencyRep = {
1683
+ encode(message, writer = new BinaryWriter()) {
1684
+ if (message.success !== false) {
1685
+ writer.uint32(8).bool(message.success);
1686
+ }
1687
+ return writer;
1688
+ },
1689
+ decode(input, length) {
1690
+ const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
1691
+ const end = length === undefined ? reader.len : reader.pos + length;
1692
+ const message = createBaseResetPubFrequencyRep();
1693
+ while (reader.pos < end) {
1694
+ const tag = reader.uint32();
1695
+ switch (tag >>> 3) {
1696
+ case 1: {
1697
+ if (tag !== 8) {
1698
+ break;
1699
+ }
1700
+ message.success = reader.bool();
1701
+ continue;
1702
+ }
1703
+ }
1704
+ if ((tag & 7) === 4 || tag === 0) {
1705
+ break;
1706
+ }
1707
+ reader.skip(tag & 7);
1708
+ }
1709
+ return message;
1710
+ },
1711
+ fromJSON(object) {
1712
+ return { success: isSet(object.success) ? gt.Boolean(object.success) : false };
1713
+ },
1714
+ toJSON(message) {
1715
+ const obj = {};
1716
+ if (message.success !== false) {
1717
+ obj.success = message.success;
1718
+ }
1719
+ return obj;
1720
+ },
1721
+ create(base) {
1722
+ return ResetPubFrequencyRep.fromPartial(base ?? {});
1723
+ },
1724
+ fromPartial(object) {
1725
+ const message = createBaseResetPubFrequencyRep();
1726
+ message.success = object.success ?? false;
1727
+ return message;
1728
+ },
1729
+ };
1730
+ function createBaseResetLogFrequencyReq() {
1731
+ return { messageType: "" };
1732
+ }
1733
+ export const ResetLogFrequencyReq = {
1734
+ encode(message, writer = new BinaryWriter()) {
1735
+ if (message.messageType !== "") {
1736
+ writer.uint32(10).string(message.messageType);
1737
+ }
1738
+ return writer;
1739
+ },
1740
+ decode(input, length) {
1741
+ const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
1742
+ const end = length === undefined ? reader.len : reader.pos + length;
1743
+ const message = createBaseResetLogFrequencyReq();
1744
+ while (reader.pos < end) {
1745
+ const tag = reader.uint32();
1746
+ switch (tag >>> 3) {
1747
+ case 1: {
1748
+ if (tag !== 10) {
1749
+ break;
1750
+ }
1751
+ message.messageType = reader.string();
1752
+ continue;
1753
+ }
1754
+ }
1755
+ if ((tag & 7) === 4 || tag === 0) {
1756
+ break;
1757
+ }
1758
+ reader.skip(tag & 7);
1759
+ }
1760
+ return message;
1761
+ },
1762
+ fromJSON(object) {
1763
+ return { messageType: isSet(object.messageType) ? gt.String(object.messageType) : "" };
1764
+ },
1765
+ toJSON(message) {
1766
+ const obj = {};
1767
+ if (message.messageType !== "") {
1768
+ obj.messageType = message.messageType;
1769
+ }
1770
+ return obj;
1771
+ },
1772
+ create(base) {
1773
+ return ResetLogFrequencyReq.fromPartial(base ?? {});
1774
+ },
1775
+ fromPartial(object) {
1776
+ const message = createBaseResetLogFrequencyReq();
1777
+ message.messageType = object.messageType ?? "";
1778
+ return message;
1779
+ },
1780
+ };
1781
+ function createBaseResetLogFrequencyRep() {
1782
+ return { success: false };
1783
+ }
1784
+ export const ResetLogFrequencyRep = {
1785
+ encode(message, writer = new BinaryWriter()) {
1786
+ if (message.success !== false) {
1787
+ writer.uint32(8).bool(message.success);
1788
+ }
1789
+ return writer;
1790
+ },
1791
+ decode(input, length) {
1792
+ const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
1793
+ const end = length === undefined ? reader.len : reader.pos + length;
1794
+ const message = createBaseResetLogFrequencyRep();
1795
+ while (reader.pos < end) {
1796
+ const tag = reader.uint32();
1797
+ switch (tag >>> 3) {
1798
+ case 1: {
1799
+ if (tag !== 8) {
1800
+ break;
1801
+ }
1802
+ message.success = reader.bool();
1803
+ continue;
1804
+ }
1805
+ }
1806
+ if ((tag & 7) === 4 || tag === 0) {
1807
+ break;
1808
+ }
1809
+ reader.skip(tag & 7);
1810
+ }
1811
+ return message;
1812
+ },
1813
+ fromJSON(object) {
1814
+ return { success: isSet(object.success) ? gt.Boolean(object.success) : false };
1815
+ },
1816
+ toJSON(message) {
1817
+ const obj = {};
1818
+ if (message.success !== false) {
1819
+ obj.success = message.success;
1820
+ }
1821
+ return obj;
1822
+ },
1823
+ create(base) {
1824
+ return ResetLogFrequencyRep.fromPartial(base ?? {});
1825
+ },
1826
+ fromPartial(object) {
1827
+ const message = createBaseResetLogFrequencyRep();
1828
+ message.success = object.success ?? false;
1829
+ return message;
1830
+ },
1831
+ };
1627
1832
  function createBaseGetTelemetryReq() {
1628
1833
  return { messageType: "" };
1629
1834
  }
@@ -2701,21 +2906,833 @@ export const GetMultibeamColorFilterRep = {
2701
2906
  return message;
2702
2907
  },
2703
2908
  };
2704
- const gt = (() => {
2705
- if (typeof globalThis !== "undefined") {
2706
- return globalThis;
2707
- }
2708
- if (typeof self !== "undefined") {
2709
- return self;
2710
- }
2711
- if (typeof window !== "undefined") {
2712
- return window;
2713
- }
2714
- if (typeof global !== "undefined") {
2715
- return global;
2716
- }
2717
- throw "Unable to locate global object";
2718
- })();
2909
+ function createBaseGetSlamMapReq() {
2910
+ return { mapId: 0, haveSequence: 0 };
2911
+ }
2912
+ export const GetSlamMapReq = {
2913
+ encode(message, writer = new BinaryWriter()) {
2914
+ if (message.mapId !== 0) {
2915
+ writer.uint32(8).uint32(message.mapId);
2916
+ }
2917
+ if (message.haveSequence !== 0) {
2918
+ writer.uint32(16).uint64(message.haveSequence);
2919
+ }
2920
+ return writer;
2921
+ },
2922
+ decode(input, length) {
2923
+ const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
2924
+ const end = length === undefined ? reader.len : reader.pos + length;
2925
+ const message = createBaseGetSlamMapReq();
2926
+ while (reader.pos < end) {
2927
+ const tag = reader.uint32();
2928
+ switch (tag >>> 3) {
2929
+ case 1: {
2930
+ if (tag !== 8) {
2931
+ break;
2932
+ }
2933
+ message.mapId = reader.uint32();
2934
+ continue;
2935
+ }
2936
+ case 2: {
2937
+ if (tag !== 16) {
2938
+ break;
2939
+ }
2940
+ message.haveSequence = longToNumber(reader.uint64());
2941
+ continue;
2942
+ }
2943
+ }
2944
+ if ((tag & 7) === 4 || tag === 0) {
2945
+ break;
2946
+ }
2947
+ reader.skip(tag & 7);
2948
+ }
2949
+ return message;
2950
+ },
2951
+ fromJSON(object) {
2952
+ return {
2953
+ mapId: isSet(object.mapId) ? gt.Number(object.mapId) : 0,
2954
+ haveSequence: isSet(object.haveSequence) ? gt.Number(object.haveSequence) : 0,
2955
+ };
2956
+ },
2957
+ toJSON(message) {
2958
+ const obj = {};
2959
+ if (message.mapId !== 0) {
2960
+ obj.mapId = Math.round(message.mapId);
2961
+ }
2962
+ if (message.haveSequence !== 0) {
2963
+ obj.haveSequence = Math.round(message.haveSequence);
2964
+ }
2965
+ return obj;
2966
+ },
2967
+ create(base) {
2968
+ return GetSlamMapReq.fromPartial(base ?? {});
2969
+ },
2970
+ fromPartial(object) {
2971
+ const message = createBaseGetSlamMapReq();
2972
+ message.mapId = object.mapId ?? 0;
2973
+ message.haveSequence = object.haveSequence ?? 0;
2974
+ return message;
2975
+ },
2976
+ };
2977
+ function createBaseGetSlamMapRep() {
2978
+ return { available: false, mapId: 0, sequence: 0, fromSequence: undefined, partCount: undefined };
2979
+ }
2980
+ export const GetSlamMapRep = {
2981
+ encode(message, writer = new BinaryWriter()) {
2982
+ if (message.available !== false) {
2983
+ writer.uint32(8).bool(message.available);
2984
+ }
2985
+ if (message.mapId !== 0) {
2986
+ writer.uint32(16).uint32(message.mapId);
2987
+ }
2988
+ if (message.sequence !== 0) {
2989
+ writer.uint32(24).uint64(message.sequence);
2990
+ }
2991
+ if (message.fromSequence !== undefined) {
2992
+ writer.uint32(32).uint64(message.fromSequence);
2993
+ }
2994
+ if (message.partCount !== undefined) {
2995
+ writer.uint32(40).uint32(message.partCount);
2996
+ }
2997
+ return writer;
2998
+ },
2999
+ decode(input, length) {
3000
+ const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
3001
+ const end = length === undefined ? reader.len : reader.pos + length;
3002
+ const message = createBaseGetSlamMapRep();
3003
+ while (reader.pos < end) {
3004
+ const tag = reader.uint32();
3005
+ switch (tag >>> 3) {
3006
+ case 1: {
3007
+ if (tag !== 8) {
3008
+ break;
3009
+ }
3010
+ message.available = reader.bool();
3011
+ continue;
3012
+ }
3013
+ case 2: {
3014
+ if (tag !== 16) {
3015
+ break;
3016
+ }
3017
+ message.mapId = reader.uint32();
3018
+ continue;
3019
+ }
3020
+ case 3: {
3021
+ if (tag !== 24) {
3022
+ break;
3023
+ }
3024
+ message.sequence = longToNumber(reader.uint64());
3025
+ continue;
3026
+ }
3027
+ case 4: {
3028
+ if (tag !== 32) {
3029
+ break;
3030
+ }
3031
+ message.fromSequence = longToNumber(reader.uint64());
3032
+ continue;
3033
+ }
3034
+ case 5: {
3035
+ if (tag !== 40) {
3036
+ break;
3037
+ }
3038
+ message.partCount = reader.uint32();
3039
+ continue;
3040
+ }
3041
+ }
3042
+ if ((tag & 7) === 4 || tag === 0) {
3043
+ break;
3044
+ }
3045
+ reader.skip(tag & 7);
3046
+ }
3047
+ return message;
3048
+ },
3049
+ fromJSON(object) {
3050
+ return {
3051
+ available: isSet(object.available) ? gt.Boolean(object.available) : false,
3052
+ mapId: isSet(object.mapId) ? gt.Number(object.mapId) : 0,
3053
+ sequence: isSet(object.sequence) ? gt.Number(object.sequence) : 0,
3054
+ fromSequence: isSet(object.fromSequence) ? gt.Number(object.fromSequence) : undefined,
3055
+ partCount: isSet(object.partCount) ? gt.Number(object.partCount) : undefined,
3056
+ };
3057
+ },
3058
+ toJSON(message) {
3059
+ const obj = {};
3060
+ if (message.available !== false) {
3061
+ obj.available = message.available;
3062
+ }
3063
+ if (message.mapId !== 0) {
3064
+ obj.mapId = Math.round(message.mapId);
3065
+ }
3066
+ if (message.sequence !== 0) {
3067
+ obj.sequence = Math.round(message.sequence);
3068
+ }
3069
+ if (message.fromSequence !== undefined) {
3070
+ obj.fromSequence = Math.round(message.fromSequence);
3071
+ }
3072
+ if (message.partCount !== undefined) {
3073
+ obj.partCount = Math.round(message.partCount);
3074
+ }
3075
+ return obj;
3076
+ },
3077
+ create(base) {
3078
+ return GetSlamMapRep.fromPartial(base ?? {});
3079
+ },
3080
+ fromPartial(object) {
3081
+ const message = createBaseGetSlamMapRep();
3082
+ message.available = object.available ?? false;
3083
+ message.mapId = object.mapId ?? 0;
3084
+ message.sequence = object.sequence ?? 0;
3085
+ message.fromSequence = object.fromSequence ?? undefined;
3086
+ message.partCount = object.partCount ?? undefined;
3087
+ return message;
3088
+ },
3089
+ };
3090
+ function createBaseResetSlamReq() {
3091
+ return { mapId: 0 };
3092
+ }
3093
+ export const ResetSlamReq = {
3094
+ encode(message, writer = new BinaryWriter()) {
3095
+ if (message.mapId !== 0) {
3096
+ writer.uint32(8).uint32(message.mapId);
3097
+ }
3098
+ return writer;
3099
+ },
3100
+ decode(input, length) {
3101
+ const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
3102
+ const end = length === undefined ? reader.len : reader.pos + length;
3103
+ const message = createBaseResetSlamReq();
3104
+ while (reader.pos < end) {
3105
+ const tag = reader.uint32();
3106
+ switch (tag >>> 3) {
3107
+ case 1: {
3108
+ if (tag !== 8) {
3109
+ break;
3110
+ }
3111
+ message.mapId = reader.uint32();
3112
+ continue;
3113
+ }
3114
+ }
3115
+ if ((tag & 7) === 4 || tag === 0) {
3116
+ break;
3117
+ }
3118
+ reader.skip(tag & 7);
3119
+ }
3120
+ return message;
3121
+ },
3122
+ fromJSON(object) {
3123
+ return { mapId: isSet(object.mapId) ? gt.Number(object.mapId) : 0 };
3124
+ },
3125
+ toJSON(message) {
3126
+ const obj = {};
3127
+ if (message.mapId !== 0) {
3128
+ obj.mapId = Math.round(message.mapId);
3129
+ }
3130
+ return obj;
3131
+ },
3132
+ create(base) {
3133
+ return ResetSlamReq.fromPartial(base ?? {});
3134
+ },
3135
+ fromPartial(object) {
3136
+ const message = createBaseResetSlamReq();
3137
+ message.mapId = object.mapId ?? 0;
3138
+ return message;
3139
+ },
3140
+ };
3141
+ function createBaseResetSlamRep() {
3142
+ return { available: false, mapId: 0, reset: false, error: 0 };
3143
+ }
3144
+ export const ResetSlamRep = {
3145
+ encode(message, writer = new BinaryWriter()) {
3146
+ if (message.available !== false) {
3147
+ writer.uint32(8).bool(message.available);
3148
+ }
3149
+ if (message.mapId !== 0) {
3150
+ writer.uint32(16).uint32(message.mapId);
3151
+ }
3152
+ if (message.reset !== false) {
3153
+ writer.uint32(24).bool(message.reset);
3154
+ }
3155
+ if (message.error !== 0) {
3156
+ writer.uint32(32).int32(message.error);
3157
+ }
3158
+ return writer;
3159
+ },
3160
+ decode(input, length) {
3161
+ const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
3162
+ const end = length === undefined ? reader.len : reader.pos + length;
3163
+ const message = createBaseResetSlamRep();
3164
+ while (reader.pos < end) {
3165
+ const tag = reader.uint32();
3166
+ switch (tag >>> 3) {
3167
+ case 1: {
3168
+ if (tag !== 8) {
3169
+ break;
3170
+ }
3171
+ message.available = reader.bool();
3172
+ continue;
3173
+ }
3174
+ case 2: {
3175
+ if (tag !== 16) {
3176
+ break;
3177
+ }
3178
+ message.mapId = reader.uint32();
3179
+ continue;
3180
+ }
3181
+ case 3: {
3182
+ if (tag !== 24) {
3183
+ break;
3184
+ }
3185
+ message.reset = reader.bool();
3186
+ continue;
3187
+ }
3188
+ case 4: {
3189
+ if (tag !== 32) {
3190
+ break;
3191
+ }
3192
+ message.error = reader.int32();
3193
+ continue;
3194
+ }
3195
+ }
3196
+ if ((tag & 7) === 4 || tag === 0) {
3197
+ break;
3198
+ }
3199
+ reader.skip(tag & 7);
3200
+ }
3201
+ return message;
3202
+ },
3203
+ fromJSON(object) {
3204
+ return {
3205
+ available: isSet(object.available) ? gt.Boolean(object.available) : false,
3206
+ mapId: isSet(object.mapId) ? gt.Number(object.mapId) : 0,
3207
+ reset: isSet(object.reset) ? gt.Boolean(object.reset) : false,
3208
+ error: isSet(object.error) ? slamRequestErrorFromJSON(object.error) : 0,
3209
+ };
3210
+ },
3211
+ toJSON(message) {
3212
+ const obj = {};
3213
+ if (message.available !== false) {
3214
+ obj.available = message.available;
3215
+ }
3216
+ if (message.mapId !== 0) {
3217
+ obj.mapId = Math.round(message.mapId);
3218
+ }
3219
+ if (message.reset !== false) {
3220
+ obj.reset = message.reset;
3221
+ }
3222
+ if (message.error !== 0) {
3223
+ obj.error = slamRequestErrorToJSON(message.error);
3224
+ }
3225
+ return obj;
3226
+ },
3227
+ create(base) {
3228
+ return ResetSlamRep.fromPartial(base ?? {});
3229
+ },
3230
+ fromPartial(object) {
3231
+ const message = createBaseResetSlamRep();
3232
+ message.available = object.available ?? false;
3233
+ message.mapId = object.mapId ?? 0;
3234
+ message.reset = object.reset ?? false;
3235
+ message.error = object.error ?? 0;
3236
+ return message;
3237
+ },
3238
+ };
3239
+ function createBaseSetSlamActiveReq() {
3240
+ return { active: false };
3241
+ }
3242
+ export const SetSlamActiveReq = {
3243
+ encode(message, writer = new BinaryWriter()) {
3244
+ if (message.active !== false) {
3245
+ writer.uint32(8).bool(message.active);
3246
+ }
3247
+ return writer;
3248
+ },
3249
+ decode(input, length) {
3250
+ const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
3251
+ const end = length === undefined ? reader.len : reader.pos + length;
3252
+ const message = createBaseSetSlamActiveReq();
3253
+ while (reader.pos < end) {
3254
+ const tag = reader.uint32();
3255
+ switch (tag >>> 3) {
3256
+ case 1: {
3257
+ if (tag !== 8) {
3258
+ break;
3259
+ }
3260
+ message.active = reader.bool();
3261
+ continue;
3262
+ }
3263
+ }
3264
+ if ((tag & 7) === 4 || tag === 0) {
3265
+ break;
3266
+ }
3267
+ reader.skip(tag & 7);
3268
+ }
3269
+ return message;
3270
+ },
3271
+ fromJSON(object) {
3272
+ return { active: isSet(object.active) ? gt.Boolean(object.active) : false };
3273
+ },
3274
+ toJSON(message) {
3275
+ const obj = {};
3276
+ if (message.active !== false) {
3277
+ obj.active = message.active;
3278
+ }
3279
+ return obj;
3280
+ },
3281
+ create(base) {
3282
+ return SetSlamActiveReq.fromPartial(base ?? {});
3283
+ },
3284
+ fromPartial(object) {
3285
+ const message = createBaseSetSlamActiveReq();
3286
+ message.active = object.active ?? false;
3287
+ return message;
3288
+ },
3289
+ };
3290
+ function createBaseSetSlamActiveRep() {
3291
+ return { available: false, active: false, error: 0 };
3292
+ }
3293
+ export const SetSlamActiveRep = {
3294
+ encode(message, writer = new BinaryWriter()) {
3295
+ if (message.available !== false) {
3296
+ writer.uint32(8).bool(message.available);
3297
+ }
3298
+ if (message.active !== false) {
3299
+ writer.uint32(16).bool(message.active);
3300
+ }
3301
+ if (message.error !== 0) {
3302
+ writer.uint32(24).int32(message.error);
3303
+ }
3304
+ return writer;
3305
+ },
3306
+ decode(input, length) {
3307
+ const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
3308
+ const end = length === undefined ? reader.len : reader.pos + length;
3309
+ const message = createBaseSetSlamActiveRep();
3310
+ while (reader.pos < end) {
3311
+ const tag = reader.uint32();
3312
+ switch (tag >>> 3) {
3313
+ case 1: {
3314
+ if (tag !== 8) {
3315
+ break;
3316
+ }
3317
+ message.available = reader.bool();
3318
+ continue;
3319
+ }
3320
+ case 2: {
3321
+ if (tag !== 16) {
3322
+ break;
3323
+ }
3324
+ message.active = reader.bool();
3325
+ continue;
3326
+ }
3327
+ case 3: {
3328
+ if (tag !== 24) {
3329
+ break;
3330
+ }
3331
+ message.error = reader.int32();
3332
+ continue;
3333
+ }
3334
+ }
3335
+ if ((tag & 7) === 4 || tag === 0) {
3336
+ break;
3337
+ }
3338
+ reader.skip(tag & 7);
3339
+ }
3340
+ return message;
3341
+ },
3342
+ fromJSON(object) {
3343
+ return {
3344
+ available: isSet(object.available) ? gt.Boolean(object.available) : false,
3345
+ active: isSet(object.active) ? gt.Boolean(object.active) : false,
3346
+ error: isSet(object.error) ? slamRequestErrorFromJSON(object.error) : 0,
3347
+ };
3348
+ },
3349
+ toJSON(message) {
3350
+ const obj = {};
3351
+ if (message.available !== false) {
3352
+ obj.available = message.available;
3353
+ }
3354
+ if (message.active !== false) {
3355
+ obj.active = message.active;
3356
+ }
3357
+ if (message.error !== 0) {
3358
+ obj.error = slamRequestErrorToJSON(message.error);
3359
+ }
3360
+ return obj;
3361
+ },
3362
+ create(base) {
3363
+ return SetSlamActiveRep.fromPartial(base ?? {});
3364
+ },
3365
+ fromPartial(object) {
3366
+ const message = createBaseSetSlamActiveRep();
3367
+ message.available = object.available ?? false;
3368
+ message.active = object.active ?? false;
3369
+ message.error = object.error ?? 0;
3370
+ return message;
3371
+ },
3372
+ };
3373
+ function createBaseSetSlamRecordingReq() {
3374
+ return { record: false, sensorData: false, storageLocation: 0 };
3375
+ }
3376
+ export const SetSlamRecordingReq = {
3377
+ encode(message, writer = new BinaryWriter()) {
3378
+ if (message.record !== false) {
3379
+ writer.uint32(8).bool(message.record);
3380
+ }
3381
+ if (message.sensorData !== false) {
3382
+ writer.uint32(16).bool(message.sensorData);
3383
+ }
3384
+ if (message.storageLocation !== 0) {
3385
+ writer.uint32(24).int32(message.storageLocation);
3386
+ }
3387
+ return writer;
3388
+ },
3389
+ decode(input, length) {
3390
+ const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
3391
+ const end = length === undefined ? reader.len : reader.pos + length;
3392
+ const message = createBaseSetSlamRecordingReq();
3393
+ while (reader.pos < end) {
3394
+ const tag = reader.uint32();
3395
+ switch (tag >>> 3) {
3396
+ case 1: {
3397
+ if (tag !== 8) {
3398
+ break;
3399
+ }
3400
+ message.record = reader.bool();
3401
+ continue;
3402
+ }
3403
+ case 2: {
3404
+ if (tag !== 16) {
3405
+ break;
3406
+ }
3407
+ message.sensorData = reader.bool();
3408
+ continue;
3409
+ }
3410
+ case 3: {
3411
+ if (tag !== 24) {
3412
+ break;
3413
+ }
3414
+ message.storageLocation = reader.int32();
3415
+ continue;
3416
+ }
3417
+ }
3418
+ if ((tag & 7) === 4 || tag === 0) {
3419
+ break;
3420
+ }
3421
+ reader.skip(tag & 7);
3422
+ }
3423
+ return message;
3424
+ },
3425
+ fromJSON(object) {
3426
+ return {
3427
+ record: isSet(object.record) ? gt.Boolean(object.record) : false,
3428
+ sensorData: isSet(object.sensorData) ? gt.Boolean(object.sensorData) : false,
3429
+ storageLocation: isSet(object.storageLocation) ? storageLocationFromJSON(object.storageLocation) : 0,
3430
+ };
3431
+ },
3432
+ toJSON(message) {
3433
+ const obj = {};
3434
+ if (message.record !== false) {
3435
+ obj.record = message.record;
3436
+ }
3437
+ if (message.sensorData !== false) {
3438
+ obj.sensorData = message.sensorData;
3439
+ }
3440
+ if (message.storageLocation !== 0) {
3441
+ obj.storageLocation = storageLocationToJSON(message.storageLocation);
3442
+ }
3443
+ return obj;
3444
+ },
3445
+ create(base) {
3446
+ return SetSlamRecordingReq.fromPartial(base ?? {});
3447
+ },
3448
+ fromPartial(object) {
3449
+ const message = createBaseSetSlamRecordingReq();
3450
+ message.record = object.record ?? false;
3451
+ message.sensorData = object.sensorData ?? false;
3452
+ message.storageLocation = object.storageLocation ?? 0;
3453
+ return message;
3454
+ },
3455
+ };
3456
+ function createBaseSetSlamRecordingRep() {
3457
+ return { available: false, recording: undefined, error: 0 };
3458
+ }
3459
+ export const SetSlamRecordingRep = {
3460
+ encode(message, writer = new BinaryWriter()) {
3461
+ if (message.available !== false) {
3462
+ writer.uint32(8).bool(message.available);
3463
+ }
3464
+ if (message.recording !== undefined) {
3465
+ SlamRecordingState.encode(message.recording, writer.uint32(18).fork()).join();
3466
+ }
3467
+ if (message.error !== 0) {
3468
+ writer.uint32(24).int32(message.error);
3469
+ }
3470
+ return writer;
3471
+ },
3472
+ decode(input, length) {
3473
+ const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
3474
+ const end = length === undefined ? reader.len : reader.pos + length;
3475
+ const message = createBaseSetSlamRecordingRep();
3476
+ while (reader.pos < end) {
3477
+ const tag = reader.uint32();
3478
+ switch (tag >>> 3) {
3479
+ case 1: {
3480
+ if (tag !== 8) {
3481
+ break;
3482
+ }
3483
+ message.available = reader.bool();
3484
+ continue;
3485
+ }
3486
+ case 2: {
3487
+ if (tag !== 18) {
3488
+ break;
3489
+ }
3490
+ message.recording = SlamRecordingState.decode(reader, reader.uint32());
3491
+ continue;
3492
+ }
3493
+ case 3: {
3494
+ if (tag !== 24) {
3495
+ break;
3496
+ }
3497
+ message.error = reader.int32();
3498
+ continue;
3499
+ }
3500
+ }
3501
+ if ((tag & 7) === 4 || tag === 0) {
3502
+ break;
3503
+ }
3504
+ reader.skip(tag & 7);
3505
+ }
3506
+ return message;
3507
+ },
3508
+ fromJSON(object) {
3509
+ return {
3510
+ available: isSet(object.available) ? gt.Boolean(object.available) : false,
3511
+ recording: isSet(object.recording) ? SlamRecordingState.fromJSON(object.recording) : undefined,
3512
+ error: isSet(object.error) ? slamRequestErrorFromJSON(object.error) : 0,
3513
+ };
3514
+ },
3515
+ toJSON(message) {
3516
+ const obj = {};
3517
+ if (message.available !== false) {
3518
+ obj.available = message.available;
3519
+ }
3520
+ if (message.recording !== undefined) {
3521
+ obj.recording = SlamRecordingState.toJSON(message.recording);
3522
+ }
3523
+ if (message.error !== 0) {
3524
+ obj.error = slamRequestErrorToJSON(message.error);
3525
+ }
3526
+ return obj;
3527
+ },
3528
+ create(base) {
3529
+ return SetSlamRecordingRep.fromPartial(base ?? {});
3530
+ },
3531
+ fromPartial(object) {
3532
+ const message = createBaseSetSlamRecordingRep();
3533
+ message.available = object.available ?? false;
3534
+ message.recording = (object.recording !== undefined && object.recording !== null)
3535
+ ? SlamRecordingState.fromPartial(object.recording)
3536
+ : undefined;
3537
+ message.error = object.error ?? 0;
3538
+ return message;
3539
+ },
3540
+ };
3541
+ function createBaseSetSlamSensorSettingsReq() {
3542
+ return { settings: undefined, sensorId: "" };
3543
+ }
3544
+ export const SetSlamSensorSettingsReq = {
3545
+ encode(message, writer = new BinaryWriter()) {
3546
+ if (message.settings !== undefined) {
3547
+ SlamSensorSettings.encode(message.settings, writer.uint32(10).fork()).join();
3548
+ }
3549
+ if (message.sensorId !== "") {
3550
+ writer.uint32(18).string(message.sensorId);
3551
+ }
3552
+ return writer;
3553
+ },
3554
+ decode(input, length) {
3555
+ const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
3556
+ const end = length === undefined ? reader.len : reader.pos + length;
3557
+ const message = createBaseSetSlamSensorSettingsReq();
3558
+ while (reader.pos < end) {
3559
+ const tag = reader.uint32();
3560
+ switch (tag >>> 3) {
3561
+ case 1: {
3562
+ if (tag !== 10) {
3563
+ break;
3564
+ }
3565
+ message.settings = SlamSensorSettings.decode(reader, reader.uint32());
3566
+ continue;
3567
+ }
3568
+ case 2: {
3569
+ if (tag !== 18) {
3570
+ break;
3571
+ }
3572
+ message.sensorId = reader.string();
3573
+ continue;
3574
+ }
3575
+ }
3576
+ if ((tag & 7) === 4 || tag === 0) {
3577
+ break;
3578
+ }
3579
+ reader.skip(tag & 7);
3580
+ }
3581
+ return message;
3582
+ },
3583
+ fromJSON(object) {
3584
+ return {
3585
+ settings: isSet(object.settings) ? SlamSensorSettings.fromJSON(object.settings) : undefined,
3586
+ sensorId: isSet(object.sensorId) ? gt.String(object.sensorId) : "",
3587
+ };
3588
+ },
3589
+ toJSON(message) {
3590
+ const obj = {};
3591
+ if (message.settings !== undefined) {
3592
+ obj.settings = SlamSensorSettings.toJSON(message.settings);
3593
+ }
3594
+ if (message.sensorId !== "") {
3595
+ obj.sensorId = message.sensorId;
3596
+ }
3597
+ return obj;
3598
+ },
3599
+ create(base) {
3600
+ return SetSlamSensorSettingsReq.fromPartial(base ?? {});
3601
+ },
3602
+ fromPartial(object) {
3603
+ const message = createBaseSetSlamSensorSettingsReq();
3604
+ message.settings = (object.settings !== undefined && object.settings !== null)
3605
+ ? SlamSensorSettings.fromPartial(object.settings)
3606
+ : undefined;
3607
+ message.sensorId = object.sensorId ?? "";
3608
+ return message;
3609
+ },
3610
+ };
3611
+ function createBaseSetSlamSensorSettingsRep() {
3612
+ return { available: false, applied: false, settings: undefined, error: 0 };
3613
+ }
3614
+ export const SetSlamSensorSettingsRep = {
3615
+ encode(message, writer = new BinaryWriter()) {
3616
+ if (message.available !== false) {
3617
+ writer.uint32(8).bool(message.available);
3618
+ }
3619
+ if (message.applied !== false) {
3620
+ writer.uint32(16).bool(message.applied);
3621
+ }
3622
+ if (message.settings !== undefined) {
3623
+ SlamSensorSettings.encode(message.settings, writer.uint32(26).fork()).join();
3624
+ }
3625
+ if (message.error !== 0) {
3626
+ writer.uint32(32).int32(message.error);
3627
+ }
3628
+ return writer;
3629
+ },
3630
+ decode(input, length) {
3631
+ const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
3632
+ const end = length === undefined ? reader.len : reader.pos + length;
3633
+ const message = createBaseSetSlamSensorSettingsRep();
3634
+ while (reader.pos < end) {
3635
+ const tag = reader.uint32();
3636
+ switch (tag >>> 3) {
3637
+ case 1: {
3638
+ if (tag !== 8) {
3639
+ break;
3640
+ }
3641
+ message.available = reader.bool();
3642
+ continue;
3643
+ }
3644
+ case 2: {
3645
+ if (tag !== 16) {
3646
+ break;
3647
+ }
3648
+ message.applied = reader.bool();
3649
+ continue;
3650
+ }
3651
+ case 3: {
3652
+ if (tag !== 26) {
3653
+ break;
3654
+ }
3655
+ message.settings = SlamSensorSettings.decode(reader, reader.uint32());
3656
+ continue;
3657
+ }
3658
+ case 4: {
3659
+ if (tag !== 32) {
3660
+ break;
3661
+ }
3662
+ message.error = reader.int32();
3663
+ continue;
3664
+ }
3665
+ }
3666
+ if ((tag & 7) === 4 || tag === 0) {
3667
+ break;
3668
+ }
3669
+ reader.skip(tag & 7);
3670
+ }
3671
+ return message;
3672
+ },
3673
+ fromJSON(object) {
3674
+ return {
3675
+ available: isSet(object.available) ? gt.Boolean(object.available) : false,
3676
+ applied: isSet(object.applied) ? gt.Boolean(object.applied) : false,
3677
+ settings: isSet(object.settings) ? SlamSensorSettings.fromJSON(object.settings) : undefined,
3678
+ error: isSet(object.error) ? slamRequestErrorFromJSON(object.error) : 0,
3679
+ };
3680
+ },
3681
+ toJSON(message) {
3682
+ const obj = {};
3683
+ if (message.available !== false) {
3684
+ obj.available = message.available;
3685
+ }
3686
+ if (message.applied !== false) {
3687
+ obj.applied = message.applied;
3688
+ }
3689
+ if (message.settings !== undefined) {
3690
+ obj.settings = SlamSensorSettings.toJSON(message.settings);
3691
+ }
3692
+ if (message.error !== 0) {
3693
+ obj.error = slamRequestErrorToJSON(message.error);
3694
+ }
3695
+ return obj;
3696
+ },
3697
+ create(base) {
3698
+ return SetSlamSensorSettingsRep.fromPartial(base ?? {});
3699
+ },
3700
+ fromPartial(object) {
3701
+ const message = createBaseSetSlamSensorSettingsRep();
3702
+ message.available = object.available ?? false;
3703
+ message.applied = object.applied ?? false;
3704
+ message.settings = (object.settings !== undefined && object.settings !== null)
3705
+ ? SlamSensorSettings.fromPartial(object.settings)
3706
+ : undefined;
3707
+ message.error = object.error ?? 0;
3708
+ return message;
3709
+ },
3710
+ };
3711
+ const gt = (() => {
3712
+ if (typeof globalThis !== "undefined") {
3713
+ return globalThis;
3714
+ }
3715
+ if (typeof self !== "undefined") {
3716
+ return self;
3717
+ }
3718
+ if (typeof window !== "undefined") {
3719
+ return window;
3720
+ }
3721
+ if (typeof global !== "undefined") {
3722
+ return global;
3723
+ }
3724
+ throw "Unable to locate global object";
3725
+ })();
3726
+ function longToNumber(int64) {
3727
+ const num = gt.Number(int64.toString());
3728
+ if (num > gt.Number.MAX_SAFE_INTEGER) {
3729
+ throw new gt.Error("Value is larger than Number.MAX_SAFE_INTEGER");
3730
+ }
3731
+ if (num < gt.Number.MIN_SAFE_INTEGER) {
3732
+ throw new gt.Error("Value is smaller than Number.MIN_SAFE_INTEGER");
3733
+ }
3734
+ return num;
3735
+ }
2719
3736
  function isSet(value) {
2720
3737
  return value !== null && value !== undefined;
2721
3738
  }