@acequants/aegis-contracts 0.1.55 → 0.1.57

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 (5) hide show
  1. package/dist/src/gen/system/v1/system.d.ts +622 -153
  2. package/dist/src/gen/system/v1/system.d.ts.map +1 -1
  3. package/dist/src/gen/system/v1/system.js +2195 -295
  4. package/package.json +35 -35
  5. package/proto/system/v1/system.proto +257 -98
package/dist/src/gen/system/v1/system.js CHANGED
@@ -8,55 +8,96 @@ import _m0 from "protobufjs/minimal";
8
8
  import { Timestamp } from "../../google/protobuf/timestamp";
9
9
  export const protobufPackage = "aegis.system.v1";
10
10
  export const AEGIS_SYSTEM_V1_PACKAGE_NAME = "aegis.system.v1";
11
- function createBaseGrpcDtoPagination() {
12
- return { totalItems: 0, totalPages: 0, currentPage: 0, pageSize: 0 };
11
+ function createBaseGrpcInputGeoSync() {
12
+ return { cursor: "", pageSize: 0 };
13
13
  }
14
- export const GrpcDtoPagination = {
14
+ export const GrpcInputGeoSync = {
15
15
  encode(message, writer = _m0.Writer.create()) {
16
- if (message.totalItems !== 0) {
17
- writer.uint32(8).int32(message.totalItems);
18
- }
19
- if (message.totalPages !== 0) {
20
- writer.uint32(16).int32(message.totalPages);
21
- }
22
- if (message.currentPage !== 0) {
23
- writer.uint32(24).int32(message.currentPage);
16
+ if (message.cursor !== "") {
17
+ writer.uint32(10).string(message.cursor);
24
18
  }
25
19
  if (message.pageSize !== 0) {
26
- writer.uint32(32).int32(message.pageSize);
20
+ writer.uint32(16).int32(message.pageSize);
27
21
  }
28
22
  return writer;
29
23
  },
30
24
  decode(input, length) {
31
25
  const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
32
26
  let end = length === undefined ? reader.len : reader.pos + length;
33
- const message = createBaseGrpcDtoPagination();
27
+ const message = createBaseGrpcInputGeoSync();
34
28
  while (reader.pos < end) {
35
29
  const tag = reader.uint32();
36
30
  switch (tag >>> 3) {
37
31
  case 1:
38
- if (tag !== 8) {
32
+ if (tag !== 10) {
39
33
  break;
40
34
  }
41
- message.totalItems = reader.int32();
35
+ message.cursor = reader.string();
42
36
  continue;
43
37
  case 2:
44
38
  if (tag !== 16) {
45
39
  break;
46
40
  }
47
- message.totalPages = reader.int32();
41
+ message.pageSize = reader.int32();
42
+ continue;
43
+ }
44
+ if ((tag & 7) === 4 || tag === 0) {
45
+ break;
46
+ }
47
+ reader.skipType(tag & 7);
48
+ }
49
+ return message;
50
+ },
51
+ };
52
+ function createBaseGrpcDtoGeoTimezone() {
53
+ return { publicId: "", iana: "" };
54
+ }
55
+ export const GrpcDtoGeoTimezone = {
56
+ encode(message, writer = _m0.Writer.create()) {
57
+ if (message.publicId !== "") {
58
+ writer.uint32(10).string(message.publicId);
59
+ }
60
+ if (message.iana !== "") {
61
+ writer.uint32(18).string(message.iana);
62
+ }
63
+ if (message.updatedAt !== undefined) {
64
+ Timestamp.encode(message.updatedAt, writer.uint32(26).fork()).ldelim();
65
+ }
66
+ if (message.deletedAt !== undefined) {
67
+ Timestamp.encode(message.deletedAt, writer.uint32(34).fork()).ldelim();
68
+ }
69
+ return writer;
70
+ },
71
+ decode(input, length) {
72
+ const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
73
+ let end = length === undefined ? reader.len : reader.pos + length;
74
+ const message = createBaseGrpcDtoGeoTimezone();
75
+ while (reader.pos < end) {
76
+ const tag = reader.uint32();
77
+ switch (tag >>> 3) {
78
+ case 1:
79
+ if (tag !== 10) {
80
+ break;
81
+ }
82
+ message.publicId = reader.string();
83
+ continue;
84
+ case 2:
85
+ if (tag !== 18) {
86
+ break;
87
+ }
88
+ message.iana = reader.string();
48
89
  continue;
49
90
  case 3:
50
- if (tag !== 24) {
91
+ if (tag !== 26) {
51
92
  break;
52
93
  }
53
- message.currentPage = reader.int32();
94
+ message.updatedAt = Timestamp.decode(reader, reader.uint32());
54
95
  continue;
55
96
  case 4:
56
- if (tag !== 32) {
97
+ if (tag !== 34) {
57
98
  break;
58
99
  }
59
- message.pageSize = reader.int32();
100
+ message.deletedAt = Timestamp.decode(reader, reader.uint32());
60
101
  continue;
61
102
  }
62
103
  if ((tag & 7) === 4 || tag === 0) {
@@ -67,20 +108,44 @@ export const GrpcDtoPagination = {
67
108
  return message;
68
109
  },
69
110
  };
70
- function createBaseGrpcDtoMessage() {
71
- return { message: "" };
111
+ function createBaseGrpcDtoGeoCurrency() {
112
+ return { publicId: "", code: "", name: "", symbol: "", isBase: false, isActive: false, exchangeRate: "" };
72
113
  }
73
- export const GrpcDtoMessage = {
114
+ export const GrpcDtoGeoCurrency = {
74
115
  encode(message, writer = _m0.Writer.create()) {
75
- if (message.message !== "") {
76
- writer.uint32(10).string(message.message);
116
+ if (message.publicId !== "") {
117
+ writer.uint32(10).string(message.publicId);
118
+ }
119
+ if (message.code !== "") {
120
+ writer.uint32(18).string(message.code);
121
+ }
122
+ if (message.name !== "") {
123
+ writer.uint32(26).string(message.name);
124
+ }
125
+ if (message.symbol !== "") {
126
+ writer.uint32(34).string(message.symbol);
127
+ }
128
+ if (message.isBase !== false) {
129
+ writer.uint32(40).bool(message.isBase);
130
+ }
131
+ if (message.isActive !== false) {
132
+ writer.uint32(48).bool(message.isActive);
133
+ }
134
+ if (message.exchangeRate !== "") {
135
+ writer.uint32(58).string(message.exchangeRate);
136
+ }
137
+ if (message.updatedAt !== undefined) {
138
+ Timestamp.encode(message.updatedAt, writer.uint32(66).fork()).ldelim();
139
+ }
140
+ if (message.deletedAt !== undefined) {
141
+ Timestamp.encode(message.deletedAt, writer.uint32(74).fork()).ldelim();
77
142
  }
78
143
  return writer;
79
144
  },
80
145
  decode(input, length) {
81
146
  const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
82
147
  let end = length === undefined ? reader.len : reader.pos + length;
83
- const message = createBaseGrpcDtoMessage();
148
+ const message = createBaseGrpcDtoGeoCurrency();
84
149
  while (reader.pos < end) {
85
150
  const tag = reader.uint32();
86
151
  switch (tag >>> 3) {
@@ -88,7 +153,55 @@ export const GrpcDtoMessage = {
88
153
  if (tag !== 10) {
89
154
  break;
90
155
  }
91
- message.message = reader.string();
156
+ message.publicId = reader.string();
157
+ continue;
158
+ case 2:
159
+ if (tag !== 18) {
160
+ break;
161
+ }
162
+ message.code = reader.string();
163
+ continue;
164
+ case 3:
165
+ if (tag !== 26) {
166
+ break;
167
+ }
168
+ message.name = reader.string();
169
+ continue;
170
+ case 4:
171
+ if (tag !== 34) {
172
+ break;
173
+ }
174
+ message.symbol = reader.string();
175
+ continue;
176
+ case 5:
177
+ if (tag !== 40) {
178
+ break;
179
+ }
180
+ message.isBase = reader.bool();
181
+ continue;
182
+ case 6:
183
+ if (tag !== 48) {
184
+ break;
185
+ }
186
+ message.isActive = reader.bool();
187
+ continue;
188
+ case 7:
189
+ if (tag !== 58) {
190
+ break;
191
+ }
192
+ message.exchangeRate = reader.string();
193
+ continue;
194
+ case 8:
195
+ if (tag !== 66) {
196
+ break;
197
+ }
198
+ message.updatedAt = Timestamp.decode(reader, reader.uint32());
199
+ continue;
200
+ case 9:
201
+ if (tag !== 74) {
202
+ break;
203
+ }
204
+ message.deletedAt = Timestamp.decode(reader, reader.uint32());
92
205
  continue;
93
206
  }
94
207
  if ((tag & 7) === 4 || tag === 0) {
@@ -99,35 +212,38 @@ export const GrpcDtoMessage = {
99
212
  return message;
100
213
  },
101
214
  };
102
- function createBaseGrpcDtoPermission() {
103
- return { publicId: "", name: "", description: "" };
215
+ function createBaseGrpcDtoGeoLanguage() {
216
+ return { publicId: "", iso6391: "", iso6392: "", name: "", isActive: false };
104
217
  }
105
- export const GrpcDtoPermission = {
218
+ export const GrpcDtoGeoLanguage = {
106
219
  encode(message, writer = _m0.Writer.create()) {
107
220
  if (message.publicId !== "") {
108
221
  writer.uint32(10).string(message.publicId);
109
222
  }
110
- if (message.name !== "") {
111
- writer.uint32(18).string(message.name);
223
+ if (message.iso6391 !== "") {
224
+ writer.uint32(18).string(message.iso6391);
112
225
  }
113
- if (message.description !== "") {
114
- writer.uint32(26).string(message.description);
226
+ if (message.iso6392 !== "") {
227
+ writer.uint32(26).string(message.iso6392);
115
228
  }
116
- if (message.createdAt !== undefined) {
117
- Timestamp.encode(message.createdAt, writer.uint32(34).fork()).ldelim();
229
+ if (message.name !== "") {
230
+ writer.uint32(34).string(message.name);
231
+ }
232
+ if (message.isActive !== false) {
233
+ writer.uint32(40).bool(message.isActive);
118
234
  }
119
235
  if (message.updatedAt !== undefined) {
120
- Timestamp.encode(message.updatedAt, writer.uint32(42).fork()).ldelim();
236
+ Timestamp.encode(message.updatedAt, writer.uint32(50).fork()).ldelim();
121
237
  }
122
238
  if (message.deletedAt !== undefined) {
123
- Timestamp.encode(message.deletedAt, writer.uint32(50).fork()).ldelim();
239
+ Timestamp.encode(message.deletedAt, writer.uint32(58).fork()).ldelim();
124
240
  }
125
241
  return writer;
126
242
  },
127
243
  decode(input, length) {
128
244
  const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
129
245
  let end = length === undefined ? reader.len : reader.pos + length;
130
- const message = createBaseGrpcDtoPermission();
246
+ const message = createBaseGrpcDtoGeoLanguage();
131
247
  while (reader.pos < end) {
132
248
  const tag = reader.uint32();
133
249
  switch (tag >>> 3) {
@@ -141,30 +257,36 @@ export const GrpcDtoPermission = {
141
257
  if (tag !== 18) {
142
258
  break;
143
259
  }
144
- message.name = reader.string();
260
+ message.iso6391 = reader.string();
145
261
  continue;
146
262
  case 3:
147
263
  if (tag !== 26) {
148
264
  break;
149
265
  }
150
- message.description = reader.string();
266
+ message.iso6392 = reader.string();
151
267
  continue;
152
268
  case 4:
153
269
  if (tag !== 34) {
154
270
  break;
155
271
  }
156
- message.createdAt = Timestamp.decode(reader, reader.uint32());
272
+ message.name = reader.string();
157
273
  continue;
158
274
  case 5:
159
- if (tag !== 42) {
275
+ if (tag !== 40) {
160
276
  break;
161
277
  }
162
- message.updatedAt = Timestamp.decode(reader, reader.uint32());
278
+ message.isActive = reader.bool();
163
279
  continue;
164
280
  case 6:
165
281
  if (tag !== 50) {
166
282
  break;
167
283
  }
284
+ message.updatedAt = Timestamp.decode(reader, reader.uint32());
285
+ continue;
286
+ case 7:
287
+ if (tag !== 58) {
288
+ break;
289
+ }
168
290
  message.deletedAt = Timestamp.decode(reader, reader.uint32());
169
291
  continue;
170
292
  }
@@ -176,20 +298,1473 @@ export const GrpcDtoPermission = {
176
298
  return message;
177
299
  },
178
300
  };
179
- function createBaseGrpcDtoPermissionsAdd() {
180
- return { permissions: [] };
301
+ function createBaseGrpcDtoGeoLocale() {
302
+ return { publicId: "", languagePublicId: "", code: "", name: "" };
303
+ }
304
+ export const GrpcDtoGeoLocale = {
305
+ encode(message, writer = _m0.Writer.create()) {
306
+ if (message.publicId !== "") {
307
+ writer.uint32(10).string(message.publicId);
308
+ }
309
+ if (message.languagePublicId !== "") {
310
+ writer.uint32(18).string(message.languagePublicId);
311
+ }
312
+ if (message.code !== "") {
313
+ writer.uint32(26).string(message.code);
314
+ }
315
+ if (message.name !== "") {
316
+ writer.uint32(34).string(message.name);
317
+ }
318
+ if (message.updatedAt !== undefined) {
319
+ Timestamp.encode(message.updatedAt, writer.uint32(42).fork()).ldelim();
320
+ }
321
+ return writer;
322
+ },
323
+ decode(input, length) {
324
+ const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
325
+ let end = length === undefined ? reader.len : reader.pos + length;
326
+ const message = createBaseGrpcDtoGeoLocale();
327
+ while (reader.pos < end) {
328
+ const tag = reader.uint32();
329
+ switch (tag >>> 3) {
330
+ case 1:
331
+ if (tag !== 10) {
332
+ break;
333
+ }
334
+ message.publicId = reader.string();
335
+ continue;
336
+ case 2:
337
+ if (tag !== 18) {
338
+ break;
339
+ }
340
+ message.languagePublicId = reader.string();
341
+ continue;
342
+ case 3:
343
+ if (tag !== 26) {
344
+ break;
345
+ }
346
+ message.code = reader.string();
347
+ continue;
348
+ case 4:
349
+ if (tag !== 34) {
350
+ break;
351
+ }
352
+ message.name = reader.string();
353
+ continue;
354
+ case 5:
355
+ if (tag !== 42) {
356
+ break;
357
+ }
358
+ message.updatedAt = Timestamp.decode(reader, reader.uint32());
359
+ continue;
360
+ }
361
+ if ((tag & 7) === 4 || tag === 0) {
362
+ break;
363
+ }
364
+ reader.skipType(tag & 7);
365
+ }
366
+ return message;
367
+ },
368
+ };
369
+ function createBaseGrpcDtoGeoDivision() {
370
+ return {
371
+ publicId: "",
372
+ timezonePublicId: "",
373
+ currencyPublicId: "",
374
+ parentPublicId: "",
375
+ type: "",
376
+ level: 0,
377
+ code: "",
378
+ path: "",
379
+ iso2: "",
380
+ iso3: "",
381
+ name: "",
382
+ phoneCode: "",
383
+ isCapital: false,
384
+ isActive: false,
385
+ lat: 0,
386
+ lng: 0,
387
+ hasLat: false,
388
+ hasLng: false,
389
+ geoJson: "",
390
+ };
391
+ }
392
+ export const GrpcDtoGeoDivision = {
393
+ encode(message, writer = _m0.Writer.create()) {
394
+ if (message.publicId !== "") {
395
+ writer.uint32(10).string(message.publicId);
396
+ }
397
+ if (message.timezonePublicId !== "") {
398
+ writer.uint32(18).string(message.timezonePublicId);
399
+ }
400
+ if (message.currencyPublicId !== "") {
401
+ writer.uint32(26).string(message.currencyPublicId);
402
+ }
403
+ if (message.parentPublicId !== "") {
404
+ writer.uint32(34).string(message.parentPublicId);
405
+ }
406
+ if (message.type !== "") {
407
+ writer.uint32(42).string(message.type);
408
+ }
409
+ if (message.level !== 0) {
410
+ writer.uint32(48).int32(message.level);
411
+ }
412
+ if (message.code !== "") {
413
+ writer.uint32(58).string(message.code);
414
+ }
415
+ if (message.path !== "") {
416
+ writer.uint32(66).string(message.path);
417
+ }
418
+ if (message.iso2 !== "") {
419
+ writer.uint32(74).string(message.iso2);
420
+ }
421
+ if (message.iso3 !== "") {
422
+ writer.uint32(82).string(message.iso3);
423
+ }
424
+ if (message.name !== "") {
425
+ writer.uint32(90).string(message.name);
426
+ }
427
+ if (message.phoneCode !== "") {
428
+ writer.uint32(98).string(message.phoneCode);
429
+ }
430
+ if (message.isCapital !== false) {
431
+ writer.uint32(104).bool(message.isCapital);
432
+ }
433
+ if (message.isActive !== false) {
434
+ writer.uint32(112).bool(message.isActive);
435
+ }
436
+ if (message.lat !== 0) {
437
+ writer.uint32(121).double(message.lat);
438
+ }
439
+ if (message.lng !== 0) {
440
+ writer.uint32(129).double(message.lng);
441
+ }
442
+ if (message.hasLat !== false) {
443
+ writer.uint32(136).bool(message.hasLat);
444
+ }
445
+ if (message.hasLng !== false) {
446
+ writer.uint32(144).bool(message.hasLng);
447
+ }
448
+ if (message.geoJson !== "") {
449
+ writer.uint32(154).string(message.geoJson);
450
+ }
451
+ if (message.updatedAt !== undefined) {
452
+ Timestamp.encode(message.updatedAt, writer.uint32(162).fork()).ldelim();
453
+ }
454
+ if (message.deletedAt !== undefined) {
455
+ Timestamp.encode(message.deletedAt, writer.uint32(170).fork()).ldelim();
456
+ }
457
+ return writer;
458
+ },
459
+ decode(input, length) {
460
+ const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
461
+ let end = length === undefined ? reader.len : reader.pos + length;
462
+ const message = createBaseGrpcDtoGeoDivision();
463
+ while (reader.pos < end) {
464
+ const tag = reader.uint32();
465
+ switch (tag >>> 3) {
466
+ case 1:
467
+ if (tag !== 10) {
468
+ break;
469
+ }
470
+ message.publicId = reader.string();
471
+ continue;
472
+ case 2:
473
+ if (tag !== 18) {
474
+ break;
475
+ }
476
+ message.timezonePublicId = reader.string();
477
+ continue;
478
+ case 3:
479
+ if (tag !== 26) {
480
+ break;
481
+ }
482
+ message.currencyPublicId = reader.string();
483
+ continue;
484
+ case 4:
485
+ if (tag !== 34) {
486
+ break;
487
+ }
488
+ message.parentPublicId = reader.string();
489
+ continue;
490
+ case 5:
491
+ if (tag !== 42) {
492
+ break;
493
+ }
494
+ message.type = reader.string();
495
+ continue;
496
+ case 6:
497
+ if (tag !== 48) {
498
+ break;
499
+ }
500
+ message.level = reader.int32();
501
+ continue;
502
+ case 7:
503
+ if (tag !== 58) {
504
+ break;
505
+ }
506
+ message.code = reader.string();
507
+ continue;
508
+ case 8:
509
+ if (tag !== 66) {
510
+ break;
511
+ }
512
+ message.path = reader.string();
513
+ continue;
514
+ case 9:
515
+ if (tag !== 74) {
516
+ break;
517
+ }
518
+ message.iso2 = reader.string();
519
+ continue;
520
+ case 10:
521
+ if (tag !== 82) {
522
+ break;
523
+ }
524
+ message.iso3 = reader.string();
525
+ continue;
526
+ case 11:
527
+ if (tag !== 90) {
528
+ break;
529
+ }
530
+ message.name = reader.string();
531
+ continue;
532
+ case 12:
533
+ if (tag !== 98) {
534
+ break;
535
+ }
536
+ message.phoneCode = reader.string();
537
+ continue;
538
+ case 13:
539
+ if (tag !== 104) {
540
+ break;
541
+ }
542
+ message.isCapital = reader.bool();
543
+ continue;
544
+ case 14:
545
+ if (tag !== 112) {
546
+ break;
547
+ }
548
+ message.isActive = reader.bool();
549
+ continue;
550
+ case 15:
551
+ if (tag !== 121) {
552
+ break;
553
+ }
554
+ message.lat = reader.double();
555
+ continue;
556
+ case 16:
557
+ if (tag !== 129) {
558
+ break;
559
+ }
560
+ message.lng = reader.double();
561
+ continue;
562
+ case 17:
563
+ if (tag !== 136) {
564
+ break;
565
+ }
566
+ message.hasLat = reader.bool();
567
+ continue;
568
+ case 18:
569
+ if (tag !== 144) {
570
+ break;
571
+ }
572
+ message.hasLng = reader.bool();
573
+ continue;
574
+ case 19:
575
+ if (tag !== 154) {
576
+ break;
577
+ }
578
+ message.geoJson = reader.string();
579
+ continue;
580
+ case 20:
581
+ if (tag !== 162) {
582
+ break;
583
+ }
584
+ message.updatedAt = Timestamp.decode(reader, reader.uint32());
585
+ continue;
586
+ case 21:
587
+ if (tag !== 170) {
588
+ break;
589
+ }
590
+ message.deletedAt = Timestamp.decode(reader, reader.uint32());
591
+ continue;
592
+ }
593
+ if ((tag & 7) === 4 || tag === 0) {
594
+ break;
595
+ }
596
+ reader.skipType(tag & 7);
597
+ }
598
+ return message;
599
+ },
600
+ };
601
+ function createBaseGrpcDtoGeoCountryMeta() {
602
+ return { publicId: "", divisionPublicId: "" };
603
+ }
604
+ export const GrpcDtoGeoCountryMeta = {
605
+ encode(message, writer = _m0.Writer.create()) {
606
+ if (message.publicId !== "") {
607
+ writer.uint32(10).string(message.publicId);
608
+ }
609
+ if (message.divisionPublicId !== "") {
610
+ writer.uint32(18).string(message.divisionPublicId);
611
+ }
612
+ if (message.updatedAt !== undefined) {
613
+ Timestamp.encode(message.updatedAt, writer.uint32(26).fork()).ldelim();
614
+ }
615
+ return writer;
616
+ },
617
+ decode(input, length) {
618
+ const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
619
+ let end = length === undefined ? reader.len : reader.pos + length;
620
+ const message = createBaseGrpcDtoGeoCountryMeta();
621
+ while (reader.pos < end) {
622
+ const tag = reader.uint32();
623
+ switch (tag >>> 3) {
624
+ case 1:
625
+ if (tag !== 10) {
626
+ break;
627
+ }
628
+ message.publicId = reader.string();
629
+ continue;
630
+ case 2:
631
+ if (tag !== 18) {
632
+ break;
633
+ }
634
+ message.divisionPublicId = reader.string();
635
+ continue;
636
+ case 3:
637
+ if (tag !== 26) {
638
+ break;
639
+ }
640
+ message.updatedAt = Timestamp.decode(reader, reader.uint32());
641
+ continue;
642
+ }
643
+ if ((tag & 7) === 4 || tag === 0) {
644
+ break;
645
+ }
646
+ reader.skipType(tag & 7);
647
+ }
648
+ return message;
649
+ },
650
+ };
651
+ function createBaseGrpcDtoGeoCountryTimezone() {
652
+ return { publicId: "", countryMetaPublicId: "", timezonePublicId: "", isPrimary: false };
653
+ }
654
+ export const GrpcDtoGeoCountryTimezone = {
655
+ encode(message, writer = _m0.Writer.create()) {
656
+ if (message.publicId !== "") {
657
+ writer.uint32(10).string(message.publicId);
658
+ }
659
+ if (message.countryMetaPublicId !== "") {
660
+ writer.uint32(18).string(message.countryMetaPublicId);
661
+ }
662
+ if (message.timezonePublicId !== "") {
663
+ writer.uint32(26).string(message.timezonePublicId);
664
+ }
665
+ if (message.isPrimary !== false) {
666
+ writer.uint32(32).bool(message.isPrimary);
667
+ }
668
+ return writer;
669
+ },
670
+ decode(input, length) {
671
+ const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
672
+ let end = length === undefined ? reader.len : reader.pos + length;
673
+ const message = createBaseGrpcDtoGeoCountryTimezone();
674
+ while (reader.pos < end) {
675
+ const tag = reader.uint32();
676
+ switch (tag >>> 3) {
677
+ case 1:
678
+ if (tag !== 10) {
679
+ break;
680
+ }
681
+ message.publicId = reader.string();
682
+ continue;
683
+ case 2:
684
+ if (tag !== 18) {
685
+ break;
686
+ }
687
+ message.countryMetaPublicId = reader.string();
688
+ continue;
689
+ case 3:
690
+ if (tag !== 26) {
691
+ break;
692
+ }
693
+ message.timezonePublicId = reader.string();
694
+ continue;
695
+ case 4:
696
+ if (tag !== 32) {
697
+ break;
698
+ }
699
+ message.isPrimary = reader.bool();
700
+ continue;
701
+ }
702
+ if ((tag & 7) === 4 || tag === 0) {
703
+ break;
704
+ }
705
+ reader.skipType(tag & 7);
706
+ }
707
+ return message;
708
+ },
709
+ };
710
+ function createBaseGrpcDtoGeoCountryCurrency() {
711
+ return { publicId: "", countryMetaPublicId: "", currencyPublicId: "", isPrimary: false };
712
+ }
713
+ export const GrpcDtoGeoCountryCurrency = {
714
+ encode(message, writer = _m0.Writer.create()) {
715
+ if (message.publicId !== "") {
716
+ writer.uint32(10).string(message.publicId);
717
+ }
718
+ if (message.countryMetaPublicId !== "") {
719
+ writer.uint32(18).string(message.countryMetaPublicId);
720
+ }
721
+ if (message.currencyPublicId !== "") {
722
+ writer.uint32(26).string(message.currencyPublicId);
723
+ }
724
+ if (message.isPrimary !== false) {
725
+ writer.uint32(32).bool(message.isPrimary);
726
+ }
727
+ return writer;
728
+ },
729
+ decode(input, length) {
730
+ const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
731
+ let end = length === undefined ? reader.len : reader.pos + length;
732
+ const message = createBaseGrpcDtoGeoCountryCurrency();
733
+ while (reader.pos < end) {
734
+ const tag = reader.uint32();
735
+ switch (tag >>> 3) {
736
+ case 1:
737
+ if (tag !== 10) {
738
+ break;
739
+ }
740
+ message.publicId = reader.string();
741
+ continue;
742
+ case 2:
743
+ if (tag !== 18) {
744
+ break;
745
+ }
746
+ message.countryMetaPublicId = reader.string();
747
+ continue;
748
+ case 3:
749
+ if (tag !== 26) {
750
+ break;
751
+ }
752
+ message.currencyPublicId = reader.string();
753
+ continue;
754
+ case 4:
755
+ if (tag !== 32) {
756
+ break;
757
+ }
758
+ message.isPrimary = reader.bool();
759
+ continue;
760
+ }
761
+ if ((tag & 7) === 4 || tag === 0) {
762
+ break;
763
+ }
764
+ reader.skipType(tag & 7);
765
+ }
766
+ return message;
767
+ },
768
+ };
769
+ function createBaseGrpcDtoGeoCountryLanguage() {
770
+ return { publicId: "", countryMetaPublicId: "", languagePublicId: "", isOfficial: false, isNational: false };
771
+ }
772
+ export const GrpcDtoGeoCountryLanguage = {
773
+ encode(message, writer = _m0.Writer.create()) {
774
+ if (message.publicId !== "") {
775
+ writer.uint32(10).string(message.publicId);
776
+ }
777
+ if (message.countryMetaPublicId !== "") {
778
+ writer.uint32(18).string(message.countryMetaPublicId);
779
+ }
780
+ if (message.languagePublicId !== "") {
781
+ writer.uint32(26).string(message.languagePublicId);
782
+ }
783
+ if (message.isOfficial !== false) {
784
+ writer.uint32(32).bool(message.isOfficial);
785
+ }
786
+ if (message.isNational !== false) {
787
+ writer.uint32(40).bool(message.isNational);
788
+ }
789
+ return writer;
790
+ },
791
+ decode(input, length) {
792
+ const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
793
+ let end = length === undefined ? reader.len : reader.pos + length;
794
+ const message = createBaseGrpcDtoGeoCountryLanguage();
795
+ while (reader.pos < end) {
796
+ const tag = reader.uint32();
797
+ switch (tag >>> 3) {
798
+ case 1:
799
+ if (tag !== 10) {
800
+ break;
801
+ }
802
+ message.publicId = reader.string();
803
+ continue;
804
+ case 2:
805
+ if (tag !== 18) {
806
+ break;
807
+ }
808
+ message.countryMetaPublicId = reader.string();
809
+ continue;
810
+ case 3:
811
+ if (tag !== 26) {
812
+ break;
813
+ }
814
+ message.languagePublicId = reader.string();
815
+ continue;
816
+ case 4:
817
+ if (tag !== 32) {
818
+ break;
819
+ }
820
+ message.isOfficial = reader.bool();
821
+ continue;
822
+ case 5:
823
+ if (tag !== 40) {
824
+ break;
825
+ }
826
+ message.isNational = reader.bool();
827
+ continue;
828
+ }
829
+ if ((tag & 7) === 4 || tag === 0) {
830
+ break;
831
+ }
832
+ reader.skipType(tag & 7);
833
+ }
834
+ return message;
835
+ },
836
+ };
837
+ function createBaseGrpcDtoGeoTimezonesSync() {
838
+ return { items: [], nextCursor: "", hasMore: false };
839
+ }
840
+ export const GrpcDtoGeoTimezonesSync = {
841
+ encode(message, writer = _m0.Writer.create()) {
842
+ for (const v of message.items) {
843
+ GrpcDtoGeoTimezone.encode(v, writer.uint32(10).fork()).ldelim();
844
+ }
845
+ if (message.nextCursor !== "") {
846
+ writer.uint32(18).string(message.nextCursor);
847
+ }
848
+ if (message.hasMore !== false) {
849
+ writer.uint32(24).bool(message.hasMore);
850
+ }
851
+ return writer;
852
+ },
853
+ decode(input, length) {
854
+ const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
855
+ let end = length === undefined ? reader.len : reader.pos + length;
856
+ const message = createBaseGrpcDtoGeoTimezonesSync();
857
+ while (reader.pos < end) {
858
+ const tag = reader.uint32();
859
+ switch (tag >>> 3) {
860
+ case 1:
861
+ if (tag !== 10) {
862
+ break;
863
+ }
864
+ message.items.push(GrpcDtoGeoTimezone.decode(reader, reader.uint32()));
865
+ continue;
866
+ case 2:
867
+ if (tag !== 18) {
868
+ break;
869
+ }
870
+ message.nextCursor = reader.string();
871
+ continue;
872
+ case 3:
873
+ if (tag !== 24) {
874
+ break;
875
+ }
876
+ message.hasMore = reader.bool();
877
+ continue;
878
+ }
879
+ if ((tag & 7) === 4 || tag === 0) {
880
+ break;
881
+ }
882
+ reader.skipType(tag & 7);
883
+ }
884
+ return message;
885
+ },
886
+ };
887
+ function createBaseGrpcDtoGeoCurrenciesSync() {
888
+ return { items: [], nextCursor: "", hasMore: false };
889
+ }
890
+ export const GrpcDtoGeoCurrenciesSync = {
891
+ encode(message, writer = _m0.Writer.create()) {
892
+ for (const v of message.items) {
893
+ GrpcDtoGeoCurrency.encode(v, writer.uint32(10).fork()).ldelim();
894
+ }
895
+ if (message.nextCursor !== "") {
896
+ writer.uint32(18).string(message.nextCursor);
897
+ }
898
+ if (message.hasMore !== false) {
899
+ writer.uint32(24).bool(message.hasMore);
900
+ }
901
+ return writer;
902
+ },
903
+ decode(input, length) {
904
+ const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
905
+ let end = length === undefined ? reader.len : reader.pos + length;
906
+ const message = createBaseGrpcDtoGeoCurrenciesSync();
907
+ while (reader.pos < end) {
908
+ const tag = reader.uint32();
909
+ switch (tag >>> 3) {
910
+ case 1:
911
+ if (tag !== 10) {
912
+ break;
913
+ }
914
+ message.items.push(GrpcDtoGeoCurrency.decode(reader, reader.uint32()));
915
+ continue;
916
+ case 2:
917
+ if (tag !== 18) {
918
+ break;
919
+ }
920
+ message.nextCursor = reader.string();
921
+ continue;
922
+ case 3:
923
+ if (tag !== 24) {
924
+ break;
925
+ }
926
+ message.hasMore = reader.bool();
927
+ continue;
928
+ }
929
+ if ((tag & 7) === 4 || tag === 0) {
930
+ break;
931
+ }
932
+ reader.skipType(tag & 7);
933
+ }
934
+ return message;
935
+ },
936
+ };
937
+ function createBaseGrpcDtoGeoLanguagesSync() {
938
+ return { items: [], nextCursor: "", hasMore: false };
939
+ }
940
+ export const GrpcDtoGeoLanguagesSync = {
941
+ encode(message, writer = _m0.Writer.create()) {
942
+ for (const v of message.items) {
943
+ GrpcDtoGeoLanguage.encode(v, writer.uint32(10).fork()).ldelim();
944
+ }
945
+ if (message.nextCursor !== "") {
946
+ writer.uint32(18).string(message.nextCursor);
947
+ }
948
+ if (message.hasMore !== false) {
949
+ writer.uint32(24).bool(message.hasMore);
950
+ }
951
+ return writer;
952
+ },
953
+ decode(input, length) {
954
+ const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
955
+ let end = length === undefined ? reader.len : reader.pos + length;
956
+ const message = createBaseGrpcDtoGeoLanguagesSync();
957
+ while (reader.pos < end) {
958
+ const tag = reader.uint32();
959
+ switch (tag >>> 3) {
960
+ case 1:
961
+ if (tag !== 10) {
962
+ break;
963
+ }
964
+ message.items.push(GrpcDtoGeoLanguage.decode(reader, reader.uint32()));
965
+ continue;
966
+ case 2:
967
+ if (tag !== 18) {
968
+ break;
969
+ }
970
+ message.nextCursor = reader.string();
971
+ continue;
972
+ case 3:
973
+ if (tag !== 24) {
974
+ break;
975
+ }
976
+ message.hasMore = reader.bool();
977
+ continue;
978
+ }
979
+ if ((tag & 7) === 4 || tag === 0) {
980
+ break;
981
+ }
982
+ reader.skipType(tag & 7);
983
+ }
984
+ return message;
985
+ },
986
+ };
987
+ function createBaseGrpcDtoGeoLocalesSync() {
988
+ return { items: [], nextCursor: "", hasMore: false };
989
+ }
990
+ export const GrpcDtoGeoLocalesSync = {
991
+ encode(message, writer = _m0.Writer.create()) {
992
+ for (const v of message.items) {
993
+ GrpcDtoGeoLocale.encode(v, writer.uint32(10).fork()).ldelim();
994
+ }
995
+ if (message.nextCursor !== "") {
996
+ writer.uint32(18).string(message.nextCursor);
997
+ }
998
+ if (message.hasMore !== false) {
999
+ writer.uint32(24).bool(message.hasMore);
1000
+ }
1001
+ return writer;
1002
+ },
1003
+ decode(input, length) {
1004
+ const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
1005
+ let end = length === undefined ? reader.len : reader.pos + length;
1006
+ const message = createBaseGrpcDtoGeoLocalesSync();
1007
+ while (reader.pos < end) {
1008
+ const tag = reader.uint32();
1009
+ switch (tag >>> 3) {
1010
+ case 1:
1011
+ if (tag !== 10) {
1012
+ break;
1013
+ }
1014
+ message.items.push(GrpcDtoGeoLocale.decode(reader, reader.uint32()));
1015
+ continue;
1016
+ case 2:
1017
+ if (tag !== 18) {
1018
+ break;
1019
+ }
1020
+ message.nextCursor = reader.string();
1021
+ continue;
1022
+ case 3:
1023
+ if (tag !== 24) {
1024
+ break;
1025
+ }
1026
+ message.hasMore = reader.bool();
1027
+ continue;
1028
+ }
1029
+ if ((tag & 7) === 4 || tag === 0) {
1030
+ break;
1031
+ }
1032
+ reader.skipType(tag & 7);
1033
+ }
1034
+ return message;
1035
+ },
1036
+ };
1037
+ function createBaseGrpcDtoGeoDivisionsSync() {
1038
+ return { items: [], nextCursor: "", hasMore: false };
1039
+ }
1040
+ export const GrpcDtoGeoDivisionsSync = {
1041
+ encode(message, writer = _m0.Writer.create()) {
1042
+ for (const v of message.items) {
1043
+ GrpcDtoGeoDivision.encode(v, writer.uint32(10).fork()).ldelim();
1044
+ }
1045
+ if (message.nextCursor !== "") {
1046
+ writer.uint32(18).string(message.nextCursor);
1047
+ }
1048
+ if (message.hasMore !== false) {
1049
+ writer.uint32(24).bool(message.hasMore);
1050
+ }
1051
+ return writer;
1052
+ },
1053
+ decode(input, length) {
1054
+ const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
1055
+ let end = length === undefined ? reader.len : reader.pos + length;
1056
+ const message = createBaseGrpcDtoGeoDivisionsSync();
1057
+ while (reader.pos < end) {
1058
+ const tag = reader.uint32();
1059
+ switch (tag >>> 3) {
1060
+ case 1:
1061
+ if (tag !== 10) {
1062
+ break;
1063
+ }
1064
+ message.items.push(GrpcDtoGeoDivision.decode(reader, reader.uint32()));
1065
+ continue;
1066
+ case 2:
1067
+ if (tag !== 18) {
1068
+ break;
1069
+ }
1070
+ message.nextCursor = reader.string();
1071
+ continue;
1072
+ case 3:
1073
+ if (tag !== 24) {
1074
+ break;
1075
+ }
1076
+ message.hasMore = reader.bool();
1077
+ continue;
1078
+ }
1079
+ if ((tag & 7) === 4 || tag === 0) {
1080
+ break;
1081
+ }
1082
+ reader.skipType(tag & 7);
1083
+ }
1084
+ return message;
1085
+ },
1086
+ };
1087
+ function createBaseGrpcDtoGeoCountryMetasSync() {
1088
+ return { items: [], nextCursor: "", hasMore: false };
1089
+ }
1090
+ export const GrpcDtoGeoCountryMetasSync = {
1091
+ encode(message, writer = _m0.Writer.create()) {
1092
+ for (const v of message.items) {
1093
+ GrpcDtoGeoCountryMeta.encode(v, writer.uint32(10).fork()).ldelim();
1094
+ }
1095
+ if (message.nextCursor !== "") {
1096
+ writer.uint32(18).string(message.nextCursor);
1097
+ }
1098
+ if (message.hasMore !== false) {
1099
+ writer.uint32(24).bool(message.hasMore);
1100
+ }
1101
+ return writer;
1102
+ },
1103
+ decode(input, length) {
1104
+ const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
1105
+ let end = length === undefined ? reader.len : reader.pos + length;
1106
+ const message = createBaseGrpcDtoGeoCountryMetasSync();
1107
+ while (reader.pos < end) {
1108
+ const tag = reader.uint32();
1109
+ switch (tag >>> 3) {
1110
+ case 1:
1111
+ if (tag !== 10) {
1112
+ break;
1113
+ }
1114
+ message.items.push(GrpcDtoGeoCountryMeta.decode(reader, reader.uint32()));
1115
+ continue;
1116
+ case 2:
1117
+ if (tag !== 18) {
1118
+ break;
1119
+ }
1120
+ message.nextCursor = reader.string();
1121
+ continue;
1122
+ case 3:
1123
+ if (tag !== 24) {
1124
+ break;
1125
+ }
1126
+ message.hasMore = reader.bool();
1127
+ continue;
1128
+ }
1129
+ if ((tag & 7) === 4 || tag === 0) {
1130
+ break;
1131
+ }
1132
+ reader.skipType(tag & 7);
1133
+ }
1134
+ return message;
1135
+ },
1136
+ };
1137
+ function createBaseGrpcDtoGeoCountryTimezonesSync() {
1138
+ return { items: [], nextCursor: "", hasMore: false };
1139
+ }
1140
+ export const GrpcDtoGeoCountryTimezonesSync = {
1141
+ encode(message, writer = _m0.Writer.create()) {
1142
+ for (const v of message.items) {
1143
+ GrpcDtoGeoCountryTimezone.encode(v, writer.uint32(10).fork()).ldelim();
1144
+ }
1145
+ if (message.nextCursor !== "") {
1146
+ writer.uint32(18).string(message.nextCursor);
1147
+ }
1148
+ if (message.hasMore !== false) {
1149
+ writer.uint32(24).bool(message.hasMore);
1150
+ }
1151
+ return writer;
1152
+ },
1153
+ decode(input, length) {
1154
+ const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
1155
+ let end = length === undefined ? reader.len : reader.pos + length;
1156
+ const message = createBaseGrpcDtoGeoCountryTimezonesSync();
1157
+ while (reader.pos < end) {
1158
+ const tag = reader.uint32();
1159
+ switch (tag >>> 3) {
1160
+ case 1:
1161
+ if (tag !== 10) {
1162
+ break;
1163
+ }
1164
+ message.items.push(GrpcDtoGeoCountryTimezone.decode(reader, reader.uint32()));
1165
+ continue;
1166
+ case 2:
1167
+ if (tag !== 18) {
1168
+ break;
1169
+ }
1170
+ message.nextCursor = reader.string();
1171
+ continue;
1172
+ case 3:
1173
+ if (tag !== 24) {
1174
+ break;
1175
+ }
1176
+ message.hasMore = reader.bool();
1177
+ continue;
1178
+ }
1179
+ if ((tag & 7) === 4 || tag === 0) {
1180
+ break;
1181
+ }
1182
+ reader.skipType(tag & 7);
1183
+ }
1184
+ return message;
1185
+ },
1186
+ };
1187
+ function createBaseGrpcDtoGeoCountryCurrenciesSync() {
1188
+ return { items: [], nextCursor: "", hasMore: false };
1189
+ }
1190
+ export const GrpcDtoGeoCountryCurrenciesSync = {
1191
+ encode(message, writer = _m0.Writer.create()) {
1192
+ for (const v of message.items) {
1193
+ GrpcDtoGeoCountryCurrency.encode(v, writer.uint32(10).fork()).ldelim();
1194
+ }
1195
+ if (message.nextCursor !== "") {
1196
+ writer.uint32(18).string(message.nextCursor);
1197
+ }
1198
+ if (message.hasMore !== false) {
1199
+ writer.uint32(24).bool(message.hasMore);
1200
+ }
1201
+ return writer;
1202
+ },
1203
+ decode(input, length) {
1204
+ const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
1205
+ let end = length === undefined ? reader.len : reader.pos + length;
1206
+ const message = createBaseGrpcDtoGeoCountryCurrenciesSync();
1207
+ while (reader.pos < end) {
1208
+ const tag = reader.uint32();
1209
+ switch (tag >>> 3) {
1210
+ case 1:
1211
+ if (tag !== 10) {
1212
+ break;
1213
+ }
1214
+ message.items.push(GrpcDtoGeoCountryCurrency.decode(reader, reader.uint32()));
1215
+ continue;
1216
+ case 2:
1217
+ if (tag !== 18) {
1218
+ break;
1219
+ }
1220
+ message.nextCursor = reader.string();
1221
+ continue;
1222
+ case 3:
1223
+ if (tag !== 24) {
1224
+ break;
1225
+ }
1226
+ message.hasMore = reader.bool();
1227
+ continue;
1228
+ }
1229
+ if ((tag & 7) === 4 || tag === 0) {
1230
+ break;
1231
+ }
1232
+ reader.skipType(tag & 7);
1233
+ }
1234
+ return message;
1235
+ },
1236
+ };
1237
+ function createBaseGrpcDtoGeoCountryLanguagesSync() {
1238
+ return { items: [], nextCursor: "", hasMore: false };
1239
+ }
1240
+ export const GrpcDtoGeoCountryLanguagesSync = {
1241
+ encode(message, writer = _m0.Writer.create()) {
1242
+ for (const v of message.items) {
1243
+ GrpcDtoGeoCountryLanguage.encode(v, writer.uint32(10).fork()).ldelim();
1244
+ }
1245
+ if (message.nextCursor !== "") {
1246
+ writer.uint32(18).string(message.nextCursor);
1247
+ }
1248
+ if (message.hasMore !== false) {
1249
+ writer.uint32(24).bool(message.hasMore);
1250
+ }
1251
+ return writer;
1252
+ },
1253
+ decode(input, length) {
1254
+ const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
1255
+ let end = length === undefined ? reader.len : reader.pos + length;
1256
+ const message = createBaseGrpcDtoGeoCountryLanguagesSync();
1257
+ while (reader.pos < end) {
1258
+ const tag = reader.uint32();
1259
+ switch (tag >>> 3) {
1260
+ case 1:
1261
+ if (tag !== 10) {
1262
+ break;
1263
+ }
1264
+ message.items.push(GrpcDtoGeoCountryLanguage.decode(reader, reader.uint32()));
1265
+ continue;
1266
+ case 2:
1267
+ if (tag !== 18) {
1268
+ break;
1269
+ }
1270
+ message.nextCursor = reader.string();
1271
+ continue;
1272
+ case 3:
1273
+ if (tag !== 24) {
1274
+ break;
1275
+ }
1276
+ message.hasMore = reader.bool();
1277
+ continue;
1278
+ }
1279
+ if ((tag & 7) === 4 || tag === 0) {
1280
+ break;
1281
+ }
1282
+ reader.skipType(tag & 7);
1283
+ }
1284
+ return message;
1285
+ },
1286
+ };
1287
+ function createBaseGrpcDtoPagination() {
1288
+ return { totalItems: 0, totalPages: 0, currentPage: 0, pageSize: 0 };
1289
+ }
1290
+ export const GrpcDtoPagination = {
1291
+ encode(message, writer = _m0.Writer.create()) {
1292
+ if (message.totalItems !== 0) {
1293
+ writer.uint32(8).int32(message.totalItems);
1294
+ }
1295
+ if (message.totalPages !== 0) {
1296
+ writer.uint32(16).int32(message.totalPages);
1297
+ }
1298
+ if (message.currentPage !== 0) {
1299
+ writer.uint32(24).int32(message.currentPage);
1300
+ }
1301
+ if (message.pageSize !== 0) {
1302
+ writer.uint32(32).int32(message.pageSize);
1303
+ }
1304
+ return writer;
1305
+ },
1306
+ decode(input, length) {
1307
+ const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
1308
+ let end = length === undefined ? reader.len : reader.pos + length;
1309
+ const message = createBaseGrpcDtoPagination();
1310
+ while (reader.pos < end) {
1311
+ const tag = reader.uint32();
1312
+ switch (tag >>> 3) {
1313
+ case 1:
1314
+ if (tag !== 8) {
1315
+ break;
1316
+ }
1317
+ message.totalItems = reader.int32();
1318
+ continue;
1319
+ case 2:
1320
+ if (tag !== 16) {
1321
+ break;
1322
+ }
1323
+ message.totalPages = reader.int32();
1324
+ continue;
1325
+ case 3:
1326
+ if (tag !== 24) {
1327
+ break;
1328
+ }
1329
+ message.currentPage = reader.int32();
1330
+ continue;
1331
+ case 4:
1332
+ if (tag !== 32) {
1333
+ break;
1334
+ }
1335
+ message.pageSize = reader.int32();
1336
+ continue;
1337
+ }
1338
+ if ((tag & 7) === 4 || tag === 0) {
1339
+ break;
1340
+ }
1341
+ reader.skipType(tag & 7);
1342
+ }
1343
+ return message;
1344
+ },
1345
+ };
1346
+ function createBaseGrpcDtoMessage() {
1347
+ return { message: "" };
1348
+ }
1349
+ export const GrpcDtoMessage = {
1350
+ encode(message, writer = _m0.Writer.create()) {
1351
+ if (message.message !== "") {
1352
+ writer.uint32(10).string(message.message);
1353
+ }
1354
+ return writer;
1355
+ },
1356
+ decode(input, length) {
1357
+ const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
1358
+ let end = length === undefined ? reader.len : reader.pos + length;
1359
+ const message = createBaseGrpcDtoMessage();
1360
+ while (reader.pos < end) {
1361
+ const tag = reader.uint32();
1362
+ switch (tag >>> 3) {
1363
+ case 1:
1364
+ if (tag !== 10) {
1365
+ break;
1366
+ }
1367
+ message.message = reader.string();
1368
+ continue;
1369
+ }
1370
+ if ((tag & 7) === 4 || tag === 0) {
1371
+ break;
1372
+ }
1373
+ reader.skipType(tag & 7);
1374
+ }
1375
+ return message;
1376
+ },
1377
+ };
1378
+ function createBaseGrpcDtoPermission() {
1379
+ return { publicId: "", name: "", description: "" };
1380
+ }
1381
+ export const GrpcDtoPermission = {
1382
+ encode(message, writer = _m0.Writer.create()) {
1383
+ if (message.publicId !== "") {
1384
+ writer.uint32(10).string(message.publicId);
1385
+ }
1386
+ if (message.name !== "") {
1387
+ writer.uint32(18).string(message.name);
1388
+ }
1389
+ if (message.description !== "") {
1390
+ writer.uint32(26).string(message.description);
1391
+ }
1392
+ if (message.createdAt !== undefined) {
1393
+ Timestamp.encode(message.createdAt, writer.uint32(34).fork()).ldelim();
1394
+ }
1395
+ if (message.updatedAt !== undefined) {
1396
+ Timestamp.encode(message.updatedAt, writer.uint32(42).fork()).ldelim();
1397
+ }
1398
+ if (message.deletedAt !== undefined) {
1399
+ Timestamp.encode(message.deletedAt, writer.uint32(50).fork()).ldelim();
1400
+ }
1401
+ return writer;
1402
+ },
1403
+ decode(input, length) {
1404
+ const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
1405
+ let end = length === undefined ? reader.len : reader.pos + length;
1406
+ const message = createBaseGrpcDtoPermission();
1407
+ while (reader.pos < end) {
1408
+ const tag = reader.uint32();
1409
+ switch (tag >>> 3) {
1410
+ case 1:
1411
+ if (tag !== 10) {
1412
+ break;
1413
+ }
1414
+ message.publicId = reader.string();
1415
+ continue;
1416
+ case 2:
1417
+ if (tag !== 18) {
1418
+ break;
1419
+ }
1420
+ message.name = reader.string();
1421
+ continue;
1422
+ case 3:
1423
+ if (tag !== 26) {
1424
+ break;
1425
+ }
1426
+ message.description = reader.string();
1427
+ continue;
1428
+ case 4:
1429
+ if (tag !== 34) {
1430
+ break;
1431
+ }
1432
+ message.createdAt = Timestamp.decode(reader, reader.uint32());
1433
+ continue;
1434
+ case 5:
1435
+ if (tag !== 42) {
1436
+ break;
1437
+ }
1438
+ message.updatedAt = Timestamp.decode(reader, reader.uint32());
1439
+ continue;
1440
+ case 6:
1441
+ if (tag !== 50) {
1442
+ break;
1443
+ }
1444
+ message.deletedAt = Timestamp.decode(reader, reader.uint32());
1445
+ continue;
1446
+ }
1447
+ if ((tag & 7) === 4 || tag === 0) {
1448
+ break;
1449
+ }
1450
+ reader.skipType(tag & 7);
1451
+ }
1452
+ return message;
1453
+ },
1454
+ };
1455
+ function createBaseGrpcDtoPermissionsAdd() {
1456
+ return { permissions: [] };
1457
+ }
1458
+ export const GrpcDtoPermissionsAdd = {
1459
+ encode(message, writer = _m0.Writer.create()) {
1460
+ for (const v of message.permissions) {
1461
+ GrpcDtoPermission.encode(v, writer.uint32(10).fork()).ldelim();
1462
+ }
1463
+ return writer;
1464
+ },
1465
+ decode(input, length) {
1466
+ const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
1467
+ let end = length === undefined ? reader.len : reader.pos + length;
1468
+ const message = createBaseGrpcDtoPermissionsAdd();
1469
+ while (reader.pos < end) {
1470
+ const tag = reader.uint32();
1471
+ switch (tag >>> 3) {
1472
+ case 1:
1473
+ if (tag !== 10) {
1474
+ break;
1475
+ }
1476
+ message.permissions.push(GrpcDtoPermission.decode(reader, reader.uint32()));
1477
+ continue;
1478
+ }
1479
+ if ((tag & 7) === 4 || tag === 0) {
1480
+ break;
1481
+ }
1482
+ reader.skipType(tag & 7);
1483
+ }
1484
+ return message;
1485
+ },
1486
+ };
1487
+ function createBaseGrpcInputClientTypeSeed() {
1488
+ return { name: "" };
1489
+ }
1490
+ export const GrpcInputClientTypeSeed = {
1491
+ encode(message, writer = _m0.Writer.create()) {
1492
+ if (message.name !== "") {
1493
+ writer.uint32(10).string(message.name);
1494
+ }
1495
+ return writer;
1496
+ },
1497
+ decode(input, length) {
1498
+ const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
1499
+ let end = length === undefined ? reader.len : reader.pos + length;
1500
+ const message = createBaseGrpcInputClientTypeSeed();
1501
+ while (reader.pos < end) {
1502
+ const tag = reader.uint32();
1503
+ switch (tag >>> 3) {
1504
+ case 1:
1505
+ if (tag !== 10) {
1506
+ break;
1507
+ }
1508
+ message.name = reader.string();
1509
+ continue;
1510
+ }
1511
+ if ((tag & 7) === 4 || tag === 0) {
1512
+ break;
1513
+ }
1514
+ reader.skipType(tag & 7);
1515
+ }
1516
+ return message;
1517
+ },
1518
+ };
1519
+ function createBaseGrpcInputClientTypesSeed() {
1520
+ return { clientTypes: [] };
1521
+ }
1522
+ export const GrpcInputClientTypesSeed = {
1523
+ encode(message, writer = _m0.Writer.create()) {
1524
+ for (const v of message.clientTypes) {
1525
+ GrpcInputClientTypeSeed.encode(v, writer.uint32(10).fork()).ldelim();
1526
+ }
1527
+ return writer;
1528
+ },
1529
+ decode(input, length) {
1530
+ const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
1531
+ let end = length === undefined ? reader.len : reader.pos + length;
1532
+ const message = createBaseGrpcInputClientTypesSeed();
1533
+ while (reader.pos < end) {
1534
+ const tag = reader.uint32();
1535
+ switch (tag >>> 3) {
1536
+ case 1:
1537
+ if (tag !== 10) {
1538
+ break;
1539
+ }
1540
+ message.clientTypes.push(GrpcInputClientTypeSeed.decode(reader, reader.uint32()));
1541
+ continue;
1542
+ }
1543
+ if ((tag & 7) === 4 || tag === 0) {
1544
+ break;
1545
+ }
1546
+ reader.skipType(tag & 7);
1547
+ }
1548
+ return message;
1549
+ },
1550
+ };
1551
+ function createBaseGrpcInputClientType() {
1552
+ return { publicId: "" };
1553
+ }
1554
+ export const GrpcInputClientType = {
1555
+ encode(message, writer = _m0.Writer.create()) {
1556
+ if (message.publicId !== "") {
1557
+ writer.uint32(10).string(message.publicId);
1558
+ }
1559
+ return writer;
1560
+ },
1561
+ decode(input, length) {
1562
+ const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
1563
+ let end = length === undefined ? reader.len : reader.pos + length;
1564
+ const message = createBaseGrpcInputClientType();
1565
+ while (reader.pos < end) {
1566
+ const tag = reader.uint32();
1567
+ switch (tag >>> 3) {
1568
+ case 1:
1569
+ if (tag !== 10) {
1570
+ break;
1571
+ }
1572
+ message.publicId = reader.string();
1573
+ continue;
1574
+ }
1575
+ if ((tag & 7) === 4 || tag === 0) {
1576
+ break;
1577
+ }
1578
+ reader.skipType(tag & 7);
1579
+ }
1580
+ return message;
1581
+ },
1582
+ };
1583
+ function createBaseGrpcInputClientTypes() {
1584
+ return {};
1585
+ }
1586
+ export const GrpcInputClientTypes = {
1587
+ encode(message, writer = _m0.Writer.create()) {
1588
+ if (message.search !== undefined) {
1589
+ writer.uint32(10).string(message.search);
1590
+ }
1591
+ if (message.page !== undefined) {
1592
+ writer.uint32(16).int32(message.page);
1593
+ }
1594
+ if (message.pageSize !== undefined) {
1595
+ writer.uint32(24).int32(message.pageSize);
1596
+ }
1597
+ if (message.sortBy !== undefined) {
1598
+ writer.uint32(34).string(message.sortBy);
1599
+ }
1600
+ if (message.sortOrder !== undefined) {
1601
+ writer.uint32(42).string(message.sortOrder);
1602
+ }
1603
+ return writer;
1604
+ },
1605
+ decode(input, length) {
1606
+ const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
1607
+ let end = length === undefined ? reader.len : reader.pos + length;
1608
+ const message = createBaseGrpcInputClientTypes();
1609
+ while (reader.pos < end) {
1610
+ const tag = reader.uint32();
1611
+ switch (tag >>> 3) {
1612
+ case 1:
1613
+ if (tag !== 10) {
1614
+ break;
1615
+ }
1616
+ message.search = reader.string();
1617
+ continue;
1618
+ case 2:
1619
+ if (tag !== 16) {
1620
+ break;
1621
+ }
1622
+ message.page = reader.int32();
1623
+ continue;
1624
+ case 3:
1625
+ if (tag !== 24) {
1626
+ break;
1627
+ }
1628
+ message.pageSize = reader.int32();
1629
+ continue;
1630
+ case 4:
1631
+ if (tag !== 34) {
1632
+ break;
1633
+ }
1634
+ message.sortBy = reader.string();
1635
+ continue;
1636
+ case 5:
1637
+ if (tag !== 42) {
1638
+ break;
1639
+ }
1640
+ message.sortOrder = reader.string();
1641
+ continue;
1642
+ }
1643
+ if ((tag & 7) === 4 || tag === 0) {
1644
+ break;
1645
+ }
1646
+ reader.skipType(tag & 7);
1647
+ }
1648
+ return message;
1649
+ },
1650
+ };
1651
+ function createBaseGrpcDtoClientType() {
1652
+ return { publicId: "", name: "" };
1653
+ }
1654
+ export const GrpcDtoClientType = {
1655
+ encode(message, writer = _m0.Writer.create()) {
1656
+ if (message.publicId !== "") {
1657
+ writer.uint32(10).string(message.publicId);
1658
+ }
1659
+ if (message.name !== "") {
1660
+ writer.uint32(18).string(message.name);
1661
+ }
1662
+ if (message.createdAt !== undefined) {
1663
+ Timestamp.encode(message.createdAt, writer.uint32(26).fork()).ldelim();
1664
+ }
1665
+ if (message.updatedAt !== undefined) {
1666
+ Timestamp.encode(message.updatedAt, writer.uint32(34).fork()).ldelim();
1667
+ }
1668
+ if (message.deletedAt !== undefined) {
1669
+ Timestamp.encode(message.deletedAt, writer.uint32(42).fork()).ldelim();
1670
+ }
1671
+ return writer;
1672
+ },
1673
+ decode(input, length) {
1674
+ const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
1675
+ let end = length === undefined ? reader.len : reader.pos + length;
1676
+ const message = createBaseGrpcDtoClientType();
1677
+ while (reader.pos < end) {
1678
+ const tag = reader.uint32();
1679
+ switch (tag >>> 3) {
1680
+ case 1:
1681
+ if (tag !== 10) {
1682
+ break;
1683
+ }
1684
+ message.publicId = reader.string();
1685
+ continue;
1686
+ case 2:
1687
+ if (tag !== 18) {
1688
+ break;
1689
+ }
1690
+ message.name = reader.string();
1691
+ continue;
1692
+ case 3:
1693
+ if (tag !== 26) {
1694
+ break;
1695
+ }
1696
+ message.createdAt = Timestamp.decode(reader, reader.uint32());
1697
+ continue;
1698
+ case 4:
1699
+ if (tag !== 34) {
1700
+ break;
1701
+ }
1702
+ message.updatedAt = Timestamp.decode(reader, reader.uint32());
1703
+ continue;
1704
+ case 5:
1705
+ if (tag !== 42) {
1706
+ break;
1707
+ }
1708
+ message.deletedAt = Timestamp.decode(reader, reader.uint32());
1709
+ continue;
1710
+ }
1711
+ if ((tag & 7) === 4 || tag === 0) {
1712
+ break;
1713
+ }
1714
+ reader.skipType(tag & 7);
1715
+ }
1716
+ return message;
1717
+ },
1718
+ };
1719
+ function createBaseGrpcDtoClientTypesSeed() {
1720
+ return { clientTypes: [] };
1721
+ }
1722
+ export const GrpcDtoClientTypesSeed = {
1723
+ encode(message, writer = _m0.Writer.create()) {
1724
+ for (const v of message.clientTypes) {
1725
+ GrpcDtoClientType.encode(v, writer.uint32(10).fork()).ldelim();
1726
+ }
1727
+ return writer;
1728
+ },
1729
+ decode(input, length) {
1730
+ const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
1731
+ let end = length === undefined ? reader.len : reader.pos + length;
1732
+ const message = createBaseGrpcDtoClientTypesSeed();
1733
+ while (reader.pos < end) {
1734
+ const tag = reader.uint32();
1735
+ switch (tag >>> 3) {
1736
+ case 1:
1737
+ if (tag !== 10) {
1738
+ break;
1739
+ }
1740
+ message.clientTypes.push(GrpcDtoClientType.decode(reader, reader.uint32()));
1741
+ continue;
1742
+ }
1743
+ if ((tag & 7) === 4 || tag === 0) {
1744
+ break;
1745
+ }
1746
+ reader.skipType(tag & 7);
1747
+ }
1748
+ return message;
1749
+ },
1750
+ };
1751
+ function createBaseGrpcDtoClientTypes() {
1752
+ return { items: [] };
181
1753
  }
182
- export const GrpcDtoPermissionsAdd = {
1754
+ export const GrpcDtoClientTypes = {
183
1755
  encode(message, writer = _m0.Writer.create()) {
184
- for (const v of message.permissions) {
185
- GrpcDtoPermission.encode(v, writer.uint32(10).fork()).ldelim();
1756
+ for (const v of message.items) {
1757
+ GrpcDtoClientType.encode(v, writer.uint32(10).fork()).ldelim();
1758
+ }
1759
+ if (message.meta !== undefined) {
1760
+ GrpcDtoPagination.encode(message.meta, writer.uint32(18).fork()).ldelim();
186
1761
  }
187
1762
  return writer;
188
1763
  },
189
1764
  decode(input, length) {
190
1765
  const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
191
1766
  let end = length === undefined ? reader.len : reader.pos + length;
192
- const message = createBaseGrpcDtoPermissionsAdd();
1767
+ const message = createBaseGrpcDtoClientTypes();
193
1768
  while (reader.pos < end) {
194
1769
  const tag = reader.uint32();
195
1770
  switch (tag >>> 3) {
@@ -197,7 +1772,13 @@ export const GrpcDtoPermissionsAdd = {
197
1772
  if (tag !== 10) {
198
1773
  break;
199
1774
  }
200
- message.permissions.push(GrpcDtoPermission.decode(reader, reader.uint32()));
1775
+ message.items.push(GrpcDtoClientType.decode(reader, reader.uint32()));
1776
+ continue;
1777
+ case 2:
1778
+ if (tag !== 18) {
1779
+ break;
1780
+ }
1781
+ message.meta = GrpcDtoPagination.decode(reader, reader.uint32());
201
1782
  continue;
202
1783
  }
203
1784
  if ((tag & 7) === 4 || tag === 0) {
@@ -736,93 +2317,302 @@ export const GrpcDtoFeaturePermissions = {
736
2317
  return message;
737
2318
  },
738
2319
  };
739
- function createBaseGrpcDtoGeoDivision() {
740
- return {
741
- publicId: "",
742
- parentPublicId: "",
743
- type: "",
744
- level: 0,
745
- code: "",
746
- path: "",
747
- name: "",
748
- iso2: "",
749
- iso3: "",
750
- phoneCode: "",
751
- isCapital: false,
752
- isActive: false,
753
- geoJson: "",
754
- timezonePublicId: "",
755
- currencyPublicId: "",
756
- };
2320
+ function createBaseGrpcInputClientCreate() {
2321
+ return { clientTypePublicId: "", name: "" };
757
2322
  }
758
- export const GrpcDtoGeoDivision = {
2323
+ export const GrpcInputClientCreate = {
2324
+ encode(message, writer = _m0.Writer.create()) {
2325
+ if (message.clientTypePublicId !== "") {
2326
+ writer.uint32(10).string(message.clientTypePublicId);
2327
+ }
2328
+ if (message.name !== "") {
2329
+ writer.uint32(18).string(message.name);
2330
+ }
2331
+ if (message.managerPublicId !== undefined) {
2332
+ writer.uint32(26).string(message.managerPublicId);
2333
+ }
2334
+ if (message.description !== undefined) {
2335
+ writer.uint32(34).string(message.description);
2336
+ }
2337
+ return writer;
2338
+ },
2339
+ decode(input, length) {
2340
+ const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
2341
+ let end = length === undefined ? reader.len : reader.pos + length;
2342
+ const message = createBaseGrpcInputClientCreate();
2343
+ while (reader.pos < end) {
2344
+ const tag = reader.uint32();
2345
+ switch (tag >>> 3) {
2346
+ case 1:
2347
+ if (tag !== 10) {
2348
+ break;
2349
+ }
2350
+ message.clientTypePublicId = reader.string();
2351
+ continue;
2352
+ case 2:
2353
+ if (tag !== 18) {
2354
+ break;
2355
+ }
2356
+ message.name = reader.string();
2357
+ continue;
2358
+ case 3:
2359
+ if (tag !== 26) {
2360
+ break;
2361
+ }
2362
+ message.managerPublicId = reader.string();
2363
+ continue;
2364
+ case 4:
2365
+ if (tag !== 34) {
2366
+ break;
2367
+ }
2368
+ message.description = reader.string();
2369
+ continue;
2370
+ }
2371
+ if ((tag & 7) === 4 || tag === 0) {
2372
+ break;
2373
+ }
2374
+ reader.skipType(tag & 7);
2375
+ }
2376
+ return message;
2377
+ },
2378
+ };
2379
+ function createBaseGrpcInputClientUpdate() {
2380
+ return { publicId: "" };
2381
+ }
2382
+ export const GrpcInputClientUpdate = {
759
2383
  encode(message, writer = _m0.Writer.create()) {
760
2384
  if (message.publicId !== "") {
761
2385
  writer.uint32(10).string(message.publicId);
762
2386
  }
763
- if (message.parentPublicId !== "") {
764
- writer.uint32(18).string(message.parentPublicId);
2387
+ if (message.name !== undefined) {
2388
+ writer.uint32(18).string(message.name);
765
2389
  }
766
- if (message.type !== "") {
767
- writer.uint32(26).string(message.type);
2390
+ if (message.description !== undefined) {
2391
+ writer.uint32(26).string(message.description);
768
2392
  }
769
- if (message.level !== 0) {
770
- writer.uint32(32).int32(message.level);
2393
+ if (message.clientTypePublicId !== undefined) {
2394
+ writer.uint32(34).string(message.clientTypePublicId);
771
2395
  }
772
- if (message.code !== "") {
773
- writer.uint32(42).string(message.code);
2396
+ if (message.managerPublicId !== undefined) {
2397
+ writer.uint32(42).string(message.managerPublicId);
774
2398
  }
775
- if (message.path !== "") {
776
- writer.uint32(50).string(message.path);
2399
+ return writer;
2400
+ },
2401
+ decode(input, length) {
2402
+ const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
2403
+ let end = length === undefined ? reader.len : reader.pos + length;
2404
+ const message = createBaseGrpcInputClientUpdate();
2405
+ while (reader.pos < end) {
2406
+ const tag = reader.uint32();
2407
+ switch (tag >>> 3) {
2408
+ case 1:
2409
+ if (tag !== 10) {
2410
+ break;
2411
+ }
2412
+ message.publicId = reader.string();
2413
+ continue;
2414
+ case 2:
2415
+ if (tag !== 18) {
2416
+ break;
2417
+ }
2418
+ message.name = reader.string();
2419
+ continue;
2420
+ case 3:
2421
+ if (tag !== 26) {
2422
+ break;
2423
+ }
2424
+ message.description = reader.string();
2425
+ continue;
2426
+ case 4:
2427
+ if (tag !== 34) {
2428
+ break;
2429
+ }
2430
+ message.clientTypePublicId = reader.string();
2431
+ continue;
2432
+ case 5:
2433
+ if (tag !== 42) {
2434
+ break;
2435
+ }
2436
+ message.managerPublicId = reader.string();
2437
+ continue;
2438
+ }
2439
+ if ((tag & 7) === 4 || tag === 0) {
2440
+ break;
2441
+ }
2442
+ reader.skipType(tag & 7);
777
2443
  }
778
- if (message.name !== "") {
779
- writer.uint32(58).string(message.name);
2444
+ return message;
2445
+ },
2446
+ };
2447
+ function createBaseGrpcInputClientFeaturesAdd() {
2448
+ return { publicId: "", featureIds: [] };
2449
+ }
2450
+ export const GrpcInputClientFeaturesAdd = {
2451
+ encode(message, writer = _m0.Writer.create()) {
2452
+ if (message.publicId !== "") {
2453
+ writer.uint32(10).string(message.publicId);
780
2454
  }
781
- if (message.iso2 !== "") {
782
- writer.uint32(66).string(message.iso2);
2455
+ for (const v of message.featureIds) {
2456
+ writer.uint32(18).string(v);
783
2457
  }
784
- if (message.iso3 !== "") {
785
- writer.uint32(74).string(message.iso3);
2458
+ return writer;
2459
+ },
2460
+ decode(input, length) {
2461
+ const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
2462
+ let end = length === undefined ? reader.len : reader.pos + length;
2463
+ const message = createBaseGrpcInputClientFeaturesAdd();
2464
+ while (reader.pos < end) {
2465
+ const tag = reader.uint32();
2466
+ switch (tag >>> 3) {
2467
+ case 1:
2468
+ if (tag !== 10) {
2469
+ break;
2470
+ }
2471
+ message.publicId = reader.string();
2472
+ continue;
2473
+ case 2:
2474
+ if (tag !== 18) {
2475
+ break;
2476
+ }
2477
+ message.featureIds.push(reader.string());
2478
+ continue;
2479
+ }
2480
+ if ((tag & 7) === 4 || tag === 0) {
2481
+ break;
2482
+ }
2483
+ reader.skipType(tag & 7);
786
2484
  }
787
- if (message.phoneCode !== "") {
788
- writer.uint32(82).string(message.phoneCode);
2485
+ return message;
2486
+ },
2487
+ };
2488
+ function createBaseGrpcInputClientFeaturesRemove() {
2489
+ return { publicClientFeatureIds: [] };
2490
+ }
2491
+ export const GrpcInputClientFeaturesRemove = {
2492
+ encode(message, writer = _m0.Writer.create()) {
2493
+ for (const v of message.publicClientFeatureIds) {
2494
+ writer.uint32(10).string(v);
789
2495
  }
790
- if (message.isCapital !== false) {
791
- writer.uint32(88).bool(message.isCapital);
2496
+ return writer;
2497
+ },
2498
+ decode(input, length) {
2499
+ const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
2500
+ let end = length === undefined ? reader.len : reader.pos + length;
2501
+ const message = createBaseGrpcInputClientFeaturesRemove();
2502
+ while (reader.pos < end) {
2503
+ const tag = reader.uint32();
2504
+ switch (tag >>> 3) {
2505
+ case 1:
2506
+ if (tag !== 10) {
2507
+ break;
2508
+ }
2509
+ message.publicClientFeatureIds.push(reader.string());
2510
+ continue;
2511
+ }
2512
+ if ((tag & 7) === 4 || tag === 0) {
2513
+ break;
2514
+ }
2515
+ reader.skipType(tag & 7);
792
2516
  }
793
- if (message.isActive !== false) {
794
- writer.uint32(96).bool(message.isActive);
2517
+ return message;
2518
+ },
2519
+ };
2520
+ function createBaseGrpcInputClient() {
2521
+ return { publicId: "" };
2522
+ }
2523
+ export const GrpcInputClient = {
2524
+ encode(message, writer = _m0.Writer.create()) {
2525
+ if (message.publicId !== "") {
2526
+ writer.uint32(10).string(message.publicId);
2527
+ }
2528
+ return writer;
2529
+ },
2530
+ decode(input, length) {
2531
+ const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
2532
+ let end = length === undefined ? reader.len : reader.pos + length;
2533
+ const message = createBaseGrpcInputClient();
2534
+ while (reader.pos < end) {
2535
+ const tag = reader.uint32();
2536
+ switch (tag >>> 3) {
2537
+ case 1:
2538
+ if (tag !== 10) {
2539
+ break;
2540
+ }
2541
+ message.publicId = reader.string();
2542
+ continue;
2543
+ }
2544
+ if ((tag & 7) === 4 || tag === 0) {
2545
+ break;
2546
+ }
2547
+ reader.skipType(tag & 7);
2548
+ }
2549
+ return message;
2550
+ },
2551
+ };
2552
+ function createBaseGrpcInputClientFeatures() {
2553
+ return { clientPublicId: "" };
2554
+ }
2555
+ export const GrpcInputClientFeatures = {
2556
+ encode(message, writer = _m0.Writer.create()) {
2557
+ if (message.clientPublicId !== "") {
2558
+ writer.uint32(10).string(message.clientPublicId);
795
2559
  }
796
- if (message.lat !== undefined) {
797
- writer.uint32(105).double(message.lat);
2560
+ return writer;
2561
+ },
2562
+ decode(input, length) {
2563
+ const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
2564
+ let end = length === undefined ? reader.len : reader.pos + length;
2565
+ const message = createBaseGrpcInputClientFeatures();
2566
+ while (reader.pos < end) {
2567
+ const tag = reader.uint32();
2568
+ switch (tag >>> 3) {
2569
+ case 1:
2570
+ if (tag !== 10) {
2571
+ break;
2572
+ }
2573
+ message.clientPublicId = reader.string();
2574
+ continue;
2575
+ }
2576
+ if ((tag & 7) === 4 || tag === 0) {
2577
+ break;
2578
+ }
2579
+ reader.skipType(tag & 7);
798
2580
  }
799
- if (message.lng !== undefined) {
800
- writer.uint32(113).double(message.lng);
2581
+ return message;
2582
+ },
2583
+ };
2584
+ function createBaseGrpcInputClients() {
2585
+ return {};
2586
+ }
2587
+ export const GrpcInputClients = {
2588
+ encode(message, writer = _m0.Writer.create()) {
2589
+ if (message.clientTypePublicId !== undefined) {
2590
+ writer.uint32(10).string(message.clientTypePublicId);
801
2591
  }
802
- if (message.geoJson !== "") {
803
- writer.uint32(122).string(message.geoJson);
2592
+ if (message.managerPublicId !== undefined) {
2593
+ writer.uint32(18).string(message.managerPublicId);
804
2594
  }
805
- if (message.timezonePublicId !== "") {
806
- writer.uint32(130).string(message.timezonePublicId);
2595
+ if (message.search !== undefined) {
2596
+ writer.uint32(26).string(message.search);
807
2597
  }
808
- if (message.currencyPublicId !== "") {
809
- writer.uint32(138).string(message.currencyPublicId);
2598
+ if (message.page !== undefined) {
2599
+ writer.uint32(32).int32(message.page);
810
2600
  }
811
- if (message.createdAt !== undefined) {
812
- Timestamp.encode(message.createdAt, writer.uint32(146).fork()).ldelim();
2601
+ if (message.pageSize !== undefined) {
2602
+ writer.uint32(40).int32(message.pageSize);
813
2603
  }
814
- if (message.updatedAt !== undefined) {
815
- Timestamp.encode(message.updatedAt, writer.uint32(154).fork()).ldelim();
2604
+ if (message.sortBy !== undefined) {
2605
+ writer.uint32(50).string(message.sortBy);
816
2606
  }
817
- if (message.deletedAt !== undefined) {
818
- Timestamp.encode(message.deletedAt, writer.uint32(162).fork()).ldelim();
2607
+ if (message.sortOrder !== undefined) {
2608
+ writer.uint32(58).string(message.sortOrder);
819
2609
  }
820
2610
  return writer;
821
2611
  },
822
2612
  decode(input, length) {
823
2613
  const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
824
2614
  let end = length === undefined ? reader.len : reader.pos + length;
825
- const message = createBaseGrpcDtoGeoDivision();
2615
+ const message = createBaseGrpcInputClients();
826
2616
  while (reader.pos < end) {
827
2617
  const tag = reader.uint32();
828
2618
  switch (tag >>> 3) {
@@ -830,118 +2620,126 @@ export const GrpcDtoGeoDivision = {
830
2620
  if (tag !== 10) {
831
2621
  break;
832
2622
  }
833
- message.publicId = reader.string();
2623
+ message.clientTypePublicId = reader.string();
834
2624
  continue;
835
2625
  case 2:
836
2626
  if (tag !== 18) {
837
2627
  break;
838
2628
  }
839
- message.parentPublicId = reader.string();
2629
+ message.managerPublicId = reader.string();
840
2630
  continue;
841
2631
  case 3:
842
2632
  if (tag !== 26) {
843
2633
  break;
844
2634
  }
845
- message.type = reader.string();
2635
+ message.search = reader.string();
846
2636
  continue;
847
2637
  case 4:
848
2638
  if (tag !== 32) {
849
2639
  break;
850
2640
  }
851
- message.level = reader.int32();
2641
+ message.page = reader.int32();
852
2642
  continue;
853
2643
  case 5:
854
- if (tag !== 42) {
2644
+ if (tag !== 40) {
855
2645
  break;
856
2646
  }
857
- message.code = reader.string();
2647
+ message.pageSize = reader.int32();
858
2648
  continue;
859
2649
  case 6:
860
2650
  if (tag !== 50) {
861
2651
  break;
862
2652
  }
863
- message.path = reader.string();
2653
+ message.sortBy = reader.string();
864
2654
  continue;
865
2655
  case 7:
866
2656
  if (tag !== 58) {
867
2657
  break;
868
2658
  }
869
- message.name = reader.string();
870
- continue;
871
- case 8:
872
- if (tag !== 66) {
873
- break;
874
- }
875
- message.iso2 = reader.string();
876
- continue;
877
- case 9:
878
- if (tag !== 74) {
879
- break;
880
- }
881
- message.iso3 = reader.string();
882
- continue;
883
- case 10:
884
- if (tag !== 82) {
885
- break;
886
- }
887
- message.phoneCode = reader.string();
888
- continue;
889
- case 11:
890
- if (tag !== 88) {
891
- break;
892
- }
893
- message.isCapital = reader.bool();
894
- continue;
895
- case 12:
896
- if (tag !== 96) {
897
- break;
898
- }
899
- message.isActive = reader.bool();
900
- continue;
901
- case 13:
902
- if (tag !== 105) {
903
- break;
904
- }
905
- message.lat = reader.double();
2659
+ message.sortOrder = reader.string();
906
2660
  continue;
907
- case 14:
908
- if (tag !== 113) {
2661
+ }
2662
+ if ((tag & 7) === 4 || tag === 0) {
2663
+ break;
2664
+ }
2665
+ reader.skipType(tag & 7);
2666
+ }
2667
+ return message;
2668
+ },
2669
+ };
2670
+ function createBaseGrpcDtoClient() {
2671
+ return { publicId: "", name: "" };
2672
+ }
2673
+ export const GrpcDtoClient = {
2674
+ encode(message, writer = _m0.Writer.create()) {
2675
+ if (message.publicId !== "") {
2676
+ writer.uint32(10).string(message.publicId);
2677
+ }
2678
+ if (message.name !== "") {
2679
+ writer.uint32(18).string(message.name);
2680
+ }
2681
+ if (message.description !== undefined) {
2682
+ writer.uint32(26).string(message.description);
2683
+ }
2684
+ if (message.clientType !== undefined) {
2685
+ GrpcDtoClientType.encode(message.clientType, writer.uint32(34).fork()).ldelim();
2686
+ }
2687
+ if (message.createdAt !== undefined) {
2688
+ Timestamp.encode(message.createdAt, writer.uint32(42).fork()).ldelim();
2689
+ }
2690
+ if (message.updatedAt !== undefined) {
2691
+ Timestamp.encode(message.updatedAt, writer.uint32(50).fork()).ldelim();
2692
+ }
2693
+ if (message.deletedAt !== undefined) {
2694
+ Timestamp.encode(message.deletedAt, writer.uint32(58).fork()).ldelim();
2695
+ }
2696
+ return writer;
2697
+ },
2698
+ decode(input, length) {
2699
+ const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
2700
+ let end = length === undefined ? reader.len : reader.pos + length;
2701
+ const message = createBaseGrpcDtoClient();
2702
+ while (reader.pos < end) {
2703
+ const tag = reader.uint32();
2704
+ switch (tag >>> 3) {
2705
+ case 1:
2706
+ if (tag !== 10) {
909
2707
  break;
910
2708
  }
911
- message.lng = reader.double();
2709
+ message.publicId = reader.string();
912
2710
  continue;
913
- case 15:
914
- if (tag !== 122) {
2711
+ case 2:
2712
+ if (tag !== 18) {
915
2713
  break;
916
2714
  }
917
- message.geoJson = reader.string();
2715
+ message.name = reader.string();
918
2716
  continue;
919
- case 16:
920
- if (tag !== 130) {
2717
+ case 3:
2718
+ if (tag !== 26) {
921
2719
  break;
922
2720
  }
923
- message.timezonePublicId = reader.string();
2721
+ message.description = reader.string();
924
2722
  continue;
925
- case 17:
926
- if (tag !== 138) {
2723
+ case 4:
2724
+ if (tag !== 34) {
927
2725
  break;
928
2726
  }
929
- message.currencyPublicId = reader.string();
2727
+ message.clientType = GrpcDtoClientType.decode(reader, reader.uint32());
930
2728
  continue;
931
- case 18:
932
- if (tag !== 146) {
2729
+ case 5:
2730
+ if (tag !== 42) {
933
2731
  break;
934
2732
  }
935
2733
  message.createdAt = Timestamp.decode(reader, reader.uint32());
936
2734
  continue;
937
- case 19:
938
- if (tag !== 154) {
2735
+ case 6:
2736
+ if (tag !== 50) {
939
2737
  break;
940
2738
  }
941
2739
  message.updatedAt = Timestamp.decode(reader, reader.uint32());
942
2740
  continue;
943
- case 20:
944
- if (tag !== 162) {
2741
+ case 7:
2742
+ if (tag !== 58) {
945
2743
  break;
946
2744
  }
947
2745
  message.deletedAt = Timestamp.decode(reader, reader.uint32());
@@ -955,23 +2753,23 @@ export const GrpcDtoGeoDivision = {
955
2753
  return message;
956
2754
  },
957
2755
  };
958
- function createBaseGrpcDtoGeoDivisionsPage() {
959
- return { items: [], nextCursor: "" };
2756
+ function createBaseGrpcDtoClients() {
2757
+ return { items: [] };
960
2758
  }
961
- export const GrpcDtoGeoDivisionsPage = {
2759
+ export const GrpcDtoClients = {
962
2760
  encode(message, writer = _m0.Writer.create()) {
963
2761
  for (const v of message.items) {
964
- GrpcDtoGeoDivision.encode(v, writer.uint32(10).fork()).ldelim();
2762
+ GrpcDtoClient.encode(v, writer.uint32(10).fork()).ldelim();
965
2763
  }
966
- if (message.nextCursor !== "") {
967
- writer.uint32(18).string(message.nextCursor);
2764
+ if (message.meta !== undefined) {
2765
+ GrpcDtoPagination.encode(message.meta, writer.uint32(18).fork()).ldelim();
968
2766
  }
969
2767
  return writer;
970
2768
  },
971
2769
  decode(input, length) {
972
2770
  const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
973
2771
  let end = length === undefined ? reader.len : reader.pos + length;
974
- const message = createBaseGrpcDtoGeoDivisionsPage();
2772
+ const message = createBaseGrpcDtoClients();
975
2773
  while (reader.pos < end) {
976
2774
  const tag = reader.uint32();
977
2775
  switch (tag >>> 3) {
@@ -979,13 +2777,13 @@ export const GrpcDtoGeoDivisionsPage = {
979
2777
  if (tag !== 10) {
980
2778
  break;
981
2779
  }
982
- message.items.push(GrpcDtoGeoDivision.decode(reader, reader.uint32()));
2780
+ message.items.push(GrpcDtoClient.decode(reader, reader.uint32()));
983
2781
  continue;
984
2782
  case 2:
985
2783
  if (tag !== 18) {
986
2784
  break;
987
2785
  }
988
- message.nextCursor = reader.string();
2786
+ message.meta = GrpcDtoPagination.decode(reader, reader.uint32());
989
2787
  continue;
990
2788
  }
991
2789
  if ((tag & 7) === 4 || tag === 0) {
@@ -996,20 +2794,20 @@ export const GrpcDtoGeoDivisionsPage = {
996
2794
  return message;
997
2795
  },
998
2796
  };
999
- function createBaseGrpcDtoGeoDivisions() {
1000
- return { items: [] };
2797
+ function createBaseGrpcDtoFeaturesAdd() {
2798
+ return { features: [] };
1001
2799
  }
1002
- export const GrpcDtoGeoDivisions = {
2800
+ export const GrpcDtoFeaturesAdd = {
1003
2801
  encode(message, writer = _m0.Writer.create()) {
1004
- for (const v of message.items) {
1005
- GrpcDtoGeoDivision.encode(v, writer.uint32(10).fork()).ldelim();
2802
+ for (const v of message.features) {
2803
+ GrpcDtoFeature.encode(v, writer.uint32(10).fork()).ldelim();
1006
2804
  }
1007
2805
  return writer;
1008
2806
  },
1009
2807
  decode(input, length) {
1010
2808
  const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
1011
2809
  let end = length === undefined ? reader.len : reader.pos + length;
1012
- const message = createBaseGrpcDtoGeoDivisions();
2810
+ const message = createBaseGrpcDtoFeaturesAdd();
1013
2811
  while (reader.pos < end) {
1014
2812
  const tag = reader.uint32();
1015
2813
  switch (tag >>> 3) {
@@ -1017,7 +2815,7 @@ export const GrpcDtoGeoDivisions = {
1017
2815
  if (tag !== 10) {
1018
2816
  break;
1019
2817
  }
1020
- message.items.push(GrpcDtoGeoDivision.decode(reader, reader.uint32()));
2818
+ message.features.push(GrpcDtoFeature.decode(reader, reader.uint32()));
1021
2819
  continue;
1022
2820
  }
1023
2821
  if ((tag & 7) === 4 || tag === 0) {
@@ -1028,23 +2826,26 @@ export const GrpcDtoGeoDivisions = {
1028
2826
  return message;
1029
2827
  },
1030
2828
  };
1031
- function createBaseGrpcInputGeoDivisionsListAll() {
1032
- return { cursor: "", limit: 0 };
2829
+ function createBaseGrpcDtoClientFeature() {
2830
+ return { publicId: "" };
1033
2831
  }
1034
- export const GrpcInputGeoDivisionsListAll = {
2832
+ export const GrpcDtoClientFeature = {
1035
2833
  encode(message, writer = _m0.Writer.create()) {
1036
- if (message.cursor !== "") {
1037
- writer.uint32(10).string(message.cursor);
2834
+ if (message.publicId !== "") {
2835
+ writer.uint32(10).string(message.publicId);
2836
+ }
2837
+ if (message.feature !== undefined) {
2838
+ GrpcDtoFeature.encode(message.feature, writer.uint32(18).fork()).ldelim();
1038
2839
  }
1039
- if (message.limit !== 0) {
1040
- writer.uint32(16).int32(message.limit);
2840
+ if (message.client !== undefined) {
2841
+ GrpcDtoClient.encode(message.client, writer.uint32(26).fork()).ldelim();
1041
2842
  }
1042
2843
  return writer;
1043
2844
  },
1044
2845
  decode(input, length) {
1045
2846
  const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
1046
2847
  let end = length === undefined ? reader.len : reader.pos + length;
1047
- const message = createBaseGrpcInputGeoDivisionsListAll();
2848
+ const message = createBaseGrpcDtoClientFeature();
1048
2849
  while (reader.pos < end) {
1049
2850
  const tag = reader.uint32();
1050
2851
  switch (tag >>> 3) {
@@ -1052,45 +2853,19 @@ export const GrpcInputGeoDivisionsListAll = {
1052
2853
  if (tag !== 10) {
1053
2854
  break;
1054
2855
  }
1055
- message.cursor = reader.string();
2856
+ message.publicId = reader.string();
1056
2857
  continue;
1057
2858
  case 2:
1058
- if (tag !== 16) {
2859
+ if (tag !== 18) {
1059
2860
  break;
1060
2861
  }
1061
- message.limit = reader.int32();
2862
+ message.feature = GrpcDtoFeature.decode(reader, reader.uint32());
1062
2863
  continue;
1063
- }
1064
- if ((tag & 7) === 4 || tag === 0) {
1065
- break;
1066
- }
1067
- reader.skipType(tag & 7);
1068
- }
1069
- return message;
1070
- },
1071
- };
1072
- function createBaseGrpcInputGeoDivisionsGetByPublicIds() {
1073
- return { publicIds: [] };
1074
- }
1075
- export const GrpcInputGeoDivisionsGetByPublicIds = {
1076
- encode(message, writer = _m0.Writer.create()) {
1077
- for (const v of message.publicIds) {
1078
- writer.uint32(10).string(v);
1079
- }
1080
- return writer;
1081
- },
1082
- decode(input, length) {
1083
- const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
1084
- let end = length === undefined ? reader.len : reader.pos + length;
1085
- const message = createBaseGrpcInputGeoDivisionsGetByPublicIds();
1086
- while (reader.pos < end) {
1087
- const tag = reader.uint32();
1088
- switch (tag >>> 3) {
1089
- case 1:
1090
- if (tag !== 10) {
2864
+ case 3:
2865
+ if (tag !== 26) {
1091
2866
  break;
1092
2867
  }
1093
- message.publicIds.push(reader.string());
2868
+ message.client = GrpcDtoClient.decode(reader, reader.uint32());
1094
2869
  continue;
1095
2870
  }
1096
2871
  if ((tag & 7) === 4 || tag === 0) {
@@ -1101,26 +2876,20 @@ export const GrpcInputGeoDivisionsGetByPublicIds = {
1101
2876
  return message;
1102
2877
  },
1103
2878
  };
1104
- function createBaseGrpcInputGeoDivisionsListChangedSince() {
1105
- return { cursor: "", limit: 0 };
2879
+ function createBaseGrpcDtoClientFeatures() {
2880
+ return { clientFeatures: [] };
1106
2881
  }
1107
- export const GrpcInputGeoDivisionsListChangedSince = {
2882
+ export const GrpcDtoClientFeatures = {
1108
2883
  encode(message, writer = _m0.Writer.create()) {
1109
- if (message.since !== undefined) {
1110
- Timestamp.encode(message.since, writer.uint32(10).fork()).ldelim();
1111
- }
1112
- if (message.cursor !== "") {
1113
- writer.uint32(18).string(message.cursor);
1114
- }
1115
- if (message.limit !== 0) {
1116
- writer.uint32(24).int32(message.limit);
2884
+ for (const v of message.clientFeatures) {
2885
+ GrpcDtoClientFeature.encode(v, writer.uint32(10).fork()).ldelim();
1117
2886
  }
1118
2887
  return writer;
1119
2888
  },
1120
2889
  decode(input, length) {
1121
2890
  const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
1122
2891
  let end = length === undefined ? reader.len : reader.pos + length;
1123
- const message = createBaseGrpcInputGeoDivisionsListChangedSince();
2892
+ const message = createBaseGrpcDtoClientFeatures();
1124
2893
  while (reader.pos < end) {
1125
2894
  const tag = reader.uint32();
1126
2895
  switch (tag >>> 3) {
@@ -1128,19 +2897,7 @@ export const GrpcInputGeoDivisionsListChangedSince = {
1128
2897
  if (tag !== 10) {
1129
2898
  break;
1130
2899
  }
1131
- message.since = Timestamp.decode(reader, reader.uint32());
1132
- continue;
1133
- case 2:
1134
- if (tag !== 18) {
1135
- break;
1136
- }
1137
- message.cursor = reader.string();
1138
- continue;
1139
- case 3:
1140
- if (tag !== 24) {
1141
- break;
1142
- }
1143
- message.limit = reader.int32();
2900
+ message.clientFeatures.push(GrpcDtoClientFeature.decode(reader, reader.uint32()));
1144
2901
  continue;
1145
2902
  }
1146
2903
  if ((tag & 7) === 4 || tag === 0) {
@@ -1154,12 +2911,31 @@ export const GrpcInputGeoDivisionsListChangedSince = {
1154
2911
  export function SystemServiceControllerMethods() {
1155
2912
  return function (constructor) {
1156
2913
  const grpcMethods = [
2914
+ "clientTypesSeed",
2915
+ "clientTypes",
2916
+ "clientType",
1157
2917
  "featuresSeed",
1158
2918
  "features",
1159
2919
  "feature",
1160
2920
  "featurePermissions",
1161
2921
  "featurePermissionsAdd",
1162
2922
  "featurePermissionsRemove",
2923
+ "clientCreate",
2924
+ "clientUpdate",
2925
+ "clients",
2926
+ "client",
2927
+ "clientFeaturesAdd",
2928
+ "clientFeaturesRemove",
2929
+ "clientFeatures",
2930
+ "geoTimezonesSync",
2931
+ "geoCurrenciesSync",
2932
+ "geoLanguagesSync",
2933
+ "geoLocalesSync",
2934
+ "geoDivisionsSync",
2935
+ "geoCountryMetasSync",
2936
+ "geoCountryTimezonesSync",
2937
+ "geoCountryCurrenciesSync",
2938
+ "geoCountryLanguagesSync",
1163
2939
  ];
1164
2940
  for (const method of grpcMethods) {
1165
2941
  const descriptor = Reflect.getOwnPropertyDescriptor(constructor.prototype, method);
@@ -1174,6 +2950,34 @@ export function SystemServiceControllerMethods() {
1174
2950
  }
1175
2951
  export const SYSTEM_SERVICE_NAME = "SystemService";
1176
2952
  export const SystemServiceService = {
2953
+ /** --- Client Types --- */
2954
+ clientTypesSeed: {
2955
+ path: "/aegis.system.v1.SystemService/ClientTypesSeed",
2956
+ requestStream: false,
2957
+ responseStream: false,
2958
+ requestSerialize: (value) => Buffer.from(GrpcInputClientTypesSeed.encode(value).finish()),
2959
+ requestDeserialize: (value) => GrpcInputClientTypesSeed.decode(value),
2960
+ responseSerialize: (value) => Buffer.from(GrpcDtoClientTypesSeed.encode(value).finish()),
2961
+ responseDeserialize: (value) => GrpcDtoClientTypesSeed.decode(value),
2962
+ },
2963
+ clientTypes: {
2964
+ path: "/aegis.system.v1.SystemService/ClientTypes",
2965
+ requestStream: false,
2966
+ responseStream: false,
2967
+ requestSerialize: (value) => Buffer.from(GrpcInputClientTypes.encode(value).finish()),
2968
+ requestDeserialize: (value) => GrpcInputClientTypes.decode(value),
2969
+ responseSerialize: (value) => Buffer.from(GrpcDtoClientTypes.encode(value).finish()),
2970
+ responseDeserialize: (value) => GrpcDtoClientTypes.decode(value),
2971
+ },
2972
+ clientType: {
2973
+ path: "/aegis.system.v1.SystemService/ClientType",
2974
+ requestStream: false,
2975
+ responseStream: false,
2976
+ requestSerialize: (value) => Buffer.from(GrpcInputClientType.encode(value).finish()),
2977
+ requestDeserialize: (value) => GrpcInputClientType.decode(value),
2978
+ responseSerialize: (value) => Buffer.from(GrpcDtoClientType.encode(value).finish()),
2979
+ responseDeserialize: (value) => GrpcDtoClientType.decode(value),
2980
+ },
1177
2981
  /** --- Features --- */
1178
2982
  featuresSeed: {
1179
2983
  path: "/aegis.system.v1.SystemService/FeaturesSeed",
@@ -1229,54 +3033,150 @@ export const SystemServiceService = {
1229
3033
  responseSerialize: (value) => Buffer.from(GrpcDtoMessage.encode(value).finish()),
1230
3034
  responseDeserialize: (value) => GrpcDtoMessage.decode(value),
1231
3035
  },
1232
- };
1233
- export function GeoServiceControllerMethods() {
1234
- return function (constructor) {
1235
- const grpcMethods = ["geoDivisionsListAll", "geoDivisionsGetByPublicIds", "geoDivisionsListChangedSince"];
1236
- for (const method of grpcMethods) {
1237
- const descriptor = Reflect.getOwnPropertyDescriptor(constructor.prototype, method);
1238
- GrpcMethod("GeoService", method)(constructor.prototype[method], method, descriptor);
1239
- }
1240
- const grpcStreamMethods = [];
1241
- for (const method of grpcStreamMethods) {
1242
- const descriptor = Reflect.getOwnPropertyDescriptor(constructor.prototype, method);
1243
- GrpcStreamMethod("GeoService", method)(constructor.prototype[method], method, descriptor);
1244
- }
1245
- };
1246
- }
1247
- export const GEO_SERVICE_NAME = "GeoService";
1248
- export const GeoServiceService = {
1249
- /** Full sync (used on first mirror boot). Paged by public_id cursor. */
1250
- geoDivisionsListAll: {
1251
- path: "/aegis.system.v1.GeoService/GeoDivisionsListAll",
3036
+ /** --- Clients --- */
3037
+ clientCreate: {
3038
+ path: "/aegis.system.v1.SystemService/ClientCreate",
3039
+ requestStream: false,
3040
+ responseStream: false,
3041
+ requestSerialize: (value) => Buffer.from(GrpcInputClientCreate.encode(value).finish()),
3042
+ requestDeserialize: (value) => GrpcInputClientCreate.decode(value),
3043
+ responseSerialize: (value) => Buffer.from(GrpcDtoClient.encode(value).finish()),
3044
+ responseDeserialize: (value) => GrpcDtoClient.decode(value),
3045
+ },
3046
+ clientUpdate: {
3047
+ path: "/aegis.system.v1.SystemService/ClientUpdate",
3048
+ requestStream: false,
3049
+ responseStream: false,
3050
+ requestSerialize: (value) => Buffer.from(GrpcInputClientUpdate.encode(value).finish()),
3051
+ requestDeserialize: (value) => GrpcInputClientUpdate.decode(value),
3052
+ responseSerialize: (value) => Buffer.from(GrpcDtoClient.encode(value).finish()),
3053
+ responseDeserialize: (value) => GrpcDtoClient.decode(value),
3054
+ },
3055
+ clients: {
3056
+ path: "/aegis.system.v1.SystemService/Clients",
3057
+ requestStream: false,
3058
+ responseStream: false,
3059
+ requestSerialize: (value) => Buffer.from(GrpcInputClients.encode(value).finish()),
3060
+ requestDeserialize: (value) => GrpcInputClients.decode(value),
3061
+ responseSerialize: (value) => Buffer.from(GrpcDtoClients.encode(value).finish()),
3062
+ responseDeserialize: (value) => GrpcDtoClients.decode(value),
3063
+ },
3064
+ client: {
3065
+ path: "/aegis.system.v1.SystemService/Client",
3066
+ requestStream: false,
3067
+ responseStream: false,
3068
+ requestSerialize: (value) => Buffer.from(GrpcInputClient.encode(value).finish()),
3069
+ requestDeserialize: (value) => GrpcInputClient.decode(value),
3070
+ responseSerialize: (value) => Buffer.from(GrpcDtoClient.encode(value).finish()),
3071
+ responseDeserialize: (value) => GrpcDtoClient.decode(value),
3072
+ },
3073
+ clientFeaturesAdd: {
3074
+ path: "/aegis.system.v1.SystemService/ClientFeaturesAdd",
3075
+ requestStream: false,
3076
+ responseStream: false,
3077
+ requestSerialize: (value) => Buffer.from(GrpcInputClientFeaturesAdd.encode(value).finish()),
3078
+ requestDeserialize: (value) => GrpcInputClientFeaturesAdd.decode(value),
3079
+ responseSerialize: (value) => Buffer.from(GrpcDtoFeaturesAdd.encode(value).finish()),
3080
+ responseDeserialize: (value) => GrpcDtoFeaturesAdd.decode(value),
3081
+ },
3082
+ clientFeaturesRemove: {
3083
+ path: "/aegis.system.v1.SystemService/ClientFeaturesRemove",
3084
+ requestStream: false,
3085
+ responseStream: false,
3086
+ requestSerialize: (value) => Buffer.from(GrpcInputClientFeaturesRemove.encode(value).finish()),
3087
+ requestDeserialize: (value) => GrpcInputClientFeaturesRemove.decode(value),
3088
+ responseSerialize: (value) => Buffer.from(GrpcDtoMessage.encode(value).finish()),
3089
+ responseDeserialize: (value) => GrpcDtoMessage.decode(value),
3090
+ },
3091
+ clientFeatures: {
3092
+ path: "/aegis.system.v1.SystemService/ClientFeatures",
3093
+ requestStream: false,
3094
+ responseStream: false,
3095
+ requestSerialize: (value) => Buffer.from(GrpcInputClientFeatures.encode(value).finish()),
3096
+ requestDeserialize: (value) => GrpcInputClientFeatures.decode(value),
3097
+ responseSerialize: (value) => Buffer.from(GrpcDtoClientFeatures.encode(value).finish()),
3098
+ responseDeserialize: (value) => GrpcDtoClientFeatures.decode(value),
3099
+ },
3100
+ /** --- Geo delta sync (hourly pull from gtms mirror) --- */
3101
+ geoTimezonesSync: {
3102
+ path: "/aegis.system.v1.SystemService/GeoTimezonesSync",
3103
+ requestStream: false,
3104
+ responseStream: false,
3105
+ requestSerialize: (value) => Buffer.from(GrpcInputGeoSync.encode(value).finish()),
3106
+ requestDeserialize: (value) => GrpcInputGeoSync.decode(value),
3107
+ responseSerialize: (value) => Buffer.from(GrpcDtoGeoTimezonesSync.encode(value).finish()),
3108
+ responseDeserialize: (value) => GrpcDtoGeoTimezonesSync.decode(value),
3109
+ },
3110
+ geoCurrenciesSync: {
3111
+ path: "/aegis.system.v1.SystemService/GeoCurrenciesSync",
3112
+ requestStream: false,
3113
+ responseStream: false,
3114
+ requestSerialize: (value) => Buffer.from(GrpcInputGeoSync.encode(value).finish()),
3115
+ requestDeserialize: (value) => GrpcInputGeoSync.decode(value),
3116
+ responseSerialize: (value) => Buffer.from(GrpcDtoGeoCurrenciesSync.encode(value).finish()),
3117
+ responseDeserialize: (value) => GrpcDtoGeoCurrenciesSync.decode(value),
3118
+ },
3119
+ geoLanguagesSync: {
3120
+ path: "/aegis.system.v1.SystemService/GeoLanguagesSync",
3121
+ requestStream: false,
3122
+ responseStream: false,
3123
+ requestSerialize: (value) => Buffer.from(GrpcInputGeoSync.encode(value).finish()),
3124
+ requestDeserialize: (value) => GrpcInputGeoSync.decode(value),
3125
+ responseSerialize: (value) => Buffer.from(GrpcDtoGeoLanguagesSync.encode(value).finish()),
3126
+ responseDeserialize: (value) => GrpcDtoGeoLanguagesSync.decode(value),
3127
+ },
3128
+ geoLocalesSync: {
3129
+ path: "/aegis.system.v1.SystemService/GeoLocalesSync",
3130
+ requestStream: false,
3131
+ responseStream: false,
3132
+ requestSerialize: (value) => Buffer.from(GrpcInputGeoSync.encode(value).finish()),
3133
+ requestDeserialize: (value) => GrpcInputGeoSync.decode(value),
3134
+ responseSerialize: (value) => Buffer.from(GrpcDtoGeoLocalesSync.encode(value).finish()),
3135
+ responseDeserialize: (value) => GrpcDtoGeoLocalesSync.decode(value),
3136
+ },
3137
+ geoDivisionsSync: {
3138
+ path: "/aegis.system.v1.SystemService/GeoDivisionsSync",
1252
3139
  requestStream: false,
1253
3140
  responseStream: false,
1254
- requestSerialize: (value) => Buffer.from(GrpcInputGeoDivisionsListAll.encode(value).finish()),
1255
- requestDeserialize: (value) => GrpcInputGeoDivisionsListAll.decode(value),
1256
- responseSerialize: (value) => Buffer.from(GrpcDtoGeoDivisionsPage.encode(value).finish()),
1257
- responseDeserialize: (value) => GrpcDtoGeoDivisionsPage.decode(value),
1258
- },
1259
- /** Batch fetch by public_id (used by live Redis event consumers). */
1260
- geoDivisionsGetByPublicIds: {
1261
- path: "/aegis.system.v1.GeoService/GeoDivisionsGetByPublicIds",
3141
+ requestSerialize: (value) => Buffer.from(GrpcInputGeoSync.encode(value).finish()),
3142
+ requestDeserialize: (value) => GrpcInputGeoSync.decode(value),
3143
+ responseSerialize: (value) => Buffer.from(GrpcDtoGeoDivisionsSync.encode(value).finish()),
3144
+ responseDeserialize: (value) => GrpcDtoGeoDivisionsSync.decode(value),
3145
+ },
3146
+ geoCountryMetasSync: {
3147
+ path: "/aegis.system.v1.SystemService/GeoCountryMetasSync",
3148
+ requestStream: false,
3149
+ responseStream: false,
3150
+ requestSerialize: (value) => Buffer.from(GrpcInputGeoSync.encode(value).finish()),
3151
+ requestDeserialize: (value) => GrpcInputGeoSync.decode(value),
3152
+ responseSerialize: (value) => Buffer.from(GrpcDtoGeoCountryMetasSync.encode(value).finish()),
3153
+ responseDeserialize: (value) => GrpcDtoGeoCountryMetasSync.decode(value),
3154
+ },
3155
+ geoCountryTimezonesSync: {
3156
+ path: "/aegis.system.v1.SystemService/GeoCountryTimezonesSync",
1262
3157
  requestStream: false,
1263
3158
  responseStream: false,
1264
- requestSerialize: (value) => Buffer.from(GrpcInputGeoDivisionsGetByPublicIds.encode(value).finish()),
1265
- requestDeserialize: (value) => GrpcInputGeoDivisionsGetByPublicIds.decode(value),
1266
- responseSerialize: (value) => Buffer.from(GrpcDtoGeoDivisions.encode(value).finish()),
1267
- responseDeserialize: (value) => GrpcDtoGeoDivisions.decode(value),
1268
- },
1269
- /**
1270
- * Hourly safety-net reconciler. Catches anything the Redis publisher
1271
- * dropped due to restart races.
1272
- */
1273
- geoDivisionsListChangedSince: {
1274
- path: "/aegis.system.v1.GeoService/GeoDivisionsListChangedSince",
3159
+ requestSerialize: (value) => Buffer.from(GrpcInputGeoSync.encode(value).finish()),
3160
+ requestDeserialize: (value) => GrpcInputGeoSync.decode(value),
3161
+ responseSerialize: (value) => Buffer.from(GrpcDtoGeoCountryTimezonesSync.encode(value).finish()),
3162
+ responseDeserialize: (value) => GrpcDtoGeoCountryTimezonesSync.decode(value),
3163
+ },
3164
+ geoCountryCurrenciesSync: {
3165
+ path: "/aegis.system.v1.SystemService/GeoCountryCurrenciesSync",
3166
+ requestStream: false,
3167
+ responseStream: false,
3168
+ requestSerialize: (value) => Buffer.from(GrpcInputGeoSync.encode(value).finish()),
3169
+ requestDeserialize: (value) => GrpcInputGeoSync.decode(value),
3170
+ responseSerialize: (value) => Buffer.from(GrpcDtoGeoCountryCurrenciesSync.encode(value).finish()),
3171
+ responseDeserialize: (value) => GrpcDtoGeoCountryCurrenciesSync.decode(value),
3172
+ },
3173
+ geoCountryLanguagesSync: {
3174
+ path: "/aegis.system.v1.SystemService/GeoCountryLanguagesSync",
1275
3175
  requestStream: false,
1276
3176
  responseStream: false,
1277
- requestSerialize: (value) => Buffer.from(GrpcInputGeoDivisionsListChangedSince.encode(value).finish()),
1278
- requestDeserialize: (value) => GrpcInputGeoDivisionsListChangedSince.decode(value),
1279
- responseSerialize: (value) => Buffer.from(GrpcDtoGeoDivisionsPage.encode(value).finish()),
1280
- responseDeserialize: (value) => GrpcDtoGeoDivisionsPage.decode(value),
3177
+ requestSerialize: (value) => Buffer.from(GrpcInputGeoSync.encode(value).finish()),
3178
+ requestDeserialize: (value) => GrpcInputGeoSync.decode(value),
3179
+ responseSerialize: (value) => Buffer.from(GrpcDtoGeoCountryLanguagesSync.encode(value).finish()),
3180
+ responseDeserialize: (value) => GrpcDtoGeoCountryLanguagesSync.decode(value),
1281
3181
  },
1282
3182
  };