@acequants/aegis-contracts 0.1.21 → 0.1.22

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.
@@ -1,1568 +0,0 @@
1
- // Code generated by protoc-gen-ts_proto. DO NOT EDIT.
2
- // versions:
3
- // protoc-gen-ts_proto v1.181.2
4
- // protoc v6.32.0
5
- // source: auth/v1/auth.proto
6
- import { GrpcMethod, GrpcStreamMethod } from "@nestjs/microservices";
7
- import _m0 from "protobufjs/minimal";
8
- import { Timestamp } from "../../google/protobuf/timestamp";
9
- export const protobufPackage = "aegis.auth.v1";
10
- export const AEGIS_AUTH_V1_PACKAGE_NAME = "aegis.auth.v1";
11
- function createBaseGrpcDtoPagination() {
12
- return { totalItems: 0, totalPages: 0, currentPage: 0, pageSize: 0 };
13
- }
14
- export const GrpcDtoPagination = {
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);
24
- }
25
- if (message.pageSize !== 0) {
26
- writer.uint32(32).int32(message.pageSize);
27
- }
28
- return writer;
29
- },
30
- decode(input, length) {
31
- const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
32
- let end = length === undefined ? reader.len : reader.pos + length;
33
- const message = createBaseGrpcDtoPagination();
34
- while (reader.pos < end) {
35
- const tag = reader.uint32();
36
- switch (tag >>> 3) {
37
- case 1:
38
- if (tag !== 8) {
39
- break;
40
- }
41
- message.totalItems = reader.int32();
42
- continue;
43
- case 2:
44
- if (tag !== 16) {
45
- break;
46
- }
47
- message.totalPages = reader.int32();
48
- continue;
49
- case 3:
50
- if (tag !== 24) {
51
- break;
52
- }
53
- message.currentPage = reader.int32();
54
- continue;
55
- case 4:
56
- if (tag !== 32) {
57
- break;
58
- }
59
- message.pageSize = reader.int32();
60
- continue;
61
- }
62
- if ((tag & 7) === 4 || tag === 0) {
63
- break;
64
- }
65
- reader.skipType(tag & 7);
66
- }
67
- return message;
68
- },
69
- };
70
- function createBaseGrpcDtoMessage() {
71
- return { message: "" };
72
- }
73
- export const GrpcDtoMessage = {
74
- encode(message, writer = _m0.Writer.create()) {
75
- if (message.message !== "") {
76
- writer.uint32(10).string(message.message);
77
- }
78
- return writer;
79
- },
80
- decode(input, length) {
81
- const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
82
- let end = length === undefined ? reader.len : reader.pos + length;
83
- const message = createBaseGrpcDtoMessage();
84
- while (reader.pos < end) {
85
- const tag = reader.uint32();
86
- switch (tag >>> 3) {
87
- case 1:
88
- if (tag !== 10) {
89
- break;
90
- }
91
- message.message = reader.string();
92
- continue;
93
- }
94
- if ((tag & 7) === 4 || tag === 0) {
95
- break;
96
- }
97
- reader.skipType(tag & 7);
98
- }
99
- return message;
100
- },
101
- };
102
- function createBaseGrpcDtoService() {
103
- return { publicId: "", namespace: "" };
104
- }
105
- export const GrpcDtoService = {
106
- encode(message, writer = _m0.Writer.create()) {
107
- if (message.publicId !== "") {
108
- writer.uint32(10).string(message.publicId);
109
- }
110
- if (message.namespace !== "") {
111
- writer.uint32(18).string(message.namespace);
112
- }
113
- return writer;
114
- },
115
- decode(input, length) {
116
- const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
117
- let end = length === undefined ? reader.len : reader.pos + length;
118
- const message = createBaseGrpcDtoService();
119
- while (reader.pos < end) {
120
- const tag = reader.uint32();
121
- switch (tag >>> 3) {
122
- case 1:
123
- if (tag !== 10) {
124
- break;
125
- }
126
- message.publicId = reader.string();
127
- continue;
128
- case 2:
129
- if (tag !== 18) {
130
- break;
131
- }
132
- message.namespace = reader.string();
133
- continue;
134
- }
135
- if ((tag & 7) === 4 || tag === 0) {
136
- break;
137
- }
138
- reader.skipType(tag & 7);
139
- }
140
- return message;
141
- },
142
- };
143
- function createBaseGrpcDtoSession() {
144
- return { publicId: "" };
145
- }
146
- export const GrpcDtoSession = {
147
- encode(message, writer = _m0.Writer.create()) {
148
- if (message.publicId !== "") {
149
- writer.uint32(10).string(message.publicId);
150
- }
151
- if (message.service !== undefined) {
152
- GrpcDtoService.encode(message.service, writer.uint32(18).fork()).ldelim();
153
- }
154
- if (message.user !== undefined) {
155
- GrpcDtoUser.encode(message.user, writer.uint32(26).fork()).ldelim();
156
- }
157
- return writer;
158
- },
159
- decode(input, length) {
160
- const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
161
- let end = length === undefined ? reader.len : reader.pos + length;
162
- const message = createBaseGrpcDtoSession();
163
- while (reader.pos < end) {
164
- const tag = reader.uint32();
165
- switch (tag >>> 3) {
166
- case 1:
167
- if (tag !== 10) {
168
- break;
169
- }
170
- message.publicId = reader.string();
171
- continue;
172
- case 2:
173
- if (tag !== 18) {
174
- break;
175
- }
176
- message.service = GrpcDtoService.decode(reader, reader.uint32());
177
- continue;
178
- case 3:
179
- if (tag !== 26) {
180
- break;
181
- }
182
- message.user = GrpcDtoUser.decode(reader, reader.uint32());
183
- continue;
184
- }
185
- if ((tag & 7) === 4 || tag === 0) {
186
- break;
187
- }
188
- reader.skipType(tag & 7);
189
- }
190
- return message;
191
- },
192
- };
193
- function createBaseGrpcDtoAuthenticate() {
194
- return {};
195
- }
196
- export const GrpcDtoAuthenticate = {
197
- encode(message, writer = _m0.Writer.create()) {
198
- if (message.valid !== undefined) {
199
- writer.uint32(8).bool(message.valid);
200
- }
201
- if (message.reason !== undefined) {
202
- writer.uint32(18).string(message.reason);
203
- }
204
- if (message.session !== undefined) {
205
- GrpcDtoSession.encode(message.session, writer.uint32(26).fork()).ldelim();
206
- }
207
- return writer;
208
- },
209
- decode(input, length) {
210
- const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
211
- let end = length === undefined ? reader.len : reader.pos + length;
212
- const message = createBaseGrpcDtoAuthenticate();
213
- while (reader.pos < end) {
214
- const tag = reader.uint32();
215
- switch (tag >>> 3) {
216
- case 1:
217
- if (tag !== 8) {
218
- break;
219
- }
220
- message.valid = reader.bool();
221
- continue;
222
- case 2:
223
- if (tag !== 18) {
224
- break;
225
- }
226
- message.reason = reader.string();
227
- continue;
228
- case 3:
229
- if (tag !== 26) {
230
- break;
231
- }
232
- message.session = GrpcDtoSession.decode(reader, reader.uint32());
233
- continue;
234
- }
235
- if ((tag & 7) === 4 || tag === 0) {
236
- break;
237
- }
238
- reader.skipType(tag & 7);
239
- }
240
- return message;
241
- },
242
- };
243
- function createBaseGrpcDtoAuthorize() {
244
- return { allowed: false, reason: "" };
245
- }
246
- export const GrpcDtoAuthorize = {
247
- encode(message, writer = _m0.Writer.create()) {
248
- if (message.allowed !== false) {
249
- writer.uint32(8).bool(message.allowed);
250
- }
251
- if (message.reason !== "") {
252
- writer.uint32(18).string(message.reason);
253
- }
254
- return writer;
255
- },
256
- decode(input, length) {
257
- const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
258
- let end = length === undefined ? reader.len : reader.pos + length;
259
- const message = createBaseGrpcDtoAuthorize();
260
- while (reader.pos < end) {
261
- const tag = reader.uint32();
262
- switch (tag >>> 3) {
263
- case 1:
264
- if (tag !== 8) {
265
- break;
266
- }
267
- message.allowed = reader.bool();
268
- continue;
269
- case 2:
270
- if (tag !== 18) {
271
- break;
272
- }
273
- message.reason = reader.string();
274
- continue;
275
- }
276
- if ((tag & 7) === 4 || tag === 0) {
277
- break;
278
- }
279
- reader.skipType(tag & 7);
280
- }
281
- return message;
282
- },
283
- };
284
- function createBaseGrpcInputAuthenticate() {
285
- return { accessToken: "", userAgent: "", ip: "" };
286
- }
287
- export const GrpcInputAuthenticate = {
288
- encode(message, writer = _m0.Writer.create()) {
289
- if (message.accessToken !== "") {
290
- writer.uint32(10).string(message.accessToken);
291
- }
292
- if (message.userAgent !== "") {
293
- writer.uint32(18).string(message.userAgent);
294
- }
295
- if (message.ip !== "") {
296
- writer.uint32(26).string(message.ip);
297
- }
298
- return writer;
299
- },
300
- decode(input, length) {
301
- const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
302
- let end = length === undefined ? reader.len : reader.pos + length;
303
- const message = createBaseGrpcInputAuthenticate();
304
- while (reader.pos < end) {
305
- const tag = reader.uint32();
306
- switch (tag >>> 3) {
307
- case 1:
308
- if (tag !== 10) {
309
- break;
310
- }
311
- message.accessToken = reader.string();
312
- continue;
313
- case 2:
314
- if (tag !== 18) {
315
- break;
316
- }
317
- message.userAgent = reader.string();
318
- continue;
319
- case 3:
320
- if (tag !== 26) {
321
- break;
322
- }
323
- message.ip = reader.string();
324
- continue;
325
- }
326
- if ((tag & 7) === 4 || tag === 0) {
327
- break;
328
- }
329
- reader.skipType(tag & 7);
330
- }
331
- return message;
332
- },
333
- };
334
- function createBaseGrpcInputAuthorize() {
335
- return {};
336
- }
337
- export const GrpcInputAuthorize = {
338
- encode(_, writer = _m0.Writer.create()) {
339
- return writer;
340
- },
341
- decode(input, length) {
342
- const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
343
- let end = length === undefined ? reader.len : reader.pos + length;
344
- const message = createBaseGrpcInputAuthorize();
345
- while (reader.pos < end) {
346
- const tag = reader.uint32();
347
- switch (tag >>> 3) {
348
- }
349
- if ((tag & 7) === 4 || tag === 0) {
350
- break;
351
- }
352
- reader.skipType(tag & 7);
353
- }
354
- return message;
355
- },
356
- };
357
- function createBaseGrpcInputPermission() {
358
- return { publicId: "" };
359
- }
360
- export const GrpcInputPermission = {
361
- encode(message, writer = _m0.Writer.create()) {
362
- if (message.publicId !== "") {
363
- writer.uint32(10).string(message.publicId);
364
- }
365
- return writer;
366
- },
367
- decode(input, length) {
368
- const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
369
- let end = length === undefined ? reader.len : reader.pos + length;
370
- const message = createBaseGrpcInputPermission();
371
- while (reader.pos < end) {
372
- const tag = reader.uint32();
373
- switch (tag >>> 3) {
374
- case 1:
375
- if (tag !== 10) {
376
- break;
377
- }
378
- message.publicId = reader.string();
379
- continue;
380
- }
381
- if ((tag & 7) === 4 || tag === 0) {
382
- break;
383
- }
384
- reader.skipType(tag & 7);
385
- }
386
- return message;
387
- },
388
- };
389
- function createBaseGrpcInputPermissions() {
390
- return {};
391
- }
392
- export const GrpcInputPermissions = {
393
- encode(message, writer = _m0.Writer.create()) {
394
- if (message.search !== undefined) {
395
- writer.uint32(10).string(message.search);
396
- }
397
- if (message.page !== undefined) {
398
- writer.uint32(16).int32(message.page);
399
- }
400
- if (message.pageSize !== undefined) {
401
- writer.uint32(24).int32(message.pageSize);
402
- }
403
- if (message.sortBy !== undefined) {
404
- writer.uint32(34).string(message.sortBy);
405
- }
406
- if (message.sortOrder !== undefined) {
407
- writer.uint32(42).string(message.sortOrder);
408
- }
409
- return writer;
410
- },
411
- decode(input, length) {
412
- const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
413
- let end = length === undefined ? reader.len : reader.pos + length;
414
- const message = createBaseGrpcInputPermissions();
415
- while (reader.pos < end) {
416
- const tag = reader.uint32();
417
- switch (tag >>> 3) {
418
- case 1:
419
- if (tag !== 10) {
420
- break;
421
- }
422
- message.search = reader.string();
423
- continue;
424
- case 2:
425
- if (tag !== 16) {
426
- break;
427
- }
428
- message.page = reader.int32();
429
- continue;
430
- case 3:
431
- if (tag !== 24) {
432
- break;
433
- }
434
- message.pageSize = reader.int32();
435
- continue;
436
- case 4:
437
- if (tag !== 34) {
438
- break;
439
- }
440
- message.sortBy = reader.string();
441
- continue;
442
- case 5:
443
- if (tag !== 42) {
444
- break;
445
- }
446
- message.sortOrder = reader.string();
447
- continue;
448
- }
449
- if ((tag & 7) === 4 || tag === 0) {
450
- break;
451
- }
452
- reader.skipType(tag & 7);
453
- }
454
- return message;
455
- },
456
- };
457
- function createBaseGrpcInputRolePermissions() {
458
- return { rolePublicId: "" };
459
- }
460
- export const GrpcInputRolePermissions = {
461
- encode(message, writer = _m0.Writer.create()) {
462
- if (message.rolePublicId !== "") {
463
- writer.uint32(10).string(message.rolePublicId);
464
- }
465
- return writer;
466
- },
467
- decode(input, length) {
468
- const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
469
- let end = length === undefined ? reader.len : reader.pos + length;
470
- const message = createBaseGrpcInputRolePermissions();
471
- while (reader.pos < end) {
472
- const tag = reader.uint32();
473
- switch (tag >>> 3) {
474
- case 1:
475
- if (tag !== 10) {
476
- break;
477
- }
478
- message.rolePublicId = reader.string();
479
- continue;
480
- }
481
- if ((tag & 7) === 4 || tag === 0) {
482
- break;
483
- }
484
- reader.skipType(tag & 7);
485
- }
486
- return message;
487
- },
488
- };
489
- function createBaseGrpcInputSeedPermission() {
490
- return { name: "" };
491
- }
492
- export const GrpcInputSeedPermission = {
493
- encode(message, writer = _m0.Writer.create()) {
494
- if (message.name !== "") {
495
- writer.uint32(10).string(message.name);
496
- }
497
- return writer;
498
- },
499
- decode(input, length) {
500
- const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
501
- let end = length === undefined ? reader.len : reader.pos + length;
502
- const message = createBaseGrpcInputSeedPermission();
503
- while (reader.pos < end) {
504
- const tag = reader.uint32();
505
- switch (tag >>> 3) {
506
- case 1:
507
- if (tag !== 10) {
508
- break;
509
- }
510
- message.name = reader.string();
511
- continue;
512
- }
513
- if ((tag & 7) === 4 || tag === 0) {
514
- break;
515
- }
516
- reader.skipType(tag & 7);
517
- }
518
- return message;
519
- },
520
- };
521
- function createBaseGrpcInputSeedPermissions() {
522
- return { permissions: [] };
523
- }
524
- export const GrpcInputSeedPermissions = {
525
- encode(message, writer = _m0.Writer.create()) {
526
- for (const v of message.permissions) {
527
- GrpcInputSeedPermission.encode(v, writer.uint32(10).fork()).ldelim();
528
- }
529
- return writer;
530
- },
531
- decode(input, length) {
532
- const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
533
- let end = length === undefined ? reader.len : reader.pos + length;
534
- const message = createBaseGrpcInputSeedPermissions();
535
- while (reader.pos < end) {
536
- const tag = reader.uint32();
537
- switch (tag >>> 3) {
538
- case 1:
539
- if (tag !== 10) {
540
- break;
541
- }
542
- message.permissions.push(GrpcInputSeedPermission.decode(reader, reader.uint32()));
543
- continue;
544
- }
545
- if ((tag & 7) === 4 || tag === 0) {
546
- break;
547
- }
548
- reader.skipType(tag & 7);
549
- }
550
- return message;
551
- },
552
- };
553
- function createBaseGrpcDtoPermission() {
554
- return { publicId: "", name: "", description: "" };
555
- }
556
- export const GrpcDtoPermission = {
557
- encode(message, writer = _m0.Writer.create()) {
558
- if (message.publicId !== "") {
559
- writer.uint32(10).string(message.publicId);
560
- }
561
- if (message.name !== "") {
562
- writer.uint32(18).string(message.name);
563
- }
564
- if (message.description !== "") {
565
- writer.uint32(26).string(message.description);
566
- }
567
- if (message.createdAt !== undefined) {
568
- Timestamp.encode(message.createdAt, writer.uint32(34).fork()).ldelim();
569
- }
570
- if (message.updatedAt !== undefined) {
571
- Timestamp.encode(message.updatedAt, writer.uint32(42).fork()).ldelim();
572
- }
573
- if (message.deletedAt !== undefined) {
574
- Timestamp.encode(message.deletedAt, writer.uint32(50).fork()).ldelim();
575
- }
576
- return writer;
577
- },
578
- decode(input, length) {
579
- const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
580
- let end = length === undefined ? reader.len : reader.pos + length;
581
- const message = createBaseGrpcDtoPermission();
582
- while (reader.pos < end) {
583
- const tag = reader.uint32();
584
- switch (tag >>> 3) {
585
- case 1:
586
- if (tag !== 10) {
587
- break;
588
- }
589
- message.publicId = reader.string();
590
- continue;
591
- case 2:
592
- if (tag !== 18) {
593
- break;
594
- }
595
- message.name = reader.string();
596
- continue;
597
- case 3:
598
- if (tag !== 26) {
599
- break;
600
- }
601
- message.description = reader.string();
602
- continue;
603
- case 4:
604
- if (tag !== 34) {
605
- break;
606
- }
607
- message.createdAt = Timestamp.decode(reader, reader.uint32());
608
- continue;
609
- case 5:
610
- if (tag !== 42) {
611
- break;
612
- }
613
- message.updatedAt = Timestamp.decode(reader, reader.uint32());
614
- continue;
615
- case 6:
616
- if (tag !== 50) {
617
- break;
618
- }
619
- message.deletedAt = Timestamp.decode(reader, reader.uint32());
620
- continue;
621
- }
622
- if ((tag & 7) === 4 || tag === 0) {
623
- break;
624
- }
625
- reader.skipType(tag & 7);
626
- }
627
- return message;
628
- },
629
- };
630
- function createBaseGrpcDtoPermissions() {
631
- return { permissions: [] };
632
- }
633
- export const GrpcDtoPermissions = {
634
- encode(message, writer = _m0.Writer.create()) {
635
- for (const v of message.permissions) {
636
- GrpcDtoPermission.encode(v, writer.uint32(10).fork()).ldelim();
637
- }
638
- return writer;
639
- },
640
- decode(input, length) {
641
- const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
642
- let end = length === undefined ? reader.len : reader.pos + length;
643
- const message = createBaseGrpcDtoPermissions();
644
- while (reader.pos < end) {
645
- const tag = reader.uint32();
646
- switch (tag >>> 3) {
647
- case 1:
648
- if (tag !== 10) {
649
- break;
650
- }
651
- message.permissions.push(GrpcDtoPermission.decode(reader, reader.uint32()));
652
- continue;
653
- }
654
- if ((tag & 7) === 4 || tag === 0) {
655
- break;
656
- }
657
- reader.skipType(tag & 7);
658
- }
659
- return message;
660
- },
661
- };
662
- function createBaseGrpcDtoRolePermission() {
663
- return {};
664
- }
665
- export const GrpcDtoRolePermission = {
666
- encode(message, writer = _m0.Writer.create()) {
667
- if (message.permission !== undefined) {
668
- GrpcDtoPermission.encode(message.permission, writer.uint32(10).fork()).ldelim();
669
- }
670
- if (message.role !== undefined) {
671
- GrpcDtoRole.encode(message.role, writer.uint32(18).fork()).ldelim();
672
- }
673
- return writer;
674
- },
675
- decode(input, length) {
676
- const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
677
- let end = length === undefined ? reader.len : reader.pos + length;
678
- const message = createBaseGrpcDtoRolePermission();
679
- while (reader.pos < end) {
680
- const tag = reader.uint32();
681
- switch (tag >>> 3) {
682
- case 1:
683
- if (tag !== 10) {
684
- break;
685
- }
686
- message.permission = GrpcDtoPermission.decode(reader, reader.uint32());
687
- continue;
688
- case 2:
689
- if (tag !== 18) {
690
- break;
691
- }
692
- message.role = GrpcDtoRole.decode(reader, reader.uint32());
693
- continue;
694
- }
695
- if ((tag & 7) === 4 || tag === 0) {
696
- break;
697
- }
698
- reader.skipType(tag & 7);
699
- }
700
- return message;
701
- },
702
- };
703
- function createBaseGrpcDtoRolePermissions() {
704
- return { rolePermissions: [] };
705
- }
706
- export const GrpcDtoRolePermissions = {
707
- encode(message, writer = _m0.Writer.create()) {
708
- for (const v of message.rolePermissions) {
709
- GrpcDtoRolePermission.encode(v, writer.uint32(10).fork()).ldelim();
710
- }
711
- return writer;
712
- },
713
- decode(input, length) {
714
- const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
715
- let end = length === undefined ? reader.len : reader.pos + length;
716
- const message = createBaseGrpcDtoRolePermissions();
717
- while (reader.pos < end) {
718
- const tag = reader.uint32();
719
- switch (tag >>> 3) {
720
- case 1:
721
- if (tag !== 10) {
722
- break;
723
- }
724
- message.rolePermissions.push(GrpcDtoRolePermission.decode(reader, reader.uint32()));
725
- continue;
726
- }
727
- if ((tag & 7) === 4 || tag === 0) {
728
- break;
729
- }
730
- reader.skipType(tag & 7);
731
- }
732
- return message;
733
- },
734
- };
735
- function createBaseGrpcDtoPermissionsPaginated() {
736
- return { items: [] };
737
- }
738
- export const GrpcDtoPermissionsPaginated = {
739
- encode(message, writer = _m0.Writer.create()) {
740
- for (const v of message.items) {
741
- GrpcDtoPermission.encode(v, writer.uint32(10).fork()).ldelim();
742
- }
743
- if (message.meta !== undefined) {
744
- GrpcDtoPagination.encode(message.meta, writer.uint32(18).fork()).ldelim();
745
- }
746
- return writer;
747
- },
748
- decode(input, length) {
749
- const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
750
- let end = length === undefined ? reader.len : reader.pos + length;
751
- const message = createBaseGrpcDtoPermissionsPaginated();
752
- while (reader.pos < end) {
753
- const tag = reader.uint32();
754
- switch (tag >>> 3) {
755
- case 1:
756
- if (tag !== 10) {
757
- break;
758
- }
759
- message.items.push(GrpcDtoPermission.decode(reader, reader.uint32()));
760
- continue;
761
- case 2:
762
- if (tag !== 18) {
763
- break;
764
- }
765
- message.meta = GrpcDtoPagination.decode(reader, reader.uint32());
766
- continue;
767
- }
768
- if ((tag & 7) === 4 || tag === 0) {
769
- break;
770
- }
771
- reader.skipType(tag & 7);
772
- }
773
- return message;
774
- },
775
- };
776
- function createBaseGrpcInputRoles() {
777
- return { page: 0, pageSize: 0 };
778
- }
779
- export const GrpcInputRoles = {
780
- encode(message, writer = _m0.Writer.create()) {
781
- if (message.search !== undefined) {
782
- writer.uint32(10).string(message.search);
783
- }
784
- if (message.page !== 0) {
785
- writer.uint32(16).int32(message.page);
786
- }
787
- if (message.pageSize !== 0) {
788
- writer.uint32(24).int32(message.pageSize);
789
- }
790
- if (message.sortBy !== undefined) {
791
- writer.uint32(34).string(message.sortBy);
792
- }
793
- if (message.sortOrder !== undefined) {
794
- writer.uint32(42).string(message.sortOrder);
795
- }
796
- return writer;
797
- },
798
- decode(input, length) {
799
- const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
800
- let end = length === undefined ? reader.len : reader.pos + length;
801
- const message = createBaseGrpcInputRoles();
802
- while (reader.pos < end) {
803
- const tag = reader.uint32();
804
- switch (tag >>> 3) {
805
- case 1:
806
- if (tag !== 10) {
807
- break;
808
- }
809
- message.search = reader.string();
810
- continue;
811
- case 2:
812
- if (tag !== 16) {
813
- break;
814
- }
815
- message.page = reader.int32();
816
- continue;
817
- case 3:
818
- if (tag !== 24) {
819
- break;
820
- }
821
- message.pageSize = reader.int32();
822
- continue;
823
- case 4:
824
- if (tag !== 34) {
825
- break;
826
- }
827
- message.sortBy = reader.string();
828
- continue;
829
- case 5:
830
- if (tag !== 42) {
831
- break;
832
- }
833
- message.sortOrder = reader.string();
834
- continue;
835
- }
836
- if ((tag & 7) === 4 || tag === 0) {
837
- break;
838
- }
839
- reader.skipType(tag & 7);
840
- }
841
- return message;
842
- },
843
- };
844
- function createBaseGrpcInputRole() {
845
- return { publicId: "" };
846
- }
847
- export const GrpcInputRole = {
848
- encode(message, writer = _m0.Writer.create()) {
849
- if (message.publicId !== "") {
850
- writer.uint32(10).string(message.publicId);
851
- }
852
- return writer;
853
- },
854
- decode(input, length) {
855
- const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
856
- let end = length === undefined ? reader.len : reader.pos + length;
857
- const message = createBaseGrpcInputRole();
858
- while (reader.pos < end) {
859
- const tag = reader.uint32();
860
- switch (tag >>> 3) {
861
- case 1:
862
- if (tag !== 10) {
863
- break;
864
- }
865
- message.publicId = reader.string();
866
- continue;
867
- }
868
- if ((tag & 7) === 4 || tag === 0) {
869
- break;
870
- }
871
- reader.skipType(tag & 7);
872
- }
873
- return message;
874
- },
875
- };
876
- function createBaseGrpcInputRoleCreate() {
877
- return { name: "" };
878
- }
879
- export const GrpcInputRoleCreate = {
880
- encode(message, writer = _m0.Writer.create()) {
881
- if (message.name !== "") {
882
- writer.uint32(10).string(message.name);
883
- }
884
- if (message.description !== undefined) {
885
- writer.uint32(18).string(message.description);
886
- }
887
- return writer;
888
- },
889
- decode(input, length) {
890
- const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
891
- let end = length === undefined ? reader.len : reader.pos + length;
892
- const message = createBaseGrpcInputRoleCreate();
893
- while (reader.pos < end) {
894
- const tag = reader.uint32();
895
- switch (tag >>> 3) {
896
- case 1:
897
- if (tag !== 10) {
898
- break;
899
- }
900
- message.name = reader.string();
901
- continue;
902
- case 2:
903
- if (tag !== 18) {
904
- break;
905
- }
906
- message.description = reader.string();
907
- continue;
908
- }
909
- if ((tag & 7) === 4 || tag === 0) {
910
- break;
911
- }
912
- reader.skipType(tag & 7);
913
- }
914
- return message;
915
- },
916
- };
917
- function createBaseGrpcInputRoleUpdate() {
918
- return { publicId: "" };
919
- }
920
- export const GrpcInputRoleUpdate = {
921
- encode(message, writer = _m0.Writer.create()) {
922
- if (message.publicId !== "") {
923
- writer.uint32(10).string(message.publicId);
924
- }
925
- if (message.name !== undefined) {
926
- writer.uint32(18).string(message.name);
927
- }
928
- if (message.description !== undefined) {
929
- writer.uint32(26).string(message.description);
930
- }
931
- return writer;
932
- },
933
- decode(input, length) {
934
- const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
935
- let end = length === undefined ? reader.len : reader.pos + length;
936
- const message = createBaseGrpcInputRoleUpdate();
937
- while (reader.pos < end) {
938
- const tag = reader.uint32();
939
- switch (tag >>> 3) {
940
- case 1:
941
- if (tag !== 10) {
942
- break;
943
- }
944
- message.publicId = reader.string();
945
- continue;
946
- case 2:
947
- if (tag !== 18) {
948
- break;
949
- }
950
- message.name = reader.string();
951
- continue;
952
- case 3:
953
- if (tag !== 26) {
954
- break;
955
- }
956
- message.description = reader.string();
957
- continue;
958
- }
959
- if ((tag & 7) === 4 || tag === 0) {
960
- break;
961
- }
962
- reader.skipType(tag & 7);
963
- }
964
- return message;
965
- },
966
- };
967
- function createBaseGrpcInputRoleRecycle() {
968
- return { publicIds: [] };
969
- }
970
- export const GrpcInputRoleRecycle = {
971
- encode(message, writer = _m0.Writer.create()) {
972
- for (const v of message.publicIds) {
973
- writer.uint32(10).string(v);
974
- }
975
- return writer;
976
- },
977
- decode(input, length) {
978
- const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
979
- let end = length === undefined ? reader.len : reader.pos + length;
980
- const message = createBaseGrpcInputRoleRecycle();
981
- while (reader.pos < end) {
982
- const tag = reader.uint32();
983
- switch (tag >>> 3) {
984
- case 1:
985
- if (tag !== 10) {
986
- break;
987
- }
988
- message.publicIds.push(reader.string());
989
- continue;
990
- }
991
- if ((tag & 7) === 4 || tag === 0) {
992
- break;
993
- }
994
- reader.skipType(tag & 7);
995
- }
996
- return message;
997
- },
998
- };
999
- function createBaseGrpcInputRoleRestore() {
1000
- return { publicIds: [] };
1001
- }
1002
- export const GrpcInputRoleRestore = {
1003
- encode(message, writer = _m0.Writer.create()) {
1004
- for (const v of message.publicIds) {
1005
- writer.uint32(10).string(v);
1006
- }
1007
- return writer;
1008
- },
1009
- decode(input, length) {
1010
- const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
1011
- let end = length === undefined ? reader.len : reader.pos + length;
1012
- const message = createBaseGrpcInputRoleRestore();
1013
- while (reader.pos < end) {
1014
- const tag = reader.uint32();
1015
- switch (tag >>> 3) {
1016
- case 1:
1017
- if (tag !== 10) {
1018
- break;
1019
- }
1020
- message.publicIds.push(reader.string());
1021
- continue;
1022
- }
1023
- if ((tag & 7) === 4 || tag === 0) {
1024
- break;
1025
- }
1026
- reader.skipType(tag & 7);
1027
- }
1028
- return message;
1029
- },
1030
- };
1031
- function createBaseGrpcInputRolePermissionsAdd() {
1032
- return { publicId: "", permissionIds: [] };
1033
- }
1034
- export const GrpcInputRolePermissionsAdd = {
1035
- encode(message, writer = _m0.Writer.create()) {
1036
- if (message.publicId !== "") {
1037
- writer.uint32(10).string(message.publicId);
1038
- }
1039
- for (const v of message.permissionIds) {
1040
- writer.uint32(18).string(v);
1041
- }
1042
- return writer;
1043
- },
1044
- decode(input, length) {
1045
- const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
1046
- let end = length === undefined ? reader.len : reader.pos + length;
1047
- const message = createBaseGrpcInputRolePermissionsAdd();
1048
- while (reader.pos < end) {
1049
- const tag = reader.uint32();
1050
- switch (tag >>> 3) {
1051
- case 1:
1052
- if (tag !== 10) {
1053
- break;
1054
- }
1055
- message.publicId = reader.string();
1056
- continue;
1057
- case 2:
1058
- if (tag !== 18) {
1059
- break;
1060
- }
1061
- message.permissionIds.push(reader.string());
1062
- 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 createBaseGrpcInputRolePermissionsRemove() {
1073
- return { publicRolePermissionIds: [] };
1074
- }
1075
- export const GrpcInputRolePermissionsRemove = {
1076
- encode(message, writer = _m0.Writer.create()) {
1077
- for (const v of message.publicRolePermissionIds) {
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 = createBaseGrpcInputRolePermissionsRemove();
1086
- while (reader.pos < end) {
1087
- const tag = reader.uint32();
1088
- switch (tag >>> 3) {
1089
- case 1:
1090
- if (tag !== 10) {
1091
- break;
1092
- }
1093
- message.publicRolePermissionIds.push(reader.string());
1094
- continue;
1095
- }
1096
- if ((tag & 7) === 4 || tag === 0) {
1097
- break;
1098
- }
1099
- reader.skipType(tag & 7);
1100
- }
1101
- return message;
1102
- },
1103
- };
1104
- function createBaseGrpcDtoRole() {
1105
- return { publicId: "", name: "", permissions: [], users: [] };
1106
- }
1107
- export const GrpcDtoRole = {
1108
- encode(message, writer = _m0.Writer.create()) {
1109
- if (message.publicId !== "") {
1110
- writer.uint32(10).string(message.publicId);
1111
- }
1112
- if (message.name !== "") {
1113
- writer.uint32(18).string(message.name);
1114
- }
1115
- if (message.description !== undefined) {
1116
- writer.uint32(26).string(message.description);
1117
- }
1118
- if (message.createdAt !== undefined) {
1119
- Timestamp.encode(message.createdAt, writer.uint32(34).fork()).ldelim();
1120
- }
1121
- if (message.updatedAt !== undefined) {
1122
- Timestamp.encode(message.updatedAt, writer.uint32(42).fork()).ldelim();
1123
- }
1124
- if (message.deletedAt !== undefined) {
1125
- Timestamp.encode(message.deletedAt, writer.uint32(50).fork()).ldelim();
1126
- }
1127
- for (const v of message.permissions) {
1128
- GrpcDtoPermission.encode(v, writer.uint32(58).fork()).ldelim();
1129
- }
1130
- for (const v of message.users) {
1131
- GrpcDtoUser.encode(v, writer.uint32(66).fork()).ldelim();
1132
- }
1133
- return writer;
1134
- },
1135
- decode(input, length) {
1136
- const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
1137
- let end = length === undefined ? reader.len : reader.pos + length;
1138
- const message = createBaseGrpcDtoRole();
1139
- while (reader.pos < end) {
1140
- const tag = reader.uint32();
1141
- switch (tag >>> 3) {
1142
- case 1:
1143
- if (tag !== 10) {
1144
- break;
1145
- }
1146
- message.publicId = reader.string();
1147
- continue;
1148
- case 2:
1149
- if (tag !== 18) {
1150
- break;
1151
- }
1152
- message.name = reader.string();
1153
- continue;
1154
- case 3:
1155
- if (tag !== 26) {
1156
- break;
1157
- }
1158
- message.description = reader.string();
1159
- continue;
1160
- case 4:
1161
- if (tag !== 34) {
1162
- break;
1163
- }
1164
- message.createdAt = Timestamp.decode(reader, reader.uint32());
1165
- continue;
1166
- case 5:
1167
- if (tag !== 42) {
1168
- break;
1169
- }
1170
- message.updatedAt = Timestamp.decode(reader, reader.uint32());
1171
- continue;
1172
- case 6:
1173
- if (tag !== 50) {
1174
- break;
1175
- }
1176
- message.deletedAt = Timestamp.decode(reader, reader.uint32());
1177
- continue;
1178
- case 7:
1179
- if (tag !== 58) {
1180
- break;
1181
- }
1182
- message.permissions.push(GrpcDtoPermission.decode(reader, reader.uint32()));
1183
- continue;
1184
- case 8:
1185
- if (tag !== 66) {
1186
- break;
1187
- }
1188
- message.users.push(GrpcDtoUser.decode(reader, reader.uint32()));
1189
- continue;
1190
- }
1191
- if ((tag & 7) === 4 || tag === 0) {
1192
- break;
1193
- }
1194
- reader.skipType(tag & 7);
1195
- }
1196
- return message;
1197
- },
1198
- };
1199
- function createBaseGrpcDtoRoles() {
1200
- return { items: [] };
1201
- }
1202
- export const GrpcDtoRoles = {
1203
- encode(message, writer = _m0.Writer.create()) {
1204
- for (const v of message.items) {
1205
- GrpcDtoRole.encode(v, writer.uint32(10).fork()).ldelim();
1206
- }
1207
- if (message.meta !== undefined) {
1208
- GrpcDtoPagination.encode(message.meta, writer.uint32(18).fork()).ldelim();
1209
- }
1210
- return writer;
1211
- },
1212
- decode(input, length) {
1213
- const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
1214
- let end = length === undefined ? reader.len : reader.pos + length;
1215
- const message = createBaseGrpcDtoRoles();
1216
- while (reader.pos < end) {
1217
- const tag = reader.uint32();
1218
- switch (tag >>> 3) {
1219
- case 1:
1220
- if (tag !== 10) {
1221
- break;
1222
- }
1223
- message.items.push(GrpcDtoRole.decode(reader, reader.uint32()));
1224
- continue;
1225
- case 2:
1226
- if (tag !== 18) {
1227
- break;
1228
- }
1229
- message.meta = GrpcDtoPagination.decode(reader, reader.uint32());
1230
- continue;
1231
- }
1232
- if ((tag & 7) === 4 || tag === 0) {
1233
- break;
1234
- }
1235
- reader.skipType(tag & 7);
1236
- }
1237
- return message;
1238
- },
1239
- };
1240
- function createBaseGrpcDtoPermissionsAdd() {
1241
- return { permissions: [] };
1242
- }
1243
- export const GrpcDtoPermissionsAdd = {
1244
- encode(message, writer = _m0.Writer.create()) {
1245
- for (const v of message.permissions) {
1246
- GrpcDtoPermission.encode(v, writer.uint32(10).fork()).ldelim();
1247
- }
1248
- return writer;
1249
- },
1250
- decode(input, length) {
1251
- const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
1252
- let end = length === undefined ? reader.len : reader.pos + length;
1253
- const message = createBaseGrpcDtoPermissionsAdd();
1254
- while (reader.pos < end) {
1255
- const tag = reader.uint32();
1256
- switch (tag >>> 3) {
1257
- case 1:
1258
- if (tag !== 10) {
1259
- break;
1260
- }
1261
- message.permissions.push(GrpcDtoPermission.decode(reader, reader.uint32()));
1262
- continue;
1263
- }
1264
- if ((tag & 7) === 4 || tag === 0) {
1265
- break;
1266
- }
1267
- reader.skipType(tag & 7);
1268
- }
1269
- return message;
1270
- },
1271
- };
1272
- function createBaseGrpcDtoUserRole() {
1273
- return {};
1274
- }
1275
- export const GrpcDtoUserRole = {
1276
- encode(message, writer = _m0.Writer.create()) {
1277
- if (message.role !== undefined) {
1278
- GrpcDtoRole.encode(message.role, writer.uint32(10).fork()).ldelim();
1279
- }
1280
- return writer;
1281
- },
1282
- decode(input, length) {
1283
- const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
1284
- let end = length === undefined ? reader.len : reader.pos + length;
1285
- const message = createBaseGrpcDtoUserRole();
1286
- while (reader.pos < end) {
1287
- const tag = reader.uint32();
1288
- switch (tag >>> 3) {
1289
- case 1:
1290
- if (tag !== 10) {
1291
- break;
1292
- }
1293
- message.role = GrpcDtoRole.decode(reader, reader.uint32());
1294
- continue;
1295
- }
1296
- if ((tag & 7) === 4 || tag === 0) {
1297
- break;
1298
- }
1299
- reader.skipType(tag & 7);
1300
- }
1301
- return message;
1302
- },
1303
- };
1304
- function createBaseGrpcDtoUser() {
1305
- return { publicId: "", email: "", phone: "", isEmailVerified: false, roles: [] };
1306
- }
1307
- export const GrpcDtoUser = {
1308
- encode(message, writer = _m0.Writer.create()) {
1309
- if (message.publicId !== "") {
1310
- writer.uint32(10).string(message.publicId);
1311
- }
1312
- if (message.email !== "") {
1313
- writer.uint32(18).string(message.email);
1314
- }
1315
- if (message.phone !== "") {
1316
- writer.uint32(26).string(message.phone);
1317
- }
1318
- if (message.isEmailVerified !== false) {
1319
- writer.uint32(32).bool(message.isEmailVerified);
1320
- }
1321
- if (message.displayName !== undefined) {
1322
- writer.uint32(42).string(message.displayName);
1323
- }
1324
- if (message.createdAt !== undefined) {
1325
- Timestamp.encode(message.createdAt, writer.uint32(50).fork()).ldelim();
1326
- }
1327
- if (message.updatedAt !== undefined) {
1328
- Timestamp.encode(message.updatedAt, writer.uint32(58).fork()).ldelim();
1329
- }
1330
- if (message.deletedAt !== undefined) {
1331
- Timestamp.encode(message.deletedAt, writer.uint32(66).fork()).ldelim();
1332
- }
1333
- for (const v of message.roles) {
1334
- GrpcDtoUserRole.encode(v, writer.uint32(74).fork()).ldelim();
1335
- }
1336
- return writer;
1337
- },
1338
- decode(input, length) {
1339
- const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
1340
- let end = length === undefined ? reader.len : reader.pos + length;
1341
- const message = createBaseGrpcDtoUser();
1342
- while (reader.pos < end) {
1343
- const tag = reader.uint32();
1344
- switch (tag >>> 3) {
1345
- case 1:
1346
- if (tag !== 10) {
1347
- break;
1348
- }
1349
- message.publicId = reader.string();
1350
- continue;
1351
- case 2:
1352
- if (tag !== 18) {
1353
- break;
1354
- }
1355
- message.email = reader.string();
1356
- continue;
1357
- case 3:
1358
- if (tag !== 26) {
1359
- break;
1360
- }
1361
- message.phone = reader.string();
1362
- continue;
1363
- case 4:
1364
- if (tag !== 32) {
1365
- break;
1366
- }
1367
- message.isEmailVerified = reader.bool();
1368
- continue;
1369
- case 5:
1370
- if (tag !== 42) {
1371
- break;
1372
- }
1373
- message.displayName = reader.string();
1374
- continue;
1375
- case 6:
1376
- if (tag !== 50) {
1377
- break;
1378
- }
1379
- message.createdAt = Timestamp.decode(reader, reader.uint32());
1380
- continue;
1381
- case 7:
1382
- if (tag !== 58) {
1383
- break;
1384
- }
1385
- message.updatedAt = Timestamp.decode(reader, reader.uint32());
1386
- continue;
1387
- case 8:
1388
- if (tag !== 66) {
1389
- break;
1390
- }
1391
- message.deletedAt = Timestamp.decode(reader, reader.uint32());
1392
- continue;
1393
- case 9:
1394
- if (tag !== 74) {
1395
- break;
1396
- }
1397
- message.roles.push(GrpcDtoUserRole.decode(reader, reader.uint32()));
1398
- continue;
1399
- }
1400
- if ((tag & 7) === 4 || tag === 0) {
1401
- break;
1402
- }
1403
- reader.skipType(tag & 7);
1404
- }
1405
- return message;
1406
- },
1407
- };
1408
- export function AuthServiceControllerMethods() {
1409
- return function (constructor) {
1410
- const grpcMethods = [
1411
- "authenticate",
1412
- "authorize",
1413
- "permissionsSeed",
1414
- "permissions",
1415
- "permission",
1416
- "rolePermissions",
1417
- "roles",
1418
- "role",
1419
- "roleCreate",
1420
- "roleUpdate",
1421
- "rolesRecycle",
1422
- "rolesRestore",
1423
- "rolePermissionsAdd",
1424
- "rolePermissionsRemove",
1425
- ];
1426
- for (const method of grpcMethods) {
1427
- const descriptor = Reflect.getOwnPropertyDescriptor(constructor.prototype, method);
1428
- GrpcMethod("AuthService", method)(constructor.prototype[method], method, descriptor);
1429
- }
1430
- const grpcStreamMethods = [];
1431
- for (const method of grpcStreamMethods) {
1432
- const descriptor = Reflect.getOwnPropertyDescriptor(constructor.prototype, method);
1433
- GrpcStreamMethod("AuthService", method)(constructor.prototype[method], method, descriptor);
1434
- }
1435
- };
1436
- }
1437
- export const AUTH_SERVICE_NAME = "AuthService";
1438
- export const AuthServiceService = {
1439
- /** --- authz --- */
1440
- authenticate: {
1441
- path: "/aegis.auth.v1.AuthService/Authenticate",
1442
- requestStream: false,
1443
- responseStream: false,
1444
- requestSerialize: (value) => Buffer.from(GrpcInputAuthenticate.encode(value).finish()),
1445
- requestDeserialize: (value) => GrpcInputAuthenticate.decode(value),
1446
- responseSerialize: (value) => Buffer.from(GrpcDtoAuthenticate.encode(value).finish()),
1447
- responseDeserialize: (value) => GrpcDtoAuthenticate.decode(value),
1448
- },
1449
- authorize: {
1450
- path: "/aegis.auth.v1.AuthService/Authorize",
1451
- requestStream: false,
1452
- responseStream: false,
1453
- requestSerialize: (value) => Buffer.from(GrpcInputAuthorize.encode(value).finish()),
1454
- requestDeserialize: (value) => GrpcInputAuthorize.decode(value),
1455
- responseSerialize: (value) => Buffer.from(GrpcDtoAuthorize.encode(value).finish()),
1456
- responseDeserialize: (value) => GrpcDtoAuthorize.decode(value),
1457
- },
1458
- /** --- permission --- */
1459
- permissionsSeed: {
1460
- path: "/aegis.auth.v1.AuthService/PermissionsSeed",
1461
- requestStream: false,
1462
- responseStream: false,
1463
- requestSerialize: (value) => Buffer.from(GrpcInputSeedPermissions.encode(value).finish()),
1464
- requestDeserialize: (value) => GrpcInputSeedPermissions.decode(value),
1465
- responseSerialize: (value) => Buffer.from(GrpcDtoPermissions.encode(value).finish()),
1466
- responseDeserialize: (value) => GrpcDtoPermissions.decode(value),
1467
- },
1468
- permissions: {
1469
- path: "/aegis.auth.v1.AuthService/Permissions",
1470
- requestStream: false,
1471
- responseStream: false,
1472
- requestSerialize: (value) => Buffer.from(GrpcInputPermissions.encode(value).finish()),
1473
- requestDeserialize: (value) => GrpcInputPermissions.decode(value),
1474
- responseSerialize: (value) => Buffer.from(GrpcDtoPermissionsPaginated.encode(value).finish()),
1475
- responseDeserialize: (value) => GrpcDtoPermissionsPaginated.decode(value),
1476
- },
1477
- permission: {
1478
- path: "/aegis.auth.v1.AuthService/Permission",
1479
- requestStream: false,
1480
- responseStream: false,
1481
- requestSerialize: (value) => Buffer.from(GrpcInputPermission.encode(value).finish()),
1482
- requestDeserialize: (value) => GrpcInputPermission.decode(value),
1483
- responseSerialize: (value) => Buffer.from(GrpcDtoPermission.encode(value).finish()),
1484
- responseDeserialize: (value) => GrpcDtoPermission.decode(value),
1485
- },
1486
- rolePermissions: {
1487
- path: "/aegis.auth.v1.AuthService/RolePermissions",
1488
- requestStream: false,
1489
- responseStream: false,
1490
- requestSerialize: (value) => Buffer.from(GrpcInputRolePermissions.encode(value).finish()),
1491
- requestDeserialize: (value) => GrpcInputRolePermissions.decode(value),
1492
- responseSerialize: (value) => Buffer.from(GrpcDtoRolePermissions.encode(value).finish()),
1493
- responseDeserialize: (value) => GrpcDtoRolePermissions.decode(value),
1494
- },
1495
- /** --- role --- */
1496
- roles: {
1497
- path: "/aegis.auth.v1.AuthService/Roles",
1498
- requestStream: false,
1499
- responseStream: false,
1500
- requestSerialize: (value) => Buffer.from(GrpcInputRoles.encode(value).finish()),
1501
- requestDeserialize: (value) => GrpcInputRoles.decode(value),
1502
- responseSerialize: (value) => Buffer.from(GrpcDtoRoles.encode(value).finish()),
1503
- responseDeserialize: (value) => GrpcDtoRoles.decode(value),
1504
- },
1505
- role: {
1506
- path: "/aegis.auth.v1.AuthService/Role",
1507
- requestStream: false,
1508
- responseStream: false,
1509
- requestSerialize: (value) => Buffer.from(GrpcInputRole.encode(value).finish()),
1510
- requestDeserialize: (value) => GrpcInputRole.decode(value),
1511
- responseSerialize: (value) => Buffer.from(GrpcDtoRole.encode(value).finish()),
1512
- responseDeserialize: (value) => GrpcDtoRole.decode(value),
1513
- },
1514
- roleCreate: {
1515
- path: "/aegis.auth.v1.AuthService/RoleCreate",
1516
- requestStream: false,
1517
- responseStream: false,
1518
- requestSerialize: (value) => Buffer.from(GrpcInputRoleCreate.encode(value).finish()),
1519
- requestDeserialize: (value) => GrpcInputRoleCreate.decode(value),
1520
- responseSerialize: (value) => Buffer.from(GrpcDtoRole.encode(value).finish()),
1521
- responseDeserialize: (value) => GrpcDtoRole.decode(value),
1522
- },
1523
- roleUpdate: {
1524
- path: "/aegis.auth.v1.AuthService/RoleUpdate",
1525
- requestStream: false,
1526
- responseStream: false,
1527
- requestSerialize: (value) => Buffer.from(GrpcInputRoleUpdate.encode(value).finish()),
1528
- requestDeserialize: (value) => GrpcInputRoleUpdate.decode(value),
1529
- responseSerialize: (value) => Buffer.from(GrpcDtoRole.encode(value).finish()),
1530
- responseDeserialize: (value) => GrpcDtoRole.decode(value),
1531
- },
1532
- rolesRecycle: {
1533
- path: "/aegis.auth.v1.AuthService/RolesRecycle",
1534
- requestStream: false,
1535
- responseStream: false,
1536
- requestSerialize: (value) => Buffer.from(GrpcInputRoleRecycle.encode(value).finish()),
1537
- requestDeserialize: (value) => GrpcInputRoleRecycle.decode(value),
1538
- responseSerialize: (value) => Buffer.from(GrpcDtoMessage.encode(value).finish()),
1539
- responseDeserialize: (value) => GrpcDtoMessage.decode(value),
1540
- },
1541
- rolesRestore: {
1542
- path: "/aegis.auth.v1.AuthService/RolesRestore",
1543
- requestStream: false,
1544
- responseStream: false,
1545
- requestSerialize: (value) => Buffer.from(GrpcInputRoleRestore.encode(value).finish()),
1546
- requestDeserialize: (value) => GrpcInputRoleRestore.decode(value),
1547
- responseSerialize: (value) => Buffer.from(GrpcDtoMessage.encode(value).finish()),
1548
- responseDeserialize: (value) => GrpcDtoMessage.decode(value),
1549
- },
1550
- rolePermissionsAdd: {
1551
- path: "/aegis.auth.v1.AuthService/RolePermissionsAdd",
1552
- requestStream: false,
1553
- responseStream: false,
1554
- requestSerialize: (value) => Buffer.from(GrpcInputRolePermissionsAdd.encode(value).finish()),
1555
- requestDeserialize: (value) => GrpcInputRolePermissionsAdd.decode(value),
1556
- responseSerialize: (value) => Buffer.from(GrpcDtoPermissionsAdd.encode(value).finish()),
1557
- responseDeserialize: (value) => GrpcDtoPermissionsAdd.decode(value),
1558
- },
1559
- rolePermissionsRemove: {
1560
- path: "/aegis.auth.v1.AuthService/RolePermissionsRemove",
1561
- requestStream: false,
1562
- responseStream: false,
1563
- requestSerialize: (value) => Buffer.from(GrpcInputRolePermissionsRemove.encode(value).finish()),
1564
- requestDeserialize: (value) => GrpcInputRolePermissionsRemove.decode(value),
1565
- responseSerialize: (value) => Buffer.from(GrpcDtoMessage.encode(value).finish()),
1566
- responseDeserialize: (value) => GrpcDtoMessage.decode(value),
1567
- },
1568
- };