@m1kad0/hannah-proto 4.4.0 → 4.6.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +21 -0
- package/dist/compat_interceptor.js +6 -6
- package/dist/compat_versions.js +176 -85
- package/dist/descriptor.binpb +0 -0
- package/dist/index.d.ts +2 -0
- package/dist/index.js +3 -1
- package/dist/logging.d.ts +189 -0
- package/dist/logging.js +775 -0
- package/dist/v1/activity_log.d.ts +60 -0
- package/dist/v1/activity_log.js +453 -0
- package/dist/v1/agent.d.ts +433 -0
- package/dist/v1/agent.js +2527 -0
- package/dist/v1/automation.d.ts +54 -0
- package/dist/v1/automation.js +303 -0
- package/dist/v1/car_state.d.ts +72 -0
- package/dist/v1/car_state.js +516 -0
- package/dist/v1/channel.d.ts +102 -0
- package/dist/v1/channel.js +587 -0
- package/dist/v1/control.d.ts +383 -0
- package/dist/v1/control.js +3879 -0
- package/dist/v1/device_control_menu.d.ts +88 -0
- package/dist/v1/device_control_menu.js +629 -0
- package/dist/v1/event_stream.d.ts +63 -0
- package/dist/v1/event_stream.js +494 -0
- package/dist/v1/hannah.d.ts +1644 -0
- package/dist/v1/hannah.js +968 -0
- package/dist/v1/index.d.ts +22 -0
- package/dist/v1/index.js +58 -0
- package/dist/v1/infrastructure.d.ts +98 -0
- package/dist/v1/infrastructure.js +652 -0
- package/dist/v1/logging.d.ts +189 -0
- package/dist/v1/logging.js +775 -0
- package/dist/v1/messages.d.ts +56 -0
- package/dist/v1/messages.js +398 -0
- package/dist/v1/satellite.d.ts +90 -0
- package/dist/v1/satellite.js +637 -0
- package/dist/v1/satellite_provisioning.d.ts +33 -0
- package/dist/v1/satellite_provisioning.js +84 -0
- package/dist/v1/satellite_proxy.d.ts +100 -0
- package/dist/v1/satellite_proxy.js +546 -0
- package/dist/v1/shared.d.ts +54 -0
- package/dist/v1/shared.js +249 -0
- package/dist/v1/speaker_enrollment.d.ts +44 -0
- package/dist/v1/speaker_enrollment.js +157 -0
- package/dist/v1/timer_admin.d.ts +42 -0
- package/dist/v1/timer_admin.js +273 -0
- package/dist/v1/timer_service.d.ts +133 -0
- package/dist/v1/timer_service.js +945 -0
- package/dist/v1/user_registry.d.ts +187 -0
- package/dist/v1/user_registry.js +1612 -0
- package/dist/v1/wakeword_capture.d.ts +101 -0
- package/dist/v1/wakeword_capture.js +611 -0
- package/dist/v1/weather.d.ts +81 -0
- package/dist/v1/weather.js +366 -0
- package/package.json +1 -1
|
@@ -0,0 +1,3879 @@
|
|
|
1
|
+
"use strict";
|
|
2
|
+
// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
|
|
3
|
+
// versions:
|
|
4
|
+
// protoc-gen-ts_proto v2.12.1
|
|
5
|
+
// protoc unknown
|
|
6
|
+
// source: hannah/v1/control.proto
|
|
7
|
+
Object.defineProperty(exports, "__esModule", { value: true });
|
|
8
|
+
exports.DeleteCarRequest = exports.UpdateCarRequest = exports.CreateCarResponse = exports.CreateCarRequest = exports.GetCarsResponse = exports.Car = exports.DeletePresenceSourceRequest = exports.UpdatePresenceSourceRequest = exports.CreatePresenceSourceResponse = exports.CreatePresenceSourceRequest = exports.GetPresenceSourcesResponse = exports.PresenceSource = exports.DeleteBleTagRequest = exports.UpdateBleTagRequest = exports.CreateBleTagResponse = exports.CreateBleTagRequest = exports.GetBleTagsResponse = exports.BleTag = exports.UpdateConfigRequest = exports.SettingUpdate = exports.GetSettingsResponse = exports.Setting = exports.Category = exports.DeleteAlarmRequest = exports.UpdateAlarmRequest = exports.CreateAlarmResponse = exports.CreateAlarmRequest = exports.GetAlarmsResponse = exports.Alarm = exports.DeleteTriggerRequest = exports.UpdateTriggerRequest = exports.CreateTriggerRequest = exports.GetTriggersResponse = exports.Trigger = exports.SetGroupSatellitesRequest = exports.DeleteGroupRequest = exports.UpdateGroupRequest = exports.CreateGroupRequest = exports.GetGroupsResponse = exports.Group = exports.GroupSatellite = exports.GetRoomsResponse = exports.Room = exports.AnnounceRequest = exports.SubmitVoiceResponse = exports.SubmitVoiceRequest = exports.SubmitTextResponse = exports.SubmitTextRequest = exports.protobufPackage = void 0;
|
|
9
|
+
/* eslint-disable */
|
|
10
|
+
const wire_1 = require("@bufbuild/protobuf/wire");
|
|
11
|
+
exports.protobufPackage = "hannah.v1";
|
|
12
|
+
function createBaseSubmitTextRequest() {
|
|
13
|
+
return { text: "", sourceService: "", sourceUserId: "" };
|
|
14
|
+
}
|
|
15
|
+
exports.SubmitTextRequest = {
|
|
16
|
+
encode(message, writer = new wire_1.BinaryWriter()) {
|
|
17
|
+
if (message.text !== "") {
|
|
18
|
+
writer.uint32(10).string(message.text);
|
|
19
|
+
}
|
|
20
|
+
if (message.sourceService !== "") {
|
|
21
|
+
writer.uint32(18).string(message.sourceService);
|
|
22
|
+
}
|
|
23
|
+
if (message.sourceUserId !== "") {
|
|
24
|
+
writer.uint32(26).string(message.sourceUserId);
|
|
25
|
+
}
|
|
26
|
+
return writer;
|
|
27
|
+
},
|
|
28
|
+
decode(input, length) {
|
|
29
|
+
const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
|
|
30
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
31
|
+
if (previousRecursionDepth >= 100) {
|
|
32
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
33
|
+
}
|
|
34
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
35
|
+
try {
|
|
36
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
37
|
+
const message = createBaseSubmitTextRequest();
|
|
38
|
+
while (reader.pos < end) {
|
|
39
|
+
const tag = reader.uint32();
|
|
40
|
+
switch (tag >>> 3) {
|
|
41
|
+
case 1: {
|
|
42
|
+
if (tag !== 10) {
|
|
43
|
+
break;
|
|
44
|
+
}
|
|
45
|
+
message.text = reader.string();
|
|
46
|
+
continue;
|
|
47
|
+
}
|
|
48
|
+
case 2: {
|
|
49
|
+
if (tag !== 18) {
|
|
50
|
+
break;
|
|
51
|
+
}
|
|
52
|
+
message.sourceService = reader.string();
|
|
53
|
+
continue;
|
|
54
|
+
}
|
|
55
|
+
case 3: {
|
|
56
|
+
if (tag !== 26) {
|
|
57
|
+
break;
|
|
58
|
+
}
|
|
59
|
+
message.sourceUserId = reader.string();
|
|
60
|
+
continue;
|
|
61
|
+
}
|
|
62
|
+
}
|
|
63
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
64
|
+
break;
|
|
65
|
+
}
|
|
66
|
+
reader.skip(tag & 7);
|
|
67
|
+
}
|
|
68
|
+
return message;
|
|
69
|
+
}
|
|
70
|
+
finally {
|
|
71
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
72
|
+
}
|
|
73
|
+
},
|
|
74
|
+
create(base) {
|
|
75
|
+
return exports.SubmitTextRequest.fromPartial(base ?? {});
|
|
76
|
+
},
|
|
77
|
+
fromPartial(object) {
|
|
78
|
+
const message = createBaseSubmitTextRequest();
|
|
79
|
+
message.text = object.text ?? "";
|
|
80
|
+
message.sourceService = object.sourceService ?? "";
|
|
81
|
+
message.sourceUserId = object.sourceUserId ?? "";
|
|
82
|
+
return message;
|
|
83
|
+
},
|
|
84
|
+
};
|
|
85
|
+
function createBaseSubmitTextResponse() {
|
|
86
|
+
return { answer: "", intentName: "" };
|
|
87
|
+
}
|
|
88
|
+
exports.SubmitTextResponse = {
|
|
89
|
+
encode(message, writer = new wire_1.BinaryWriter()) {
|
|
90
|
+
if (message.answer !== "") {
|
|
91
|
+
writer.uint32(10).string(message.answer);
|
|
92
|
+
}
|
|
93
|
+
if (message.intentName !== "") {
|
|
94
|
+
writer.uint32(18).string(message.intentName);
|
|
95
|
+
}
|
|
96
|
+
return writer;
|
|
97
|
+
},
|
|
98
|
+
decode(input, length) {
|
|
99
|
+
const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
|
|
100
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
101
|
+
if (previousRecursionDepth >= 100) {
|
|
102
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
103
|
+
}
|
|
104
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
105
|
+
try {
|
|
106
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
107
|
+
const message = createBaseSubmitTextResponse();
|
|
108
|
+
while (reader.pos < end) {
|
|
109
|
+
const tag = reader.uint32();
|
|
110
|
+
switch (tag >>> 3) {
|
|
111
|
+
case 1: {
|
|
112
|
+
if (tag !== 10) {
|
|
113
|
+
break;
|
|
114
|
+
}
|
|
115
|
+
message.answer = reader.string();
|
|
116
|
+
continue;
|
|
117
|
+
}
|
|
118
|
+
case 2: {
|
|
119
|
+
if (tag !== 18) {
|
|
120
|
+
break;
|
|
121
|
+
}
|
|
122
|
+
message.intentName = reader.string();
|
|
123
|
+
continue;
|
|
124
|
+
}
|
|
125
|
+
}
|
|
126
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
127
|
+
break;
|
|
128
|
+
}
|
|
129
|
+
reader.skip(tag & 7);
|
|
130
|
+
}
|
|
131
|
+
return message;
|
|
132
|
+
}
|
|
133
|
+
finally {
|
|
134
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
135
|
+
}
|
|
136
|
+
},
|
|
137
|
+
create(base) {
|
|
138
|
+
return exports.SubmitTextResponse.fromPartial(base ?? {});
|
|
139
|
+
},
|
|
140
|
+
fromPartial(object) {
|
|
141
|
+
const message = createBaseSubmitTextResponse();
|
|
142
|
+
message.answer = object.answer ?? "";
|
|
143
|
+
message.intentName = object.intentName ?? "";
|
|
144
|
+
return message;
|
|
145
|
+
},
|
|
146
|
+
};
|
|
147
|
+
function createBaseSubmitVoiceRequest() {
|
|
148
|
+
return { audio: new Uint8Array(0), sourceService: "", sourceUserId: "" };
|
|
149
|
+
}
|
|
150
|
+
exports.SubmitVoiceRequest = {
|
|
151
|
+
encode(message, writer = new wire_1.BinaryWriter()) {
|
|
152
|
+
if (message.audio.length !== 0) {
|
|
153
|
+
writer.uint32(10).bytes(message.audio);
|
|
154
|
+
}
|
|
155
|
+
if (message.sourceService !== "") {
|
|
156
|
+
writer.uint32(18).string(message.sourceService);
|
|
157
|
+
}
|
|
158
|
+
if (message.sourceUserId !== "") {
|
|
159
|
+
writer.uint32(26).string(message.sourceUserId);
|
|
160
|
+
}
|
|
161
|
+
return writer;
|
|
162
|
+
},
|
|
163
|
+
decode(input, length) {
|
|
164
|
+
const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
|
|
165
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
166
|
+
if (previousRecursionDepth >= 100) {
|
|
167
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
168
|
+
}
|
|
169
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
170
|
+
try {
|
|
171
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
172
|
+
const message = createBaseSubmitVoiceRequest();
|
|
173
|
+
while (reader.pos < end) {
|
|
174
|
+
const tag = reader.uint32();
|
|
175
|
+
switch (tag >>> 3) {
|
|
176
|
+
case 1: {
|
|
177
|
+
if (tag !== 10) {
|
|
178
|
+
break;
|
|
179
|
+
}
|
|
180
|
+
message.audio = reader.bytes();
|
|
181
|
+
continue;
|
|
182
|
+
}
|
|
183
|
+
case 2: {
|
|
184
|
+
if (tag !== 18) {
|
|
185
|
+
break;
|
|
186
|
+
}
|
|
187
|
+
message.sourceService = reader.string();
|
|
188
|
+
continue;
|
|
189
|
+
}
|
|
190
|
+
case 3: {
|
|
191
|
+
if (tag !== 26) {
|
|
192
|
+
break;
|
|
193
|
+
}
|
|
194
|
+
message.sourceUserId = reader.string();
|
|
195
|
+
continue;
|
|
196
|
+
}
|
|
197
|
+
}
|
|
198
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
199
|
+
break;
|
|
200
|
+
}
|
|
201
|
+
reader.skip(tag & 7);
|
|
202
|
+
}
|
|
203
|
+
return message;
|
|
204
|
+
}
|
|
205
|
+
finally {
|
|
206
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
207
|
+
}
|
|
208
|
+
},
|
|
209
|
+
create(base) {
|
|
210
|
+
return exports.SubmitVoiceRequest.fromPartial(base ?? {});
|
|
211
|
+
},
|
|
212
|
+
fromPartial(object) {
|
|
213
|
+
const message = createBaseSubmitVoiceRequest();
|
|
214
|
+
message.audio = object.audio ?? new Uint8Array(0);
|
|
215
|
+
message.sourceService = object.sourceService ?? "";
|
|
216
|
+
message.sourceUserId = object.sourceUserId ?? "";
|
|
217
|
+
return message;
|
|
218
|
+
},
|
|
219
|
+
};
|
|
220
|
+
function createBaseSubmitVoiceResponse() {
|
|
221
|
+
return { transcript: "", answer: "", intentName: "", audioOgg: new Uint8Array(0) };
|
|
222
|
+
}
|
|
223
|
+
exports.SubmitVoiceResponse = {
|
|
224
|
+
encode(message, writer = new wire_1.BinaryWriter()) {
|
|
225
|
+
if (message.transcript !== "") {
|
|
226
|
+
writer.uint32(10).string(message.transcript);
|
|
227
|
+
}
|
|
228
|
+
if (message.answer !== "") {
|
|
229
|
+
writer.uint32(18).string(message.answer);
|
|
230
|
+
}
|
|
231
|
+
if (message.intentName !== "") {
|
|
232
|
+
writer.uint32(26).string(message.intentName);
|
|
233
|
+
}
|
|
234
|
+
if (message.audioOgg.length !== 0) {
|
|
235
|
+
writer.uint32(34).bytes(message.audioOgg);
|
|
236
|
+
}
|
|
237
|
+
return writer;
|
|
238
|
+
},
|
|
239
|
+
decode(input, length) {
|
|
240
|
+
const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
|
|
241
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
242
|
+
if (previousRecursionDepth >= 100) {
|
|
243
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
244
|
+
}
|
|
245
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
246
|
+
try {
|
|
247
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
248
|
+
const message = createBaseSubmitVoiceResponse();
|
|
249
|
+
while (reader.pos < end) {
|
|
250
|
+
const tag = reader.uint32();
|
|
251
|
+
switch (tag >>> 3) {
|
|
252
|
+
case 1: {
|
|
253
|
+
if (tag !== 10) {
|
|
254
|
+
break;
|
|
255
|
+
}
|
|
256
|
+
message.transcript = reader.string();
|
|
257
|
+
continue;
|
|
258
|
+
}
|
|
259
|
+
case 2: {
|
|
260
|
+
if (tag !== 18) {
|
|
261
|
+
break;
|
|
262
|
+
}
|
|
263
|
+
message.answer = reader.string();
|
|
264
|
+
continue;
|
|
265
|
+
}
|
|
266
|
+
case 3: {
|
|
267
|
+
if (tag !== 26) {
|
|
268
|
+
break;
|
|
269
|
+
}
|
|
270
|
+
message.intentName = reader.string();
|
|
271
|
+
continue;
|
|
272
|
+
}
|
|
273
|
+
case 4: {
|
|
274
|
+
if (tag !== 34) {
|
|
275
|
+
break;
|
|
276
|
+
}
|
|
277
|
+
message.audioOgg = reader.bytes();
|
|
278
|
+
continue;
|
|
279
|
+
}
|
|
280
|
+
}
|
|
281
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
282
|
+
break;
|
|
283
|
+
}
|
|
284
|
+
reader.skip(tag & 7);
|
|
285
|
+
}
|
|
286
|
+
return message;
|
|
287
|
+
}
|
|
288
|
+
finally {
|
|
289
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
290
|
+
}
|
|
291
|
+
},
|
|
292
|
+
create(base) {
|
|
293
|
+
return exports.SubmitVoiceResponse.fromPartial(base ?? {});
|
|
294
|
+
},
|
|
295
|
+
fromPartial(object) {
|
|
296
|
+
const message = createBaseSubmitVoiceResponse();
|
|
297
|
+
message.transcript = object.transcript ?? "";
|
|
298
|
+
message.answer = object.answer ?? "";
|
|
299
|
+
message.intentName = object.intentName ?? "";
|
|
300
|
+
message.audioOgg = object.audioOgg ?? new Uint8Array(0);
|
|
301
|
+
return message;
|
|
302
|
+
},
|
|
303
|
+
};
|
|
304
|
+
function createBaseAnnounceRequest() {
|
|
305
|
+
return { text: "", device: "", roomId: "", userId: 0 };
|
|
306
|
+
}
|
|
307
|
+
exports.AnnounceRequest = {
|
|
308
|
+
encode(message, writer = new wire_1.BinaryWriter()) {
|
|
309
|
+
if (message.text !== "") {
|
|
310
|
+
writer.uint32(10).string(message.text);
|
|
311
|
+
}
|
|
312
|
+
if (message.device !== "") {
|
|
313
|
+
writer.uint32(18).string(message.device);
|
|
314
|
+
}
|
|
315
|
+
if (message.roomId !== "") {
|
|
316
|
+
writer.uint32(26).string(message.roomId);
|
|
317
|
+
}
|
|
318
|
+
if (message.userId !== 0) {
|
|
319
|
+
writer.uint32(32).int32(message.userId);
|
|
320
|
+
}
|
|
321
|
+
return writer;
|
|
322
|
+
},
|
|
323
|
+
decode(input, length) {
|
|
324
|
+
const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
|
|
325
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
326
|
+
if (previousRecursionDepth >= 100) {
|
|
327
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
328
|
+
}
|
|
329
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
330
|
+
try {
|
|
331
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
332
|
+
const message = createBaseAnnounceRequest();
|
|
333
|
+
while (reader.pos < end) {
|
|
334
|
+
const tag = reader.uint32();
|
|
335
|
+
switch (tag >>> 3) {
|
|
336
|
+
case 1: {
|
|
337
|
+
if (tag !== 10) {
|
|
338
|
+
break;
|
|
339
|
+
}
|
|
340
|
+
message.text = reader.string();
|
|
341
|
+
continue;
|
|
342
|
+
}
|
|
343
|
+
case 2: {
|
|
344
|
+
if (tag !== 18) {
|
|
345
|
+
break;
|
|
346
|
+
}
|
|
347
|
+
message.device = reader.string();
|
|
348
|
+
continue;
|
|
349
|
+
}
|
|
350
|
+
case 3: {
|
|
351
|
+
if (tag !== 26) {
|
|
352
|
+
break;
|
|
353
|
+
}
|
|
354
|
+
message.roomId = reader.string();
|
|
355
|
+
continue;
|
|
356
|
+
}
|
|
357
|
+
case 4: {
|
|
358
|
+
if (tag !== 32) {
|
|
359
|
+
break;
|
|
360
|
+
}
|
|
361
|
+
message.userId = reader.int32();
|
|
362
|
+
continue;
|
|
363
|
+
}
|
|
364
|
+
}
|
|
365
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
366
|
+
break;
|
|
367
|
+
}
|
|
368
|
+
reader.skip(tag & 7);
|
|
369
|
+
}
|
|
370
|
+
return message;
|
|
371
|
+
}
|
|
372
|
+
finally {
|
|
373
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
374
|
+
}
|
|
375
|
+
},
|
|
376
|
+
create(base) {
|
|
377
|
+
return exports.AnnounceRequest.fromPartial(base ?? {});
|
|
378
|
+
},
|
|
379
|
+
fromPartial(object) {
|
|
380
|
+
const message = createBaseAnnounceRequest();
|
|
381
|
+
message.text = object.text ?? "";
|
|
382
|
+
message.device = object.device ?? "";
|
|
383
|
+
message.roomId = object.roomId ?? "";
|
|
384
|
+
message.userId = object.userId ?? 0;
|
|
385
|
+
return message;
|
|
386
|
+
},
|
|
387
|
+
};
|
|
388
|
+
function createBaseRoom() {
|
|
389
|
+
return { roomId: "", displayName: "" };
|
|
390
|
+
}
|
|
391
|
+
exports.Room = {
|
|
392
|
+
encode(message, writer = new wire_1.BinaryWriter()) {
|
|
393
|
+
if (message.roomId !== "") {
|
|
394
|
+
writer.uint32(10).string(message.roomId);
|
|
395
|
+
}
|
|
396
|
+
if (message.displayName !== "") {
|
|
397
|
+
writer.uint32(18).string(message.displayName);
|
|
398
|
+
}
|
|
399
|
+
return writer;
|
|
400
|
+
},
|
|
401
|
+
decode(input, length) {
|
|
402
|
+
const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
|
|
403
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
404
|
+
if (previousRecursionDepth >= 100) {
|
|
405
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
406
|
+
}
|
|
407
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
408
|
+
try {
|
|
409
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
410
|
+
const message = createBaseRoom();
|
|
411
|
+
while (reader.pos < end) {
|
|
412
|
+
const tag = reader.uint32();
|
|
413
|
+
switch (tag >>> 3) {
|
|
414
|
+
case 1: {
|
|
415
|
+
if (tag !== 10) {
|
|
416
|
+
break;
|
|
417
|
+
}
|
|
418
|
+
message.roomId = reader.string();
|
|
419
|
+
continue;
|
|
420
|
+
}
|
|
421
|
+
case 2: {
|
|
422
|
+
if (tag !== 18) {
|
|
423
|
+
break;
|
|
424
|
+
}
|
|
425
|
+
message.displayName = reader.string();
|
|
426
|
+
continue;
|
|
427
|
+
}
|
|
428
|
+
}
|
|
429
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
430
|
+
break;
|
|
431
|
+
}
|
|
432
|
+
reader.skip(tag & 7);
|
|
433
|
+
}
|
|
434
|
+
return message;
|
|
435
|
+
}
|
|
436
|
+
finally {
|
|
437
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
438
|
+
}
|
|
439
|
+
},
|
|
440
|
+
create(base) {
|
|
441
|
+
return exports.Room.fromPartial(base ?? {});
|
|
442
|
+
},
|
|
443
|
+
fromPartial(object) {
|
|
444
|
+
const message = createBaseRoom();
|
|
445
|
+
message.roomId = object.roomId ?? "";
|
|
446
|
+
message.displayName = object.displayName ?? "";
|
|
447
|
+
return message;
|
|
448
|
+
},
|
|
449
|
+
};
|
|
450
|
+
function createBaseGetRoomsResponse() {
|
|
451
|
+
return { rooms: [] };
|
|
452
|
+
}
|
|
453
|
+
exports.GetRoomsResponse = {
|
|
454
|
+
encode(message, writer = new wire_1.BinaryWriter()) {
|
|
455
|
+
for (const v of message.rooms) {
|
|
456
|
+
exports.Room.encode(v, writer.uint32(10).fork()).join();
|
|
457
|
+
}
|
|
458
|
+
return writer;
|
|
459
|
+
},
|
|
460
|
+
decode(input, length) {
|
|
461
|
+
const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
|
|
462
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
463
|
+
if (previousRecursionDepth >= 100) {
|
|
464
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
465
|
+
}
|
|
466
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
467
|
+
try {
|
|
468
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
469
|
+
const message = createBaseGetRoomsResponse();
|
|
470
|
+
while (reader.pos < end) {
|
|
471
|
+
const tag = reader.uint32();
|
|
472
|
+
switch (tag >>> 3) {
|
|
473
|
+
case 1: {
|
|
474
|
+
if (tag !== 10) {
|
|
475
|
+
break;
|
|
476
|
+
}
|
|
477
|
+
message.rooms.push(exports.Room.decode(reader, reader.uint32()));
|
|
478
|
+
continue;
|
|
479
|
+
}
|
|
480
|
+
}
|
|
481
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
482
|
+
break;
|
|
483
|
+
}
|
|
484
|
+
reader.skip(tag & 7);
|
|
485
|
+
}
|
|
486
|
+
return message;
|
|
487
|
+
}
|
|
488
|
+
finally {
|
|
489
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
490
|
+
}
|
|
491
|
+
},
|
|
492
|
+
create(base) {
|
|
493
|
+
return exports.GetRoomsResponse.fromPartial(base ?? {});
|
|
494
|
+
},
|
|
495
|
+
fromPartial(object) {
|
|
496
|
+
const message = createBaseGetRoomsResponse();
|
|
497
|
+
message.rooms = object.rooms?.map((e) => exports.Room.fromPartial(e)) || [];
|
|
498
|
+
return message;
|
|
499
|
+
},
|
|
500
|
+
};
|
|
501
|
+
function createBaseGroupSatellite() {
|
|
502
|
+
return { deviceId: "", displayName: "", roomId: "" };
|
|
503
|
+
}
|
|
504
|
+
exports.GroupSatellite = {
|
|
505
|
+
encode(message, writer = new wire_1.BinaryWriter()) {
|
|
506
|
+
if (message.deviceId !== "") {
|
|
507
|
+
writer.uint32(10).string(message.deviceId);
|
|
508
|
+
}
|
|
509
|
+
if (message.displayName !== "") {
|
|
510
|
+
writer.uint32(18).string(message.displayName);
|
|
511
|
+
}
|
|
512
|
+
if (message.roomId !== "") {
|
|
513
|
+
writer.uint32(26).string(message.roomId);
|
|
514
|
+
}
|
|
515
|
+
return writer;
|
|
516
|
+
},
|
|
517
|
+
decode(input, length) {
|
|
518
|
+
const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
|
|
519
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
520
|
+
if (previousRecursionDepth >= 100) {
|
|
521
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
522
|
+
}
|
|
523
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
524
|
+
try {
|
|
525
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
526
|
+
const message = createBaseGroupSatellite();
|
|
527
|
+
while (reader.pos < end) {
|
|
528
|
+
const tag = reader.uint32();
|
|
529
|
+
switch (tag >>> 3) {
|
|
530
|
+
case 1: {
|
|
531
|
+
if (tag !== 10) {
|
|
532
|
+
break;
|
|
533
|
+
}
|
|
534
|
+
message.deviceId = reader.string();
|
|
535
|
+
continue;
|
|
536
|
+
}
|
|
537
|
+
case 2: {
|
|
538
|
+
if (tag !== 18) {
|
|
539
|
+
break;
|
|
540
|
+
}
|
|
541
|
+
message.displayName = reader.string();
|
|
542
|
+
continue;
|
|
543
|
+
}
|
|
544
|
+
case 3: {
|
|
545
|
+
if (tag !== 26) {
|
|
546
|
+
break;
|
|
547
|
+
}
|
|
548
|
+
message.roomId = reader.string();
|
|
549
|
+
continue;
|
|
550
|
+
}
|
|
551
|
+
}
|
|
552
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
553
|
+
break;
|
|
554
|
+
}
|
|
555
|
+
reader.skip(tag & 7);
|
|
556
|
+
}
|
|
557
|
+
return message;
|
|
558
|
+
}
|
|
559
|
+
finally {
|
|
560
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
561
|
+
}
|
|
562
|
+
},
|
|
563
|
+
create(base) {
|
|
564
|
+
return exports.GroupSatellite.fromPartial(base ?? {});
|
|
565
|
+
},
|
|
566
|
+
fromPartial(object) {
|
|
567
|
+
const message = createBaseGroupSatellite();
|
|
568
|
+
message.deviceId = object.deviceId ?? "";
|
|
569
|
+
message.displayName = object.displayName ?? "";
|
|
570
|
+
message.roomId = object.roomId ?? "";
|
|
571
|
+
return message;
|
|
572
|
+
},
|
|
573
|
+
};
|
|
574
|
+
function createBaseGroup() {
|
|
575
|
+
return { groupId: "", displayName: "", satellites: [] };
|
|
576
|
+
}
|
|
577
|
+
exports.Group = {
|
|
578
|
+
encode(message, writer = new wire_1.BinaryWriter()) {
|
|
579
|
+
if (message.groupId !== "") {
|
|
580
|
+
writer.uint32(10).string(message.groupId);
|
|
581
|
+
}
|
|
582
|
+
if (message.displayName !== "") {
|
|
583
|
+
writer.uint32(18).string(message.displayName);
|
|
584
|
+
}
|
|
585
|
+
for (const v of message.satellites) {
|
|
586
|
+
exports.GroupSatellite.encode(v, writer.uint32(26).fork()).join();
|
|
587
|
+
}
|
|
588
|
+
return writer;
|
|
589
|
+
},
|
|
590
|
+
decode(input, length) {
|
|
591
|
+
const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
|
|
592
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
593
|
+
if (previousRecursionDepth >= 100) {
|
|
594
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
595
|
+
}
|
|
596
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
597
|
+
try {
|
|
598
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
599
|
+
const message = createBaseGroup();
|
|
600
|
+
while (reader.pos < end) {
|
|
601
|
+
const tag = reader.uint32();
|
|
602
|
+
switch (tag >>> 3) {
|
|
603
|
+
case 1: {
|
|
604
|
+
if (tag !== 10) {
|
|
605
|
+
break;
|
|
606
|
+
}
|
|
607
|
+
message.groupId = reader.string();
|
|
608
|
+
continue;
|
|
609
|
+
}
|
|
610
|
+
case 2: {
|
|
611
|
+
if (tag !== 18) {
|
|
612
|
+
break;
|
|
613
|
+
}
|
|
614
|
+
message.displayName = reader.string();
|
|
615
|
+
continue;
|
|
616
|
+
}
|
|
617
|
+
case 3: {
|
|
618
|
+
if (tag !== 26) {
|
|
619
|
+
break;
|
|
620
|
+
}
|
|
621
|
+
message.satellites.push(exports.GroupSatellite.decode(reader, reader.uint32()));
|
|
622
|
+
continue;
|
|
623
|
+
}
|
|
624
|
+
}
|
|
625
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
626
|
+
break;
|
|
627
|
+
}
|
|
628
|
+
reader.skip(tag & 7);
|
|
629
|
+
}
|
|
630
|
+
return message;
|
|
631
|
+
}
|
|
632
|
+
finally {
|
|
633
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
634
|
+
}
|
|
635
|
+
},
|
|
636
|
+
create(base) {
|
|
637
|
+
return exports.Group.fromPartial(base ?? {});
|
|
638
|
+
},
|
|
639
|
+
fromPartial(object) {
|
|
640
|
+
const message = createBaseGroup();
|
|
641
|
+
message.groupId = object.groupId ?? "";
|
|
642
|
+
message.displayName = object.displayName ?? "";
|
|
643
|
+
message.satellites = object.satellites?.map((e) => exports.GroupSatellite.fromPartial(e)) || [];
|
|
644
|
+
return message;
|
|
645
|
+
},
|
|
646
|
+
};
|
|
647
|
+
function createBaseGetGroupsResponse() {
|
|
648
|
+
return { groups: [] };
|
|
649
|
+
}
|
|
650
|
+
exports.GetGroupsResponse = {
|
|
651
|
+
encode(message, writer = new wire_1.BinaryWriter()) {
|
|
652
|
+
for (const v of message.groups) {
|
|
653
|
+
exports.Group.encode(v, writer.uint32(10).fork()).join();
|
|
654
|
+
}
|
|
655
|
+
return writer;
|
|
656
|
+
},
|
|
657
|
+
decode(input, length) {
|
|
658
|
+
const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
|
|
659
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
660
|
+
if (previousRecursionDepth >= 100) {
|
|
661
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
662
|
+
}
|
|
663
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
664
|
+
try {
|
|
665
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
666
|
+
const message = createBaseGetGroupsResponse();
|
|
667
|
+
while (reader.pos < end) {
|
|
668
|
+
const tag = reader.uint32();
|
|
669
|
+
switch (tag >>> 3) {
|
|
670
|
+
case 1: {
|
|
671
|
+
if (tag !== 10) {
|
|
672
|
+
break;
|
|
673
|
+
}
|
|
674
|
+
message.groups.push(exports.Group.decode(reader, reader.uint32()));
|
|
675
|
+
continue;
|
|
676
|
+
}
|
|
677
|
+
}
|
|
678
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
679
|
+
break;
|
|
680
|
+
}
|
|
681
|
+
reader.skip(tag & 7);
|
|
682
|
+
}
|
|
683
|
+
return message;
|
|
684
|
+
}
|
|
685
|
+
finally {
|
|
686
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
687
|
+
}
|
|
688
|
+
},
|
|
689
|
+
create(base) {
|
|
690
|
+
return exports.GetGroupsResponse.fromPartial(base ?? {});
|
|
691
|
+
},
|
|
692
|
+
fromPartial(object) {
|
|
693
|
+
const message = createBaseGetGroupsResponse();
|
|
694
|
+
message.groups = object.groups?.map((e) => exports.Group.fromPartial(e)) || [];
|
|
695
|
+
return message;
|
|
696
|
+
},
|
|
697
|
+
};
|
|
698
|
+
function createBaseCreateGroupRequest() {
|
|
699
|
+
return { groupId: "", displayName: "" };
|
|
700
|
+
}
|
|
701
|
+
exports.CreateGroupRequest = {
|
|
702
|
+
encode(message, writer = new wire_1.BinaryWriter()) {
|
|
703
|
+
if (message.groupId !== "") {
|
|
704
|
+
writer.uint32(10).string(message.groupId);
|
|
705
|
+
}
|
|
706
|
+
if (message.displayName !== "") {
|
|
707
|
+
writer.uint32(18).string(message.displayName);
|
|
708
|
+
}
|
|
709
|
+
return writer;
|
|
710
|
+
},
|
|
711
|
+
decode(input, length) {
|
|
712
|
+
const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
|
|
713
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
714
|
+
if (previousRecursionDepth >= 100) {
|
|
715
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
716
|
+
}
|
|
717
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
718
|
+
try {
|
|
719
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
720
|
+
const message = createBaseCreateGroupRequest();
|
|
721
|
+
while (reader.pos < end) {
|
|
722
|
+
const tag = reader.uint32();
|
|
723
|
+
switch (tag >>> 3) {
|
|
724
|
+
case 1: {
|
|
725
|
+
if (tag !== 10) {
|
|
726
|
+
break;
|
|
727
|
+
}
|
|
728
|
+
message.groupId = reader.string();
|
|
729
|
+
continue;
|
|
730
|
+
}
|
|
731
|
+
case 2: {
|
|
732
|
+
if (tag !== 18) {
|
|
733
|
+
break;
|
|
734
|
+
}
|
|
735
|
+
message.displayName = reader.string();
|
|
736
|
+
continue;
|
|
737
|
+
}
|
|
738
|
+
}
|
|
739
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
740
|
+
break;
|
|
741
|
+
}
|
|
742
|
+
reader.skip(tag & 7);
|
|
743
|
+
}
|
|
744
|
+
return message;
|
|
745
|
+
}
|
|
746
|
+
finally {
|
|
747
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
748
|
+
}
|
|
749
|
+
},
|
|
750
|
+
create(base) {
|
|
751
|
+
return exports.CreateGroupRequest.fromPartial(base ?? {});
|
|
752
|
+
},
|
|
753
|
+
fromPartial(object) {
|
|
754
|
+
const message = createBaseCreateGroupRequest();
|
|
755
|
+
message.groupId = object.groupId ?? "";
|
|
756
|
+
message.displayName = object.displayName ?? "";
|
|
757
|
+
return message;
|
|
758
|
+
},
|
|
759
|
+
};
|
|
760
|
+
function createBaseUpdateGroupRequest() {
|
|
761
|
+
return { groupId: "", displayName: "" };
|
|
762
|
+
}
|
|
763
|
+
exports.UpdateGroupRequest = {
|
|
764
|
+
encode(message, writer = new wire_1.BinaryWriter()) {
|
|
765
|
+
if (message.groupId !== "") {
|
|
766
|
+
writer.uint32(10).string(message.groupId);
|
|
767
|
+
}
|
|
768
|
+
if (message.displayName !== "") {
|
|
769
|
+
writer.uint32(18).string(message.displayName);
|
|
770
|
+
}
|
|
771
|
+
return writer;
|
|
772
|
+
},
|
|
773
|
+
decode(input, length) {
|
|
774
|
+
const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
|
|
775
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
776
|
+
if (previousRecursionDepth >= 100) {
|
|
777
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
778
|
+
}
|
|
779
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
780
|
+
try {
|
|
781
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
782
|
+
const message = createBaseUpdateGroupRequest();
|
|
783
|
+
while (reader.pos < end) {
|
|
784
|
+
const tag = reader.uint32();
|
|
785
|
+
switch (tag >>> 3) {
|
|
786
|
+
case 1: {
|
|
787
|
+
if (tag !== 10) {
|
|
788
|
+
break;
|
|
789
|
+
}
|
|
790
|
+
message.groupId = reader.string();
|
|
791
|
+
continue;
|
|
792
|
+
}
|
|
793
|
+
case 2: {
|
|
794
|
+
if (tag !== 18) {
|
|
795
|
+
break;
|
|
796
|
+
}
|
|
797
|
+
message.displayName = reader.string();
|
|
798
|
+
continue;
|
|
799
|
+
}
|
|
800
|
+
}
|
|
801
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
802
|
+
break;
|
|
803
|
+
}
|
|
804
|
+
reader.skip(tag & 7);
|
|
805
|
+
}
|
|
806
|
+
return message;
|
|
807
|
+
}
|
|
808
|
+
finally {
|
|
809
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
810
|
+
}
|
|
811
|
+
},
|
|
812
|
+
create(base) {
|
|
813
|
+
return exports.UpdateGroupRequest.fromPartial(base ?? {});
|
|
814
|
+
},
|
|
815
|
+
fromPartial(object) {
|
|
816
|
+
const message = createBaseUpdateGroupRequest();
|
|
817
|
+
message.groupId = object.groupId ?? "";
|
|
818
|
+
message.displayName = object.displayName ?? "";
|
|
819
|
+
return message;
|
|
820
|
+
},
|
|
821
|
+
};
|
|
822
|
+
function createBaseDeleteGroupRequest() {
|
|
823
|
+
return { groupId: "" };
|
|
824
|
+
}
|
|
825
|
+
exports.DeleteGroupRequest = {
|
|
826
|
+
encode(message, writer = new wire_1.BinaryWriter()) {
|
|
827
|
+
if (message.groupId !== "") {
|
|
828
|
+
writer.uint32(10).string(message.groupId);
|
|
829
|
+
}
|
|
830
|
+
return writer;
|
|
831
|
+
},
|
|
832
|
+
decode(input, length) {
|
|
833
|
+
const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
|
|
834
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
835
|
+
if (previousRecursionDepth >= 100) {
|
|
836
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
837
|
+
}
|
|
838
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
839
|
+
try {
|
|
840
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
841
|
+
const message = createBaseDeleteGroupRequest();
|
|
842
|
+
while (reader.pos < end) {
|
|
843
|
+
const tag = reader.uint32();
|
|
844
|
+
switch (tag >>> 3) {
|
|
845
|
+
case 1: {
|
|
846
|
+
if (tag !== 10) {
|
|
847
|
+
break;
|
|
848
|
+
}
|
|
849
|
+
message.groupId = reader.string();
|
|
850
|
+
continue;
|
|
851
|
+
}
|
|
852
|
+
}
|
|
853
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
854
|
+
break;
|
|
855
|
+
}
|
|
856
|
+
reader.skip(tag & 7);
|
|
857
|
+
}
|
|
858
|
+
return message;
|
|
859
|
+
}
|
|
860
|
+
finally {
|
|
861
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
862
|
+
}
|
|
863
|
+
},
|
|
864
|
+
create(base) {
|
|
865
|
+
return exports.DeleteGroupRequest.fromPartial(base ?? {});
|
|
866
|
+
},
|
|
867
|
+
fromPartial(object) {
|
|
868
|
+
const message = createBaseDeleteGroupRequest();
|
|
869
|
+
message.groupId = object.groupId ?? "";
|
|
870
|
+
return message;
|
|
871
|
+
},
|
|
872
|
+
};
|
|
873
|
+
function createBaseSetGroupSatellitesRequest() {
|
|
874
|
+
return { groupId: "", deviceIds: [] };
|
|
875
|
+
}
|
|
876
|
+
exports.SetGroupSatellitesRequest = {
|
|
877
|
+
encode(message, writer = new wire_1.BinaryWriter()) {
|
|
878
|
+
if (message.groupId !== "") {
|
|
879
|
+
writer.uint32(10).string(message.groupId);
|
|
880
|
+
}
|
|
881
|
+
for (const v of message.deviceIds) {
|
|
882
|
+
writer.uint32(18).string(v);
|
|
883
|
+
}
|
|
884
|
+
return writer;
|
|
885
|
+
},
|
|
886
|
+
decode(input, length) {
|
|
887
|
+
const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
|
|
888
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
889
|
+
if (previousRecursionDepth >= 100) {
|
|
890
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
891
|
+
}
|
|
892
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
893
|
+
try {
|
|
894
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
895
|
+
const message = createBaseSetGroupSatellitesRequest();
|
|
896
|
+
while (reader.pos < end) {
|
|
897
|
+
const tag = reader.uint32();
|
|
898
|
+
switch (tag >>> 3) {
|
|
899
|
+
case 1: {
|
|
900
|
+
if (tag !== 10) {
|
|
901
|
+
break;
|
|
902
|
+
}
|
|
903
|
+
message.groupId = reader.string();
|
|
904
|
+
continue;
|
|
905
|
+
}
|
|
906
|
+
case 2: {
|
|
907
|
+
if (tag !== 18) {
|
|
908
|
+
break;
|
|
909
|
+
}
|
|
910
|
+
message.deviceIds.push(reader.string());
|
|
911
|
+
continue;
|
|
912
|
+
}
|
|
913
|
+
}
|
|
914
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
915
|
+
break;
|
|
916
|
+
}
|
|
917
|
+
reader.skip(tag & 7);
|
|
918
|
+
}
|
|
919
|
+
return message;
|
|
920
|
+
}
|
|
921
|
+
finally {
|
|
922
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
923
|
+
}
|
|
924
|
+
},
|
|
925
|
+
create(base) {
|
|
926
|
+
return exports.SetGroupSatellitesRequest.fromPartial(base ?? {});
|
|
927
|
+
},
|
|
928
|
+
fromPartial(object) {
|
|
929
|
+
const message = createBaseSetGroupSatellitesRequest();
|
|
930
|
+
message.groupId = object.groupId ?? "";
|
|
931
|
+
message.deviceIds = object.deviceIds?.map((e) => e) || [];
|
|
932
|
+
return message;
|
|
933
|
+
},
|
|
934
|
+
};
|
|
935
|
+
function createBaseTrigger() {
|
|
936
|
+
return {
|
|
937
|
+
id: "",
|
|
938
|
+
whenJson: "",
|
|
939
|
+
cancelWhenJson: "",
|
|
940
|
+
onResponseJson: "",
|
|
941
|
+
say: "",
|
|
942
|
+
ask: "",
|
|
943
|
+
rephrase: false,
|
|
944
|
+
target: "",
|
|
945
|
+
cooldown: 0,
|
|
946
|
+
delay: "",
|
|
947
|
+
actionsJson: "",
|
|
948
|
+
};
|
|
949
|
+
}
|
|
950
|
+
exports.Trigger = {
|
|
951
|
+
encode(message, writer = new wire_1.BinaryWriter()) {
|
|
952
|
+
if (message.id !== "") {
|
|
953
|
+
writer.uint32(10).string(message.id);
|
|
954
|
+
}
|
|
955
|
+
if (message.whenJson !== "") {
|
|
956
|
+
writer.uint32(18).string(message.whenJson);
|
|
957
|
+
}
|
|
958
|
+
if (message.cancelWhenJson !== "") {
|
|
959
|
+
writer.uint32(26).string(message.cancelWhenJson);
|
|
960
|
+
}
|
|
961
|
+
if (message.onResponseJson !== "") {
|
|
962
|
+
writer.uint32(34).string(message.onResponseJson);
|
|
963
|
+
}
|
|
964
|
+
if (message.say !== "") {
|
|
965
|
+
writer.uint32(42).string(message.say);
|
|
966
|
+
}
|
|
967
|
+
if (message.ask !== "") {
|
|
968
|
+
writer.uint32(50).string(message.ask);
|
|
969
|
+
}
|
|
970
|
+
if (message.rephrase !== false) {
|
|
971
|
+
writer.uint32(56).bool(message.rephrase);
|
|
972
|
+
}
|
|
973
|
+
if (message.target !== "") {
|
|
974
|
+
writer.uint32(66).string(message.target);
|
|
975
|
+
}
|
|
976
|
+
if (message.cooldown !== 0) {
|
|
977
|
+
writer.uint32(72).int32(message.cooldown);
|
|
978
|
+
}
|
|
979
|
+
if (message.delay !== "") {
|
|
980
|
+
writer.uint32(82).string(message.delay);
|
|
981
|
+
}
|
|
982
|
+
if (message.actionsJson !== "") {
|
|
983
|
+
writer.uint32(90).string(message.actionsJson);
|
|
984
|
+
}
|
|
985
|
+
return writer;
|
|
986
|
+
},
|
|
987
|
+
decode(input, length) {
|
|
988
|
+
const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
|
|
989
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
990
|
+
if (previousRecursionDepth >= 100) {
|
|
991
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
992
|
+
}
|
|
993
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
994
|
+
try {
|
|
995
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
996
|
+
const message = createBaseTrigger();
|
|
997
|
+
while (reader.pos < end) {
|
|
998
|
+
const tag = reader.uint32();
|
|
999
|
+
switch (tag >>> 3) {
|
|
1000
|
+
case 1: {
|
|
1001
|
+
if (tag !== 10) {
|
|
1002
|
+
break;
|
|
1003
|
+
}
|
|
1004
|
+
message.id = reader.string();
|
|
1005
|
+
continue;
|
|
1006
|
+
}
|
|
1007
|
+
case 2: {
|
|
1008
|
+
if (tag !== 18) {
|
|
1009
|
+
break;
|
|
1010
|
+
}
|
|
1011
|
+
message.whenJson = reader.string();
|
|
1012
|
+
continue;
|
|
1013
|
+
}
|
|
1014
|
+
case 3: {
|
|
1015
|
+
if (tag !== 26) {
|
|
1016
|
+
break;
|
|
1017
|
+
}
|
|
1018
|
+
message.cancelWhenJson = reader.string();
|
|
1019
|
+
continue;
|
|
1020
|
+
}
|
|
1021
|
+
case 4: {
|
|
1022
|
+
if (tag !== 34) {
|
|
1023
|
+
break;
|
|
1024
|
+
}
|
|
1025
|
+
message.onResponseJson = reader.string();
|
|
1026
|
+
continue;
|
|
1027
|
+
}
|
|
1028
|
+
case 5: {
|
|
1029
|
+
if (tag !== 42) {
|
|
1030
|
+
break;
|
|
1031
|
+
}
|
|
1032
|
+
message.say = reader.string();
|
|
1033
|
+
continue;
|
|
1034
|
+
}
|
|
1035
|
+
case 6: {
|
|
1036
|
+
if (tag !== 50) {
|
|
1037
|
+
break;
|
|
1038
|
+
}
|
|
1039
|
+
message.ask = reader.string();
|
|
1040
|
+
continue;
|
|
1041
|
+
}
|
|
1042
|
+
case 7: {
|
|
1043
|
+
if (tag !== 56) {
|
|
1044
|
+
break;
|
|
1045
|
+
}
|
|
1046
|
+
message.rephrase = reader.bool();
|
|
1047
|
+
continue;
|
|
1048
|
+
}
|
|
1049
|
+
case 8: {
|
|
1050
|
+
if (tag !== 66) {
|
|
1051
|
+
break;
|
|
1052
|
+
}
|
|
1053
|
+
message.target = reader.string();
|
|
1054
|
+
continue;
|
|
1055
|
+
}
|
|
1056
|
+
case 9: {
|
|
1057
|
+
if (tag !== 72) {
|
|
1058
|
+
break;
|
|
1059
|
+
}
|
|
1060
|
+
message.cooldown = reader.int32();
|
|
1061
|
+
continue;
|
|
1062
|
+
}
|
|
1063
|
+
case 10: {
|
|
1064
|
+
if (tag !== 82) {
|
|
1065
|
+
break;
|
|
1066
|
+
}
|
|
1067
|
+
message.delay = reader.string();
|
|
1068
|
+
continue;
|
|
1069
|
+
}
|
|
1070
|
+
case 11: {
|
|
1071
|
+
if (tag !== 90) {
|
|
1072
|
+
break;
|
|
1073
|
+
}
|
|
1074
|
+
message.actionsJson = reader.string();
|
|
1075
|
+
continue;
|
|
1076
|
+
}
|
|
1077
|
+
}
|
|
1078
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
1079
|
+
break;
|
|
1080
|
+
}
|
|
1081
|
+
reader.skip(tag & 7);
|
|
1082
|
+
}
|
|
1083
|
+
return message;
|
|
1084
|
+
}
|
|
1085
|
+
finally {
|
|
1086
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
1087
|
+
}
|
|
1088
|
+
},
|
|
1089
|
+
create(base) {
|
|
1090
|
+
return exports.Trigger.fromPartial(base ?? {});
|
|
1091
|
+
},
|
|
1092
|
+
fromPartial(object) {
|
|
1093
|
+
const message = createBaseTrigger();
|
|
1094
|
+
message.id = object.id ?? "";
|
|
1095
|
+
message.whenJson = object.whenJson ?? "";
|
|
1096
|
+
message.cancelWhenJson = object.cancelWhenJson ?? "";
|
|
1097
|
+
message.onResponseJson = object.onResponseJson ?? "";
|
|
1098
|
+
message.say = object.say ?? "";
|
|
1099
|
+
message.ask = object.ask ?? "";
|
|
1100
|
+
message.rephrase = object.rephrase ?? false;
|
|
1101
|
+
message.target = object.target ?? "";
|
|
1102
|
+
message.cooldown = object.cooldown ?? 0;
|
|
1103
|
+
message.delay = object.delay ?? "";
|
|
1104
|
+
message.actionsJson = object.actionsJson ?? "";
|
|
1105
|
+
return message;
|
|
1106
|
+
},
|
|
1107
|
+
};
|
|
1108
|
+
function createBaseGetTriggersResponse() {
|
|
1109
|
+
return { triggers: [] };
|
|
1110
|
+
}
|
|
1111
|
+
exports.GetTriggersResponse = {
|
|
1112
|
+
encode(message, writer = new wire_1.BinaryWriter()) {
|
|
1113
|
+
for (const v of message.triggers) {
|
|
1114
|
+
exports.Trigger.encode(v, writer.uint32(10).fork()).join();
|
|
1115
|
+
}
|
|
1116
|
+
return writer;
|
|
1117
|
+
},
|
|
1118
|
+
decode(input, length) {
|
|
1119
|
+
const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
|
|
1120
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
1121
|
+
if (previousRecursionDepth >= 100) {
|
|
1122
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
1123
|
+
}
|
|
1124
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
1125
|
+
try {
|
|
1126
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
1127
|
+
const message = createBaseGetTriggersResponse();
|
|
1128
|
+
while (reader.pos < end) {
|
|
1129
|
+
const tag = reader.uint32();
|
|
1130
|
+
switch (tag >>> 3) {
|
|
1131
|
+
case 1: {
|
|
1132
|
+
if (tag !== 10) {
|
|
1133
|
+
break;
|
|
1134
|
+
}
|
|
1135
|
+
message.triggers.push(exports.Trigger.decode(reader, reader.uint32()));
|
|
1136
|
+
continue;
|
|
1137
|
+
}
|
|
1138
|
+
}
|
|
1139
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
1140
|
+
break;
|
|
1141
|
+
}
|
|
1142
|
+
reader.skip(tag & 7);
|
|
1143
|
+
}
|
|
1144
|
+
return message;
|
|
1145
|
+
}
|
|
1146
|
+
finally {
|
|
1147
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
1148
|
+
}
|
|
1149
|
+
},
|
|
1150
|
+
create(base) {
|
|
1151
|
+
return exports.GetTriggersResponse.fromPartial(base ?? {});
|
|
1152
|
+
},
|
|
1153
|
+
fromPartial(object) {
|
|
1154
|
+
const message = createBaseGetTriggersResponse();
|
|
1155
|
+
message.triggers = object.triggers?.map((e) => exports.Trigger.fromPartial(e)) || [];
|
|
1156
|
+
return message;
|
|
1157
|
+
},
|
|
1158
|
+
};
|
|
1159
|
+
function createBaseCreateTriggerRequest() {
|
|
1160
|
+
return {
|
|
1161
|
+
id: "",
|
|
1162
|
+
whenJson: "",
|
|
1163
|
+
cancelWhenJson: "",
|
|
1164
|
+
onResponseJson: "",
|
|
1165
|
+
say: "",
|
|
1166
|
+
ask: "",
|
|
1167
|
+
rephrase: false,
|
|
1168
|
+
target: "",
|
|
1169
|
+
cooldown: 0,
|
|
1170
|
+
delay: "",
|
|
1171
|
+
actionsJson: "",
|
|
1172
|
+
};
|
|
1173
|
+
}
|
|
1174
|
+
exports.CreateTriggerRequest = {
|
|
1175
|
+
encode(message, writer = new wire_1.BinaryWriter()) {
|
|
1176
|
+
if (message.id !== "") {
|
|
1177
|
+
writer.uint32(10).string(message.id);
|
|
1178
|
+
}
|
|
1179
|
+
if (message.whenJson !== "") {
|
|
1180
|
+
writer.uint32(18).string(message.whenJson);
|
|
1181
|
+
}
|
|
1182
|
+
if (message.cancelWhenJson !== "") {
|
|
1183
|
+
writer.uint32(26).string(message.cancelWhenJson);
|
|
1184
|
+
}
|
|
1185
|
+
if (message.onResponseJson !== "") {
|
|
1186
|
+
writer.uint32(34).string(message.onResponseJson);
|
|
1187
|
+
}
|
|
1188
|
+
if (message.say !== "") {
|
|
1189
|
+
writer.uint32(42).string(message.say);
|
|
1190
|
+
}
|
|
1191
|
+
if (message.ask !== "") {
|
|
1192
|
+
writer.uint32(50).string(message.ask);
|
|
1193
|
+
}
|
|
1194
|
+
if (message.rephrase !== false) {
|
|
1195
|
+
writer.uint32(56).bool(message.rephrase);
|
|
1196
|
+
}
|
|
1197
|
+
if (message.target !== "") {
|
|
1198
|
+
writer.uint32(66).string(message.target);
|
|
1199
|
+
}
|
|
1200
|
+
if (message.cooldown !== 0) {
|
|
1201
|
+
writer.uint32(72).int32(message.cooldown);
|
|
1202
|
+
}
|
|
1203
|
+
if (message.delay !== "") {
|
|
1204
|
+
writer.uint32(82).string(message.delay);
|
|
1205
|
+
}
|
|
1206
|
+
if (message.actionsJson !== "") {
|
|
1207
|
+
writer.uint32(90).string(message.actionsJson);
|
|
1208
|
+
}
|
|
1209
|
+
return writer;
|
|
1210
|
+
},
|
|
1211
|
+
decode(input, length) {
|
|
1212
|
+
const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
|
|
1213
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
1214
|
+
if (previousRecursionDepth >= 100) {
|
|
1215
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
1216
|
+
}
|
|
1217
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
1218
|
+
try {
|
|
1219
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
1220
|
+
const message = createBaseCreateTriggerRequest();
|
|
1221
|
+
while (reader.pos < end) {
|
|
1222
|
+
const tag = reader.uint32();
|
|
1223
|
+
switch (tag >>> 3) {
|
|
1224
|
+
case 1: {
|
|
1225
|
+
if (tag !== 10) {
|
|
1226
|
+
break;
|
|
1227
|
+
}
|
|
1228
|
+
message.id = reader.string();
|
|
1229
|
+
continue;
|
|
1230
|
+
}
|
|
1231
|
+
case 2: {
|
|
1232
|
+
if (tag !== 18) {
|
|
1233
|
+
break;
|
|
1234
|
+
}
|
|
1235
|
+
message.whenJson = reader.string();
|
|
1236
|
+
continue;
|
|
1237
|
+
}
|
|
1238
|
+
case 3: {
|
|
1239
|
+
if (tag !== 26) {
|
|
1240
|
+
break;
|
|
1241
|
+
}
|
|
1242
|
+
message.cancelWhenJson = reader.string();
|
|
1243
|
+
continue;
|
|
1244
|
+
}
|
|
1245
|
+
case 4: {
|
|
1246
|
+
if (tag !== 34) {
|
|
1247
|
+
break;
|
|
1248
|
+
}
|
|
1249
|
+
message.onResponseJson = reader.string();
|
|
1250
|
+
continue;
|
|
1251
|
+
}
|
|
1252
|
+
case 5: {
|
|
1253
|
+
if (tag !== 42) {
|
|
1254
|
+
break;
|
|
1255
|
+
}
|
|
1256
|
+
message.say = reader.string();
|
|
1257
|
+
continue;
|
|
1258
|
+
}
|
|
1259
|
+
case 6: {
|
|
1260
|
+
if (tag !== 50) {
|
|
1261
|
+
break;
|
|
1262
|
+
}
|
|
1263
|
+
message.ask = reader.string();
|
|
1264
|
+
continue;
|
|
1265
|
+
}
|
|
1266
|
+
case 7: {
|
|
1267
|
+
if (tag !== 56) {
|
|
1268
|
+
break;
|
|
1269
|
+
}
|
|
1270
|
+
message.rephrase = reader.bool();
|
|
1271
|
+
continue;
|
|
1272
|
+
}
|
|
1273
|
+
case 8: {
|
|
1274
|
+
if (tag !== 66) {
|
|
1275
|
+
break;
|
|
1276
|
+
}
|
|
1277
|
+
message.target = reader.string();
|
|
1278
|
+
continue;
|
|
1279
|
+
}
|
|
1280
|
+
case 9: {
|
|
1281
|
+
if (tag !== 72) {
|
|
1282
|
+
break;
|
|
1283
|
+
}
|
|
1284
|
+
message.cooldown = reader.int32();
|
|
1285
|
+
continue;
|
|
1286
|
+
}
|
|
1287
|
+
case 10: {
|
|
1288
|
+
if (tag !== 82) {
|
|
1289
|
+
break;
|
|
1290
|
+
}
|
|
1291
|
+
message.delay = reader.string();
|
|
1292
|
+
continue;
|
|
1293
|
+
}
|
|
1294
|
+
case 11: {
|
|
1295
|
+
if (tag !== 90) {
|
|
1296
|
+
break;
|
|
1297
|
+
}
|
|
1298
|
+
message.actionsJson = reader.string();
|
|
1299
|
+
continue;
|
|
1300
|
+
}
|
|
1301
|
+
}
|
|
1302
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
1303
|
+
break;
|
|
1304
|
+
}
|
|
1305
|
+
reader.skip(tag & 7);
|
|
1306
|
+
}
|
|
1307
|
+
return message;
|
|
1308
|
+
}
|
|
1309
|
+
finally {
|
|
1310
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
1311
|
+
}
|
|
1312
|
+
},
|
|
1313
|
+
create(base) {
|
|
1314
|
+
return exports.CreateTriggerRequest.fromPartial(base ?? {});
|
|
1315
|
+
},
|
|
1316
|
+
fromPartial(object) {
|
|
1317
|
+
const message = createBaseCreateTriggerRequest();
|
|
1318
|
+
message.id = object.id ?? "";
|
|
1319
|
+
message.whenJson = object.whenJson ?? "";
|
|
1320
|
+
message.cancelWhenJson = object.cancelWhenJson ?? "";
|
|
1321
|
+
message.onResponseJson = object.onResponseJson ?? "";
|
|
1322
|
+
message.say = object.say ?? "";
|
|
1323
|
+
message.ask = object.ask ?? "";
|
|
1324
|
+
message.rephrase = object.rephrase ?? false;
|
|
1325
|
+
message.target = object.target ?? "";
|
|
1326
|
+
message.cooldown = object.cooldown ?? 0;
|
|
1327
|
+
message.delay = object.delay ?? "";
|
|
1328
|
+
message.actionsJson = object.actionsJson ?? "";
|
|
1329
|
+
return message;
|
|
1330
|
+
},
|
|
1331
|
+
};
|
|
1332
|
+
function createBaseUpdateTriggerRequest() {
|
|
1333
|
+
return {
|
|
1334
|
+
id: "",
|
|
1335
|
+
whenJson: "",
|
|
1336
|
+
cancelWhenJson: "",
|
|
1337
|
+
onResponseJson: "",
|
|
1338
|
+
say: "",
|
|
1339
|
+
ask: "",
|
|
1340
|
+
rephrase: false,
|
|
1341
|
+
target: "",
|
|
1342
|
+
cooldown: 0,
|
|
1343
|
+
delay: "",
|
|
1344
|
+
actionsJson: "",
|
|
1345
|
+
};
|
|
1346
|
+
}
|
|
1347
|
+
exports.UpdateTriggerRequest = {
|
|
1348
|
+
encode(message, writer = new wire_1.BinaryWriter()) {
|
|
1349
|
+
if (message.id !== "") {
|
|
1350
|
+
writer.uint32(10).string(message.id);
|
|
1351
|
+
}
|
|
1352
|
+
if (message.whenJson !== "") {
|
|
1353
|
+
writer.uint32(18).string(message.whenJson);
|
|
1354
|
+
}
|
|
1355
|
+
if (message.cancelWhenJson !== "") {
|
|
1356
|
+
writer.uint32(26).string(message.cancelWhenJson);
|
|
1357
|
+
}
|
|
1358
|
+
if (message.onResponseJson !== "") {
|
|
1359
|
+
writer.uint32(34).string(message.onResponseJson);
|
|
1360
|
+
}
|
|
1361
|
+
if (message.say !== "") {
|
|
1362
|
+
writer.uint32(42).string(message.say);
|
|
1363
|
+
}
|
|
1364
|
+
if (message.ask !== "") {
|
|
1365
|
+
writer.uint32(50).string(message.ask);
|
|
1366
|
+
}
|
|
1367
|
+
if (message.rephrase !== false) {
|
|
1368
|
+
writer.uint32(56).bool(message.rephrase);
|
|
1369
|
+
}
|
|
1370
|
+
if (message.target !== "") {
|
|
1371
|
+
writer.uint32(66).string(message.target);
|
|
1372
|
+
}
|
|
1373
|
+
if (message.cooldown !== 0) {
|
|
1374
|
+
writer.uint32(72).int32(message.cooldown);
|
|
1375
|
+
}
|
|
1376
|
+
if (message.delay !== "") {
|
|
1377
|
+
writer.uint32(82).string(message.delay);
|
|
1378
|
+
}
|
|
1379
|
+
if (message.actionsJson !== "") {
|
|
1380
|
+
writer.uint32(90).string(message.actionsJson);
|
|
1381
|
+
}
|
|
1382
|
+
return writer;
|
|
1383
|
+
},
|
|
1384
|
+
decode(input, length) {
|
|
1385
|
+
const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
|
|
1386
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
1387
|
+
if (previousRecursionDepth >= 100) {
|
|
1388
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
1389
|
+
}
|
|
1390
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
1391
|
+
try {
|
|
1392
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
1393
|
+
const message = createBaseUpdateTriggerRequest();
|
|
1394
|
+
while (reader.pos < end) {
|
|
1395
|
+
const tag = reader.uint32();
|
|
1396
|
+
switch (tag >>> 3) {
|
|
1397
|
+
case 1: {
|
|
1398
|
+
if (tag !== 10) {
|
|
1399
|
+
break;
|
|
1400
|
+
}
|
|
1401
|
+
message.id = reader.string();
|
|
1402
|
+
continue;
|
|
1403
|
+
}
|
|
1404
|
+
case 2: {
|
|
1405
|
+
if (tag !== 18) {
|
|
1406
|
+
break;
|
|
1407
|
+
}
|
|
1408
|
+
message.whenJson = reader.string();
|
|
1409
|
+
continue;
|
|
1410
|
+
}
|
|
1411
|
+
case 3: {
|
|
1412
|
+
if (tag !== 26) {
|
|
1413
|
+
break;
|
|
1414
|
+
}
|
|
1415
|
+
message.cancelWhenJson = reader.string();
|
|
1416
|
+
continue;
|
|
1417
|
+
}
|
|
1418
|
+
case 4: {
|
|
1419
|
+
if (tag !== 34) {
|
|
1420
|
+
break;
|
|
1421
|
+
}
|
|
1422
|
+
message.onResponseJson = reader.string();
|
|
1423
|
+
continue;
|
|
1424
|
+
}
|
|
1425
|
+
case 5: {
|
|
1426
|
+
if (tag !== 42) {
|
|
1427
|
+
break;
|
|
1428
|
+
}
|
|
1429
|
+
message.say = reader.string();
|
|
1430
|
+
continue;
|
|
1431
|
+
}
|
|
1432
|
+
case 6: {
|
|
1433
|
+
if (tag !== 50) {
|
|
1434
|
+
break;
|
|
1435
|
+
}
|
|
1436
|
+
message.ask = reader.string();
|
|
1437
|
+
continue;
|
|
1438
|
+
}
|
|
1439
|
+
case 7: {
|
|
1440
|
+
if (tag !== 56) {
|
|
1441
|
+
break;
|
|
1442
|
+
}
|
|
1443
|
+
message.rephrase = reader.bool();
|
|
1444
|
+
continue;
|
|
1445
|
+
}
|
|
1446
|
+
case 8: {
|
|
1447
|
+
if (tag !== 66) {
|
|
1448
|
+
break;
|
|
1449
|
+
}
|
|
1450
|
+
message.target = reader.string();
|
|
1451
|
+
continue;
|
|
1452
|
+
}
|
|
1453
|
+
case 9: {
|
|
1454
|
+
if (tag !== 72) {
|
|
1455
|
+
break;
|
|
1456
|
+
}
|
|
1457
|
+
message.cooldown = reader.int32();
|
|
1458
|
+
continue;
|
|
1459
|
+
}
|
|
1460
|
+
case 10: {
|
|
1461
|
+
if (tag !== 82) {
|
|
1462
|
+
break;
|
|
1463
|
+
}
|
|
1464
|
+
message.delay = reader.string();
|
|
1465
|
+
continue;
|
|
1466
|
+
}
|
|
1467
|
+
case 11: {
|
|
1468
|
+
if (tag !== 90) {
|
|
1469
|
+
break;
|
|
1470
|
+
}
|
|
1471
|
+
message.actionsJson = reader.string();
|
|
1472
|
+
continue;
|
|
1473
|
+
}
|
|
1474
|
+
}
|
|
1475
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
1476
|
+
break;
|
|
1477
|
+
}
|
|
1478
|
+
reader.skip(tag & 7);
|
|
1479
|
+
}
|
|
1480
|
+
return message;
|
|
1481
|
+
}
|
|
1482
|
+
finally {
|
|
1483
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
1484
|
+
}
|
|
1485
|
+
},
|
|
1486
|
+
create(base) {
|
|
1487
|
+
return exports.UpdateTriggerRequest.fromPartial(base ?? {});
|
|
1488
|
+
},
|
|
1489
|
+
fromPartial(object) {
|
|
1490
|
+
const message = createBaseUpdateTriggerRequest();
|
|
1491
|
+
message.id = object.id ?? "";
|
|
1492
|
+
message.whenJson = object.whenJson ?? "";
|
|
1493
|
+
message.cancelWhenJson = object.cancelWhenJson ?? "";
|
|
1494
|
+
message.onResponseJson = object.onResponseJson ?? "";
|
|
1495
|
+
message.say = object.say ?? "";
|
|
1496
|
+
message.ask = object.ask ?? "";
|
|
1497
|
+
message.rephrase = object.rephrase ?? false;
|
|
1498
|
+
message.target = object.target ?? "";
|
|
1499
|
+
message.cooldown = object.cooldown ?? 0;
|
|
1500
|
+
message.delay = object.delay ?? "";
|
|
1501
|
+
message.actionsJson = object.actionsJson ?? "";
|
|
1502
|
+
return message;
|
|
1503
|
+
},
|
|
1504
|
+
};
|
|
1505
|
+
function createBaseDeleteTriggerRequest() {
|
|
1506
|
+
return { id: "" };
|
|
1507
|
+
}
|
|
1508
|
+
exports.DeleteTriggerRequest = {
|
|
1509
|
+
encode(message, writer = new wire_1.BinaryWriter()) {
|
|
1510
|
+
if (message.id !== "") {
|
|
1511
|
+
writer.uint32(10).string(message.id);
|
|
1512
|
+
}
|
|
1513
|
+
return writer;
|
|
1514
|
+
},
|
|
1515
|
+
decode(input, length) {
|
|
1516
|
+
const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
|
|
1517
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
1518
|
+
if (previousRecursionDepth >= 100) {
|
|
1519
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
1520
|
+
}
|
|
1521
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
1522
|
+
try {
|
|
1523
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
1524
|
+
const message = createBaseDeleteTriggerRequest();
|
|
1525
|
+
while (reader.pos < end) {
|
|
1526
|
+
const tag = reader.uint32();
|
|
1527
|
+
switch (tag >>> 3) {
|
|
1528
|
+
case 1: {
|
|
1529
|
+
if (tag !== 10) {
|
|
1530
|
+
break;
|
|
1531
|
+
}
|
|
1532
|
+
message.id = reader.string();
|
|
1533
|
+
continue;
|
|
1534
|
+
}
|
|
1535
|
+
}
|
|
1536
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
1537
|
+
break;
|
|
1538
|
+
}
|
|
1539
|
+
reader.skip(tag & 7);
|
|
1540
|
+
}
|
|
1541
|
+
return message;
|
|
1542
|
+
}
|
|
1543
|
+
finally {
|
|
1544
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
1545
|
+
}
|
|
1546
|
+
},
|
|
1547
|
+
create(base) {
|
|
1548
|
+
return exports.DeleteTriggerRequest.fromPartial(base ?? {});
|
|
1549
|
+
},
|
|
1550
|
+
fromPartial(object) {
|
|
1551
|
+
const message = createBaseDeleteTriggerRequest();
|
|
1552
|
+
message.id = object.id ?? "";
|
|
1553
|
+
return message;
|
|
1554
|
+
},
|
|
1555
|
+
};
|
|
1556
|
+
function createBaseAlarm() {
|
|
1557
|
+
return {
|
|
1558
|
+
id: 0,
|
|
1559
|
+
satelliteId: "",
|
|
1560
|
+
time: "",
|
|
1561
|
+
weekdays: [],
|
|
1562
|
+
skipDates: [],
|
|
1563
|
+
oneShotDate: "",
|
|
1564
|
+
enabled: false,
|
|
1565
|
+
label: "",
|
|
1566
|
+
userId: 0,
|
|
1567
|
+
};
|
|
1568
|
+
}
|
|
1569
|
+
exports.Alarm = {
|
|
1570
|
+
encode(message, writer = new wire_1.BinaryWriter()) {
|
|
1571
|
+
if (message.id !== 0) {
|
|
1572
|
+
writer.uint32(8).int32(message.id);
|
|
1573
|
+
}
|
|
1574
|
+
if (message.satelliteId !== "") {
|
|
1575
|
+
writer.uint32(18).string(message.satelliteId);
|
|
1576
|
+
}
|
|
1577
|
+
if (message.time !== "") {
|
|
1578
|
+
writer.uint32(26).string(message.time);
|
|
1579
|
+
}
|
|
1580
|
+
writer.uint32(34).fork();
|
|
1581
|
+
for (const v of message.weekdays) {
|
|
1582
|
+
writer.int32(v);
|
|
1583
|
+
}
|
|
1584
|
+
writer.join();
|
|
1585
|
+
for (const v of message.skipDates) {
|
|
1586
|
+
writer.uint32(42).string(v);
|
|
1587
|
+
}
|
|
1588
|
+
if (message.oneShotDate !== "") {
|
|
1589
|
+
writer.uint32(50).string(message.oneShotDate);
|
|
1590
|
+
}
|
|
1591
|
+
if (message.enabled !== false) {
|
|
1592
|
+
writer.uint32(56).bool(message.enabled);
|
|
1593
|
+
}
|
|
1594
|
+
if (message.label !== "") {
|
|
1595
|
+
writer.uint32(66).string(message.label);
|
|
1596
|
+
}
|
|
1597
|
+
if (message.userId !== 0) {
|
|
1598
|
+
writer.uint32(72).int32(message.userId);
|
|
1599
|
+
}
|
|
1600
|
+
return writer;
|
|
1601
|
+
},
|
|
1602
|
+
decode(input, length) {
|
|
1603
|
+
const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
|
|
1604
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
1605
|
+
if (previousRecursionDepth >= 100) {
|
|
1606
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
1607
|
+
}
|
|
1608
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
1609
|
+
try {
|
|
1610
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
1611
|
+
const message = createBaseAlarm();
|
|
1612
|
+
while (reader.pos < end) {
|
|
1613
|
+
const tag = reader.uint32();
|
|
1614
|
+
switch (tag >>> 3) {
|
|
1615
|
+
case 1: {
|
|
1616
|
+
if (tag !== 8) {
|
|
1617
|
+
break;
|
|
1618
|
+
}
|
|
1619
|
+
message.id = reader.int32();
|
|
1620
|
+
continue;
|
|
1621
|
+
}
|
|
1622
|
+
case 2: {
|
|
1623
|
+
if (tag !== 18) {
|
|
1624
|
+
break;
|
|
1625
|
+
}
|
|
1626
|
+
message.satelliteId = reader.string();
|
|
1627
|
+
continue;
|
|
1628
|
+
}
|
|
1629
|
+
case 3: {
|
|
1630
|
+
if (tag !== 26) {
|
|
1631
|
+
break;
|
|
1632
|
+
}
|
|
1633
|
+
message.time = reader.string();
|
|
1634
|
+
continue;
|
|
1635
|
+
}
|
|
1636
|
+
case 4: {
|
|
1637
|
+
if (tag === 32) {
|
|
1638
|
+
message.weekdays.push(reader.int32());
|
|
1639
|
+
continue;
|
|
1640
|
+
}
|
|
1641
|
+
if (tag === 34) {
|
|
1642
|
+
const end2 = reader.uint32() + reader.pos;
|
|
1643
|
+
while (reader.pos < end2) {
|
|
1644
|
+
message.weekdays.push(reader.int32());
|
|
1645
|
+
}
|
|
1646
|
+
continue;
|
|
1647
|
+
}
|
|
1648
|
+
break;
|
|
1649
|
+
}
|
|
1650
|
+
case 5: {
|
|
1651
|
+
if (tag !== 42) {
|
|
1652
|
+
break;
|
|
1653
|
+
}
|
|
1654
|
+
message.skipDates.push(reader.string());
|
|
1655
|
+
continue;
|
|
1656
|
+
}
|
|
1657
|
+
case 6: {
|
|
1658
|
+
if (tag !== 50) {
|
|
1659
|
+
break;
|
|
1660
|
+
}
|
|
1661
|
+
message.oneShotDate = reader.string();
|
|
1662
|
+
continue;
|
|
1663
|
+
}
|
|
1664
|
+
case 7: {
|
|
1665
|
+
if (tag !== 56) {
|
|
1666
|
+
break;
|
|
1667
|
+
}
|
|
1668
|
+
message.enabled = reader.bool();
|
|
1669
|
+
continue;
|
|
1670
|
+
}
|
|
1671
|
+
case 8: {
|
|
1672
|
+
if (tag !== 66) {
|
|
1673
|
+
break;
|
|
1674
|
+
}
|
|
1675
|
+
message.label = reader.string();
|
|
1676
|
+
continue;
|
|
1677
|
+
}
|
|
1678
|
+
case 9: {
|
|
1679
|
+
if (tag !== 72) {
|
|
1680
|
+
break;
|
|
1681
|
+
}
|
|
1682
|
+
message.userId = reader.int32();
|
|
1683
|
+
continue;
|
|
1684
|
+
}
|
|
1685
|
+
}
|
|
1686
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
1687
|
+
break;
|
|
1688
|
+
}
|
|
1689
|
+
reader.skip(tag & 7);
|
|
1690
|
+
}
|
|
1691
|
+
return message;
|
|
1692
|
+
}
|
|
1693
|
+
finally {
|
|
1694
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
1695
|
+
}
|
|
1696
|
+
},
|
|
1697
|
+
create(base) {
|
|
1698
|
+
return exports.Alarm.fromPartial(base ?? {});
|
|
1699
|
+
},
|
|
1700
|
+
fromPartial(object) {
|
|
1701
|
+
const message = createBaseAlarm();
|
|
1702
|
+
message.id = object.id ?? 0;
|
|
1703
|
+
message.satelliteId = object.satelliteId ?? "";
|
|
1704
|
+
message.time = object.time ?? "";
|
|
1705
|
+
message.weekdays = object.weekdays?.map((e) => e) || [];
|
|
1706
|
+
message.skipDates = object.skipDates?.map((e) => e) || [];
|
|
1707
|
+
message.oneShotDate = object.oneShotDate ?? "";
|
|
1708
|
+
message.enabled = object.enabled ?? false;
|
|
1709
|
+
message.label = object.label ?? "";
|
|
1710
|
+
message.userId = object.userId ?? 0;
|
|
1711
|
+
return message;
|
|
1712
|
+
},
|
|
1713
|
+
};
|
|
1714
|
+
function createBaseGetAlarmsResponse() {
|
|
1715
|
+
return { alarms: [] };
|
|
1716
|
+
}
|
|
1717
|
+
exports.GetAlarmsResponse = {
|
|
1718
|
+
encode(message, writer = new wire_1.BinaryWriter()) {
|
|
1719
|
+
for (const v of message.alarms) {
|
|
1720
|
+
exports.Alarm.encode(v, writer.uint32(10).fork()).join();
|
|
1721
|
+
}
|
|
1722
|
+
return writer;
|
|
1723
|
+
},
|
|
1724
|
+
decode(input, length) {
|
|
1725
|
+
const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
|
|
1726
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
1727
|
+
if (previousRecursionDepth >= 100) {
|
|
1728
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
1729
|
+
}
|
|
1730
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
1731
|
+
try {
|
|
1732
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
1733
|
+
const message = createBaseGetAlarmsResponse();
|
|
1734
|
+
while (reader.pos < end) {
|
|
1735
|
+
const tag = reader.uint32();
|
|
1736
|
+
switch (tag >>> 3) {
|
|
1737
|
+
case 1: {
|
|
1738
|
+
if (tag !== 10) {
|
|
1739
|
+
break;
|
|
1740
|
+
}
|
|
1741
|
+
message.alarms.push(exports.Alarm.decode(reader, reader.uint32()));
|
|
1742
|
+
continue;
|
|
1743
|
+
}
|
|
1744
|
+
}
|
|
1745
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
1746
|
+
break;
|
|
1747
|
+
}
|
|
1748
|
+
reader.skip(tag & 7);
|
|
1749
|
+
}
|
|
1750
|
+
return message;
|
|
1751
|
+
}
|
|
1752
|
+
finally {
|
|
1753
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
1754
|
+
}
|
|
1755
|
+
},
|
|
1756
|
+
create(base) {
|
|
1757
|
+
return exports.GetAlarmsResponse.fromPartial(base ?? {});
|
|
1758
|
+
},
|
|
1759
|
+
fromPartial(object) {
|
|
1760
|
+
const message = createBaseGetAlarmsResponse();
|
|
1761
|
+
message.alarms = object.alarms?.map((e) => exports.Alarm.fromPartial(e)) || [];
|
|
1762
|
+
return message;
|
|
1763
|
+
},
|
|
1764
|
+
};
|
|
1765
|
+
function createBaseCreateAlarmRequest() {
|
|
1766
|
+
return { satelliteId: "", time: "", weekdays: [], oneShotDate: "", label: "", userId: 0 };
|
|
1767
|
+
}
|
|
1768
|
+
exports.CreateAlarmRequest = {
|
|
1769
|
+
encode(message, writer = new wire_1.BinaryWriter()) {
|
|
1770
|
+
if (message.satelliteId !== "") {
|
|
1771
|
+
writer.uint32(10).string(message.satelliteId);
|
|
1772
|
+
}
|
|
1773
|
+
if (message.time !== "") {
|
|
1774
|
+
writer.uint32(18).string(message.time);
|
|
1775
|
+
}
|
|
1776
|
+
writer.uint32(26).fork();
|
|
1777
|
+
for (const v of message.weekdays) {
|
|
1778
|
+
writer.int32(v);
|
|
1779
|
+
}
|
|
1780
|
+
writer.join();
|
|
1781
|
+
if (message.oneShotDate !== "") {
|
|
1782
|
+
writer.uint32(34).string(message.oneShotDate);
|
|
1783
|
+
}
|
|
1784
|
+
if (message.label !== "") {
|
|
1785
|
+
writer.uint32(42).string(message.label);
|
|
1786
|
+
}
|
|
1787
|
+
if (message.userId !== 0) {
|
|
1788
|
+
writer.uint32(48).int32(message.userId);
|
|
1789
|
+
}
|
|
1790
|
+
return writer;
|
|
1791
|
+
},
|
|
1792
|
+
decode(input, length) {
|
|
1793
|
+
const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
|
|
1794
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
1795
|
+
if (previousRecursionDepth >= 100) {
|
|
1796
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
1797
|
+
}
|
|
1798
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
1799
|
+
try {
|
|
1800
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
1801
|
+
const message = createBaseCreateAlarmRequest();
|
|
1802
|
+
while (reader.pos < end) {
|
|
1803
|
+
const tag = reader.uint32();
|
|
1804
|
+
switch (tag >>> 3) {
|
|
1805
|
+
case 1: {
|
|
1806
|
+
if (tag !== 10) {
|
|
1807
|
+
break;
|
|
1808
|
+
}
|
|
1809
|
+
message.satelliteId = reader.string();
|
|
1810
|
+
continue;
|
|
1811
|
+
}
|
|
1812
|
+
case 2: {
|
|
1813
|
+
if (tag !== 18) {
|
|
1814
|
+
break;
|
|
1815
|
+
}
|
|
1816
|
+
message.time = reader.string();
|
|
1817
|
+
continue;
|
|
1818
|
+
}
|
|
1819
|
+
case 3: {
|
|
1820
|
+
if (tag === 24) {
|
|
1821
|
+
message.weekdays.push(reader.int32());
|
|
1822
|
+
continue;
|
|
1823
|
+
}
|
|
1824
|
+
if (tag === 26) {
|
|
1825
|
+
const end2 = reader.uint32() + reader.pos;
|
|
1826
|
+
while (reader.pos < end2) {
|
|
1827
|
+
message.weekdays.push(reader.int32());
|
|
1828
|
+
}
|
|
1829
|
+
continue;
|
|
1830
|
+
}
|
|
1831
|
+
break;
|
|
1832
|
+
}
|
|
1833
|
+
case 4: {
|
|
1834
|
+
if (tag !== 34) {
|
|
1835
|
+
break;
|
|
1836
|
+
}
|
|
1837
|
+
message.oneShotDate = reader.string();
|
|
1838
|
+
continue;
|
|
1839
|
+
}
|
|
1840
|
+
case 5: {
|
|
1841
|
+
if (tag !== 42) {
|
|
1842
|
+
break;
|
|
1843
|
+
}
|
|
1844
|
+
message.label = reader.string();
|
|
1845
|
+
continue;
|
|
1846
|
+
}
|
|
1847
|
+
case 6: {
|
|
1848
|
+
if (tag !== 48) {
|
|
1849
|
+
break;
|
|
1850
|
+
}
|
|
1851
|
+
message.userId = reader.int32();
|
|
1852
|
+
continue;
|
|
1853
|
+
}
|
|
1854
|
+
}
|
|
1855
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
1856
|
+
break;
|
|
1857
|
+
}
|
|
1858
|
+
reader.skip(tag & 7);
|
|
1859
|
+
}
|
|
1860
|
+
return message;
|
|
1861
|
+
}
|
|
1862
|
+
finally {
|
|
1863
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
1864
|
+
}
|
|
1865
|
+
},
|
|
1866
|
+
create(base) {
|
|
1867
|
+
return exports.CreateAlarmRequest.fromPartial(base ?? {});
|
|
1868
|
+
},
|
|
1869
|
+
fromPartial(object) {
|
|
1870
|
+
const message = createBaseCreateAlarmRequest();
|
|
1871
|
+
message.satelliteId = object.satelliteId ?? "";
|
|
1872
|
+
message.time = object.time ?? "";
|
|
1873
|
+
message.weekdays = object.weekdays?.map((e) => e) || [];
|
|
1874
|
+
message.oneShotDate = object.oneShotDate ?? "";
|
|
1875
|
+
message.label = object.label ?? "";
|
|
1876
|
+
message.userId = object.userId ?? 0;
|
|
1877
|
+
return message;
|
|
1878
|
+
},
|
|
1879
|
+
};
|
|
1880
|
+
function createBaseCreateAlarmResponse() {
|
|
1881
|
+
return { ok: false, id: 0, message: "" };
|
|
1882
|
+
}
|
|
1883
|
+
exports.CreateAlarmResponse = {
|
|
1884
|
+
encode(message, writer = new wire_1.BinaryWriter()) {
|
|
1885
|
+
if (message.ok !== false) {
|
|
1886
|
+
writer.uint32(8).bool(message.ok);
|
|
1887
|
+
}
|
|
1888
|
+
if (message.id !== 0) {
|
|
1889
|
+
writer.uint32(16).int32(message.id);
|
|
1890
|
+
}
|
|
1891
|
+
if (message.message !== "") {
|
|
1892
|
+
writer.uint32(26).string(message.message);
|
|
1893
|
+
}
|
|
1894
|
+
return writer;
|
|
1895
|
+
},
|
|
1896
|
+
decode(input, length) {
|
|
1897
|
+
const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
|
|
1898
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
1899
|
+
if (previousRecursionDepth >= 100) {
|
|
1900
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
1901
|
+
}
|
|
1902
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
1903
|
+
try {
|
|
1904
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
1905
|
+
const message = createBaseCreateAlarmResponse();
|
|
1906
|
+
while (reader.pos < end) {
|
|
1907
|
+
const tag = reader.uint32();
|
|
1908
|
+
switch (tag >>> 3) {
|
|
1909
|
+
case 1: {
|
|
1910
|
+
if (tag !== 8) {
|
|
1911
|
+
break;
|
|
1912
|
+
}
|
|
1913
|
+
message.ok = reader.bool();
|
|
1914
|
+
continue;
|
|
1915
|
+
}
|
|
1916
|
+
case 2: {
|
|
1917
|
+
if (tag !== 16) {
|
|
1918
|
+
break;
|
|
1919
|
+
}
|
|
1920
|
+
message.id = reader.int32();
|
|
1921
|
+
continue;
|
|
1922
|
+
}
|
|
1923
|
+
case 3: {
|
|
1924
|
+
if (tag !== 26) {
|
|
1925
|
+
break;
|
|
1926
|
+
}
|
|
1927
|
+
message.message = reader.string();
|
|
1928
|
+
continue;
|
|
1929
|
+
}
|
|
1930
|
+
}
|
|
1931
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
1932
|
+
break;
|
|
1933
|
+
}
|
|
1934
|
+
reader.skip(tag & 7);
|
|
1935
|
+
}
|
|
1936
|
+
return message;
|
|
1937
|
+
}
|
|
1938
|
+
finally {
|
|
1939
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
1940
|
+
}
|
|
1941
|
+
},
|
|
1942
|
+
create(base) {
|
|
1943
|
+
return exports.CreateAlarmResponse.fromPartial(base ?? {});
|
|
1944
|
+
},
|
|
1945
|
+
fromPartial(object) {
|
|
1946
|
+
const message = createBaseCreateAlarmResponse();
|
|
1947
|
+
message.ok = object.ok ?? false;
|
|
1948
|
+
message.id = object.id ?? 0;
|
|
1949
|
+
message.message = object.message ?? "";
|
|
1950
|
+
return message;
|
|
1951
|
+
},
|
|
1952
|
+
};
|
|
1953
|
+
function createBaseUpdateAlarmRequest() {
|
|
1954
|
+
return { id: 0, satelliteId: "", time: "", weekdays: [], skipDates: [], oneShotDate: "", enabled: false, label: "" };
|
|
1955
|
+
}
|
|
1956
|
+
exports.UpdateAlarmRequest = {
|
|
1957
|
+
encode(message, writer = new wire_1.BinaryWriter()) {
|
|
1958
|
+
if (message.id !== 0) {
|
|
1959
|
+
writer.uint32(8).int32(message.id);
|
|
1960
|
+
}
|
|
1961
|
+
if (message.satelliteId !== "") {
|
|
1962
|
+
writer.uint32(18).string(message.satelliteId);
|
|
1963
|
+
}
|
|
1964
|
+
if (message.time !== "") {
|
|
1965
|
+
writer.uint32(26).string(message.time);
|
|
1966
|
+
}
|
|
1967
|
+
writer.uint32(34).fork();
|
|
1968
|
+
for (const v of message.weekdays) {
|
|
1969
|
+
writer.int32(v);
|
|
1970
|
+
}
|
|
1971
|
+
writer.join();
|
|
1972
|
+
for (const v of message.skipDates) {
|
|
1973
|
+
writer.uint32(42).string(v);
|
|
1974
|
+
}
|
|
1975
|
+
if (message.oneShotDate !== "") {
|
|
1976
|
+
writer.uint32(50).string(message.oneShotDate);
|
|
1977
|
+
}
|
|
1978
|
+
if (message.enabled !== false) {
|
|
1979
|
+
writer.uint32(56).bool(message.enabled);
|
|
1980
|
+
}
|
|
1981
|
+
if (message.label !== "") {
|
|
1982
|
+
writer.uint32(66).string(message.label);
|
|
1983
|
+
}
|
|
1984
|
+
return writer;
|
|
1985
|
+
},
|
|
1986
|
+
decode(input, length) {
|
|
1987
|
+
const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
|
|
1988
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
1989
|
+
if (previousRecursionDepth >= 100) {
|
|
1990
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
1991
|
+
}
|
|
1992
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
1993
|
+
try {
|
|
1994
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
1995
|
+
const message = createBaseUpdateAlarmRequest();
|
|
1996
|
+
while (reader.pos < end) {
|
|
1997
|
+
const tag = reader.uint32();
|
|
1998
|
+
switch (tag >>> 3) {
|
|
1999
|
+
case 1: {
|
|
2000
|
+
if (tag !== 8) {
|
|
2001
|
+
break;
|
|
2002
|
+
}
|
|
2003
|
+
message.id = reader.int32();
|
|
2004
|
+
continue;
|
|
2005
|
+
}
|
|
2006
|
+
case 2: {
|
|
2007
|
+
if (tag !== 18) {
|
|
2008
|
+
break;
|
|
2009
|
+
}
|
|
2010
|
+
message.satelliteId = reader.string();
|
|
2011
|
+
continue;
|
|
2012
|
+
}
|
|
2013
|
+
case 3: {
|
|
2014
|
+
if (tag !== 26) {
|
|
2015
|
+
break;
|
|
2016
|
+
}
|
|
2017
|
+
message.time = reader.string();
|
|
2018
|
+
continue;
|
|
2019
|
+
}
|
|
2020
|
+
case 4: {
|
|
2021
|
+
if (tag === 32) {
|
|
2022
|
+
message.weekdays.push(reader.int32());
|
|
2023
|
+
continue;
|
|
2024
|
+
}
|
|
2025
|
+
if (tag === 34) {
|
|
2026
|
+
const end2 = reader.uint32() + reader.pos;
|
|
2027
|
+
while (reader.pos < end2) {
|
|
2028
|
+
message.weekdays.push(reader.int32());
|
|
2029
|
+
}
|
|
2030
|
+
continue;
|
|
2031
|
+
}
|
|
2032
|
+
break;
|
|
2033
|
+
}
|
|
2034
|
+
case 5: {
|
|
2035
|
+
if (tag !== 42) {
|
|
2036
|
+
break;
|
|
2037
|
+
}
|
|
2038
|
+
message.skipDates.push(reader.string());
|
|
2039
|
+
continue;
|
|
2040
|
+
}
|
|
2041
|
+
case 6: {
|
|
2042
|
+
if (tag !== 50) {
|
|
2043
|
+
break;
|
|
2044
|
+
}
|
|
2045
|
+
message.oneShotDate = reader.string();
|
|
2046
|
+
continue;
|
|
2047
|
+
}
|
|
2048
|
+
case 7: {
|
|
2049
|
+
if (tag !== 56) {
|
|
2050
|
+
break;
|
|
2051
|
+
}
|
|
2052
|
+
message.enabled = reader.bool();
|
|
2053
|
+
continue;
|
|
2054
|
+
}
|
|
2055
|
+
case 8: {
|
|
2056
|
+
if (tag !== 66) {
|
|
2057
|
+
break;
|
|
2058
|
+
}
|
|
2059
|
+
message.label = reader.string();
|
|
2060
|
+
continue;
|
|
2061
|
+
}
|
|
2062
|
+
}
|
|
2063
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
2064
|
+
break;
|
|
2065
|
+
}
|
|
2066
|
+
reader.skip(tag & 7);
|
|
2067
|
+
}
|
|
2068
|
+
return message;
|
|
2069
|
+
}
|
|
2070
|
+
finally {
|
|
2071
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
2072
|
+
}
|
|
2073
|
+
},
|
|
2074
|
+
create(base) {
|
|
2075
|
+
return exports.UpdateAlarmRequest.fromPartial(base ?? {});
|
|
2076
|
+
},
|
|
2077
|
+
fromPartial(object) {
|
|
2078
|
+
const message = createBaseUpdateAlarmRequest();
|
|
2079
|
+
message.id = object.id ?? 0;
|
|
2080
|
+
message.satelliteId = object.satelliteId ?? "";
|
|
2081
|
+
message.time = object.time ?? "";
|
|
2082
|
+
message.weekdays = object.weekdays?.map((e) => e) || [];
|
|
2083
|
+
message.skipDates = object.skipDates?.map((e) => e) || [];
|
|
2084
|
+
message.oneShotDate = object.oneShotDate ?? "";
|
|
2085
|
+
message.enabled = object.enabled ?? false;
|
|
2086
|
+
message.label = object.label ?? "";
|
|
2087
|
+
return message;
|
|
2088
|
+
},
|
|
2089
|
+
};
|
|
2090
|
+
function createBaseDeleteAlarmRequest() {
|
|
2091
|
+
return { id: 0 };
|
|
2092
|
+
}
|
|
2093
|
+
exports.DeleteAlarmRequest = {
|
|
2094
|
+
encode(message, writer = new wire_1.BinaryWriter()) {
|
|
2095
|
+
if (message.id !== 0) {
|
|
2096
|
+
writer.uint32(8).int32(message.id);
|
|
2097
|
+
}
|
|
2098
|
+
return writer;
|
|
2099
|
+
},
|
|
2100
|
+
decode(input, length) {
|
|
2101
|
+
const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
|
|
2102
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
2103
|
+
if (previousRecursionDepth >= 100) {
|
|
2104
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
2105
|
+
}
|
|
2106
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
2107
|
+
try {
|
|
2108
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
2109
|
+
const message = createBaseDeleteAlarmRequest();
|
|
2110
|
+
while (reader.pos < end) {
|
|
2111
|
+
const tag = reader.uint32();
|
|
2112
|
+
switch (tag >>> 3) {
|
|
2113
|
+
case 1: {
|
|
2114
|
+
if (tag !== 8) {
|
|
2115
|
+
break;
|
|
2116
|
+
}
|
|
2117
|
+
message.id = reader.int32();
|
|
2118
|
+
continue;
|
|
2119
|
+
}
|
|
2120
|
+
}
|
|
2121
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
2122
|
+
break;
|
|
2123
|
+
}
|
|
2124
|
+
reader.skip(tag & 7);
|
|
2125
|
+
}
|
|
2126
|
+
return message;
|
|
2127
|
+
}
|
|
2128
|
+
finally {
|
|
2129
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
2130
|
+
}
|
|
2131
|
+
},
|
|
2132
|
+
create(base) {
|
|
2133
|
+
return exports.DeleteAlarmRequest.fromPartial(base ?? {});
|
|
2134
|
+
},
|
|
2135
|
+
fromPartial(object) {
|
|
2136
|
+
const message = createBaseDeleteAlarmRequest();
|
|
2137
|
+
message.id = object.id ?? 0;
|
|
2138
|
+
return message;
|
|
2139
|
+
},
|
|
2140
|
+
};
|
|
2141
|
+
function createBaseCategory() {
|
|
2142
|
+
return { id: 0, name: "", parentId: 0 };
|
|
2143
|
+
}
|
|
2144
|
+
exports.Category = {
|
|
2145
|
+
encode(message, writer = new wire_1.BinaryWriter()) {
|
|
2146
|
+
if (message.id !== 0) {
|
|
2147
|
+
writer.uint32(8).int32(message.id);
|
|
2148
|
+
}
|
|
2149
|
+
if (message.name !== "") {
|
|
2150
|
+
writer.uint32(18).string(message.name);
|
|
2151
|
+
}
|
|
2152
|
+
if (message.parentId !== 0) {
|
|
2153
|
+
writer.uint32(24).int32(message.parentId);
|
|
2154
|
+
}
|
|
2155
|
+
return writer;
|
|
2156
|
+
},
|
|
2157
|
+
decode(input, length) {
|
|
2158
|
+
const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
|
|
2159
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
2160
|
+
if (previousRecursionDepth >= 100) {
|
|
2161
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
2162
|
+
}
|
|
2163
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
2164
|
+
try {
|
|
2165
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
2166
|
+
const message = createBaseCategory();
|
|
2167
|
+
while (reader.pos < end) {
|
|
2168
|
+
const tag = reader.uint32();
|
|
2169
|
+
switch (tag >>> 3) {
|
|
2170
|
+
case 1: {
|
|
2171
|
+
if (tag !== 8) {
|
|
2172
|
+
break;
|
|
2173
|
+
}
|
|
2174
|
+
message.id = reader.int32();
|
|
2175
|
+
continue;
|
|
2176
|
+
}
|
|
2177
|
+
case 2: {
|
|
2178
|
+
if (tag !== 18) {
|
|
2179
|
+
break;
|
|
2180
|
+
}
|
|
2181
|
+
message.name = reader.string();
|
|
2182
|
+
continue;
|
|
2183
|
+
}
|
|
2184
|
+
case 3: {
|
|
2185
|
+
if (tag !== 24) {
|
|
2186
|
+
break;
|
|
2187
|
+
}
|
|
2188
|
+
message.parentId = reader.int32();
|
|
2189
|
+
continue;
|
|
2190
|
+
}
|
|
2191
|
+
}
|
|
2192
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
2193
|
+
break;
|
|
2194
|
+
}
|
|
2195
|
+
reader.skip(tag & 7);
|
|
2196
|
+
}
|
|
2197
|
+
return message;
|
|
2198
|
+
}
|
|
2199
|
+
finally {
|
|
2200
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
2201
|
+
}
|
|
2202
|
+
},
|
|
2203
|
+
create(base) {
|
|
2204
|
+
return exports.Category.fromPartial(base ?? {});
|
|
2205
|
+
},
|
|
2206
|
+
fromPartial(object) {
|
|
2207
|
+
const message = createBaseCategory();
|
|
2208
|
+
message.id = object.id ?? 0;
|
|
2209
|
+
message.name = object.name ?? "";
|
|
2210
|
+
message.parentId = object.parentId ?? 0;
|
|
2211
|
+
return message;
|
|
2212
|
+
},
|
|
2213
|
+
};
|
|
2214
|
+
function createBaseSetting() {
|
|
2215
|
+
return { id: 0, categoryId: 0, name: "", value: "" };
|
|
2216
|
+
}
|
|
2217
|
+
exports.Setting = {
|
|
2218
|
+
encode(message, writer = new wire_1.BinaryWriter()) {
|
|
2219
|
+
if (message.id !== 0) {
|
|
2220
|
+
writer.uint32(8).int32(message.id);
|
|
2221
|
+
}
|
|
2222
|
+
if (message.categoryId !== 0) {
|
|
2223
|
+
writer.uint32(16).int32(message.categoryId);
|
|
2224
|
+
}
|
|
2225
|
+
if (message.name !== "") {
|
|
2226
|
+
writer.uint32(26).string(message.name);
|
|
2227
|
+
}
|
|
2228
|
+
if (message.value !== "") {
|
|
2229
|
+
writer.uint32(34).string(message.value);
|
|
2230
|
+
}
|
|
2231
|
+
return writer;
|
|
2232
|
+
},
|
|
2233
|
+
decode(input, length) {
|
|
2234
|
+
const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
|
|
2235
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
2236
|
+
if (previousRecursionDepth >= 100) {
|
|
2237
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
2238
|
+
}
|
|
2239
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
2240
|
+
try {
|
|
2241
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
2242
|
+
const message = createBaseSetting();
|
|
2243
|
+
while (reader.pos < end) {
|
|
2244
|
+
const tag = reader.uint32();
|
|
2245
|
+
switch (tag >>> 3) {
|
|
2246
|
+
case 1: {
|
|
2247
|
+
if (tag !== 8) {
|
|
2248
|
+
break;
|
|
2249
|
+
}
|
|
2250
|
+
message.id = reader.int32();
|
|
2251
|
+
continue;
|
|
2252
|
+
}
|
|
2253
|
+
case 2: {
|
|
2254
|
+
if (tag !== 16) {
|
|
2255
|
+
break;
|
|
2256
|
+
}
|
|
2257
|
+
message.categoryId = reader.int32();
|
|
2258
|
+
continue;
|
|
2259
|
+
}
|
|
2260
|
+
case 3: {
|
|
2261
|
+
if (tag !== 26) {
|
|
2262
|
+
break;
|
|
2263
|
+
}
|
|
2264
|
+
message.name = reader.string();
|
|
2265
|
+
continue;
|
|
2266
|
+
}
|
|
2267
|
+
case 4: {
|
|
2268
|
+
if (tag !== 34) {
|
|
2269
|
+
break;
|
|
2270
|
+
}
|
|
2271
|
+
message.value = reader.string();
|
|
2272
|
+
continue;
|
|
2273
|
+
}
|
|
2274
|
+
}
|
|
2275
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
2276
|
+
break;
|
|
2277
|
+
}
|
|
2278
|
+
reader.skip(tag & 7);
|
|
2279
|
+
}
|
|
2280
|
+
return message;
|
|
2281
|
+
}
|
|
2282
|
+
finally {
|
|
2283
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
2284
|
+
}
|
|
2285
|
+
},
|
|
2286
|
+
create(base) {
|
|
2287
|
+
return exports.Setting.fromPartial(base ?? {});
|
|
2288
|
+
},
|
|
2289
|
+
fromPartial(object) {
|
|
2290
|
+
const message = createBaseSetting();
|
|
2291
|
+
message.id = object.id ?? 0;
|
|
2292
|
+
message.categoryId = object.categoryId ?? 0;
|
|
2293
|
+
message.name = object.name ?? "";
|
|
2294
|
+
message.value = object.value ?? "";
|
|
2295
|
+
return message;
|
|
2296
|
+
},
|
|
2297
|
+
};
|
|
2298
|
+
function createBaseGetSettingsResponse() {
|
|
2299
|
+
return { categories: [], settings: [] };
|
|
2300
|
+
}
|
|
2301
|
+
exports.GetSettingsResponse = {
|
|
2302
|
+
encode(message, writer = new wire_1.BinaryWriter()) {
|
|
2303
|
+
for (const v of message.categories) {
|
|
2304
|
+
exports.Category.encode(v, writer.uint32(10).fork()).join();
|
|
2305
|
+
}
|
|
2306
|
+
for (const v of message.settings) {
|
|
2307
|
+
exports.Setting.encode(v, writer.uint32(18).fork()).join();
|
|
2308
|
+
}
|
|
2309
|
+
return writer;
|
|
2310
|
+
},
|
|
2311
|
+
decode(input, length) {
|
|
2312
|
+
const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
|
|
2313
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
2314
|
+
if (previousRecursionDepth >= 100) {
|
|
2315
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
2316
|
+
}
|
|
2317
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
2318
|
+
try {
|
|
2319
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
2320
|
+
const message = createBaseGetSettingsResponse();
|
|
2321
|
+
while (reader.pos < end) {
|
|
2322
|
+
const tag = reader.uint32();
|
|
2323
|
+
switch (tag >>> 3) {
|
|
2324
|
+
case 1: {
|
|
2325
|
+
if (tag !== 10) {
|
|
2326
|
+
break;
|
|
2327
|
+
}
|
|
2328
|
+
message.categories.push(exports.Category.decode(reader, reader.uint32()));
|
|
2329
|
+
continue;
|
|
2330
|
+
}
|
|
2331
|
+
case 2: {
|
|
2332
|
+
if (tag !== 18) {
|
|
2333
|
+
break;
|
|
2334
|
+
}
|
|
2335
|
+
message.settings.push(exports.Setting.decode(reader, reader.uint32()));
|
|
2336
|
+
continue;
|
|
2337
|
+
}
|
|
2338
|
+
}
|
|
2339
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
2340
|
+
break;
|
|
2341
|
+
}
|
|
2342
|
+
reader.skip(tag & 7);
|
|
2343
|
+
}
|
|
2344
|
+
return message;
|
|
2345
|
+
}
|
|
2346
|
+
finally {
|
|
2347
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
2348
|
+
}
|
|
2349
|
+
},
|
|
2350
|
+
create(base) {
|
|
2351
|
+
return exports.GetSettingsResponse.fromPartial(base ?? {});
|
|
2352
|
+
},
|
|
2353
|
+
fromPartial(object) {
|
|
2354
|
+
const message = createBaseGetSettingsResponse();
|
|
2355
|
+
message.categories = object.categories?.map((e) => exports.Category.fromPartial(e)) || [];
|
|
2356
|
+
message.settings = object.settings?.map((e) => exports.Setting.fromPartial(e)) || [];
|
|
2357
|
+
return message;
|
|
2358
|
+
},
|
|
2359
|
+
};
|
|
2360
|
+
function createBaseSettingUpdate() {
|
|
2361
|
+
return { settingId: 0, value: "" };
|
|
2362
|
+
}
|
|
2363
|
+
exports.SettingUpdate = {
|
|
2364
|
+
encode(message, writer = new wire_1.BinaryWriter()) {
|
|
2365
|
+
if (message.settingId !== 0) {
|
|
2366
|
+
writer.uint32(8).int32(message.settingId);
|
|
2367
|
+
}
|
|
2368
|
+
if (message.value !== "") {
|
|
2369
|
+
writer.uint32(18).string(message.value);
|
|
2370
|
+
}
|
|
2371
|
+
return writer;
|
|
2372
|
+
},
|
|
2373
|
+
decode(input, length) {
|
|
2374
|
+
const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
|
|
2375
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
2376
|
+
if (previousRecursionDepth >= 100) {
|
|
2377
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
2378
|
+
}
|
|
2379
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
2380
|
+
try {
|
|
2381
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
2382
|
+
const message = createBaseSettingUpdate();
|
|
2383
|
+
while (reader.pos < end) {
|
|
2384
|
+
const tag = reader.uint32();
|
|
2385
|
+
switch (tag >>> 3) {
|
|
2386
|
+
case 1: {
|
|
2387
|
+
if (tag !== 8) {
|
|
2388
|
+
break;
|
|
2389
|
+
}
|
|
2390
|
+
message.settingId = reader.int32();
|
|
2391
|
+
continue;
|
|
2392
|
+
}
|
|
2393
|
+
case 2: {
|
|
2394
|
+
if (tag !== 18) {
|
|
2395
|
+
break;
|
|
2396
|
+
}
|
|
2397
|
+
message.value = reader.string();
|
|
2398
|
+
continue;
|
|
2399
|
+
}
|
|
2400
|
+
}
|
|
2401
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
2402
|
+
break;
|
|
2403
|
+
}
|
|
2404
|
+
reader.skip(tag & 7);
|
|
2405
|
+
}
|
|
2406
|
+
return message;
|
|
2407
|
+
}
|
|
2408
|
+
finally {
|
|
2409
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
2410
|
+
}
|
|
2411
|
+
},
|
|
2412
|
+
create(base) {
|
|
2413
|
+
return exports.SettingUpdate.fromPartial(base ?? {});
|
|
2414
|
+
},
|
|
2415
|
+
fromPartial(object) {
|
|
2416
|
+
const message = createBaseSettingUpdate();
|
|
2417
|
+
message.settingId = object.settingId ?? 0;
|
|
2418
|
+
message.value = object.value ?? "";
|
|
2419
|
+
return message;
|
|
2420
|
+
},
|
|
2421
|
+
};
|
|
2422
|
+
function createBaseUpdateConfigRequest() {
|
|
2423
|
+
return { updates: [] };
|
|
2424
|
+
}
|
|
2425
|
+
exports.UpdateConfigRequest = {
|
|
2426
|
+
encode(message, writer = new wire_1.BinaryWriter()) {
|
|
2427
|
+
for (const v of message.updates) {
|
|
2428
|
+
exports.SettingUpdate.encode(v, writer.uint32(10).fork()).join();
|
|
2429
|
+
}
|
|
2430
|
+
return writer;
|
|
2431
|
+
},
|
|
2432
|
+
decode(input, length) {
|
|
2433
|
+
const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
|
|
2434
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
2435
|
+
if (previousRecursionDepth >= 100) {
|
|
2436
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
2437
|
+
}
|
|
2438
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
2439
|
+
try {
|
|
2440
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
2441
|
+
const message = createBaseUpdateConfigRequest();
|
|
2442
|
+
while (reader.pos < end) {
|
|
2443
|
+
const tag = reader.uint32();
|
|
2444
|
+
switch (tag >>> 3) {
|
|
2445
|
+
case 1: {
|
|
2446
|
+
if (tag !== 10) {
|
|
2447
|
+
break;
|
|
2448
|
+
}
|
|
2449
|
+
message.updates.push(exports.SettingUpdate.decode(reader, reader.uint32()));
|
|
2450
|
+
continue;
|
|
2451
|
+
}
|
|
2452
|
+
}
|
|
2453
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
2454
|
+
break;
|
|
2455
|
+
}
|
|
2456
|
+
reader.skip(tag & 7);
|
|
2457
|
+
}
|
|
2458
|
+
return message;
|
|
2459
|
+
}
|
|
2460
|
+
finally {
|
|
2461
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
2462
|
+
}
|
|
2463
|
+
},
|
|
2464
|
+
create(base) {
|
|
2465
|
+
return exports.UpdateConfigRequest.fromPartial(base ?? {});
|
|
2466
|
+
},
|
|
2467
|
+
fromPartial(object) {
|
|
2468
|
+
const message = createBaseUpdateConfigRequest();
|
|
2469
|
+
message.updates = object.updates?.map((e) => exports.SettingUpdate.fromPartial(e)) || [];
|
|
2470
|
+
return message;
|
|
2471
|
+
},
|
|
2472
|
+
};
|
|
2473
|
+
function createBaseBleTag() {
|
|
2474
|
+
return { id: 0, macAddress: "", label: "", userId: 0 };
|
|
2475
|
+
}
|
|
2476
|
+
exports.BleTag = {
|
|
2477
|
+
encode(message, writer = new wire_1.BinaryWriter()) {
|
|
2478
|
+
if (message.id !== 0) {
|
|
2479
|
+
writer.uint32(8).int32(message.id);
|
|
2480
|
+
}
|
|
2481
|
+
if (message.macAddress !== "") {
|
|
2482
|
+
writer.uint32(18).string(message.macAddress);
|
|
2483
|
+
}
|
|
2484
|
+
if (message.label !== "") {
|
|
2485
|
+
writer.uint32(26).string(message.label);
|
|
2486
|
+
}
|
|
2487
|
+
if (message.userId !== 0) {
|
|
2488
|
+
writer.uint32(32).int32(message.userId);
|
|
2489
|
+
}
|
|
2490
|
+
return writer;
|
|
2491
|
+
},
|
|
2492
|
+
decode(input, length) {
|
|
2493
|
+
const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
|
|
2494
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
2495
|
+
if (previousRecursionDepth >= 100) {
|
|
2496
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
2497
|
+
}
|
|
2498
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
2499
|
+
try {
|
|
2500
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
2501
|
+
const message = createBaseBleTag();
|
|
2502
|
+
while (reader.pos < end) {
|
|
2503
|
+
const tag = reader.uint32();
|
|
2504
|
+
switch (tag >>> 3) {
|
|
2505
|
+
case 1: {
|
|
2506
|
+
if (tag !== 8) {
|
|
2507
|
+
break;
|
|
2508
|
+
}
|
|
2509
|
+
message.id = reader.int32();
|
|
2510
|
+
continue;
|
|
2511
|
+
}
|
|
2512
|
+
case 2: {
|
|
2513
|
+
if (tag !== 18) {
|
|
2514
|
+
break;
|
|
2515
|
+
}
|
|
2516
|
+
message.macAddress = reader.string();
|
|
2517
|
+
continue;
|
|
2518
|
+
}
|
|
2519
|
+
case 3: {
|
|
2520
|
+
if (tag !== 26) {
|
|
2521
|
+
break;
|
|
2522
|
+
}
|
|
2523
|
+
message.label = reader.string();
|
|
2524
|
+
continue;
|
|
2525
|
+
}
|
|
2526
|
+
case 4: {
|
|
2527
|
+
if (tag !== 32) {
|
|
2528
|
+
break;
|
|
2529
|
+
}
|
|
2530
|
+
message.userId = reader.int32();
|
|
2531
|
+
continue;
|
|
2532
|
+
}
|
|
2533
|
+
}
|
|
2534
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
2535
|
+
break;
|
|
2536
|
+
}
|
|
2537
|
+
reader.skip(tag & 7);
|
|
2538
|
+
}
|
|
2539
|
+
return message;
|
|
2540
|
+
}
|
|
2541
|
+
finally {
|
|
2542
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
2543
|
+
}
|
|
2544
|
+
},
|
|
2545
|
+
create(base) {
|
|
2546
|
+
return exports.BleTag.fromPartial(base ?? {});
|
|
2547
|
+
},
|
|
2548
|
+
fromPartial(object) {
|
|
2549
|
+
const message = createBaseBleTag();
|
|
2550
|
+
message.id = object.id ?? 0;
|
|
2551
|
+
message.macAddress = object.macAddress ?? "";
|
|
2552
|
+
message.label = object.label ?? "";
|
|
2553
|
+
message.userId = object.userId ?? 0;
|
|
2554
|
+
return message;
|
|
2555
|
+
},
|
|
2556
|
+
};
|
|
2557
|
+
function createBaseGetBleTagsResponse() {
|
|
2558
|
+
return { tags: [] };
|
|
2559
|
+
}
|
|
2560
|
+
exports.GetBleTagsResponse = {
|
|
2561
|
+
encode(message, writer = new wire_1.BinaryWriter()) {
|
|
2562
|
+
for (const v of message.tags) {
|
|
2563
|
+
exports.BleTag.encode(v, writer.uint32(10).fork()).join();
|
|
2564
|
+
}
|
|
2565
|
+
return writer;
|
|
2566
|
+
},
|
|
2567
|
+
decode(input, length) {
|
|
2568
|
+
const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
|
|
2569
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
2570
|
+
if (previousRecursionDepth >= 100) {
|
|
2571
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
2572
|
+
}
|
|
2573
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
2574
|
+
try {
|
|
2575
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
2576
|
+
const message = createBaseGetBleTagsResponse();
|
|
2577
|
+
while (reader.pos < end) {
|
|
2578
|
+
const tag = reader.uint32();
|
|
2579
|
+
switch (tag >>> 3) {
|
|
2580
|
+
case 1: {
|
|
2581
|
+
if (tag !== 10) {
|
|
2582
|
+
break;
|
|
2583
|
+
}
|
|
2584
|
+
message.tags.push(exports.BleTag.decode(reader, reader.uint32()));
|
|
2585
|
+
continue;
|
|
2586
|
+
}
|
|
2587
|
+
}
|
|
2588
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
2589
|
+
break;
|
|
2590
|
+
}
|
|
2591
|
+
reader.skip(tag & 7);
|
|
2592
|
+
}
|
|
2593
|
+
return message;
|
|
2594
|
+
}
|
|
2595
|
+
finally {
|
|
2596
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
2597
|
+
}
|
|
2598
|
+
},
|
|
2599
|
+
create(base) {
|
|
2600
|
+
return exports.GetBleTagsResponse.fromPartial(base ?? {});
|
|
2601
|
+
},
|
|
2602
|
+
fromPartial(object) {
|
|
2603
|
+
const message = createBaseGetBleTagsResponse();
|
|
2604
|
+
message.tags = object.tags?.map((e) => exports.BleTag.fromPartial(e)) || [];
|
|
2605
|
+
return message;
|
|
2606
|
+
},
|
|
2607
|
+
};
|
|
2608
|
+
function createBaseCreateBleTagRequest() {
|
|
2609
|
+
return { macAddress: "", label: "", userId: 0 };
|
|
2610
|
+
}
|
|
2611
|
+
exports.CreateBleTagRequest = {
|
|
2612
|
+
encode(message, writer = new wire_1.BinaryWriter()) {
|
|
2613
|
+
if (message.macAddress !== "") {
|
|
2614
|
+
writer.uint32(10).string(message.macAddress);
|
|
2615
|
+
}
|
|
2616
|
+
if (message.label !== "") {
|
|
2617
|
+
writer.uint32(18).string(message.label);
|
|
2618
|
+
}
|
|
2619
|
+
if (message.userId !== 0) {
|
|
2620
|
+
writer.uint32(24).int32(message.userId);
|
|
2621
|
+
}
|
|
2622
|
+
return writer;
|
|
2623
|
+
},
|
|
2624
|
+
decode(input, length) {
|
|
2625
|
+
const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
|
|
2626
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
2627
|
+
if (previousRecursionDepth >= 100) {
|
|
2628
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
2629
|
+
}
|
|
2630
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
2631
|
+
try {
|
|
2632
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
2633
|
+
const message = createBaseCreateBleTagRequest();
|
|
2634
|
+
while (reader.pos < end) {
|
|
2635
|
+
const tag = reader.uint32();
|
|
2636
|
+
switch (tag >>> 3) {
|
|
2637
|
+
case 1: {
|
|
2638
|
+
if (tag !== 10) {
|
|
2639
|
+
break;
|
|
2640
|
+
}
|
|
2641
|
+
message.macAddress = reader.string();
|
|
2642
|
+
continue;
|
|
2643
|
+
}
|
|
2644
|
+
case 2: {
|
|
2645
|
+
if (tag !== 18) {
|
|
2646
|
+
break;
|
|
2647
|
+
}
|
|
2648
|
+
message.label = reader.string();
|
|
2649
|
+
continue;
|
|
2650
|
+
}
|
|
2651
|
+
case 3: {
|
|
2652
|
+
if (tag !== 24) {
|
|
2653
|
+
break;
|
|
2654
|
+
}
|
|
2655
|
+
message.userId = reader.int32();
|
|
2656
|
+
continue;
|
|
2657
|
+
}
|
|
2658
|
+
}
|
|
2659
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
2660
|
+
break;
|
|
2661
|
+
}
|
|
2662
|
+
reader.skip(tag & 7);
|
|
2663
|
+
}
|
|
2664
|
+
return message;
|
|
2665
|
+
}
|
|
2666
|
+
finally {
|
|
2667
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
2668
|
+
}
|
|
2669
|
+
},
|
|
2670
|
+
create(base) {
|
|
2671
|
+
return exports.CreateBleTagRequest.fromPartial(base ?? {});
|
|
2672
|
+
},
|
|
2673
|
+
fromPartial(object) {
|
|
2674
|
+
const message = createBaseCreateBleTagRequest();
|
|
2675
|
+
message.macAddress = object.macAddress ?? "";
|
|
2676
|
+
message.label = object.label ?? "";
|
|
2677
|
+
message.userId = object.userId ?? 0;
|
|
2678
|
+
return message;
|
|
2679
|
+
},
|
|
2680
|
+
};
|
|
2681
|
+
function createBaseCreateBleTagResponse() {
|
|
2682
|
+
return { ok: false, id: 0, message: "" };
|
|
2683
|
+
}
|
|
2684
|
+
exports.CreateBleTagResponse = {
|
|
2685
|
+
encode(message, writer = new wire_1.BinaryWriter()) {
|
|
2686
|
+
if (message.ok !== false) {
|
|
2687
|
+
writer.uint32(8).bool(message.ok);
|
|
2688
|
+
}
|
|
2689
|
+
if (message.id !== 0) {
|
|
2690
|
+
writer.uint32(16).int32(message.id);
|
|
2691
|
+
}
|
|
2692
|
+
if (message.message !== "") {
|
|
2693
|
+
writer.uint32(26).string(message.message);
|
|
2694
|
+
}
|
|
2695
|
+
return writer;
|
|
2696
|
+
},
|
|
2697
|
+
decode(input, length) {
|
|
2698
|
+
const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
|
|
2699
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
2700
|
+
if (previousRecursionDepth >= 100) {
|
|
2701
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
2702
|
+
}
|
|
2703
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
2704
|
+
try {
|
|
2705
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
2706
|
+
const message = createBaseCreateBleTagResponse();
|
|
2707
|
+
while (reader.pos < end) {
|
|
2708
|
+
const tag = reader.uint32();
|
|
2709
|
+
switch (tag >>> 3) {
|
|
2710
|
+
case 1: {
|
|
2711
|
+
if (tag !== 8) {
|
|
2712
|
+
break;
|
|
2713
|
+
}
|
|
2714
|
+
message.ok = reader.bool();
|
|
2715
|
+
continue;
|
|
2716
|
+
}
|
|
2717
|
+
case 2: {
|
|
2718
|
+
if (tag !== 16) {
|
|
2719
|
+
break;
|
|
2720
|
+
}
|
|
2721
|
+
message.id = reader.int32();
|
|
2722
|
+
continue;
|
|
2723
|
+
}
|
|
2724
|
+
case 3: {
|
|
2725
|
+
if (tag !== 26) {
|
|
2726
|
+
break;
|
|
2727
|
+
}
|
|
2728
|
+
message.message = reader.string();
|
|
2729
|
+
continue;
|
|
2730
|
+
}
|
|
2731
|
+
}
|
|
2732
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
2733
|
+
break;
|
|
2734
|
+
}
|
|
2735
|
+
reader.skip(tag & 7);
|
|
2736
|
+
}
|
|
2737
|
+
return message;
|
|
2738
|
+
}
|
|
2739
|
+
finally {
|
|
2740
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
2741
|
+
}
|
|
2742
|
+
},
|
|
2743
|
+
create(base) {
|
|
2744
|
+
return exports.CreateBleTagResponse.fromPartial(base ?? {});
|
|
2745
|
+
},
|
|
2746
|
+
fromPartial(object) {
|
|
2747
|
+
const message = createBaseCreateBleTagResponse();
|
|
2748
|
+
message.ok = object.ok ?? false;
|
|
2749
|
+
message.id = object.id ?? 0;
|
|
2750
|
+
message.message = object.message ?? "";
|
|
2751
|
+
return message;
|
|
2752
|
+
},
|
|
2753
|
+
};
|
|
2754
|
+
function createBaseUpdateBleTagRequest() {
|
|
2755
|
+
return { id: 0, macAddress: "", label: "", userId: 0 };
|
|
2756
|
+
}
|
|
2757
|
+
exports.UpdateBleTagRequest = {
|
|
2758
|
+
encode(message, writer = new wire_1.BinaryWriter()) {
|
|
2759
|
+
if (message.id !== 0) {
|
|
2760
|
+
writer.uint32(8).int32(message.id);
|
|
2761
|
+
}
|
|
2762
|
+
if (message.macAddress !== "") {
|
|
2763
|
+
writer.uint32(18).string(message.macAddress);
|
|
2764
|
+
}
|
|
2765
|
+
if (message.label !== "") {
|
|
2766
|
+
writer.uint32(26).string(message.label);
|
|
2767
|
+
}
|
|
2768
|
+
if (message.userId !== 0) {
|
|
2769
|
+
writer.uint32(32).int32(message.userId);
|
|
2770
|
+
}
|
|
2771
|
+
return writer;
|
|
2772
|
+
},
|
|
2773
|
+
decode(input, length) {
|
|
2774
|
+
const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
|
|
2775
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
2776
|
+
if (previousRecursionDepth >= 100) {
|
|
2777
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
2778
|
+
}
|
|
2779
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
2780
|
+
try {
|
|
2781
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
2782
|
+
const message = createBaseUpdateBleTagRequest();
|
|
2783
|
+
while (reader.pos < end) {
|
|
2784
|
+
const tag = reader.uint32();
|
|
2785
|
+
switch (tag >>> 3) {
|
|
2786
|
+
case 1: {
|
|
2787
|
+
if (tag !== 8) {
|
|
2788
|
+
break;
|
|
2789
|
+
}
|
|
2790
|
+
message.id = reader.int32();
|
|
2791
|
+
continue;
|
|
2792
|
+
}
|
|
2793
|
+
case 2: {
|
|
2794
|
+
if (tag !== 18) {
|
|
2795
|
+
break;
|
|
2796
|
+
}
|
|
2797
|
+
message.macAddress = reader.string();
|
|
2798
|
+
continue;
|
|
2799
|
+
}
|
|
2800
|
+
case 3: {
|
|
2801
|
+
if (tag !== 26) {
|
|
2802
|
+
break;
|
|
2803
|
+
}
|
|
2804
|
+
message.label = reader.string();
|
|
2805
|
+
continue;
|
|
2806
|
+
}
|
|
2807
|
+
case 4: {
|
|
2808
|
+
if (tag !== 32) {
|
|
2809
|
+
break;
|
|
2810
|
+
}
|
|
2811
|
+
message.userId = reader.int32();
|
|
2812
|
+
continue;
|
|
2813
|
+
}
|
|
2814
|
+
}
|
|
2815
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
2816
|
+
break;
|
|
2817
|
+
}
|
|
2818
|
+
reader.skip(tag & 7);
|
|
2819
|
+
}
|
|
2820
|
+
return message;
|
|
2821
|
+
}
|
|
2822
|
+
finally {
|
|
2823
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
2824
|
+
}
|
|
2825
|
+
},
|
|
2826
|
+
create(base) {
|
|
2827
|
+
return exports.UpdateBleTagRequest.fromPartial(base ?? {});
|
|
2828
|
+
},
|
|
2829
|
+
fromPartial(object) {
|
|
2830
|
+
const message = createBaseUpdateBleTagRequest();
|
|
2831
|
+
message.id = object.id ?? 0;
|
|
2832
|
+
message.macAddress = object.macAddress ?? "";
|
|
2833
|
+
message.label = object.label ?? "";
|
|
2834
|
+
message.userId = object.userId ?? 0;
|
|
2835
|
+
return message;
|
|
2836
|
+
},
|
|
2837
|
+
};
|
|
2838
|
+
function createBaseDeleteBleTagRequest() {
|
|
2839
|
+
return { id: 0 };
|
|
2840
|
+
}
|
|
2841
|
+
exports.DeleteBleTagRequest = {
|
|
2842
|
+
encode(message, writer = new wire_1.BinaryWriter()) {
|
|
2843
|
+
if (message.id !== 0) {
|
|
2844
|
+
writer.uint32(8).int32(message.id);
|
|
2845
|
+
}
|
|
2846
|
+
return writer;
|
|
2847
|
+
},
|
|
2848
|
+
decode(input, length) {
|
|
2849
|
+
const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
|
|
2850
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
2851
|
+
if (previousRecursionDepth >= 100) {
|
|
2852
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
2853
|
+
}
|
|
2854
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
2855
|
+
try {
|
|
2856
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
2857
|
+
const message = createBaseDeleteBleTagRequest();
|
|
2858
|
+
while (reader.pos < end) {
|
|
2859
|
+
const tag = reader.uint32();
|
|
2860
|
+
switch (tag >>> 3) {
|
|
2861
|
+
case 1: {
|
|
2862
|
+
if (tag !== 8) {
|
|
2863
|
+
break;
|
|
2864
|
+
}
|
|
2865
|
+
message.id = reader.int32();
|
|
2866
|
+
continue;
|
|
2867
|
+
}
|
|
2868
|
+
}
|
|
2869
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
2870
|
+
break;
|
|
2871
|
+
}
|
|
2872
|
+
reader.skip(tag & 7);
|
|
2873
|
+
}
|
|
2874
|
+
return message;
|
|
2875
|
+
}
|
|
2876
|
+
finally {
|
|
2877
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
2878
|
+
}
|
|
2879
|
+
},
|
|
2880
|
+
create(base) {
|
|
2881
|
+
return exports.DeleteBleTagRequest.fromPartial(base ?? {});
|
|
2882
|
+
},
|
|
2883
|
+
fromPartial(object) {
|
|
2884
|
+
const message = createBaseDeleteBleTagRequest();
|
|
2885
|
+
message.id = object.id ?? 0;
|
|
2886
|
+
return message;
|
|
2887
|
+
},
|
|
2888
|
+
};
|
|
2889
|
+
function createBasePresenceSource() {
|
|
2890
|
+
return { id: 0, userId: 0, sourceType: "", reference: "", homeConfidence: 0, awayConfidence: 0, enabled: false };
|
|
2891
|
+
}
|
|
2892
|
+
exports.PresenceSource = {
|
|
2893
|
+
encode(message, writer = new wire_1.BinaryWriter()) {
|
|
2894
|
+
if (message.id !== 0) {
|
|
2895
|
+
writer.uint32(8).int32(message.id);
|
|
2896
|
+
}
|
|
2897
|
+
if (message.userId !== 0) {
|
|
2898
|
+
writer.uint32(16).int32(message.userId);
|
|
2899
|
+
}
|
|
2900
|
+
if (message.sourceType !== "") {
|
|
2901
|
+
writer.uint32(26).string(message.sourceType);
|
|
2902
|
+
}
|
|
2903
|
+
if (message.reference !== "") {
|
|
2904
|
+
writer.uint32(34).string(message.reference);
|
|
2905
|
+
}
|
|
2906
|
+
if (message.homeConfidence !== 0) {
|
|
2907
|
+
writer.uint32(45).float(message.homeConfidence);
|
|
2908
|
+
}
|
|
2909
|
+
if (message.awayConfidence !== 0) {
|
|
2910
|
+
writer.uint32(53).float(message.awayConfidence);
|
|
2911
|
+
}
|
|
2912
|
+
if (message.enabled !== false) {
|
|
2913
|
+
writer.uint32(56).bool(message.enabled);
|
|
2914
|
+
}
|
|
2915
|
+
return writer;
|
|
2916
|
+
},
|
|
2917
|
+
decode(input, length) {
|
|
2918
|
+
const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
|
|
2919
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
2920
|
+
if (previousRecursionDepth >= 100) {
|
|
2921
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
2922
|
+
}
|
|
2923
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
2924
|
+
try {
|
|
2925
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
2926
|
+
const message = createBasePresenceSource();
|
|
2927
|
+
while (reader.pos < end) {
|
|
2928
|
+
const tag = reader.uint32();
|
|
2929
|
+
switch (tag >>> 3) {
|
|
2930
|
+
case 1: {
|
|
2931
|
+
if (tag !== 8) {
|
|
2932
|
+
break;
|
|
2933
|
+
}
|
|
2934
|
+
message.id = reader.int32();
|
|
2935
|
+
continue;
|
|
2936
|
+
}
|
|
2937
|
+
case 2: {
|
|
2938
|
+
if (tag !== 16) {
|
|
2939
|
+
break;
|
|
2940
|
+
}
|
|
2941
|
+
message.userId = reader.int32();
|
|
2942
|
+
continue;
|
|
2943
|
+
}
|
|
2944
|
+
case 3: {
|
|
2945
|
+
if (tag !== 26) {
|
|
2946
|
+
break;
|
|
2947
|
+
}
|
|
2948
|
+
message.sourceType = reader.string();
|
|
2949
|
+
continue;
|
|
2950
|
+
}
|
|
2951
|
+
case 4: {
|
|
2952
|
+
if (tag !== 34) {
|
|
2953
|
+
break;
|
|
2954
|
+
}
|
|
2955
|
+
message.reference = reader.string();
|
|
2956
|
+
continue;
|
|
2957
|
+
}
|
|
2958
|
+
case 5: {
|
|
2959
|
+
if (tag !== 45) {
|
|
2960
|
+
break;
|
|
2961
|
+
}
|
|
2962
|
+
message.homeConfidence = reader.float();
|
|
2963
|
+
continue;
|
|
2964
|
+
}
|
|
2965
|
+
case 6: {
|
|
2966
|
+
if (tag !== 53) {
|
|
2967
|
+
break;
|
|
2968
|
+
}
|
|
2969
|
+
message.awayConfidence = reader.float();
|
|
2970
|
+
continue;
|
|
2971
|
+
}
|
|
2972
|
+
case 7: {
|
|
2973
|
+
if (tag !== 56) {
|
|
2974
|
+
break;
|
|
2975
|
+
}
|
|
2976
|
+
message.enabled = reader.bool();
|
|
2977
|
+
continue;
|
|
2978
|
+
}
|
|
2979
|
+
}
|
|
2980
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
2981
|
+
break;
|
|
2982
|
+
}
|
|
2983
|
+
reader.skip(tag & 7);
|
|
2984
|
+
}
|
|
2985
|
+
return message;
|
|
2986
|
+
}
|
|
2987
|
+
finally {
|
|
2988
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
2989
|
+
}
|
|
2990
|
+
},
|
|
2991
|
+
create(base) {
|
|
2992
|
+
return exports.PresenceSource.fromPartial(base ?? {});
|
|
2993
|
+
},
|
|
2994
|
+
fromPartial(object) {
|
|
2995
|
+
const message = createBasePresenceSource();
|
|
2996
|
+
message.id = object.id ?? 0;
|
|
2997
|
+
message.userId = object.userId ?? 0;
|
|
2998
|
+
message.sourceType = object.sourceType ?? "";
|
|
2999
|
+
message.reference = object.reference ?? "";
|
|
3000
|
+
message.homeConfidence = object.homeConfidence ?? 0;
|
|
3001
|
+
message.awayConfidence = object.awayConfidence ?? 0;
|
|
3002
|
+
message.enabled = object.enabled ?? false;
|
|
3003
|
+
return message;
|
|
3004
|
+
},
|
|
3005
|
+
};
|
|
3006
|
+
function createBaseGetPresenceSourcesResponse() {
|
|
3007
|
+
return { presenceSources: [] };
|
|
3008
|
+
}
|
|
3009
|
+
exports.GetPresenceSourcesResponse = {
|
|
3010
|
+
encode(message, writer = new wire_1.BinaryWriter()) {
|
|
3011
|
+
for (const v of message.presenceSources) {
|
|
3012
|
+
exports.PresenceSource.encode(v, writer.uint32(10).fork()).join();
|
|
3013
|
+
}
|
|
3014
|
+
return writer;
|
|
3015
|
+
},
|
|
3016
|
+
decode(input, length) {
|
|
3017
|
+
const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
|
|
3018
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
3019
|
+
if (previousRecursionDepth >= 100) {
|
|
3020
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
3021
|
+
}
|
|
3022
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
3023
|
+
try {
|
|
3024
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
3025
|
+
const message = createBaseGetPresenceSourcesResponse();
|
|
3026
|
+
while (reader.pos < end) {
|
|
3027
|
+
const tag = reader.uint32();
|
|
3028
|
+
switch (tag >>> 3) {
|
|
3029
|
+
case 1: {
|
|
3030
|
+
if (tag !== 10) {
|
|
3031
|
+
break;
|
|
3032
|
+
}
|
|
3033
|
+
message.presenceSources.push(exports.PresenceSource.decode(reader, reader.uint32()));
|
|
3034
|
+
continue;
|
|
3035
|
+
}
|
|
3036
|
+
}
|
|
3037
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
3038
|
+
break;
|
|
3039
|
+
}
|
|
3040
|
+
reader.skip(tag & 7);
|
|
3041
|
+
}
|
|
3042
|
+
return message;
|
|
3043
|
+
}
|
|
3044
|
+
finally {
|
|
3045
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
3046
|
+
}
|
|
3047
|
+
},
|
|
3048
|
+
create(base) {
|
|
3049
|
+
return exports.GetPresenceSourcesResponse.fromPartial(base ?? {});
|
|
3050
|
+
},
|
|
3051
|
+
fromPartial(object) {
|
|
3052
|
+
const message = createBaseGetPresenceSourcesResponse();
|
|
3053
|
+
message.presenceSources = object.presenceSources?.map((e) => exports.PresenceSource.fromPartial(e)) || [];
|
|
3054
|
+
return message;
|
|
3055
|
+
},
|
|
3056
|
+
};
|
|
3057
|
+
function createBaseCreatePresenceSourceRequest() {
|
|
3058
|
+
return { userId: 0, sourceType: "", reference: "", homeConfidence: 0, awayConfidence: 0, enabled: false };
|
|
3059
|
+
}
|
|
3060
|
+
exports.CreatePresenceSourceRequest = {
|
|
3061
|
+
encode(message, writer = new wire_1.BinaryWriter()) {
|
|
3062
|
+
if (message.userId !== 0) {
|
|
3063
|
+
writer.uint32(8).int32(message.userId);
|
|
3064
|
+
}
|
|
3065
|
+
if (message.sourceType !== "") {
|
|
3066
|
+
writer.uint32(18).string(message.sourceType);
|
|
3067
|
+
}
|
|
3068
|
+
if (message.reference !== "") {
|
|
3069
|
+
writer.uint32(26).string(message.reference);
|
|
3070
|
+
}
|
|
3071
|
+
if (message.homeConfidence !== 0) {
|
|
3072
|
+
writer.uint32(37).float(message.homeConfidence);
|
|
3073
|
+
}
|
|
3074
|
+
if (message.awayConfidence !== 0) {
|
|
3075
|
+
writer.uint32(45).float(message.awayConfidence);
|
|
3076
|
+
}
|
|
3077
|
+
if (message.enabled !== false) {
|
|
3078
|
+
writer.uint32(48).bool(message.enabled);
|
|
3079
|
+
}
|
|
3080
|
+
return writer;
|
|
3081
|
+
},
|
|
3082
|
+
decode(input, length) {
|
|
3083
|
+
const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
|
|
3084
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
3085
|
+
if (previousRecursionDepth >= 100) {
|
|
3086
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
3087
|
+
}
|
|
3088
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
3089
|
+
try {
|
|
3090
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
3091
|
+
const message = createBaseCreatePresenceSourceRequest();
|
|
3092
|
+
while (reader.pos < end) {
|
|
3093
|
+
const tag = reader.uint32();
|
|
3094
|
+
switch (tag >>> 3) {
|
|
3095
|
+
case 1: {
|
|
3096
|
+
if (tag !== 8) {
|
|
3097
|
+
break;
|
|
3098
|
+
}
|
|
3099
|
+
message.userId = reader.int32();
|
|
3100
|
+
continue;
|
|
3101
|
+
}
|
|
3102
|
+
case 2: {
|
|
3103
|
+
if (tag !== 18) {
|
|
3104
|
+
break;
|
|
3105
|
+
}
|
|
3106
|
+
message.sourceType = reader.string();
|
|
3107
|
+
continue;
|
|
3108
|
+
}
|
|
3109
|
+
case 3: {
|
|
3110
|
+
if (tag !== 26) {
|
|
3111
|
+
break;
|
|
3112
|
+
}
|
|
3113
|
+
message.reference = reader.string();
|
|
3114
|
+
continue;
|
|
3115
|
+
}
|
|
3116
|
+
case 4: {
|
|
3117
|
+
if (tag !== 37) {
|
|
3118
|
+
break;
|
|
3119
|
+
}
|
|
3120
|
+
message.homeConfidence = reader.float();
|
|
3121
|
+
continue;
|
|
3122
|
+
}
|
|
3123
|
+
case 5: {
|
|
3124
|
+
if (tag !== 45) {
|
|
3125
|
+
break;
|
|
3126
|
+
}
|
|
3127
|
+
message.awayConfidence = reader.float();
|
|
3128
|
+
continue;
|
|
3129
|
+
}
|
|
3130
|
+
case 6: {
|
|
3131
|
+
if (tag !== 48) {
|
|
3132
|
+
break;
|
|
3133
|
+
}
|
|
3134
|
+
message.enabled = reader.bool();
|
|
3135
|
+
continue;
|
|
3136
|
+
}
|
|
3137
|
+
}
|
|
3138
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
3139
|
+
break;
|
|
3140
|
+
}
|
|
3141
|
+
reader.skip(tag & 7);
|
|
3142
|
+
}
|
|
3143
|
+
return message;
|
|
3144
|
+
}
|
|
3145
|
+
finally {
|
|
3146
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
3147
|
+
}
|
|
3148
|
+
},
|
|
3149
|
+
create(base) {
|
|
3150
|
+
return exports.CreatePresenceSourceRequest.fromPartial(base ?? {});
|
|
3151
|
+
},
|
|
3152
|
+
fromPartial(object) {
|
|
3153
|
+
const message = createBaseCreatePresenceSourceRequest();
|
|
3154
|
+
message.userId = object.userId ?? 0;
|
|
3155
|
+
message.sourceType = object.sourceType ?? "";
|
|
3156
|
+
message.reference = object.reference ?? "";
|
|
3157
|
+
message.homeConfidence = object.homeConfidence ?? 0;
|
|
3158
|
+
message.awayConfidence = object.awayConfidence ?? 0;
|
|
3159
|
+
message.enabled = object.enabled ?? false;
|
|
3160
|
+
return message;
|
|
3161
|
+
},
|
|
3162
|
+
};
|
|
3163
|
+
function createBaseCreatePresenceSourceResponse() {
|
|
3164
|
+
return { ok: false, id: 0, message: "" };
|
|
3165
|
+
}
|
|
3166
|
+
exports.CreatePresenceSourceResponse = {
|
|
3167
|
+
encode(message, writer = new wire_1.BinaryWriter()) {
|
|
3168
|
+
if (message.ok !== false) {
|
|
3169
|
+
writer.uint32(8).bool(message.ok);
|
|
3170
|
+
}
|
|
3171
|
+
if (message.id !== 0) {
|
|
3172
|
+
writer.uint32(16).int32(message.id);
|
|
3173
|
+
}
|
|
3174
|
+
if (message.message !== "") {
|
|
3175
|
+
writer.uint32(26).string(message.message);
|
|
3176
|
+
}
|
|
3177
|
+
return writer;
|
|
3178
|
+
},
|
|
3179
|
+
decode(input, length) {
|
|
3180
|
+
const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
|
|
3181
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
3182
|
+
if (previousRecursionDepth >= 100) {
|
|
3183
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
3184
|
+
}
|
|
3185
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
3186
|
+
try {
|
|
3187
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
3188
|
+
const message = createBaseCreatePresenceSourceResponse();
|
|
3189
|
+
while (reader.pos < end) {
|
|
3190
|
+
const tag = reader.uint32();
|
|
3191
|
+
switch (tag >>> 3) {
|
|
3192
|
+
case 1: {
|
|
3193
|
+
if (tag !== 8) {
|
|
3194
|
+
break;
|
|
3195
|
+
}
|
|
3196
|
+
message.ok = reader.bool();
|
|
3197
|
+
continue;
|
|
3198
|
+
}
|
|
3199
|
+
case 2: {
|
|
3200
|
+
if (tag !== 16) {
|
|
3201
|
+
break;
|
|
3202
|
+
}
|
|
3203
|
+
message.id = reader.int32();
|
|
3204
|
+
continue;
|
|
3205
|
+
}
|
|
3206
|
+
case 3: {
|
|
3207
|
+
if (tag !== 26) {
|
|
3208
|
+
break;
|
|
3209
|
+
}
|
|
3210
|
+
message.message = reader.string();
|
|
3211
|
+
continue;
|
|
3212
|
+
}
|
|
3213
|
+
}
|
|
3214
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
3215
|
+
break;
|
|
3216
|
+
}
|
|
3217
|
+
reader.skip(tag & 7);
|
|
3218
|
+
}
|
|
3219
|
+
return message;
|
|
3220
|
+
}
|
|
3221
|
+
finally {
|
|
3222
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
3223
|
+
}
|
|
3224
|
+
},
|
|
3225
|
+
create(base) {
|
|
3226
|
+
return exports.CreatePresenceSourceResponse.fromPartial(base ?? {});
|
|
3227
|
+
},
|
|
3228
|
+
fromPartial(object) {
|
|
3229
|
+
const message = createBaseCreatePresenceSourceResponse();
|
|
3230
|
+
message.ok = object.ok ?? false;
|
|
3231
|
+
message.id = object.id ?? 0;
|
|
3232
|
+
message.message = object.message ?? "";
|
|
3233
|
+
return message;
|
|
3234
|
+
},
|
|
3235
|
+
};
|
|
3236
|
+
function createBaseUpdatePresenceSourceRequest() {
|
|
3237
|
+
return { id: 0, userId: 0, sourceType: "", reference: "", homeConfidence: 0, awayConfidence: 0, enabled: false };
|
|
3238
|
+
}
|
|
3239
|
+
exports.UpdatePresenceSourceRequest = {
|
|
3240
|
+
encode(message, writer = new wire_1.BinaryWriter()) {
|
|
3241
|
+
if (message.id !== 0) {
|
|
3242
|
+
writer.uint32(8).int32(message.id);
|
|
3243
|
+
}
|
|
3244
|
+
if (message.userId !== 0) {
|
|
3245
|
+
writer.uint32(16).int32(message.userId);
|
|
3246
|
+
}
|
|
3247
|
+
if (message.sourceType !== "") {
|
|
3248
|
+
writer.uint32(26).string(message.sourceType);
|
|
3249
|
+
}
|
|
3250
|
+
if (message.reference !== "") {
|
|
3251
|
+
writer.uint32(34).string(message.reference);
|
|
3252
|
+
}
|
|
3253
|
+
if (message.homeConfidence !== 0) {
|
|
3254
|
+
writer.uint32(45).float(message.homeConfidence);
|
|
3255
|
+
}
|
|
3256
|
+
if (message.awayConfidence !== 0) {
|
|
3257
|
+
writer.uint32(53).float(message.awayConfidence);
|
|
3258
|
+
}
|
|
3259
|
+
if (message.enabled !== false) {
|
|
3260
|
+
writer.uint32(56).bool(message.enabled);
|
|
3261
|
+
}
|
|
3262
|
+
return writer;
|
|
3263
|
+
},
|
|
3264
|
+
decode(input, length) {
|
|
3265
|
+
const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
|
|
3266
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
3267
|
+
if (previousRecursionDepth >= 100) {
|
|
3268
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
3269
|
+
}
|
|
3270
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
3271
|
+
try {
|
|
3272
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
3273
|
+
const message = createBaseUpdatePresenceSourceRequest();
|
|
3274
|
+
while (reader.pos < end) {
|
|
3275
|
+
const tag = reader.uint32();
|
|
3276
|
+
switch (tag >>> 3) {
|
|
3277
|
+
case 1: {
|
|
3278
|
+
if (tag !== 8) {
|
|
3279
|
+
break;
|
|
3280
|
+
}
|
|
3281
|
+
message.id = reader.int32();
|
|
3282
|
+
continue;
|
|
3283
|
+
}
|
|
3284
|
+
case 2: {
|
|
3285
|
+
if (tag !== 16) {
|
|
3286
|
+
break;
|
|
3287
|
+
}
|
|
3288
|
+
message.userId = reader.int32();
|
|
3289
|
+
continue;
|
|
3290
|
+
}
|
|
3291
|
+
case 3: {
|
|
3292
|
+
if (tag !== 26) {
|
|
3293
|
+
break;
|
|
3294
|
+
}
|
|
3295
|
+
message.sourceType = reader.string();
|
|
3296
|
+
continue;
|
|
3297
|
+
}
|
|
3298
|
+
case 4: {
|
|
3299
|
+
if (tag !== 34) {
|
|
3300
|
+
break;
|
|
3301
|
+
}
|
|
3302
|
+
message.reference = reader.string();
|
|
3303
|
+
continue;
|
|
3304
|
+
}
|
|
3305
|
+
case 5: {
|
|
3306
|
+
if (tag !== 45) {
|
|
3307
|
+
break;
|
|
3308
|
+
}
|
|
3309
|
+
message.homeConfidence = reader.float();
|
|
3310
|
+
continue;
|
|
3311
|
+
}
|
|
3312
|
+
case 6: {
|
|
3313
|
+
if (tag !== 53) {
|
|
3314
|
+
break;
|
|
3315
|
+
}
|
|
3316
|
+
message.awayConfidence = reader.float();
|
|
3317
|
+
continue;
|
|
3318
|
+
}
|
|
3319
|
+
case 7: {
|
|
3320
|
+
if (tag !== 56) {
|
|
3321
|
+
break;
|
|
3322
|
+
}
|
|
3323
|
+
message.enabled = reader.bool();
|
|
3324
|
+
continue;
|
|
3325
|
+
}
|
|
3326
|
+
}
|
|
3327
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
3328
|
+
break;
|
|
3329
|
+
}
|
|
3330
|
+
reader.skip(tag & 7);
|
|
3331
|
+
}
|
|
3332
|
+
return message;
|
|
3333
|
+
}
|
|
3334
|
+
finally {
|
|
3335
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
3336
|
+
}
|
|
3337
|
+
},
|
|
3338
|
+
create(base) {
|
|
3339
|
+
return exports.UpdatePresenceSourceRequest.fromPartial(base ?? {});
|
|
3340
|
+
},
|
|
3341
|
+
fromPartial(object) {
|
|
3342
|
+
const message = createBaseUpdatePresenceSourceRequest();
|
|
3343
|
+
message.id = object.id ?? 0;
|
|
3344
|
+
message.userId = object.userId ?? 0;
|
|
3345
|
+
message.sourceType = object.sourceType ?? "";
|
|
3346
|
+
message.reference = object.reference ?? "";
|
|
3347
|
+
message.homeConfidence = object.homeConfidence ?? 0;
|
|
3348
|
+
message.awayConfidence = object.awayConfidence ?? 0;
|
|
3349
|
+
message.enabled = object.enabled ?? false;
|
|
3350
|
+
return message;
|
|
3351
|
+
},
|
|
3352
|
+
};
|
|
3353
|
+
function createBaseDeletePresenceSourceRequest() {
|
|
3354
|
+
return { id: 0 };
|
|
3355
|
+
}
|
|
3356
|
+
exports.DeletePresenceSourceRequest = {
|
|
3357
|
+
encode(message, writer = new wire_1.BinaryWriter()) {
|
|
3358
|
+
if (message.id !== 0) {
|
|
3359
|
+
writer.uint32(8).int32(message.id);
|
|
3360
|
+
}
|
|
3361
|
+
return writer;
|
|
3362
|
+
},
|
|
3363
|
+
decode(input, length) {
|
|
3364
|
+
const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
|
|
3365
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
3366
|
+
if (previousRecursionDepth >= 100) {
|
|
3367
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
3368
|
+
}
|
|
3369
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
3370
|
+
try {
|
|
3371
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
3372
|
+
const message = createBaseDeletePresenceSourceRequest();
|
|
3373
|
+
while (reader.pos < end) {
|
|
3374
|
+
const tag = reader.uint32();
|
|
3375
|
+
switch (tag >>> 3) {
|
|
3376
|
+
case 1: {
|
|
3377
|
+
if (tag !== 8) {
|
|
3378
|
+
break;
|
|
3379
|
+
}
|
|
3380
|
+
message.id = reader.int32();
|
|
3381
|
+
continue;
|
|
3382
|
+
}
|
|
3383
|
+
}
|
|
3384
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
3385
|
+
break;
|
|
3386
|
+
}
|
|
3387
|
+
reader.skip(tag & 7);
|
|
3388
|
+
}
|
|
3389
|
+
return message;
|
|
3390
|
+
}
|
|
3391
|
+
finally {
|
|
3392
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
3393
|
+
}
|
|
3394
|
+
},
|
|
3395
|
+
create(base) {
|
|
3396
|
+
return exports.DeletePresenceSourceRequest.fromPartial(base ?? {});
|
|
3397
|
+
},
|
|
3398
|
+
fromPartial(object) {
|
|
3399
|
+
const message = createBaseDeletePresenceSourceRequest();
|
|
3400
|
+
message.id = object.id ?? 0;
|
|
3401
|
+
return message;
|
|
3402
|
+
},
|
|
3403
|
+
};
|
|
3404
|
+
function createBaseCar() {
|
|
3405
|
+
return { id: 0, topicPrefix: "", homeAddress: "", ownerUserIds: [], name: "" };
|
|
3406
|
+
}
|
|
3407
|
+
exports.Car = {
|
|
3408
|
+
encode(message, writer = new wire_1.BinaryWriter()) {
|
|
3409
|
+
if (message.id !== 0) {
|
|
3410
|
+
writer.uint32(8).int32(message.id);
|
|
3411
|
+
}
|
|
3412
|
+
if (message.topicPrefix !== "") {
|
|
3413
|
+
writer.uint32(18).string(message.topicPrefix);
|
|
3414
|
+
}
|
|
3415
|
+
if (message.homeAddress !== "") {
|
|
3416
|
+
writer.uint32(26).string(message.homeAddress);
|
|
3417
|
+
}
|
|
3418
|
+
writer.uint32(34).fork();
|
|
3419
|
+
for (const v of message.ownerUserIds) {
|
|
3420
|
+
writer.int32(v);
|
|
3421
|
+
}
|
|
3422
|
+
writer.join();
|
|
3423
|
+
if (message.name !== "") {
|
|
3424
|
+
writer.uint32(42).string(message.name);
|
|
3425
|
+
}
|
|
3426
|
+
return writer;
|
|
3427
|
+
},
|
|
3428
|
+
decode(input, length) {
|
|
3429
|
+
const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
|
|
3430
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
3431
|
+
if (previousRecursionDepth >= 100) {
|
|
3432
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
3433
|
+
}
|
|
3434
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
3435
|
+
try {
|
|
3436
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
3437
|
+
const message = createBaseCar();
|
|
3438
|
+
while (reader.pos < end) {
|
|
3439
|
+
const tag = reader.uint32();
|
|
3440
|
+
switch (tag >>> 3) {
|
|
3441
|
+
case 1: {
|
|
3442
|
+
if (tag !== 8) {
|
|
3443
|
+
break;
|
|
3444
|
+
}
|
|
3445
|
+
message.id = reader.int32();
|
|
3446
|
+
continue;
|
|
3447
|
+
}
|
|
3448
|
+
case 2: {
|
|
3449
|
+
if (tag !== 18) {
|
|
3450
|
+
break;
|
|
3451
|
+
}
|
|
3452
|
+
message.topicPrefix = reader.string();
|
|
3453
|
+
continue;
|
|
3454
|
+
}
|
|
3455
|
+
case 3: {
|
|
3456
|
+
if (tag !== 26) {
|
|
3457
|
+
break;
|
|
3458
|
+
}
|
|
3459
|
+
message.homeAddress = reader.string();
|
|
3460
|
+
continue;
|
|
3461
|
+
}
|
|
3462
|
+
case 4: {
|
|
3463
|
+
if (tag === 32) {
|
|
3464
|
+
message.ownerUserIds.push(reader.int32());
|
|
3465
|
+
continue;
|
|
3466
|
+
}
|
|
3467
|
+
if (tag === 34) {
|
|
3468
|
+
const end2 = reader.uint32() + reader.pos;
|
|
3469
|
+
while (reader.pos < end2) {
|
|
3470
|
+
message.ownerUserIds.push(reader.int32());
|
|
3471
|
+
}
|
|
3472
|
+
continue;
|
|
3473
|
+
}
|
|
3474
|
+
break;
|
|
3475
|
+
}
|
|
3476
|
+
case 5: {
|
|
3477
|
+
if (tag !== 42) {
|
|
3478
|
+
break;
|
|
3479
|
+
}
|
|
3480
|
+
message.name = reader.string();
|
|
3481
|
+
continue;
|
|
3482
|
+
}
|
|
3483
|
+
}
|
|
3484
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
3485
|
+
break;
|
|
3486
|
+
}
|
|
3487
|
+
reader.skip(tag & 7);
|
|
3488
|
+
}
|
|
3489
|
+
return message;
|
|
3490
|
+
}
|
|
3491
|
+
finally {
|
|
3492
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
3493
|
+
}
|
|
3494
|
+
},
|
|
3495
|
+
create(base) {
|
|
3496
|
+
return exports.Car.fromPartial(base ?? {});
|
|
3497
|
+
},
|
|
3498
|
+
fromPartial(object) {
|
|
3499
|
+
const message = createBaseCar();
|
|
3500
|
+
message.id = object.id ?? 0;
|
|
3501
|
+
message.topicPrefix = object.topicPrefix ?? "";
|
|
3502
|
+
message.homeAddress = object.homeAddress ?? "";
|
|
3503
|
+
message.ownerUserIds = object.ownerUserIds?.map((e) => e) || [];
|
|
3504
|
+
message.name = object.name ?? "";
|
|
3505
|
+
return message;
|
|
3506
|
+
},
|
|
3507
|
+
};
|
|
3508
|
+
function createBaseGetCarsResponse() {
|
|
3509
|
+
return { cars: [] };
|
|
3510
|
+
}
|
|
3511
|
+
exports.GetCarsResponse = {
|
|
3512
|
+
encode(message, writer = new wire_1.BinaryWriter()) {
|
|
3513
|
+
for (const v of message.cars) {
|
|
3514
|
+
exports.Car.encode(v, writer.uint32(10).fork()).join();
|
|
3515
|
+
}
|
|
3516
|
+
return writer;
|
|
3517
|
+
},
|
|
3518
|
+
decode(input, length) {
|
|
3519
|
+
const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
|
|
3520
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
3521
|
+
if (previousRecursionDepth >= 100) {
|
|
3522
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
3523
|
+
}
|
|
3524
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
3525
|
+
try {
|
|
3526
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
3527
|
+
const message = createBaseGetCarsResponse();
|
|
3528
|
+
while (reader.pos < end) {
|
|
3529
|
+
const tag = reader.uint32();
|
|
3530
|
+
switch (tag >>> 3) {
|
|
3531
|
+
case 1: {
|
|
3532
|
+
if (tag !== 10) {
|
|
3533
|
+
break;
|
|
3534
|
+
}
|
|
3535
|
+
message.cars.push(exports.Car.decode(reader, reader.uint32()));
|
|
3536
|
+
continue;
|
|
3537
|
+
}
|
|
3538
|
+
}
|
|
3539
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
3540
|
+
break;
|
|
3541
|
+
}
|
|
3542
|
+
reader.skip(tag & 7);
|
|
3543
|
+
}
|
|
3544
|
+
return message;
|
|
3545
|
+
}
|
|
3546
|
+
finally {
|
|
3547
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
3548
|
+
}
|
|
3549
|
+
},
|
|
3550
|
+
create(base) {
|
|
3551
|
+
return exports.GetCarsResponse.fromPartial(base ?? {});
|
|
3552
|
+
},
|
|
3553
|
+
fromPartial(object) {
|
|
3554
|
+
const message = createBaseGetCarsResponse();
|
|
3555
|
+
message.cars = object.cars?.map((e) => exports.Car.fromPartial(e)) || [];
|
|
3556
|
+
return message;
|
|
3557
|
+
},
|
|
3558
|
+
};
|
|
3559
|
+
function createBaseCreateCarRequest() {
|
|
3560
|
+
return { topicPrefix: "", homeAddress: "", ownerUserIds: [], name: "" };
|
|
3561
|
+
}
|
|
3562
|
+
exports.CreateCarRequest = {
|
|
3563
|
+
encode(message, writer = new wire_1.BinaryWriter()) {
|
|
3564
|
+
if (message.topicPrefix !== "") {
|
|
3565
|
+
writer.uint32(10).string(message.topicPrefix);
|
|
3566
|
+
}
|
|
3567
|
+
if (message.homeAddress !== "") {
|
|
3568
|
+
writer.uint32(18).string(message.homeAddress);
|
|
3569
|
+
}
|
|
3570
|
+
writer.uint32(26).fork();
|
|
3571
|
+
for (const v of message.ownerUserIds) {
|
|
3572
|
+
writer.int32(v);
|
|
3573
|
+
}
|
|
3574
|
+
writer.join();
|
|
3575
|
+
if (message.name !== "") {
|
|
3576
|
+
writer.uint32(34).string(message.name);
|
|
3577
|
+
}
|
|
3578
|
+
return writer;
|
|
3579
|
+
},
|
|
3580
|
+
decode(input, length) {
|
|
3581
|
+
const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
|
|
3582
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
3583
|
+
if (previousRecursionDepth >= 100) {
|
|
3584
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
3585
|
+
}
|
|
3586
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
3587
|
+
try {
|
|
3588
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
3589
|
+
const message = createBaseCreateCarRequest();
|
|
3590
|
+
while (reader.pos < end) {
|
|
3591
|
+
const tag = reader.uint32();
|
|
3592
|
+
switch (tag >>> 3) {
|
|
3593
|
+
case 1: {
|
|
3594
|
+
if (tag !== 10) {
|
|
3595
|
+
break;
|
|
3596
|
+
}
|
|
3597
|
+
message.topicPrefix = reader.string();
|
|
3598
|
+
continue;
|
|
3599
|
+
}
|
|
3600
|
+
case 2: {
|
|
3601
|
+
if (tag !== 18) {
|
|
3602
|
+
break;
|
|
3603
|
+
}
|
|
3604
|
+
message.homeAddress = reader.string();
|
|
3605
|
+
continue;
|
|
3606
|
+
}
|
|
3607
|
+
case 3: {
|
|
3608
|
+
if (tag === 24) {
|
|
3609
|
+
message.ownerUserIds.push(reader.int32());
|
|
3610
|
+
continue;
|
|
3611
|
+
}
|
|
3612
|
+
if (tag === 26) {
|
|
3613
|
+
const end2 = reader.uint32() + reader.pos;
|
|
3614
|
+
while (reader.pos < end2) {
|
|
3615
|
+
message.ownerUserIds.push(reader.int32());
|
|
3616
|
+
}
|
|
3617
|
+
continue;
|
|
3618
|
+
}
|
|
3619
|
+
break;
|
|
3620
|
+
}
|
|
3621
|
+
case 4: {
|
|
3622
|
+
if (tag !== 34) {
|
|
3623
|
+
break;
|
|
3624
|
+
}
|
|
3625
|
+
message.name = reader.string();
|
|
3626
|
+
continue;
|
|
3627
|
+
}
|
|
3628
|
+
}
|
|
3629
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
3630
|
+
break;
|
|
3631
|
+
}
|
|
3632
|
+
reader.skip(tag & 7);
|
|
3633
|
+
}
|
|
3634
|
+
return message;
|
|
3635
|
+
}
|
|
3636
|
+
finally {
|
|
3637
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
3638
|
+
}
|
|
3639
|
+
},
|
|
3640
|
+
create(base) {
|
|
3641
|
+
return exports.CreateCarRequest.fromPartial(base ?? {});
|
|
3642
|
+
},
|
|
3643
|
+
fromPartial(object) {
|
|
3644
|
+
const message = createBaseCreateCarRequest();
|
|
3645
|
+
message.topicPrefix = object.topicPrefix ?? "";
|
|
3646
|
+
message.homeAddress = object.homeAddress ?? "";
|
|
3647
|
+
message.ownerUserIds = object.ownerUserIds?.map((e) => e) || [];
|
|
3648
|
+
message.name = object.name ?? "";
|
|
3649
|
+
return message;
|
|
3650
|
+
},
|
|
3651
|
+
};
|
|
3652
|
+
function createBaseCreateCarResponse() {
|
|
3653
|
+
return { ok: false, id: 0, message: "" };
|
|
3654
|
+
}
|
|
3655
|
+
exports.CreateCarResponse = {
|
|
3656
|
+
encode(message, writer = new wire_1.BinaryWriter()) {
|
|
3657
|
+
if (message.ok !== false) {
|
|
3658
|
+
writer.uint32(8).bool(message.ok);
|
|
3659
|
+
}
|
|
3660
|
+
if (message.id !== 0) {
|
|
3661
|
+
writer.uint32(16).int32(message.id);
|
|
3662
|
+
}
|
|
3663
|
+
if (message.message !== "") {
|
|
3664
|
+
writer.uint32(26).string(message.message);
|
|
3665
|
+
}
|
|
3666
|
+
return writer;
|
|
3667
|
+
},
|
|
3668
|
+
decode(input, length) {
|
|
3669
|
+
const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
|
|
3670
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
3671
|
+
if (previousRecursionDepth >= 100) {
|
|
3672
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
3673
|
+
}
|
|
3674
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
3675
|
+
try {
|
|
3676
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
3677
|
+
const message = createBaseCreateCarResponse();
|
|
3678
|
+
while (reader.pos < end) {
|
|
3679
|
+
const tag = reader.uint32();
|
|
3680
|
+
switch (tag >>> 3) {
|
|
3681
|
+
case 1: {
|
|
3682
|
+
if (tag !== 8) {
|
|
3683
|
+
break;
|
|
3684
|
+
}
|
|
3685
|
+
message.ok = reader.bool();
|
|
3686
|
+
continue;
|
|
3687
|
+
}
|
|
3688
|
+
case 2: {
|
|
3689
|
+
if (tag !== 16) {
|
|
3690
|
+
break;
|
|
3691
|
+
}
|
|
3692
|
+
message.id = reader.int32();
|
|
3693
|
+
continue;
|
|
3694
|
+
}
|
|
3695
|
+
case 3: {
|
|
3696
|
+
if (tag !== 26) {
|
|
3697
|
+
break;
|
|
3698
|
+
}
|
|
3699
|
+
message.message = reader.string();
|
|
3700
|
+
continue;
|
|
3701
|
+
}
|
|
3702
|
+
}
|
|
3703
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
3704
|
+
break;
|
|
3705
|
+
}
|
|
3706
|
+
reader.skip(tag & 7);
|
|
3707
|
+
}
|
|
3708
|
+
return message;
|
|
3709
|
+
}
|
|
3710
|
+
finally {
|
|
3711
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
3712
|
+
}
|
|
3713
|
+
},
|
|
3714
|
+
create(base) {
|
|
3715
|
+
return exports.CreateCarResponse.fromPartial(base ?? {});
|
|
3716
|
+
},
|
|
3717
|
+
fromPartial(object) {
|
|
3718
|
+
const message = createBaseCreateCarResponse();
|
|
3719
|
+
message.ok = object.ok ?? false;
|
|
3720
|
+
message.id = object.id ?? 0;
|
|
3721
|
+
message.message = object.message ?? "";
|
|
3722
|
+
return message;
|
|
3723
|
+
},
|
|
3724
|
+
};
|
|
3725
|
+
function createBaseUpdateCarRequest() {
|
|
3726
|
+
return { id: 0, topicPrefix: "", homeAddress: "", ownerUserIds: [], name: "" };
|
|
3727
|
+
}
|
|
3728
|
+
exports.UpdateCarRequest = {
|
|
3729
|
+
encode(message, writer = new wire_1.BinaryWriter()) {
|
|
3730
|
+
if (message.id !== 0) {
|
|
3731
|
+
writer.uint32(8).int32(message.id);
|
|
3732
|
+
}
|
|
3733
|
+
if (message.topicPrefix !== "") {
|
|
3734
|
+
writer.uint32(18).string(message.topicPrefix);
|
|
3735
|
+
}
|
|
3736
|
+
if (message.homeAddress !== "") {
|
|
3737
|
+
writer.uint32(26).string(message.homeAddress);
|
|
3738
|
+
}
|
|
3739
|
+
writer.uint32(34).fork();
|
|
3740
|
+
for (const v of message.ownerUserIds) {
|
|
3741
|
+
writer.int32(v);
|
|
3742
|
+
}
|
|
3743
|
+
writer.join();
|
|
3744
|
+
if (message.name !== "") {
|
|
3745
|
+
writer.uint32(42).string(message.name);
|
|
3746
|
+
}
|
|
3747
|
+
return writer;
|
|
3748
|
+
},
|
|
3749
|
+
decode(input, length) {
|
|
3750
|
+
const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
|
|
3751
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
3752
|
+
if (previousRecursionDepth >= 100) {
|
|
3753
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
3754
|
+
}
|
|
3755
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
3756
|
+
try {
|
|
3757
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
3758
|
+
const message = createBaseUpdateCarRequest();
|
|
3759
|
+
while (reader.pos < end) {
|
|
3760
|
+
const tag = reader.uint32();
|
|
3761
|
+
switch (tag >>> 3) {
|
|
3762
|
+
case 1: {
|
|
3763
|
+
if (tag !== 8) {
|
|
3764
|
+
break;
|
|
3765
|
+
}
|
|
3766
|
+
message.id = reader.int32();
|
|
3767
|
+
continue;
|
|
3768
|
+
}
|
|
3769
|
+
case 2: {
|
|
3770
|
+
if (tag !== 18) {
|
|
3771
|
+
break;
|
|
3772
|
+
}
|
|
3773
|
+
message.topicPrefix = reader.string();
|
|
3774
|
+
continue;
|
|
3775
|
+
}
|
|
3776
|
+
case 3: {
|
|
3777
|
+
if (tag !== 26) {
|
|
3778
|
+
break;
|
|
3779
|
+
}
|
|
3780
|
+
message.homeAddress = reader.string();
|
|
3781
|
+
continue;
|
|
3782
|
+
}
|
|
3783
|
+
case 4: {
|
|
3784
|
+
if (tag === 32) {
|
|
3785
|
+
message.ownerUserIds.push(reader.int32());
|
|
3786
|
+
continue;
|
|
3787
|
+
}
|
|
3788
|
+
if (tag === 34) {
|
|
3789
|
+
const end2 = reader.uint32() + reader.pos;
|
|
3790
|
+
while (reader.pos < end2) {
|
|
3791
|
+
message.ownerUserIds.push(reader.int32());
|
|
3792
|
+
}
|
|
3793
|
+
continue;
|
|
3794
|
+
}
|
|
3795
|
+
break;
|
|
3796
|
+
}
|
|
3797
|
+
case 5: {
|
|
3798
|
+
if (tag !== 42) {
|
|
3799
|
+
break;
|
|
3800
|
+
}
|
|
3801
|
+
message.name = reader.string();
|
|
3802
|
+
continue;
|
|
3803
|
+
}
|
|
3804
|
+
}
|
|
3805
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
3806
|
+
break;
|
|
3807
|
+
}
|
|
3808
|
+
reader.skip(tag & 7);
|
|
3809
|
+
}
|
|
3810
|
+
return message;
|
|
3811
|
+
}
|
|
3812
|
+
finally {
|
|
3813
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
3814
|
+
}
|
|
3815
|
+
},
|
|
3816
|
+
create(base) {
|
|
3817
|
+
return exports.UpdateCarRequest.fromPartial(base ?? {});
|
|
3818
|
+
},
|
|
3819
|
+
fromPartial(object) {
|
|
3820
|
+
const message = createBaseUpdateCarRequest();
|
|
3821
|
+
message.id = object.id ?? 0;
|
|
3822
|
+
message.topicPrefix = object.topicPrefix ?? "";
|
|
3823
|
+
message.homeAddress = object.homeAddress ?? "";
|
|
3824
|
+
message.ownerUserIds = object.ownerUserIds?.map((e) => e) || [];
|
|
3825
|
+
message.name = object.name ?? "";
|
|
3826
|
+
return message;
|
|
3827
|
+
},
|
|
3828
|
+
};
|
|
3829
|
+
function createBaseDeleteCarRequest() {
|
|
3830
|
+
return { id: 0 };
|
|
3831
|
+
}
|
|
3832
|
+
exports.DeleteCarRequest = {
|
|
3833
|
+
encode(message, writer = new wire_1.BinaryWriter()) {
|
|
3834
|
+
if (message.id !== 0) {
|
|
3835
|
+
writer.uint32(8).int32(message.id);
|
|
3836
|
+
}
|
|
3837
|
+
return writer;
|
|
3838
|
+
},
|
|
3839
|
+
decode(input, length) {
|
|
3840
|
+
const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
|
|
3841
|
+
const previousRecursionDepth = reader.__tsProtoDecodeDepth ?? 0;
|
|
3842
|
+
if (previousRecursionDepth >= 100) {
|
|
3843
|
+
throw new globalThis.Error("protobuf decode recursion limit exceeded");
|
|
3844
|
+
}
|
|
3845
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth + 1;
|
|
3846
|
+
try {
|
|
3847
|
+
const end = length === undefined ? reader.len : reader.pos + length;
|
|
3848
|
+
const message = createBaseDeleteCarRequest();
|
|
3849
|
+
while (reader.pos < end) {
|
|
3850
|
+
const tag = reader.uint32();
|
|
3851
|
+
switch (tag >>> 3) {
|
|
3852
|
+
case 1: {
|
|
3853
|
+
if (tag !== 8) {
|
|
3854
|
+
break;
|
|
3855
|
+
}
|
|
3856
|
+
message.id = reader.int32();
|
|
3857
|
+
continue;
|
|
3858
|
+
}
|
|
3859
|
+
}
|
|
3860
|
+
if ((tag & 7) === 4 || tag === 0) {
|
|
3861
|
+
break;
|
|
3862
|
+
}
|
|
3863
|
+
reader.skip(tag & 7);
|
|
3864
|
+
}
|
|
3865
|
+
return message;
|
|
3866
|
+
}
|
|
3867
|
+
finally {
|
|
3868
|
+
reader.__tsProtoDecodeDepth = previousRecursionDepth;
|
|
3869
|
+
}
|
|
3870
|
+
},
|
|
3871
|
+
create(base) {
|
|
3872
|
+
return exports.DeleteCarRequest.fromPartial(base ?? {});
|
|
3873
|
+
},
|
|
3874
|
+
fromPartial(object) {
|
|
3875
|
+
const message = createBaseDeleteCarRequest();
|
|
3876
|
+
message.id = object.id ?? 0;
|
|
3877
|
+
return message;
|
|
3878
|
+
},
|
|
3879
|
+
};
|