@fatehan/tsrp 1.6.16 → 1.6.18

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.
Files changed (88) hide show
  1. package/package.json +1 -1
  2. package/dist/fatehan/activities/workflow.d.ts +0 -219
  3. package/dist/fatehan/activities/workflow.d.ts.map +0 -1
  4. package/dist/fatehan/activities/workflow.js +0 -1941
  5. package/dist/fatehan/activities/workshift.d.ts +0 -140
  6. package/dist/fatehan/activities/workshift.d.ts.map +0 -1
  7. package/dist/fatehan/activities/workshift.js +0 -1244
  8. package/dist/fatehan/apis/client.d.ts +0 -246
  9. package/dist/fatehan/apis/client.d.ts.map +0 -1
  10. package/dist/fatehan/apis/client.js +0 -2572
  11. package/dist/fatehan/areas/area.d.ts +0 -96
  12. package/dist/fatehan/areas/area.d.ts.map +0 -1
  13. package/dist/fatehan/areas/area.js +0 -761
  14. package/dist/fatehan/devices/devices.d.ts +0 -256
  15. package/dist/fatehan/devices/devices.d.ts.map +0 -1
  16. package/dist/fatehan/devices/devices.js +0 -2730
  17. package/dist/fatehan/devices/maintenance.d.ts +0 -64
  18. package/dist/fatehan/devices/maintenance.d.ts.map +0 -1
  19. package/dist/fatehan/devices/maintenance.js +0 -484
  20. package/dist/fatehan/financial/financial.d.ts +0 -162
  21. package/dist/fatehan/financial/financial.d.ts.map +0 -1
  22. package/dist/fatehan/financial/financial.js +0 -1701
  23. package/dist/fatehan/google/protobuf/descriptor.d.ts +0 -1303
  24. package/dist/fatehan/google/protobuf/descriptor.d.ts.map +0 -1
  25. package/dist/fatehan/google/protobuf/descriptor.js +0 -3467
  26. package/dist/fatehan/google/protobuf/duration.d.ts +0 -99
  27. package/dist/fatehan/google/protobuf/duration.d.ts.map +0 -1
  28. package/dist/fatehan/google/protobuf/duration.js +0 -63
  29. package/dist/fatehan/google/protobuf/field_mask.d.ts +0 -228
  30. package/dist/fatehan/google/protobuf/field_mask.d.ts.map +0 -1
  31. package/dist/fatehan/google/protobuf/field_mask.js +0 -57
  32. package/dist/fatehan/google/protobuf/timestamp.d.ts +0 -129
  33. package/dist/fatehan/google/protobuf/timestamp.d.ts.map +0 -1
  34. package/dist/fatehan/google/protobuf/timestamp.js +0 -63
  35. package/dist/fatehan/identities/authentication.d.ts +0 -164
  36. package/dist/fatehan/identities/authentication.d.ts.map +0 -1
  37. package/dist/fatehan/identities/authentication.js +0 -1291
  38. package/dist/fatehan/identities/identities.d.ts +0 -969
  39. package/dist/fatehan/identities/identities.d.ts.map +0 -1
  40. package/dist/fatehan/identities/identities.js +0 -2993
  41. package/dist/fatehan/models/fusion.d.ts +0 -149
  42. package/dist/fatehan/models/fusion.d.ts.map +0 -1
  43. package/dist/fatehan/models/fusion.js +0 -1531
  44. package/dist/fatehan/models/models.d.ts +0 -162
  45. package/dist/fatehan/models/models.d.ts.map +0 -1
  46. package/dist/fatehan/models/models.js +0 -1486
  47. package/dist/fatehan/notifies/direct.d.ts +0 -85
  48. package/dist/fatehan/notifies/direct.d.ts.map +0 -1
  49. package/dist/fatehan/notifies/direct.js +0 -669
  50. package/dist/fatehan/notifies/notify.d.ts +0 -232
  51. package/dist/fatehan/notifies/notify.d.ts.map +0 -1
  52. package/dist/fatehan/notifies/notify.js +0 -1958
  53. package/dist/fatehan/packets/commands.d.ts +0 -150
  54. package/dist/fatehan/packets/commands.d.ts.map +0 -1
  55. package/dist/fatehan/packets/commands.js +0 -1364
  56. package/dist/fatehan/packets/dataModel.d.ts +0 -1610
  57. package/dist/fatehan/packets/dataModel.d.ts.map +0 -1
  58. package/dist/fatehan/packets/dataModel.js +0 -14947
  59. package/dist/fatehan/packets/dataModule.d.ts +0 -61
  60. package/dist/fatehan/packets/dataModule.d.ts.map +0 -1
  61. package/dist/fatehan/packets/dataModule.js +0 -386
  62. package/dist/fatehan/packets/forge.d.ts +0 -142
  63. package/dist/fatehan/packets/forge.d.ts.map +0 -1
  64. package/dist/fatehan/packets/forge.js +0 -1339
  65. package/dist/fatehan/services/api.d.ts +0 -1207
  66. package/dist/fatehan/services/api.d.ts.map +0 -1
  67. package/dist/fatehan/services/api.js +0 -12492
  68. package/dist/fatehan/services/repositories.d.ts +0 -78
  69. package/dist/fatehan/services/repositories.d.ts.map +0 -1
  70. package/dist/fatehan/services/repositories.js +0 -620
  71. package/dist/fatehan/stream/stream.d.ts +0 -224
  72. package/dist/fatehan/stream/stream.d.ts.map +0 -1
  73. package/dist/fatehan/stream/stream.js +0 -1416
  74. package/dist/fatehan/trips/trip.d.ts +0 -325
  75. package/dist/fatehan/trips/trip.d.ts.map +0 -1
  76. package/dist/fatehan/trips/trip.js +0 -1635
  77. package/dist/fatehan/utils/buf/validate/validate.d.ts +0 -3520
  78. package/dist/fatehan/utils/buf/validate/validate.d.ts.map +0 -1
  79. package/dist/fatehan/utils/buf/validate/validate.js +0 -4248
  80. package/dist/services.d.ts +0 -78
  81. package/dist/services.d.ts.map +0 -1
  82. package/dist/services.js +0 -242
  83. package/dist/store/system.io.d.ts +0 -6
  84. package/dist/store/system.io.d.ts.map +0 -1
  85. package/dist/store/system.io.js +0 -14
  86. package/dist/system.io.d.ts +0 -6
  87. package/dist/system.io.d.ts.map +0 -1
  88. package/dist/system.io.js +0 -208
@@ -1,2572 +0,0 @@
1
- // Code generated by protoc-gen-ts_proto. DO NOT EDIT.
2
- // versions:
3
- // protoc-gen-ts_proto v2.11.8
4
- // protoc v7.34.1
5
- // source: apis/client.proto
6
- /* eslint-disable */
7
- import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
8
- import Long from "long";
9
- import { Device, Tracker } from "../devices/devices";
10
- import { Maintenance, MaintenanceService } from "../devices/maintenance";
11
- import { Currency } from "../financial/financial";
12
- import { Timestamp } from "../google/protobuf/timestamp";
13
- import { Organization, Person, User } from "../identities/identities";
14
- import { LiveLocation } from "../models/models";
15
- import { CommandStruct } from "../packets/commands";
16
- export const protobufPackage = "com.fatehan.apis";
17
- function createBaseMessageOnly() {
18
- return { message: "" };
19
- }
20
- export const MessageOnly = {
21
- encode(message, writer = new BinaryWriter()) {
22
- if (message.message !== "") {
23
- writer.uint32(10).string(message.message);
24
- }
25
- return writer;
26
- },
27
- decode(input, length) {
28
- const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
29
- const end = length === undefined ? reader.len : reader.pos + length;
30
- const message = createBaseMessageOnly();
31
- while (reader.pos < end) {
32
- const tag = reader.uint32();
33
- switch (tag >>> 3) {
34
- case 1: {
35
- if (tag !== 10) {
36
- break;
37
- }
38
- message.message = reader.string();
39
- continue;
40
- }
41
- }
42
- if ((tag & 7) === 4 || tag === 0) {
43
- break;
44
- }
45
- reader.skip(tag & 7);
46
- }
47
- return message;
48
- },
49
- create(base) {
50
- return MessageOnly.fromPartial(base ?? {});
51
- },
52
- fromPartial(object) {
53
- const message = createBaseMessageOnly();
54
- message.message = object.message ?? "";
55
- return message;
56
- },
57
- };
58
- function createBaseUserPagination() {
59
- return {
60
- currentPage: 0,
61
- firstPageUrl: "",
62
- lastPageUrl: "",
63
- nextPageUrl: "",
64
- prevPageUrl: "",
65
- path: "",
66
- from: 0,
67
- lastPage: 0,
68
- perPage: 0,
69
- to: 0,
70
- data: [],
71
- };
72
- }
73
- export const UserPagination = {
74
- encode(message, writer = new BinaryWriter()) {
75
- if (message.currentPage !== 0) {
76
- writer.uint32(8).uint32(message.currentPage);
77
- }
78
- if (message.firstPageUrl !== "") {
79
- writer.uint32(18).string(message.firstPageUrl);
80
- }
81
- if (message.lastPageUrl !== "") {
82
- writer.uint32(26).string(message.lastPageUrl);
83
- }
84
- if (message.nextPageUrl !== "") {
85
- writer.uint32(34).string(message.nextPageUrl);
86
- }
87
- if (message.prevPageUrl !== "") {
88
- writer.uint32(42).string(message.prevPageUrl);
89
- }
90
- if (message.path !== "") {
91
- writer.uint32(50).string(message.path);
92
- }
93
- if (message.from !== 0) {
94
- writer.uint32(56).uint32(message.from);
95
- }
96
- if (message.lastPage !== 0) {
97
- writer.uint32(64).uint32(message.lastPage);
98
- }
99
- if (message.perPage !== 0) {
100
- writer.uint32(72).uint32(message.perPage);
101
- }
102
- if (message.to !== 0) {
103
- writer.uint32(80).uint32(message.to);
104
- }
105
- for (const v of message.data) {
106
- User.encode(v, writer.uint32(90).fork()).join();
107
- }
108
- return writer;
109
- },
110
- decode(input, length) {
111
- const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
112
- const end = length === undefined ? reader.len : reader.pos + length;
113
- const message = createBaseUserPagination();
114
- while (reader.pos < end) {
115
- const tag = reader.uint32();
116
- switch (tag >>> 3) {
117
- case 1: {
118
- if (tag !== 8) {
119
- break;
120
- }
121
- message.currentPage = reader.uint32();
122
- continue;
123
- }
124
- case 2: {
125
- if (tag !== 18) {
126
- break;
127
- }
128
- message.firstPageUrl = reader.string();
129
- continue;
130
- }
131
- case 3: {
132
- if (tag !== 26) {
133
- break;
134
- }
135
- message.lastPageUrl = reader.string();
136
- continue;
137
- }
138
- case 4: {
139
- if (tag !== 34) {
140
- break;
141
- }
142
- message.nextPageUrl = reader.string();
143
- continue;
144
- }
145
- case 5: {
146
- if (tag !== 42) {
147
- break;
148
- }
149
- message.prevPageUrl = reader.string();
150
- continue;
151
- }
152
- case 6: {
153
- if (tag !== 50) {
154
- break;
155
- }
156
- message.path = reader.string();
157
- continue;
158
- }
159
- case 7: {
160
- if (tag !== 56) {
161
- break;
162
- }
163
- message.from = reader.uint32();
164
- continue;
165
- }
166
- case 8: {
167
- if (tag !== 64) {
168
- break;
169
- }
170
- message.lastPage = reader.uint32();
171
- continue;
172
- }
173
- case 9: {
174
- if (tag !== 72) {
175
- break;
176
- }
177
- message.perPage = reader.uint32();
178
- continue;
179
- }
180
- case 10: {
181
- if (tag !== 80) {
182
- break;
183
- }
184
- message.to = reader.uint32();
185
- continue;
186
- }
187
- case 11: {
188
- if (tag !== 90) {
189
- break;
190
- }
191
- message.data.push(User.decode(reader, reader.uint32()));
192
- continue;
193
- }
194
- }
195
- if ((tag & 7) === 4 || tag === 0) {
196
- break;
197
- }
198
- reader.skip(tag & 7);
199
- }
200
- return message;
201
- },
202
- create(base) {
203
- return UserPagination.fromPartial(base ?? {});
204
- },
205
- fromPartial(object) {
206
- const message = createBaseUserPagination();
207
- message.currentPage = object.currentPage ?? 0;
208
- message.firstPageUrl = object.firstPageUrl ?? "";
209
- message.lastPageUrl = object.lastPageUrl ?? "";
210
- message.nextPageUrl = object.nextPageUrl ?? "";
211
- message.prevPageUrl = object.prevPageUrl ?? "";
212
- message.path = object.path ?? "";
213
- message.from = object.from ?? 0;
214
- message.lastPage = object.lastPage ?? 0;
215
- message.perPage = object.perPage ?? 0;
216
- message.to = object.to ?? 0;
217
- message.data = object.data?.map((e) => User.fromPartial(e)) || [];
218
- return message;
219
- },
220
- };
221
- function createBaseVersionCheck() {
222
- return { status: false, message: "", currentVersion: "", forceUpdate: false, partnerVersion: "", userVersion: "" };
223
- }
224
- export const VersionCheck = {
225
- encode(message, writer = new BinaryWriter()) {
226
- if (message.status !== false) {
227
- writer.uint32(8).bool(message.status);
228
- }
229
- if (message.message !== "") {
230
- writer.uint32(18).string(message.message);
231
- }
232
- if (message.currentVersion !== "") {
233
- writer.uint32(26).string(message.currentVersion);
234
- }
235
- if (message.forceUpdate !== false) {
236
- writer.uint32(32).bool(message.forceUpdate);
237
- }
238
- if (message.partnerVersion !== "") {
239
- writer.uint32(42).string(message.partnerVersion);
240
- }
241
- if (message.userVersion !== "") {
242
- writer.uint32(50).string(message.userVersion);
243
- }
244
- return writer;
245
- },
246
- decode(input, length) {
247
- const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
248
- const end = length === undefined ? reader.len : reader.pos + length;
249
- const message = createBaseVersionCheck();
250
- while (reader.pos < end) {
251
- const tag = reader.uint32();
252
- switch (tag >>> 3) {
253
- case 1: {
254
- if (tag !== 8) {
255
- break;
256
- }
257
- message.status = reader.bool();
258
- continue;
259
- }
260
- case 2: {
261
- if (tag !== 18) {
262
- break;
263
- }
264
- message.message = reader.string();
265
- continue;
266
- }
267
- case 3: {
268
- if (tag !== 26) {
269
- break;
270
- }
271
- message.currentVersion = reader.string();
272
- continue;
273
- }
274
- case 4: {
275
- if (tag !== 32) {
276
- break;
277
- }
278
- message.forceUpdate = reader.bool();
279
- continue;
280
- }
281
- case 5: {
282
- if (tag !== 42) {
283
- break;
284
- }
285
- message.partnerVersion = reader.string();
286
- continue;
287
- }
288
- case 6: {
289
- if (tag !== 50) {
290
- break;
291
- }
292
- message.userVersion = reader.string();
293
- continue;
294
- }
295
- }
296
- if ((tag & 7) === 4 || tag === 0) {
297
- break;
298
- }
299
- reader.skip(tag & 7);
300
- }
301
- return message;
302
- },
303
- create(base) {
304
- return VersionCheck.fromPartial(base ?? {});
305
- },
306
- fromPartial(object) {
307
- const message = createBaseVersionCheck();
308
- message.status = object.status ?? false;
309
- message.message = object.message ?? "";
310
- message.currentVersion = object.currentVersion ?? "";
311
- message.forceUpdate = object.forceUpdate ?? false;
312
- message.partnerVersion = object.partnerVersion ?? "";
313
- message.userVersion = object.userVersion ?? "";
314
- return message;
315
- },
316
- };
317
- function createBaseMe() {
318
- return { user: undefined, person: [], currencies: [], permissions: [], device: undefined, deviceCount: undefined };
319
- }
320
- export const Me = {
321
- encode(message, writer = new BinaryWriter()) {
322
- if (message.user !== undefined) {
323
- User.encode(message.user, writer.uint32(10).fork()).join();
324
- }
325
- for (const v of message.person) {
326
- Person.encode(v, writer.uint32(18).fork()).join();
327
- }
328
- for (const v of message.currencies) {
329
- Currency.encode(v, writer.uint32(26).fork()).join();
330
- }
331
- writer.uint32(34).fork();
332
- for (const v of message.permissions) {
333
- writer.int32(v);
334
- }
335
- writer.join();
336
- if (message.device !== undefined) {
337
- Device.encode(message.device, writer.uint32(42).fork()).join();
338
- }
339
- if (message.deviceCount !== undefined) {
340
- writer.uint32(48).uint32(message.deviceCount);
341
- }
342
- return writer;
343
- },
344
- decode(input, length) {
345
- const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
346
- const end = length === undefined ? reader.len : reader.pos + length;
347
- const message = createBaseMe();
348
- while (reader.pos < end) {
349
- const tag = reader.uint32();
350
- switch (tag >>> 3) {
351
- case 1: {
352
- if (tag !== 10) {
353
- break;
354
- }
355
- message.user = User.decode(reader, reader.uint32());
356
- continue;
357
- }
358
- case 2: {
359
- if (tag !== 18) {
360
- break;
361
- }
362
- message.person.push(Person.decode(reader, reader.uint32()));
363
- continue;
364
- }
365
- case 3: {
366
- if (tag !== 26) {
367
- break;
368
- }
369
- message.currencies.push(Currency.decode(reader, reader.uint32()));
370
- continue;
371
- }
372
- case 4: {
373
- if (tag === 32) {
374
- message.permissions.push(reader.int32());
375
- continue;
376
- }
377
- if (tag === 34) {
378
- const end2 = reader.uint32() + reader.pos;
379
- while (reader.pos < end2) {
380
- message.permissions.push(reader.int32());
381
- }
382
- continue;
383
- }
384
- break;
385
- }
386
- case 5: {
387
- if (tag !== 42) {
388
- break;
389
- }
390
- message.device = Device.decode(reader, reader.uint32());
391
- continue;
392
- }
393
- case 6: {
394
- if (tag !== 48) {
395
- break;
396
- }
397
- message.deviceCount = reader.uint32();
398
- continue;
399
- }
400
- }
401
- if ((tag & 7) === 4 || tag === 0) {
402
- break;
403
- }
404
- reader.skip(tag & 7);
405
- }
406
- return message;
407
- },
408
- create(base) {
409
- return Me.fromPartial(base ?? {});
410
- },
411
- fromPartial(object) {
412
- const message = createBaseMe();
413
- message.user = (object.user !== undefined && object.user !== null) ? User.fromPartial(object.user) : undefined;
414
- message.person = object.person?.map((e) => Person.fromPartial(e)) || [];
415
- message.currencies = object.currencies?.map((e) => Currency.fromPartial(e)) || [];
416
- message.permissions = object.permissions?.map((e) => e) || [];
417
- message.device = (object.device !== undefined && object.device !== null)
418
- ? Device.fromPartial(object.device)
419
- : undefined;
420
- message.deviceCount = object.deviceCount ?? undefined;
421
- return message;
422
- },
423
- };
424
- function createBaseDevicePagination() {
425
- return {
426
- currentPage: 0,
427
- firstPageUrl: "",
428
- lastPageUrl: "",
429
- nextPageUrl: "",
430
- prevPageUrl: "",
431
- path: "",
432
- from: 0,
433
- lastPage: 0,
434
- perPage: 0,
435
- to: 0,
436
- data: [],
437
- };
438
- }
439
- export const DevicePagination = {
440
- encode(message, writer = new BinaryWriter()) {
441
- if (message.currentPage !== 0) {
442
- writer.uint32(8).uint32(message.currentPage);
443
- }
444
- if (message.firstPageUrl !== "") {
445
- writer.uint32(18).string(message.firstPageUrl);
446
- }
447
- if (message.lastPageUrl !== "") {
448
- writer.uint32(26).string(message.lastPageUrl);
449
- }
450
- if (message.nextPageUrl !== "") {
451
- writer.uint32(34).string(message.nextPageUrl);
452
- }
453
- if (message.prevPageUrl !== "") {
454
- writer.uint32(42).string(message.prevPageUrl);
455
- }
456
- if (message.path !== "") {
457
- writer.uint32(50).string(message.path);
458
- }
459
- if (message.from !== 0) {
460
- writer.uint32(56).uint32(message.from);
461
- }
462
- if (message.lastPage !== 0) {
463
- writer.uint32(64).uint32(message.lastPage);
464
- }
465
- if (message.perPage !== 0) {
466
- writer.uint32(72).uint32(message.perPage);
467
- }
468
- if (message.to !== 0) {
469
- writer.uint32(80).uint32(message.to);
470
- }
471
- for (const v of message.data) {
472
- Device.encode(v, writer.uint32(90).fork()).join();
473
- }
474
- return writer;
475
- },
476
- decode(input, length) {
477
- const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
478
- const end = length === undefined ? reader.len : reader.pos + length;
479
- const message = createBaseDevicePagination();
480
- while (reader.pos < end) {
481
- const tag = reader.uint32();
482
- switch (tag >>> 3) {
483
- case 1: {
484
- if (tag !== 8) {
485
- break;
486
- }
487
- message.currentPage = reader.uint32();
488
- continue;
489
- }
490
- case 2: {
491
- if (tag !== 18) {
492
- break;
493
- }
494
- message.firstPageUrl = reader.string();
495
- continue;
496
- }
497
- case 3: {
498
- if (tag !== 26) {
499
- break;
500
- }
501
- message.lastPageUrl = reader.string();
502
- continue;
503
- }
504
- case 4: {
505
- if (tag !== 34) {
506
- break;
507
- }
508
- message.nextPageUrl = reader.string();
509
- continue;
510
- }
511
- case 5: {
512
- if (tag !== 42) {
513
- break;
514
- }
515
- message.prevPageUrl = reader.string();
516
- continue;
517
- }
518
- case 6: {
519
- if (tag !== 50) {
520
- break;
521
- }
522
- message.path = reader.string();
523
- continue;
524
- }
525
- case 7: {
526
- if (tag !== 56) {
527
- break;
528
- }
529
- message.from = reader.uint32();
530
- continue;
531
- }
532
- case 8: {
533
- if (tag !== 64) {
534
- break;
535
- }
536
- message.lastPage = reader.uint32();
537
- continue;
538
- }
539
- case 9: {
540
- if (tag !== 72) {
541
- break;
542
- }
543
- message.perPage = reader.uint32();
544
- continue;
545
- }
546
- case 10: {
547
- if (tag !== 80) {
548
- break;
549
- }
550
- message.to = reader.uint32();
551
- continue;
552
- }
553
- case 11: {
554
- if (tag !== 90) {
555
- break;
556
- }
557
- message.data.push(Device.decode(reader, reader.uint32()));
558
- continue;
559
- }
560
- }
561
- if ((tag & 7) === 4 || tag === 0) {
562
- break;
563
- }
564
- reader.skip(tag & 7);
565
- }
566
- return message;
567
- },
568
- create(base) {
569
- return DevicePagination.fromPartial(base ?? {});
570
- },
571
- fromPartial(object) {
572
- const message = createBaseDevicePagination();
573
- message.currentPage = object.currentPage ?? 0;
574
- message.firstPageUrl = object.firstPageUrl ?? "";
575
- message.lastPageUrl = object.lastPageUrl ?? "";
576
- message.nextPageUrl = object.nextPageUrl ?? "";
577
- message.prevPageUrl = object.prevPageUrl ?? "";
578
- message.path = object.path ?? "";
579
- message.from = object.from ?? 0;
580
- message.lastPage = object.lastPage ?? 0;
581
- message.perPage = object.perPage ?? 0;
582
- message.to = object.to ?? 0;
583
- message.data = object.data?.map((e) => Device.fromPartial(e)) || [];
584
- return message;
585
- },
586
- };
587
- function createBaseConfig() {
588
- return {
589
- id: 0,
590
- organizationId: Long.UZERO,
591
- createdBy: undefined,
592
- updatedBy: undefined,
593
- key: "",
594
- value: "",
595
- createdAt: undefined,
596
- updatedAt: undefined,
597
- };
598
- }
599
- export const Config = {
600
- encode(message, writer = new BinaryWriter()) {
601
- if (message.id !== 0) {
602
- writer.uint32(8).uint32(message.id);
603
- }
604
- if (!message.organizationId.equals(Long.UZERO)) {
605
- writer.uint32(16).uint64(message.organizationId.toString());
606
- }
607
- if (message.createdBy !== undefined) {
608
- writer.uint32(24).uint64(message.createdBy.toString());
609
- }
610
- if (message.updatedBy !== undefined) {
611
- writer.uint32(32).uint64(message.updatedBy.toString());
612
- }
613
- if (message.key !== "") {
614
- writer.uint32(42).string(message.key);
615
- }
616
- if (message.value !== "") {
617
- writer.uint32(50).string(message.value);
618
- }
619
- if (message.createdAt !== undefined) {
620
- Timestamp.encode(toTimestamp(message.createdAt), writer.uint32(58).fork()).join();
621
- }
622
- if (message.updatedAt !== undefined) {
623
- Timestamp.encode(toTimestamp(message.updatedAt), writer.uint32(66).fork()).join();
624
- }
625
- return writer;
626
- },
627
- decode(input, length) {
628
- const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
629
- const end = length === undefined ? reader.len : reader.pos + length;
630
- const message = createBaseConfig();
631
- while (reader.pos < end) {
632
- const tag = reader.uint32();
633
- switch (tag >>> 3) {
634
- case 1: {
635
- if (tag !== 8) {
636
- break;
637
- }
638
- message.id = reader.uint32();
639
- continue;
640
- }
641
- case 2: {
642
- if (tag !== 16) {
643
- break;
644
- }
645
- message.organizationId = Long.fromString(reader.uint64().toString(), true);
646
- continue;
647
- }
648
- case 3: {
649
- if (tag !== 24) {
650
- break;
651
- }
652
- message.createdBy = Long.fromString(reader.uint64().toString(), true);
653
- continue;
654
- }
655
- case 4: {
656
- if (tag !== 32) {
657
- break;
658
- }
659
- message.updatedBy = Long.fromString(reader.uint64().toString(), true);
660
- continue;
661
- }
662
- case 5: {
663
- if (tag !== 42) {
664
- break;
665
- }
666
- message.key = reader.string();
667
- continue;
668
- }
669
- case 6: {
670
- if (tag !== 50) {
671
- break;
672
- }
673
- message.value = reader.string();
674
- continue;
675
- }
676
- case 7: {
677
- if (tag !== 58) {
678
- break;
679
- }
680
- message.createdAt = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
681
- continue;
682
- }
683
- case 8: {
684
- if (tag !== 66) {
685
- break;
686
- }
687
- message.updatedAt = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
688
- continue;
689
- }
690
- }
691
- if ((tag & 7) === 4 || tag === 0) {
692
- break;
693
- }
694
- reader.skip(tag & 7);
695
- }
696
- return message;
697
- },
698
- create(base) {
699
- return Config.fromPartial(base ?? {});
700
- },
701
- fromPartial(object) {
702
- const message = createBaseConfig();
703
- message.id = object.id ?? 0;
704
- message.organizationId = (object.organizationId !== undefined && object.organizationId !== null)
705
- ? Long.fromValue(object.organizationId)
706
- : Long.UZERO;
707
- message.createdBy = (object.createdBy !== undefined && object.createdBy !== null)
708
- ? Long.fromValue(object.createdBy)
709
- : undefined;
710
- message.updatedBy = (object.updatedBy !== undefined && object.updatedBy !== null)
711
- ? Long.fromValue(object.updatedBy)
712
- : undefined;
713
- message.key = object.key ?? "";
714
- message.value = object.value ?? "";
715
- message.createdAt = object.createdAt ?? undefined;
716
- message.updatedAt = object.updatedAt ?? undefined;
717
- return message;
718
- },
719
- };
720
- function createBaseConfigList() {
721
- return { configs: [] };
722
- }
723
- export const ConfigList = {
724
- encode(message, writer = new BinaryWriter()) {
725
- for (const v of message.configs) {
726
- Config.encode(v, writer.uint32(10).fork()).join();
727
- }
728
- return writer;
729
- },
730
- decode(input, length) {
731
- const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
732
- const end = length === undefined ? reader.len : reader.pos + length;
733
- const message = createBaseConfigList();
734
- while (reader.pos < end) {
735
- const tag = reader.uint32();
736
- switch (tag >>> 3) {
737
- case 1: {
738
- if (tag !== 10) {
739
- break;
740
- }
741
- message.configs.push(Config.decode(reader, reader.uint32()));
742
- continue;
743
- }
744
- }
745
- if ((tag & 7) === 4 || tag === 0) {
746
- break;
747
- }
748
- reader.skip(tag & 7);
749
- }
750
- return message;
751
- },
752
- create(base) {
753
- return ConfigList.fromPartial(base ?? {});
754
- },
755
- fromPartial(object) {
756
- const message = createBaseConfigList();
757
- message.configs = object.configs?.map((e) => Config.fromPartial(e)) || [];
758
- return message;
759
- },
760
- };
761
- function createBaseTransactionPagination() {
762
- return {
763
- currentPage: 0,
764
- firstPageUrl: "",
765
- lastPageUrl: "",
766
- nextPageUrl: "",
767
- prevPageUrl: "",
768
- path: "",
769
- from: 0,
770
- lastPage: 0,
771
- perPage: 0,
772
- to: 0,
773
- data: [],
774
- };
775
- }
776
- export const TransactionPagination = {
777
- encode(message, writer = new BinaryWriter()) {
778
- if (message.currentPage !== 0) {
779
- writer.uint32(8).uint32(message.currentPage);
780
- }
781
- if (message.firstPageUrl !== "") {
782
- writer.uint32(18).string(message.firstPageUrl);
783
- }
784
- if (message.lastPageUrl !== "") {
785
- writer.uint32(26).string(message.lastPageUrl);
786
- }
787
- if (message.nextPageUrl !== "") {
788
- writer.uint32(34).string(message.nextPageUrl);
789
- }
790
- if (message.prevPageUrl !== "") {
791
- writer.uint32(42).string(message.prevPageUrl);
792
- }
793
- if (message.path !== "") {
794
- writer.uint32(50).string(message.path);
795
- }
796
- if (message.from !== 0) {
797
- writer.uint32(56).uint32(message.from);
798
- }
799
- if (message.lastPage !== 0) {
800
- writer.uint32(64).uint32(message.lastPage);
801
- }
802
- if (message.perPage !== 0) {
803
- writer.uint32(72).uint32(message.perPage);
804
- }
805
- if (message.to !== 0) {
806
- writer.uint32(80).uint32(message.to);
807
- }
808
- for (const v of message.data) {
809
- Transaction.encode(v, writer.uint32(90).fork()).join();
810
- }
811
- return writer;
812
- },
813
- decode(input, length) {
814
- const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
815
- const end = length === undefined ? reader.len : reader.pos + length;
816
- const message = createBaseTransactionPagination();
817
- while (reader.pos < end) {
818
- const tag = reader.uint32();
819
- switch (tag >>> 3) {
820
- case 1: {
821
- if (tag !== 8) {
822
- break;
823
- }
824
- message.currentPage = reader.uint32();
825
- continue;
826
- }
827
- case 2: {
828
- if (tag !== 18) {
829
- break;
830
- }
831
- message.firstPageUrl = reader.string();
832
- continue;
833
- }
834
- case 3: {
835
- if (tag !== 26) {
836
- break;
837
- }
838
- message.lastPageUrl = reader.string();
839
- continue;
840
- }
841
- case 4: {
842
- if (tag !== 34) {
843
- break;
844
- }
845
- message.nextPageUrl = reader.string();
846
- continue;
847
- }
848
- case 5: {
849
- if (tag !== 42) {
850
- break;
851
- }
852
- message.prevPageUrl = reader.string();
853
- continue;
854
- }
855
- case 6: {
856
- if (tag !== 50) {
857
- break;
858
- }
859
- message.path = reader.string();
860
- continue;
861
- }
862
- case 7: {
863
- if (tag !== 56) {
864
- break;
865
- }
866
- message.from = reader.uint32();
867
- continue;
868
- }
869
- case 8: {
870
- if (tag !== 64) {
871
- break;
872
- }
873
- message.lastPage = reader.uint32();
874
- continue;
875
- }
876
- case 9: {
877
- if (tag !== 72) {
878
- break;
879
- }
880
- message.perPage = reader.uint32();
881
- continue;
882
- }
883
- case 10: {
884
- if (tag !== 80) {
885
- break;
886
- }
887
- message.to = reader.uint32();
888
- continue;
889
- }
890
- case 11: {
891
- if (tag !== 90) {
892
- break;
893
- }
894
- message.data.push(Transaction.decode(reader, reader.uint32()));
895
- continue;
896
- }
897
- }
898
- if ((tag & 7) === 4 || tag === 0) {
899
- break;
900
- }
901
- reader.skip(tag & 7);
902
- }
903
- return message;
904
- },
905
- create(base) {
906
- return TransactionPagination.fromPartial(base ?? {});
907
- },
908
- fromPartial(object) {
909
- const message = createBaseTransactionPagination();
910
- message.currentPage = object.currentPage ?? 0;
911
- message.firstPageUrl = object.firstPageUrl ?? "";
912
- message.lastPageUrl = object.lastPageUrl ?? "";
913
- message.nextPageUrl = object.nextPageUrl ?? "";
914
- message.prevPageUrl = object.prevPageUrl ?? "";
915
- message.path = object.path ?? "";
916
- message.from = object.from ?? 0;
917
- message.lastPage = object.lastPage ?? 0;
918
- message.perPage = object.perPage ?? 0;
919
- message.to = object.to ?? 0;
920
- message.data = object.data?.map((e) => Transaction.fromPartial(e)) || [];
921
- return message;
922
- },
923
- };
924
- function createBaseTransaction() {
925
- return {
926
- id: Long.UZERO,
927
- organizationId: Long.UZERO,
928
- fromUserId: undefined,
929
- createdBy: undefined,
930
- updatedBy: undefined,
931
- transactionReason: undefined,
932
- picture: undefined,
933
- description: undefined,
934
- fromCurrencyId: Long.UZERO,
935
- toCurrencyId: Long.UZERO,
936
- price: "",
937
- type: "",
938
- createdAt: undefined,
939
- updatedAt: undefined,
940
- currency: undefined,
941
- organization: undefined,
942
- };
943
- }
944
- export const Transaction = {
945
- encode(message, writer = new BinaryWriter()) {
946
- if (!message.id.equals(Long.UZERO)) {
947
- writer.uint32(8).uint64(message.id.toString());
948
- }
949
- if (!message.organizationId.equals(Long.UZERO)) {
950
- writer.uint32(16).uint64(message.organizationId.toString());
951
- }
952
- if (message.fromUserId !== undefined) {
953
- writer.uint32(24).uint64(message.fromUserId.toString());
954
- }
955
- if (message.createdBy !== undefined) {
956
- writer.uint32(32).uint64(message.createdBy.toString());
957
- }
958
- if (message.updatedBy !== undefined) {
959
- writer.uint32(40).uint64(message.updatedBy.toString());
960
- }
961
- if (message.transactionReason !== undefined) {
962
- writer.uint32(50).string(message.transactionReason);
963
- }
964
- if (message.picture !== undefined) {
965
- writer.uint32(58).string(message.picture);
966
- }
967
- if (message.description !== undefined) {
968
- writer.uint32(66).string(message.description);
969
- }
970
- if (!message.fromCurrencyId.equals(Long.UZERO)) {
971
- writer.uint32(72).uint64(message.fromCurrencyId.toString());
972
- }
973
- if (!message.toCurrencyId.equals(Long.UZERO)) {
974
- writer.uint32(80).uint64(message.toCurrencyId.toString());
975
- }
976
- if (message.price !== "") {
977
- writer.uint32(90).string(message.price);
978
- }
979
- if (message.type !== "") {
980
- writer.uint32(98).string(message.type);
981
- }
982
- if (message.createdAt !== undefined) {
983
- Timestamp.encode(toTimestamp(message.createdAt), writer.uint32(106).fork()).join();
984
- }
985
- if (message.updatedAt !== undefined) {
986
- Timestamp.encode(toTimestamp(message.updatedAt), writer.uint32(114).fork()).join();
987
- }
988
- if (message.currency !== undefined) {
989
- Currency.encode(message.currency, writer.uint32(122).fork()).join();
990
- }
991
- if (message.organization !== undefined) {
992
- Organization.encode(message.organization, writer.uint32(130).fork()).join();
993
- }
994
- return writer;
995
- },
996
- decode(input, length) {
997
- const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
998
- const end = length === undefined ? reader.len : reader.pos + length;
999
- const message = createBaseTransaction();
1000
- while (reader.pos < end) {
1001
- const tag = reader.uint32();
1002
- switch (tag >>> 3) {
1003
- case 1: {
1004
- if (tag !== 8) {
1005
- break;
1006
- }
1007
- message.id = Long.fromString(reader.uint64().toString(), true);
1008
- continue;
1009
- }
1010
- case 2: {
1011
- if (tag !== 16) {
1012
- break;
1013
- }
1014
- message.organizationId = Long.fromString(reader.uint64().toString(), true);
1015
- continue;
1016
- }
1017
- case 3: {
1018
- if (tag !== 24) {
1019
- break;
1020
- }
1021
- message.fromUserId = Long.fromString(reader.uint64().toString(), true);
1022
- continue;
1023
- }
1024
- case 4: {
1025
- if (tag !== 32) {
1026
- break;
1027
- }
1028
- message.createdBy = Long.fromString(reader.uint64().toString(), true);
1029
- continue;
1030
- }
1031
- case 5: {
1032
- if (tag !== 40) {
1033
- break;
1034
- }
1035
- message.updatedBy = Long.fromString(reader.uint64().toString(), true);
1036
- continue;
1037
- }
1038
- case 6: {
1039
- if (tag !== 50) {
1040
- break;
1041
- }
1042
- message.transactionReason = reader.string();
1043
- continue;
1044
- }
1045
- case 7: {
1046
- if (tag !== 58) {
1047
- break;
1048
- }
1049
- message.picture = reader.string();
1050
- continue;
1051
- }
1052
- case 8: {
1053
- if (tag !== 66) {
1054
- break;
1055
- }
1056
- message.description = reader.string();
1057
- continue;
1058
- }
1059
- case 9: {
1060
- if (tag !== 72) {
1061
- break;
1062
- }
1063
- message.fromCurrencyId = Long.fromString(reader.uint64().toString(), true);
1064
- continue;
1065
- }
1066
- case 10: {
1067
- if (tag !== 80) {
1068
- break;
1069
- }
1070
- message.toCurrencyId = Long.fromString(reader.uint64().toString(), true);
1071
- continue;
1072
- }
1073
- case 11: {
1074
- if (tag !== 90) {
1075
- break;
1076
- }
1077
- message.price = reader.string();
1078
- continue;
1079
- }
1080
- case 12: {
1081
- if (tag !== 98) {
1082
- break;
1083
- }
1084
- message.type = reader.string();
1085
- continue;
1086
- }
1087
- case 13: {
1088
- if (tag !== 106) {
1089
- break;
1090
- }
1091
- message.createdAt = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
1092
- continue;
1093
- }
1094
- case 14: {
1095
- if (tag !== 114) {
1096
- break;
1097
- }
1098
- message.updatedAt = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
1099
- continue;
1100
- }
1101
- case 15: {
1102
- if (tag !== 122) {
1103
- break;
1104
- }
1105
- message.currency = Currency.decode(reader, reader.uint32());
1106
- continue;
1107
- }
1108
- case 16: {
1109
- if (tag !== 130) {
1110
- break;
1111
- }
1112
- message.organization = Organization.decode(reader, reader.uint32());
1113
- continue;
1114
- }
1115
- }
1116
- if ((tag & 7) === 4 || tag === 0) {
1117
- break;
1118
- }
1119
- reader.skip(tag & 7);
1120
- }
1121
- return message;
1122
- },
1123
- create(base) {
1124
- return Transaction.fromPartial(base ?? {});
1125
- },
1126
- fromPartial(object) {
1127
- const message = createBaseTransaction();
1128
- message.id = (object.id !== undefined && object.id !== null) ? Long.fromValue(object.id) : Long.UZERO;
1129
- message.organizationId = (object.organizationId !== undefined && object.organizationId !== null)
1130
- ? Long.fromValue(object.organizationId)
1131
- : Long.UZERO;
1132
- message.fromUserId = (object.fromUserId !== undefined && object.fromUserId !== null)
1133
- ? Long.fromValue(object.fromUserId)
1134
- : undefined;
1135
- message.createdBy = (object.createdBy !== undefined && object.createdBy !== null)
1136
- ? Long.fromValue(object.createdBy)
1137
- : undefined;
1138
- message.updatedBy = (object.updatedBy !== undefined && object.updatedBy !== null)
1139
- ? Long.fromValue(object.updatedBy)
1140
- : undefined;
1141
- message.transactionReason = object.transactionReason ?? undefined;
1142
- message.picture = object.picture ?? undefined;
1143
- message.description = object.description ?? undefined;
1144
- message.fromCurrencyId = (object.fromCurrencyId !== undefined && object.fromCurrencyId !== null)
1145
- ? Long.fromValue(object.fromCurrencyId)
1146
- : Long.UZERO;
1147
- message.toCurrencyId = (object.toCurrencyId !== undefined && object.toCurrencyId !== null)
1148
- ? Long.fromValue(object.toCurrencyId)
1149
- : Long.UZERO;
1150
- message.price = object.price ?? "";
1151
- message.type = object.type ?? "";
1152
- message.createdAt = object.createdAt ?? undefined;
1153
- message.updatedAt = object.updatedAt ?? undefined;
1154
- message.currency = (object.currency !== undefined && object.currency !== null)
1155
- ? Currency.fromPartial(object.currency)
1156
- : undefined;
1157
- message.organization = (object.organization !== undefined && object.organization !== null)
1158
- ? Organization.fromPartial(object.organization)
1159
- : undefined;
1160
- return message;
1161
- },
1162
- };
1163
- function createBaseChannel() {
1164
- return { name: "", count: Long.UZERO };
1165
- }
1166
- export const Channel = {
1167
- encode(message, writer = new BinaryWriter()) {
1168
- if (message.name !== "") {
1169
- writer.uint32(10).string(message.name);
1170
- }
1171
- if (!message.count.equals(Long.UZERO)) {
1172
- writer.uint32(16).uint64(message.count.toString());
1173
- }
1174
- return writer;
1175
- },
1176
- decode(input, length) {
1177
- const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
1178
- const end = length === undefined ? reader.len : reader.pos + length;
1179
- const message = createBaseChannel();
1180
- while (reader.pos < end) {
1181
- const tag = reader.uint32();
1182
- switch (tag >>> 3) {
1183
- case 1: {
1184
- if (tag !== 10) {
1185
- break;
1186
- }
1187
- message.name = reader.string();
1188
- continue;
1189
- }
1190
- case 2: {
1191
- if (tag !== 16) {
1192
- break;
1193
- }
1194
- message.count = Long.fromString(reader.uint64().toString(), true);
1195
- continue;
1196
- }
1197
- }
1198
- if ((tag & 7) === 4 || tag === 0) {
1199
- break;
1200
- }
1201
- reader.skip(tag & 7);
1202
- }
1203
- return message;
1204
- },
1205
- create(base) {
1206
- return Channel.fromPartial(base ?? {});
1207
- },
1208
- fromPartial(object) {
1209
- const message = createBaseChannel();
1210
- message.name = object.name ?? "";
1211
- message.count = (object.count !== undefined && object.count !== null) ? Long.fromValue(object.count) : Long.UZERO;
1212
- return message;
1213
- },
1214
- };
1215
- function createBaseStatistics() {
1216
- return { total: Long.UZERO, read: Long.UZERO, unread: Long.UZERO, channelsUsed: [] };
1217
- }
1218
- export const Statistics = {
1219
- encode(message, writer = new BinaryWriter()) {
1220
- if (!message.total.equals(Long.UZERO)) {
1221
- writer.uint32(8).uint64(message.total.toString());
1222
- }
1223
- if (!message.read.equals(Long.UZERO)) {
1224
- writer.uint32(16).uint64(message.read.toString());
1225
- }
1226
- if (!message.unread.equals(Long.UZERO)) {
1227
- writer.uint32(24).uint64(message.unread.toString());
1228
- }
1229
- for (const v of message.channelsUsed) {
1230
- Channel.encode(v, writer.uint32(34).fork()).join();
1231
- }
1232
- return writer;
1233
- },
1234
- decode(input, length) {
1235
- const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
1236
- const end = length === undefined ? reader.len : reader.pos + length;
1237
- const message = createBaseStatistics();
1238
- while (reader.pos < end) {
1239
- const tag = reader.uint32();
1240
- switch (tag >>> 3) {
1241
- case 1: {
1242
- if (tag !== 8) {
1243
- break;
1244
- }
1245
- message.total = Long.fromString(reader.uint64().toString(), true);
1246
- continue;
1247
- }
1248
- case 2: {
1249
- if (tag !== 16) {
1250
- break;
1251
- }
1252
- message.read = Long.fromString(reader.uint64().toString(), true);
1253
- continue;
1254
- }
1255
- case 3: {
1256
- if (tag !== 24) {
1257
- break;
1258
- }
1259
- message.unread = Long.fromString(reader.uint64().toString(), true);
1260
- continue;
1261
- }
1262
- case 4: {
1263
- if (tag !== 34) {
1264
- break;
1265
- }
1266
- message.channelsUsed.push(Channel.decode(reader, reader.uint32()));
1267
- continue;
1268
- }
1269
- }
1270
- if ((tag & 7) === 4 || tag === 0) {
1271
- break;
1272
- }
1273
- reader.skip(tag & 7);
1274
- }
1275
- return message;
1276
- },
1277
- create(base) {
1278
- return Statistics.fromPartial(base ?? {});
1279
- },
1280
- fromPartial(object) {
1281
- const message = createBaseStatistics();
1282
- message.total = (object.total !== undefined && object.total !== null) ? Long.fromValue(object.total) : Long.UZERO;
1283
- message.read = (object.read !== undefined && object.read !== null) ? Long.fromValue(object.read) : Long.UZERO;
1284
- message.unread = (object.unread !== undefined && object.unread !== null)
1285
- ? Long.fromValue(object.unread)
1286
- : Long.UZERO;
1287
- message.channelsUsed = object.channelsUsed?.map((e) => Channel.fromPartial(e)) || [];
1288
- return message;
1289
- },
1290
- };
1291
- function createBaseTopRepeatedNotification() {
1292
- return { title: "", count: Long.UZERO };
1293
- }
1294
- export const TopRepeatedNotification = {
1295
- encode(message, writer = new BinaryWriter()) {
1296
- if (message.title !== "") {
1297
- writer.uint32(10).string(message.title);
1298
- }
1299
- if (!message.count.equals(Long.UZERO)) {
1300
- writer.uint32(16).uint64(message.count.toString());
1301
- }
1302
- return writer;
1303
- },
1304
- decode(input, length) {
1305
- const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
1306
- const end = length === undefined ? reader.len : reader.pos + length;
1307
- const message = createBaseTopRepeatedNotification();
1308
- while (reader.pos < end) {
1309
- const tag = reader.uint32();
1310
- switch (tag >>> 3) {
1311
- case 1: {
1312
- if (tag !== 10) {
1313
- break;
1314
- }
1315
- message.title = reader.string();
1316
- continue;
1317
- }
1318
- case 2: {
1319
- if (tag !== 16) {
1320
- break;
1321
- }
1322
- message.count = Long.fromString(reader.uint64().toString(), true);
1323
- continue;
1324
- }
1325
- }
1326
- if ((tag & 7) === 4 || tag === 0) {
1327
- break;
1328
- }
1329
- reader.skip(tag & 7);
1330
- }
1331
- return message;
1332
- },
1333
- create(base) {
1334
- return TopRepeatedNotification.fromPartial(base ?? {});
1335
- },
1336
- fromPartial(object) {
1337
- const message = createBaseTopRepeatedNotification();
1338
- message.title = object.title ?? "";
1339
- message.count = (object.count !== undefined && object.count !== null) ? Long.fromValue(object.count) : Long.UZERO;
1340
- return message;
1341
- },
1342
- };
1343
- function createBaseSessionPagination() {
1344
- return {
1345
- currentPage: 0,
1346
- firstPageUrl: "",
1347
- lastPageUrl: "",
1348
- nextPageUrl: "",
1349
- prevPageUrl: "",
1350
- path: "",
1351
- from: 0,
1352
- lastPage: 0,
1353
- perPage: 0,
1354
- to: 0,
1355
- data: [],
1356
- };
1357
- }
1358
- export const SessionPagination = {
1359
- encode(message, writer = new BinaryWriter()) {
1360
- if (message.currentPage !== 0) {
1361
- writer.uint32(8).uint32(message.currentPage);
1362
- }
1363
- if (message.firstPageUrl !== "") {
1364
- writer.uint32(18).string(message.firstPageUrl);
1365
- }
1366
- if (message.lastPageUrl !== "") {
1367
- writer.uint32(26).string(message.lastPageUrl);
1368
- }
1369
- if (message.nextPageUrl !== "") {
1370
- writer.uint32(34).string(message.nextPageUrl);
1371
- }
1372
- if (message.prevPageUrl !== "") {
1373
- writer.uint32(42).string(message.prevPageUrl);
1374
- }
1375
- if (message.path !== "") {
1376
- writer.uint32(50).string(message.path);
1377
- }
1378
- if (message.from !== 0) {
1379
- writer.uint32(56).uint32(message.from);
1380
- }
1381
- if (message.lastPage !== 0) {
1382
- writer.uint32(64).uint32(message.lastPage);
1383
- }
1384
- if (message.perPage !== 0) {
1385
- writer.uint32(72).uint32(message.perPage);
1386
- }
1387
- if (message.to !== 0) {
1388
- writer.uint32(80).uint32(message.to);
1389
- }
1390
- for (const v of message.data) {
1391
- Session.encode(v, writer.uint32(90).fork()).join();
1392
- }
1393
- return writer;
1394
- },
1395
- decode(input, length) {
1396
- const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
1397
- const end = length === undefined ? reader.len : reader.pos + length;
1398
- const message = createBaseSessionPagination();
1399
- while (reader.pos < end) {
1400
- const tag = reader.uint32();
1401
- switch (tag >>> 3) {
1402
- case 1: {
1403
- if (tag !== 8) {
1404
- break;
1405
- }
1406
- message.currentPage = reader.uint32();
1407
- continue;
1408
- }
1409
- case 2: {
1410
- if (tag !== 18) {
1411
- break;
1412
- }
1413
- message.firstPageUrl = reader.string();
1414
- continue;
1415
- }
1416
- case 3: {
1417
- if (tag !== 26) {
1418
- break;
1419
- }
1420
- message.lastPageUrl = reader.string();
1421
- continue;
1422
- }
1423
- case 4: {
1424
- if (tag !== 34) {
1425
- break;
1426
- }
1427
- message.nextPageUrl = reader.string();
1428
- continue;
1429
- }
1430
- case 5: {
1431
- if (tag !== 42) {
1432
- break;
1433
- }
1434
- message.prevPageUrl = reader.string();
1435
- continue;
1436
- }
1437
- case 6: {
1438
- if (tag !== 50) {
1439
- break;
1440
- }
1441
- message.path = reader.string();
1442
- continue;
1443
- }
1444
- case 7: {
1445
- if (tag !== 56) {
1446
- break;
1447
- }
1448
- message.from = reader.uint32();
1449
- continue;
1450
- }
1451
- case 8: {
1452
- if (tag !== 64) {
1453
- break;
1454
- }
1455
- message.lastPage = reader.uint32();
1456
- continue;
1457
- }
1458
- case 9: {
1459
- if (tag !== 72) {
1460
- break;
1461
- }
1462
- message.perPage = reader.uint32();
1463
- continue;
1464
- }
1465
- case 10: {
1466
- if (tag !== 80) {
1467
- break;
1468
- }
1469
- message.to = reader.uint32();
1470
- continue;
1471
- }
1472
- case 11: {
1473
- if (tag !== 90) {
1474
- break;
1475
- }
1476
- message.data.push(Session.decode(reader, reader.uint32()));
1477
- continue;
1478
- }
1479
- }
1480
- if ((tag & 7) === 4 || tag === 0) {
1481
- break;
1482
- }
1483
- reader.skip(tag & 7);
1484
- }
1485
- return message;
1486
- },
1487
- create(base) {
1488
- return SessionPagination.fromPartial(base ?? {});
1489
- },
1490
- fromPartial(object) {
1491
- const message = createBaseSessionPagination();
1492
- message.currentPage = object.currentPage ?? 0;
1493
- message.firstPageUrl = object.firstPageUrl ?? "";
1494
- message.lastPageUrl = object.lastPageUrl ?? "";
1495
- message.nextPageUrl = object.nextPageUrl ?? "";
1496
- message.prevPageUrl = object.prevPageUrl ?? "";
1497
- message.path = object.path ?? "";
1498
- message.from = object.from ?? 0;
1499
- message.lastPage = object.lastPage ?? 0;
1500
- message.perPage = object.perPage ?? 0;
1501
- message.to = object.to ?? 0;
1502
- message.data = object.data?.map((e) => Session.fromPartial(e)) || [];
1503
- return message;
1504
- },
1505
- };
1506
- function createBaseTrackerPagination() {
1507
- return {
1508
- currentPage: 0,
1509
- firstPageUrl: "",
1510
- lastPageUrl: "",
1511
- nextPageUrl: "",
1512
- prevPageUrl: "",
1513
- path: "",
1514
- from: 0,
1515
- lastPage: 0,
1516
- perPage: 0,
1517
- to: 0,
1518
- data: [],
1519
- };
1520
- }
1521
- export const TrackerPagination = {
1522
- encode(message, writer = new BinaryWriter()) {
1523
- if (message.currentPage !== 0) {
1524
- writer.uint32(8).uint32(message.currentPage);
1525
- }
1526
- if (message.firstPageUrl !== "") {
1527
- writer.uint32(18).string(message.firstPageUrl);
1528
- }
1529
- if (message.lastPageUrl !== "") {
1530
- writer.uint32(26).string(message.lastPageUrl);
1531
- }
1532
- if (message.nextPageUrl !== "") {
1533
- writer.uint32(34).string(message.nextPageUrl);
1534
- }
1535
- if (message.prevPageUrl !== "") {
1536
- writer.uint32(42).string(message.prevPageUrl);
1537
- }
1538
- if (message.path !== "") {
1539
- writer.uint32(50).string(message.path);
1540
- }
1541
- if (message.from !== 0) {
1542
- writer.uint32(56).uint32(message.from);
1543
- }
1544
- if (message.lastPage !== 0) {
1545
- writer.uint32(64).uint32(message.lastPage);
1546
- }
1547
- if (message.perPage !== 0) {
1548
- writer.uint32(72).uint32(message.perPage);
1549
- }
1550
- if (message.to !== 0) {
1551
- writer.uint32(80).uint32(message.to);
1552
- }
1553
- for (const v of message.data) {
1554
- Tracker.encode(v, writer.uint32(90).fork()).join();
1555
- }
1556
- return writer;
1557
- },
1558
- decode(input, length) {
1559
- const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
1560
- const end = length === undefined ? reader.len : reader.pos + length;
1561
- const message = createBaseTrackerPagination();
1562
- while (reader.pos < end) {
1563
- const tag = reader.uint32();
1564
- switch (tag >>> 3) {
1565
- case 1: {
1566
- if (tag !== 8) {
1567
- break;
1568
- }
1569
- message.currentPage = reader.uint32();
1570
- continue;
1571
- }
1572
- case 2: {
1573
- if (tag !== 18) {
1574
- break;
1575
- }
1576
- message.firstPageUrl = reader.string();
1577
- continue;
1578
- }
1579
- case 3: {
1580
- if (tag !== 26) {
1581
- break;
1582
- }
1583
- message.lastPageUrl = reader.string();
1584
- continue;
1585
- }
1586
- case 4: {
1587
- if (tag !== 34) {
1588
- break;
1589
- }
1590
- message.nextPageUrl = reader.string();
1591
- continue;
1592
- }
1593
- case 5: {
1594
- if (tag !== 42) {
1595
- break;
1596
- }
1597
- message.prevPageUrl = reader.string();
1598
- continue;
1599
- }
1600
- case 6: {
1601
- if (tag !== 50) {
1602
- break;
1603
- }
1604
- message.path = reader.string();
1605
- continue;
1606
- }
1607
- case 7: {
1608
- if (tag !== 56) {
1609
- break;
1610
- }
1611
- message.from = reader.uint32();
1612
- continue;
1613
- }
1614
- case 8: {
1615
- if (tag !== 64) {
1616
- break;
1617
- }
1618
- message.lastPage = reader.uint32();
1619
- continue;
1620
- }
1621
- case 9: {
1622
- if (tag !== 72) {
1623
- break;
1624
- }
1625
- message.perPage = reader.uint32();
1626
- continue;
1627
- }
1628
- case 10: {
1629
- if (tag !== 80) {
1630
- break;
1631
- }
1632
- message.to = reader.uint32();
1633
- continue;
1634
- }
1635
- case 11: {
1636
- if (tag !== 90) {
1637
- break;
1638
- }
1639
- message.data.push(Tracker.decode(reader, reader.uint32()));
1640
- continue;
1641
- }
1642
- }
1643
- if ((tag & 7) === 4 || tag === 0) {
1644
- break;
1645
- }
1646
- reader.skip(tag & 7);
1647
- }
1648
- return message;
1649
- },
1650
- create(base) {
1651
- return TrackerPagination.fromPartial(base ?? {});
1652
- },
1653
- fromPartial(object) {
1654
- const message = createBaseTrackerPagination();
1655
- message.currentPage = object.currentPage ?? 0;
1656
- message.firstPageUrl = object.firstPageUrl ?? "";
1657
- message.lastPageUrl = object.lastPageUrl ?? "";
1658
- message.nextPageUrl = object.nextPageUrl ?? "";
1659
- message.prevPageUrl = object.prevPageUrl ?? "";
1660
- message.path = object.path ?? "";
1661
- message.from = object.from ?? 0;
1662
- message.lastPage = object.lastPage ?? 0;
1663
- message.perPage = object.perPage ?? 0;
1664
- message.to = object.to ?? 0;
1665
- message.data = object.data?.map((e) => Tracker.fromPartial(e)) || [];
1666
- return message;
1667
- },
1668
- };
1669
- function createBaseSession() {
1670
- return {
1671
- id: Long.UZERO,
1672
- tokenableType: "",
1673
- tokenableId: Long.UZERO,
1674
- name: undefined,
1675
- abilities: [],
1676
- fcm: undefined,
1677
- ip: undefined,
1678
- domain: undefined,
1679
- partnerId: undefined,
1680
- userAgent: undefined,
1681
- deviceType: undefined,
1682
- lastUsedAt: undefined,
1683
- expiresAt: undefined,
1684
- createdAt: undefined,
1685
- updatedAt: undefined,
1686
- currentSession: false,
1687
- isExpired: false,
1688
- };
1689
- }
1690
- export const Session = {
1691
- encode(message, writer = new BinaryWriter()) {
1692
- if (!message.id.equals(Long.UZERO)) {
1693
- writer.uint32(8).uint64(message.id.toString());
1694
- }
1695
- if (message.tokenableType !== "") {
1696
- writer.uint32(18).string(message.tokenableType);
1697
- }
1698
- if (!message.tokenableId.equals(Long.UZERO)) {
1699
- writer.uint32(24).uint64(message.tokenableId.toString());
1700
- }
1701
- if (message.name !== undefined) {
1702
- writer.uint32(34).string(message.name);
1703
- }
1704
- for (const v of message.abilities) {
1705
- writer.uint32(42).string(v);
1706
- }
1707
- if (message.fcm !== undefined) {
1708
- writer.uint32(50).string(message.fcm);
1709
- }
1710
- if (message.ip !== undefined) {
1711
- writer.uint32(58).string(message.ip);
1712
- }
1713
- if (message.domain !== undefined) {
1714
- writer.uint32(66).string(message.domain);
1715
- }
1716
- if (message.partnerId !== undefined) {
1717
- writer.uint32(72).uint64(message.partnerId.toString());
1718
- }
1719
- if (message.userAgent !== undefined) {
1720
- writer.uint32(82).string(message.userAgent);
1721
- }
1722
- if (message.deviceType !== undefined) {
1723
- writer.uint32(90).string(message.deviceType);
1724
- }
1725
- if (message.lastUsedAt !== undefined) {
1726
- Timestamp.encode(toTimestamp(message.lastUsedAt), writer.uint32(98).fork()).join();
1727
- }
1728
- if (message.expiresAt !== undefined) {
1729
- Timestamp.encode(toTimestamp(message.expiresAt), writer.uint32(106).fork()).join();
1730
- }
1731
- if (message.createdAt !== undefined) {
1732
- Timestamp.encode(toTimestamp(message.createdAt), writer.uint32(114).fork()).join();
1733
- }
1734
- if (message.updatedAt !== undefined) {
1735
- Timestamp.encode(toTimestamp(message.updatedAt), writer.uint32(122).fork()).join();
1736
- }
1737
- if (message.currentSession !== false) {
1738
- writer.uint32(128).bool(message.currentSession);
1739
- }
1740
- if (message.isExpired !== false) {
1741
- writer.uint32(136).bool(message.isExpired);
1742
- }
1743
- return writer;
1744
- },
1745
- decode(input, length) {
1746
- const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
1747
- const end = length === undefined ? reader.len : reader.pos + length;
1748
- const message = createBaseSession();
1749
- while (reader.pos < end) {
1750
- const tag = reader.uint32();
1751
- switch (tag >>> 3) {
1752
- case 1: {
1753
- if (tag !== 8) {
1754
- break;
1755
- }
1756
- message.id = Long.fromString(reader.uint64().toString(), true);
1757
- continue;
1758
- }
1759
- case 2: {
1760
- if (tag !== 18) {
1761
- break;
1762
- }
1763
- message.tokenableType = reader.string();
1764
- continue;
1765
- }
1766
- case 3: {
1767
- if (tag !== 24) {
1768
- break;
1769
- }
1770
- message.tokenableId = Long.fromString(reader.uint64().toString(), true);
1771
- continue;
1772
- }
1773
- case 4: {
1774
- if (tag !== 34) {
1775
- break;
1776
- }
1777
- message.name = reader.string();
1778
- continue;
1779
- }
1780
- case 5: {
1781
- if (tag !== 42) {
1782
- break;
1783
- }
1784
- message.abilities.push(reader.string());
1785
- continue;
1786
- }
1787
- case 6: {
1788
- if (tag !== 50) {
1789
- break;
1790
- }
1791
- message.fcm = reader.string();
1792
- continue;
1793
- }
1794
- case 7: {
1795
- if (tag !== 58) {
1796
- break;
1797
- }
1798
- message.ip = reader.string();
1799
- continue;
1800
- }
1801
- case 8: {
1802
- if (tag !== 66) {
1803
- break;
1804
- }
1805
- message.domain = reader.string();
1806
- continue;
1807
- }
1808
- case 9: {
1809
- if (tag !== 72) {
1810
- break;
1811
- }
1812
- message.partnerId = Long.fromString(reader.uint64().toString(), true);
1813
- continue;
1814
- }
1815
- case 10: {
1816
- if (tag !== 82) {
1817
- break;
1818
- }
1819
- message.userAgent = reader.string();
1820
- continue;
1821
- }
1822
- case 11: {
1823
- if (tag !== 90) {
1824
- break;
1825
- }
1826
- message.deviceType = reader.string();
1827
- continue;
1828
- }
1829
- case 12: {
1830
- if (tag !== 98) {
1831
- break;
1832
- }
1833
- message.lastUsedAt = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
1834
- continue;
1835
- }
1836
- case 13: {
1837
- if (tag !== 106) {
1838
- break;
1839
- }
1840
- message.expiresAt = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
1841
- continue;
1842
- }
1843
- case 14: {
1844
- if (tag !== 114) {
1845
- break;
1846
- }
1847
- message.createdAt = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
1848
- continue;
1849
- }
1850
- case 15: {
1851
- if (tag !== 122) {
1852
- break;
1853
- }
1854
- message.updatedAt = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
1855
- continue;
1856
- }
1857
- case 16: {
1858
- if (tag !== 128) {
1859
- break;
1860
- }
1861
- message.currentSession = reader.bool();
1862
- continue;
1863
- }
1864
- case 17: {
1865
- if (tag !== 136) {
1866
- break;
1867
- }
1868
- message.isExpired = reader.bool();
1869
- continue;
1870
- }
1871
- }
1872
- if ((tag & 7) === 4 || tag === 0) {
1873
- break;
1874
- }
1875
- reader.skip(tag & 7);
1876
- }
1877
- return message;
1878
- },
1879
- create(base) {
1880
- return Session.fromPartial(base ?? {});
1881
- },
1882
- fromPartial(object) {
1883
- const message = createBaseSession();
1884
- message.id = (object.id !== undefined && object.id !== null) ? Long.fromValue(object.id) : Long.UZERO;
1885
- message.tokenableType = object.tokenableType ?? "";
1886
- message.tokenableId = (object.tokenableId !== undefined && object.tokenableId !== null)
1887
- ? Long.fromValue(object.tokenableId)
1888
- : Long.UZERO;
1889
- message.name = object.name ?? undefined;
1890
- message.abilities = object.abilities?.map((e) => e) || [];
1891
- message.fcm = object.fcm ?? undefined;
1892
- message.ip = object.ip ?? undefined;
1893
- message.domain = object.domain ?? undefined;
1894
- message.partnerId = (object.partnerId !== undefined && object.partnerId !== null)
1895
- ? Long.fromValue(object.partnerId)
1896
- : undefined;
1897
- message.userAgent = object.userAgent ?? undefined;
1898
- message.deviceType = object.deviceType ?? undefined;
1899
- message.lastUsedAt = object.lastUsedAt ?? undefined;
1900
- message.expiresAt = object.expiresAt ?? undefined;
1901
- message.createdAt = object.createdAt ?? undefined;
1902
- message.updatedAt = object.updatedAt ?? undefined;
1903
- message.currentSession = object.currentSession ?? false;
1904
- message.isExpired = object.isExpired ?? false;
1905
- return message;
1906
- },
1907
- };
1908
- function createBaseCommandPagination() {
1909
- return {
1910
- currentPage: 0,
1911
- firstPageUrl: "",
1912
- lastPageUrl: "",
1913
- nextPageUrl: "",
1914
- prevPageUrl: "",
1915
- path: "",
1916
- from: 0,
1917
- lastPage: 0,
1918
- perPage: 0,
1919
- to: 0,
1920
- data: [],
1921
- };
1922
- }
1923
- export const CommandPagination = {
1924
- encode(message, writer = new BinaryWriter()) {
1925
- if (message.currentPage !== 0) {
1926
- writer.uint32(8).uint32(message.currentPage);
1927
- }
1928
- if (message.firstPageUrl !== "") {
1929
- writer.uint32(18).string(message.firstPageUrl);
1930
- }
1931
- if (message.lastPageUrl !== "") {
1932
- writer.uint32(26).string(message.lastPageUrl);
1933
- }
1934
- if (message.nextPageUrl !== "") {
1935
- writer.uint32(34).string(message.nextPageUrl);
1936
- }
1937
- if (message.prevPageUrl !== "") {
1938
- writer.uint32(42).string(message.prevPageUrl);
1939
- }
1940
- if (message.path !== "") {
1941
- writer.uint32(50).string(message.path);
1942
- }
1943
- if (message.from !== 0) {
1944
- writer.uint32(56).uint32(message.from);
1945
- }
1946
- if (message.lastPage !== 0) {
1947
- writer.uint32(64).uint32(message.lastPage);
1948
- }
1949
- if (message.perPage !== 0) {
1950
- writer.uint32(72).uint32(message.perPage);
1951
- }
1952
- if (message.to !== 0) {
1953
- writer.uint32(80).uint32(message.to);
1954
- }
1955
- for (const v of message.data) {
1956
- CommandStruct.encode(v, writer.uint32(90).fork()).join();
1957
- }
1958
- return writer;
1959
- },
1960
- decode(input, length) {
1961
- const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
1962
- const end = length === undefined ? reader.len : reader.pos + length;
1963
- const message = createBaseCommandPagination();
1964
- while (reader.pos < end) {
1965
- const tag = reader.uint32();
1966
- switch (tag >>> 3) {
1967
- case 1: {
1968
- if (tag !== 8) {
1969
- break;
1970
- }
1971
- message.currentPage = reader.uint32();
1972
- continue;
1973
- }
1974
- case 2: {
1975
- if (tag !== 18) {
1976
- break;
1977
- }
1978
- message.firstPageUrl = reader.string();
1979
- continue;
1980
- }
1981
- case 3: {
1982
- if (tag !== 26) {
1983
- break;
1984
- }
1985
- message.lastPageUrl = reader.string();
1986
- continue;
1987
- }
1988
- case 4: {
1989
- if (tag !== 34) {
1990
- break;
1991
- }
1992
- message.nextPageUrl = reader.string();
1993
- continue;
1994
- }
1995
- case 5: {
1996
- if (tag !== 42) {
1997
- break;
1998
- }
1999
- message.prevPageUrl = reader.string();
2000
- continue;
2001
- }
2002
- case 6: {
2003
- if (tag !== 50) {
2004
- break;
2005
- }
2006
- message.path = reader.string();
2007
- continue;
2008
- }
2009
- case 7: {
2010
- if (tag !== 56) {
2011
- break;
2012
- }
2013
- message.from = reader.uint32();
2014
- continue;
2015
- }
2016
- case 8: {
2017
- if (tag !== 64) {
2018
- break;
2019
- }
2020
- message.lastPage = reader.uint32();
2021
- continue;
2022
- }
2023
- case 9: {
2024
- if (tag !== 72) {
2025
- break;
2026
- }
2027
- message.perPage = reader.uint32();
2028
- continue;
2029
- }
2030
- case 10: {
2031
- if (tag !== 80) {
2032
- break;
2033
- }
2034
- message.to = reader.uint32();
2035
- continue;
2036
- }
2037
- case 11: {
2038
- if (tag !== 90) {
2039
- break;
2040
- }
2041
- message.data.push(CommandStruct.decode(reader, reader.uint32()));
2042
- continue;
2043
- }
2044
- }
2045
- if ((tag & 7) === 4 || tag === 0) {
2046
- break;
2047
- }
2048
- reader.skip(tag & 7);
2049
- }
2050
- return message;
2051
- },
2052
- create(base) {
2053
- return CommandPagination.fromPartial(base ?? {});
2054
- },
2055
- fromPartial(object) {
2056
- const message = createBaseCommandPagination();
2057
- message.currentPage = object.currentPage ?? 0;
2058
- message.firstPageUrl = object.firstPageUrl ?? "";
2059
- message.lastPageUrl = object.lastPageUrl ?? "";
2060
- message.nextPageUrl = object.nextPageUrl ?? "";
2061
- message.prevPageUrl = object.prevPageUrl ?? "";
2062
- message.path = object.path ?? "";
2063
- message.from = object.from ?? 0;
2064
- message.lastPage = object.lastPage ?? 0;
2065
- message.perPage = object.perPage ?? 0;
2066
- message.to = object.to ?? 0;
2067
- message.data = object.data?.map((e) => CommandStruct.fromPartial(e)) || [];
2068
- return message;
2069
- },
2070
- };
2071
- function createBaseLiveLocationPagination() {
2072
- return {
2073
- currentPage: 0,
2074
- firstPageUrl: "",
2075
- lastPageUrl: "",
2076
- nextPageUrl: "",
2077
- prevPageUrl: "",
2078
- path: "",
2079
- from: 0,
2080
- lastPage: 0,
2081
- perPage: 0,
2082
- to: 0,
2083
- data: [],
2084
- };
2085
- }
2086
- export const LiveLocationPagination = {
2087
- encode(message, writer = new BinaryWriter()) {
2088
- if (message.currentPage !== 0) {
2089
- writer.uint32(8).uint32(message.currentPage);
2090
- }
2091
- if (message.firstPageUrl !== "") {
2092
- writer.uint32(18).string(message.firstPageUrl);
2093
- }
2094
- if (message.lastPageUrl !== "") {
2095
- writer.uint32(26).string(message.lastPageUrl);
2096
- }
2097
- if (message.nextPageUrl !== "") {
2098
- writer.uint32(34).string(message.nextPageUrl);
2099
- }
2100
- if (message.prevPageUrl !== "") {
2101
- writer.uint32(42).string(message.prevPageUrl);
2102
- }
2103
- if (message.path !== "") {
2104
- writer.uint32(50).string(message.path);
2105
- }
2106
- if (message.from !== 0) {
2107
- writer.uint32(56).uint32(message.from);
2108
- }
2109
- if (message.lastPage !== 0) {
2110
- writer.uint32(64).uint32(message.lastPage);
2111
- }
2112
- if (message.perPage !== 0) {
2113
- writer.uint32(72).uint32(message.perPage);
2114
- }
2115
- if (message.to !== 0) {
2116
- writer.uint32(80).uint32(message.to);
2117
- }
2118
- for (const v of message.data) {
2119
- LiveLocation.encode(v, writer.uint32(90).fork()).join();
2120
- }
2121
- return writer;
2122
- },
2123
- decode(input, length) {
2124
- const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
2125
- const end = length === undefined ? reader.len : reader.pos + length;
2126
- const message = createBaseLiveLocationPagination();
2127
- while (reader.pos < end) {
2128
- const tag = reader.uint32();
2129
- switch (tag >>> 3) {
2130
- case 1: {
2131
- if (tag !== 8) {
2132
- break;
2133
- }
2134
- message.currentPage = reader.uint32();
2135
- continue;
2136
- }
2137
- case 2: {
2138
- if (tag !== 18) {
2139
- break;
2140
- }
2141
- message.firstPageUrl = reader.string();
2142
- continue;
2143
- }
2144
- case 3: {
2145
- if (tag !== 26) {
2146
- break;
2147
- }
2148
- message.lastPageUrl = reader.string();
2149
- continue;
2150
- }
2151
- case 4: {
2152
- if (tag !== 34) {
2153
- break;
2154
- }
2155
- message.nextPageUrl = reader.string();
2156
- continue;
2157
- }
2158
- case 5: {
2159
- if (tag !== 42) {
2160
- break;
2161
- }
2162
- message.prevPageUrl = reader.string();
2163
- continue;
2164
- }
2165
- case 6: {
2166
- if (tag !== 50) {
2167
- break;
2168
- }
2169
- message.path = reader.string();
2170
- continue;
2171
- }
2172
- case 7: {
2173
- if (tag !== 56) {
2174
- break;
2175
- }
2176
- message.from = reader.uint32();
2177
- continue;
2178
- }
2179
- case 8: {
2180
- if (tag !== 64) {
2181
- break;
2182
- }
2183
- message.lastPage = reader.uint32();
2184
- continue;
2185
- }
2186
- case 9: {
2187
- if (tag !== 72) {
2188
- break;
2189
- }
2190
- message.perPage = reader.uint32();
2191
- continue;
2192
- }
2193
- case 10: {
2194
- if (tag !== 80) {
2195
- break;
2196
- }
2197
- message.to = reader.uint32();
2198
- continue;
2199
- }
2200
- case 11: {
2201
- if (tag !== 90) {
2202
- break;
2203
- }
2204
- message.data.push(LiveLocation.decode(reader, reader.uint32()));
2205
- continue;
2206
- }
2207
- }
2208
- if ((tag & 7) === 4 || tag === 0) {
2209
- break;
2210
- }
2211
- reader.skip(tag & 7);
2212
- }
2213
- return message;
2214
- },
2215
- create(base) {
2216
- return LiveLocationPagination.fromPartial(base ?? {});
2217
- },
2218
- fromPartial(object) {
2219
- const message = createBaseLiveLocationPagination();
2220
- message.currentPage = object.currentPage ?? 0;
2221
- message.firstPageUrl = object.firstPageUrl ?? "";
2222
- message.lastPageUrl = object.lastPageUrl ?? "";
2223
- message.nextPageUrl = object.nextPageUrl ?? "";
2224
- message.prevPageUrl = object.prevPageUrl ?? "";
2225
- message.path = object.path ?? "";
2226
- message.from = object.from ?? 0;
2227
- message.lastPage = object.lastPage ?? 0;
2228
- message.perPage = object.perPage ?? 0;
2229
- message.to = object.to ?? 0;
2230
- message.data = object.data?.map((e) => LiveLocation.fromPartial(e)) || [];
2231
- return message;
2232
- },
2233
- };
2234
- function createBaseMaintenancePagination() {
2235
- return {
2236
- currentPage: 0,
2237
- firstPageUrl: "",
2238
- lastPageUrl: "",
2239
- nextPageUrl: "",
2240
- prevPageUrl: "",
2241
- path: "",
2242
- from: 0,
2243
- lastPage: 0,
2244
- perPage: 0,
2245
- to: 0,
2246
- data: [],
2247
- };
2248
- }
2249
- export const MaintenancePagination = {
2250
- encode(message, writer = new BinaryWriter()) {
2251
- if (message.currentPage !== 0) {
2252
- writer.uint32(8).uint32(message.currentPage);
2253
- }
2254
- if (message.firstPageUrl !== "") {
2255
- writer.uint32(18).string(message.firstPageUrl);
2256
- }
2257
- if (message.lastPageUrl !== "") {
2258
- writer.uint32(26).string(message.lastPageUrl);
2259
- }
2260
- if (message.nextPageUrl !== "") {
2261
- writer.uint32(34).string(message.nextPageUrl);
2262
- }
2263
- if (message.prevPageUrl !== "") {
2264
- writer.uint32(42).string(message.prevPageUrl);
2265
- }
2266
- if (message.path !== "") {
2267
- writer.uint32(50).string(message.path);
2268
- }
2269
- if (message.from !== 0) {
2270
- writer.uint32(56).uint32(message.from);
2271
- }
2272
- if (message.lastPage !== 0) {
2273
- writer.uint32(64).uint32(message.lastPage);
2274
- }
2275
- if (message.perPage !== 0) {
2276
- writer.uint32(72).uint32(message.perPage);
2277
- }
2278
- if (message.to !== 0) {
2279
- writer.uint32(80).uint32(message.to);
2280
- }
2281
- for (const v of message.data) {
2282
- Maintenance.encode(v, writer.uint32(90).fork()).join();
2283
- }
2284
- return writer;
2285
- },
2286
- decode(input, length) {
2287
- const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
2288
- const end = length === undefined ? reader.len : reader.pos + length;
2289
- const message = createBaseMaintenancePagination();
2290
- while (reader.pos < end) {
2291
- const tag = reader.uint32();
2292
- switch (tag >>> 3) {
2293
- case 1: {
2294
- if (tag !== 8) {
2295
- break;
2296
- }
2297
- message.currentPage = reader.uint32();
2298
- continue;
2299
- }
2300
- case 2: {
2301
- if (tag !== 18) {
2302
- break;
2303
- }
2304
- message.firstPageUrl = reader.string();
2305
- continue;
2306
- }
2307
- case 3: {
2308
- if (tag !== 26) {
2309
- break;
2310
- }
2311
- message.lastPageUrl = reader.string();
2312
- continue;
2313
- }
2314
- case 4: {
2315
- if (tag !== 34) {
2316
- break;
2317
- }
2318
- message.nextPageUrl = reader.string();
2319
- continue;
2320
- }
2321
- case 5: {
2322
- if (tag !== 42) {
2323
- break;
2324
- }
2325
- message.prevPageUrl = reader.string();
2326
- continue;
2327
- }
2328
- case 6: {
2329
- if (tag !== 50) {
2330
- break;
2331
- }
2332
- message.path = reader.string();
2333
- continue;
2334
- }
2335
- case 7: {
2336
- if (tag !== 56) {
2337
- break;
2338
- }
2339
- message.from = reader.uint32();
2340
- continue;
2341
- }
2342
- case 8: {
2343
- if (tag !== 64) {
2344
- break;
2345
- }
2346
- message.lastPage = reader.uint32();
2347
- continue;
2348
- }
2349
- case 9: {
2350
- if (tag !== 72) {
2351
- break;
2352
- }
2353
- message.perPage = reader.uint32();
2354
- continue;
2355
- }
2356
- case 10: {
2357
- if (tag !== 80) {
2358
- break;
2359
- }
2360
- message.to = reader.uint32();
2361
- continue;
2362
- }
2363
- case 11: {
2364
- if (tag !== 90) {
2365
- break;
2366
- }
2367
- message.data.push(Maintenance.decode(reader, reader.uint32()));
2368
- continue;
2369
- }
2370
- }
2371
- if ((tag & 7) === 4 || tag === 0) {
2372
- break;
2373
- }
2374
- reader.skip(tag & 7);
2375
- }
2376
- return message;
2377
- },
2378
- create(base) {
2379
- return MaintenancePagination.fromPartial(base ?? {});
2380
- },
2381
- fromPartial(object) {
2382
- const message = createBaseMaintenancePagination();
2383
- message.currentPage = object.currentPage ?? 0;
2384
- message.firstPageUrl = object.firstPageUrl ?? "";
2385
- message.lastPageUrl = object.lastPageUrl ?? "";
2386
- message.nextPageUrl = object.nextPageUrl ?? "";
2387
- message.prevPageUrl = object.prevPageUrl ?? "";
2388
- message.path = object.path ?? "";
2389
- message.from = object.from ?? 0;
2390
- message.lastPage = object.lastPage ?? 0;
2391
- message.perPage = object.perPage ?? 0;
2392
- message.to = object.to ?? 0;
2393
- message.data = object.data?.map((e) => Maintenance.fromPartial(e)) || [];
2394
- return message;
2395
- },
2396
- };
2397
- function createBaseServicePagination() {
2398
- return {
2399
- currentPage: 0,
2400
- firstPageUrl: "",
2401
- lastPageUrl: "",
2402
- nextPageUrl: "",
2403
- prevPageUrl: "",
2404
- path: "",
2405
- from: 0,
2406
- lastPage: 0,
2407
- perPage: 0,
2408
- to: 0,
2409
- data: [],
2410
- };
2411
- }
2412
- export const ServicePagination = {
2413
- encode(message, writer = new BinaryWriter()) {
2414
- if (message.currentPage !== 0) {
2415
- writer.uint32(8).uint32(message.currentPage);
2416
- }
2417
- if (message.firstPageUrl !== "") {
2418
- writer.uint32(18).string(message.firstPageUrl);
2419
- }
2420
- if (message.lastPageUrl !== "") {
2421
- writer.uint32(26).string(message.lastPageUrl);
2422
- }
2423
- if (message.nextPageUrl !== "") {
2424
- writer.uint32(34).string(message.nextPageUrl);
2425
- }
2426
- if (message.prevPageUrl !== "") {
2427
- writer.uint32(42).string(message.prevPageUrl);
2428
- }
2429
- if (message.path !== "") {
2430
- writer.uint32(50).string(message.path);
2431
- }
2432
- if (message.from !== 0) {
2433
- writer.uint32(56).uint32(message.from);
2434
- }
2435
- if (message.lastPage !== 0) {
2436
- writer.uint32(64).uint32(message.lastPage);
2437
- }
2438
- if (message.perPage !== 0) {
2439
- writer.uint32(72).uint32(message.perPage);
2440
- }
2441
- if (message.to !== 0) {
2442
- writer.uint32(80).uint32(message.to);
2443
- }
2444
- for (const v of message.data) {
2445
- MaintenanceService.encode(v, writer.uint32(90).fork()).join();
2446
- }
2447
- return writer;
2448
- },
2449
- decode(input, length) {
2450
- const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
2451
- const end = length === undefined ? reader.len : reader.pos + length;
2452
- const message = createBaseServicePagination();
2453
- while (reader.pos < end) {
2454
- const tag = reader.uint32();
2455
- switch (tag >>> 3) {
2456
- case 1: {
2457
- if (tag !== 8) {
2458
- break;
2459
- }
2460
- message.currentPage = reader.uint32();
2461
- continue;
2462
- }
2463
- case 2: {
2464
- if (tag !== 18) {
2465
- break;
2466
- }
2467
- message.firstPageUrl = reader.string();
2468
- continue;
2469
- }
2470
- case 3: {
2471
- if (tag !== 26) {
2472
- break;
2473
- }
2474
- message.lastPageUrl = reader.string();
2475
- continue;
2476
- }
2477
- case 4: {
2478
- if (tag !== 34) {
2479
- break;
2480
- }
2481
- message.nextPageUrl = reader.string();
2482
- continue;
2483
- }
2484
- case 5: {
2485
- if (tag !== 42) {
2486
- break;
2487
- }
2488
- message.prevPageUrl = reader.string();
2489
- continue;
2490
- }
2491
- case 6: {
2492
- if (tag !== 50) {
2493
- break;
2494
- }
2495
- message.path = reader.string();
2496
- continue;
2497
- }
2498
- case 7: {
2499
- if (tag !== 56) {
2500
- break;
2501
- }
2502
- message.from = reader.uint32();
2503
- continue;
2504
- }
2505
- case 8: {
2506
- if (tag !== 64) {
2507
- break;
2508
- }
2509
- message.lastPage = reader.uint32();
2510
- continue;
2511
- }
2512
- case 9: {
2513
- if (tag !== 72) {
2514
- break;
2515
- }
2516
- message.perPage = reader.uint32();
2517
- continue;
2518
- }
2519
- case 10: {
2520
- if (tag !== 80) {
2521
- break;
2522
- }
2523
- message.to = reader.uint32();
2524
- continue;
2525
- }
2526
- case 11: {
2527
- if (tag !== 90) {
2528
- break;
2529
- }
2530
- message.data.push(MaintenanceService.decode(reader, reader.uint32()));
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
- create(base) {
2542
- return ServicePagination.fromPartial(base ?? {});
2543
- },
2544
- fromPartial(object) {
2545
- const message = createBaseServicePagination();
2546
- message.currentPage = object.currentPage ?? 0;
2547
- message.firstPageUrl = object.firstPageUrl ?? "";
2548
- message.lastPageUrl = object.lastPageUrl ?? "";
2549
- message.nextPageUrl = object.nextPageUrl ?? "";
2550
- message.prevPageUrl = object.prevPageUrl ?? "";
2551
- message.path = object.path ?? "";
2552
- message.from = object.from ?? 0;
2553
- message.lastPage = object.lastPage ?? 0;
2554
- message.perPage = object.perPage ?? 0;
2555
- message.to = object.to ?? 0;
2556
- message.data = object.data?.map((e) => MaintenanceService.fromPartial(e)) || [];
2557
- return message;
2558
- },
2559
- };
2560
- function toTimestamp(date) {
2561
- const seconds = numberToLong(Math.trunc(date.getTime() / 1_000));
2562
- const nanos = (date.getTime() % 1_000) * 1_000_000;
2563
- return { seconds, nanos };
2564
- }
2565
- function fromTimestamp(t) {
2566
- let millis = (t.seconds.toNumber() || 0) * 1_000;
2567
- millis += (t.nanos || 0) / 1_000_000;
2568
- return new globalThis.Date(millis);
2569
- }
2570
- function numberToLong(number) {
2571
- return Long.fromNumber(number);
2572
- }