@acequants/aegis-contracts 0.1.45 → 0.1.47

package/dist/src/gen/auth/v1/auth.js

@@ -8,6 +8,38 @@ import _m0 from "protobufjs/minimal";
 import { Timestamp } from "../../google/protobuf/timestamp";
 export const protobufPackage = "aegis.auth.v1";
 export const AEGIS_AUTH_V1_PACKAGE_NAME = "aegis.auth.v1";
+function createBaseGrpcDtoMessage() {
+    return { message: "" };
+}
+export const GrpcDtoMessage = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.message !== "") {
+            writer.uint32(10).string(message.message);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseGrpcDtoMessage();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.message = reader.string();
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    },
+};
 function createBaseGrpcDtoPagination() {
     return { totalItems: 0, totalPages: 0, currentPage: 0, pageSize: 0 };
 }
@@ -67,38 +99,6 @@ export const GrpcDtoPagination = {
         return message;
     },
 };
-function createBaseGrpcDtoMessage() {
-    return { message: "" };
-}
-export const GrpcDtoMessage = {
-    encode(message, writer = _m0.Writer.create()) {
-        if (message.message !== "") {
-            writer.uint32(10).string(message.message);
-        }
-        return writer;
-    },
-    decode(input, length) {
-        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
-        let end = length === undefined ? reader.len : reader.pos + length;
-        const message = createBaseGrpcDtoMessage();
-        while (reader.pos < end) {
-            const tag = reader.uint32();
-            switch (tag >>> 3) {
-                case 1:
-                    if (tag !== 10) {
-                        break;
-                    }
-                    message.message = reader.string();
-                    continue;
-            }
-            if ((tag & 7) === 4 || tag === 0) {
-                break;
-            }
-            reader.skipType(tag & 7);
-        }
-        return message;
-    },
-};
 function createBaseGrpcDtoPermission() {
     return { publicId: "", name: "", description: "" };
 }
@@ -119,9 +119,6 @@ export const GrpcDtoPermission = {
         if (message.updatedAt !== undefined) {
             Timestamp.encode(message.updatedAt, writer.uint32(42).fork()).ldelim();
         }
-        if (message.deletedAt !== undefined) {
-            Timestamp.encode(message.deletedAt, writer.uint32(50).fork()).ldelim();
-        }
         return writer;
     },
     decode(input, length) {
@@ -161,12 +158,6 @@ export const GrpcDtoPermission = {
                     }
                     message.updatedAt = Timestamp.decode(reader, reader.uint32());
                     continue;
-                case 6:
-                    if (tag !== 50) {
-                        break;
-                    }
-                    message.deletedAt = Timestamp.decode(reader, reader.uint32());
-                    continue;
             }
             if ((tag & 7) === 4 || tag === 0) {
                 break;
@@ -176,20 +167,26 @@ export const GrpcDtoPermission = {
         return message;
     },
 };
-function createBaseGrpcDtoPermissionsAdd() {
-    return { permissions: [] };
+function createBaseGrpcInputSeedPermission() {
+    return { name: "", description: "", scopes: [] };
 }
-export const GrpcDtoPermissionsAdd = {
+export const GrpcInputSeedPermission = {
     encode(message, writer = _m0.Writer.create()) {
-        for (const v of message.permissions) {
-            GrpcDtoPermission.encode(v, writer.uint32(10).fork()).ldelim();
+        if (message.name !== "") {
+            writer.uint32(10).string(message.name);
+        }
+        if (message.description !== "") {
+            writer.uint32(18).string(message.description);
+        }
+        for (const v of message.scopes) {
+            writer.uint32(26).string(v);
         }
         return writer;
     },
     decode(input, length) {
         const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
         let end = length === undefined ? reader.len : reader.pos + length;
-        const message = createBaseGrpcDtoPermissionsAdd();
+        const message = createBaseGrpcInputSeedPermission();
         while (reader.pos < end) {
             const tag = reader.uint32();
             switch (tag >>> 3) {
@@ -197,7 +194,19 @@ export const GrpcDtoPermissionsAdd = {
                     if (tag !== 10) {
                         break;
                     }
-                    message.permissions.push(GrpcDtoPermission.decode(reader, reader.uint32()));
+                    message.name = reader.string();
+                    continue;
+                case 2:
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.description = reader.string();
+                    continue;
+                case 3:
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.scopes.push(reader.string());
                     continue;
             }
             if ((tag & 7) === 4 || tag === 0) {
@@ -208,32 +217,20 @@ export const GrpcDtoPermissionsAdd = {
         return message;
     },
 };
-function createBaseGrpcDtoClientType() {
-    return { publicId: "", name: "" };
+function createBaseGrpcInputSeedPermissions() {
+    return { permissions: [] };
 }
-export const GrpcDtoClientType = {
+export const GrpcInputSeedPermissions = {
     encode(message, writer = _m0.Writer.create()) {
-        if (message.publicId !== "") {
-            writer.uint32(10).string(message.publicId);
-        }
-        if (message.name !== "") {
-            writer.uint32(18).string(message.name);
-        }
-        if (message.createdAt !== undefined) {
-            Timestamp.encode(message.createdAt, writer.uint32(26).fork()).ldelim();
-        }
-        if (message.updatedAt !== undefined) {
-            Timestamp.encode(message.updatedAt, writer.uint32(34).fork()).ldelim();
-        }
-        if (message.deletedAt !== undefined) {
-            Timestamp.encode(message.deletedAt, writer.uint32(42).fork()).ldelim();
+        for (const v of message.permissions) {
+            GrpcInputSeedPermission.encode(v, writer.uint32(10).fork()).ldelim();
         }
         return writer;
     },
     decode(input, length) {
         const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
         let end = length === undefined ? reader.len : reader.pos + length;
-        const message = createBaseGrpcDtoClientType();
+        const message = createBaseGrpcInputSeedPermissions();
         while (reader.pos < end) {
             const tag = reader.uint32();
             switch (tag >>> 3) {
@@ -241,31 +238,7 @@ export const GrpcDtoClientType = {
                     if (tag !== 10) {
                         break;
                     }
-                    message.publicId = reader.string();
-                    continue;
-                case 2:
-                    if (tag !== 18) {
-                        break;
-                    }
-                    message.name = reader.string();
-                    continue;
-                case 3:
-                    if (tag !== 26) {
-                        break;
-                    }
-                    message.createdAt = Timestamp.decode(reader, reader.uint32());
-                    continue;
-                case 4:
-                    if (tag !== 34) {
-                        break;
-                    }
-                    message.updatedAt = Timestamp.decode(reader, reader.uint32());
-                    continue;
-                case 5:
-                    if (tag !== 42) {
-                        break;
-                    }
-                    message.deletedAt = Timestamp.decode(reader, reader.uint32());
+                    message.permissions.push(GrpcInputSeedPermission.decode(reader, reader.uint32()));
                     continue;
             }
             if ((tag & 7) === 4 || tag === 0) {
@@ -276,38 +249,32 @@ export const GrpcDtoClientType = {
         return message;
     },
 };
-function createBaseGrpcDtoClient() {
-    return { publicId: "", name: "" };
+function createBaseGrpcInputPermissions() {
+    return {};
 }
-export const GrpcDtoClient = {
+export const GrpcInputPermissions = {
     encode(message, writer = _m0.Writer.create()) {
-        if (message.publicId !== "") {
-            writer.uint32(10).string(message.publicId);
-        }
-        if (message.name !== "") {
-            writer.uint32(18).string(message.name);
-        }
-        if (message.description !== undefined) {
-            writer.uint32(26).string(message.description);
+        if (message.search !== undefined) {
+            writer.uint32(10).string(message.search);
         }
-        if (message.clientType !== undefined) {
-            GrpcDtoClientType.encode(message.clientType, writer.uint32(34).fork()).ldelim();
+        if (message.page !== undefined) {
+            writer.uint32(16).int32(message.page);
         }
-        if (message.createdAt !== undefined) {
-            Timestamp.encode(message.createdAt, writer.uint32(42).fork()).ldelim();
+        if (message.pageSize !== undefined) {
+            writer.uint32(24).int32(message.pageSize);
         }
-        if (message.updatedAt !== undefined) {
-            Timestamp.encode(message.updatedAt, writer.uint32(50).fork()).ldelim();
+        if (message.sortBy !== undefined) {
+            writer.uint32(34).string(message.sortBy);
         }
-        if (message.deletedAt !== undefined) {
-            Timestamp.encode(message.deletedAt, writer.uint32(58).fork()).ldelim();
+        if (message.sortOrder !== undefined) {
+            writer.uint32(42).string(message.sortOrder);
         }
         return writer;
     },
     decode(input, length) {
         const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
         let end = length === undefined ? reader.len : reader.pos + length;
-        const message = createBaseGrpcDtoClient();
+        const message = createBaseGrpcInputPermissions();
         while (reader.pos < end) {
             const tag = reader.uint32();
             switch (tag >>> 3) {
@@ -315,43 +282,31 @@ export const GrpcDtoClient = {
                     if (tag !== 10) {
                         break;
                     }
-                    message.publicId = reader.string();
+                    message.search = reader.string();
                     continue;
                 case 2:
-                    if (tag !== 18) {
+                    if (tag !== 16) {
                         break;
                     }
-                    message.name = reader.string();
+                    message.page = reader.int32();
                     continue;
                 case 3:
-                    if (tag !== 26) {
+                    if (tag !== 24) {
                         break;
                     }
-                    message.description = reader.string();
+                    message.pageSize = reader.int32();
                     continue;
                 case 4:
                     if (tag !== 34) {
                         break;
                     }
-                    message.clientType = GrpcDtoClientType.decode(reader, reader.uint32());
+                    message.sortBy = reader.string();
                     continue;
                 case 5:
                     if (tag !== 42) {
                         break;
                     }
-                    message.createdAt = Timestamp.decode(reader, reader.uint32());
-                    continue;
-                case 6:
-                    if (tag !== 50) {
-                        break;
-                    }
-                    message.updatedAt = Timestamp.decode(reader, reader.uint32());
-                    continue;
-                case 7:
-                    if (tag !== 58) {
-                        break;
-                    }
-                    message.deletedAt = Timestamp.decode(reader, reader.uint32());
+                    message.sortOrder = reader.string();
                     continue;
             }
             if ((tag & 7) === 4 || tag === 0) {
@@ -362,23 +317,20 @@ export const GrpcDtoClient = {
         return message;
     },
 };
-function createBaseGrpcDtoService() {
-    return { publicId: "", namespace: "" };
+function createBaseGrpcDtoPermissions() {
+    return { permissions: [] };
 }
-export const GrpcDtoService = {
+export const GrpcDtoPermissions = {
     encode(message, writer = _m0.Writer.create()) {
-        if (message.publicId !== "") {
-            writer.uint32(10).string(message.publicId);
-        }
-        if (message.namespace !== "") {
-            writer.uint32(18).string(message.namespace);
+        for (const v of message.permissions) {
+            GrpcDtoPermission.encode(v, writer.uint32(10).fork()).ldelim();
         }
         return writer;
     },
     decode(input, length) {
         const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
         let end = length === undefined ? reader.len : reader.pos + length;
-        const message = createBaseGrpcDtoService();
+        const message = createBaseGrpcDtoPermissions();
         while (reader.pos < end) {
             const tag = reader.uint32();
             switch (tag >>> 3) {
@@ -386,13 +338,7 @@ export const GrpcDtoService = {
                     if (tag !== 10) {
                         break;
                     }
-                    message.publicId = reader.string();
-                    continue;
-                case 2:
-                    if (tag !== 18) {
-                        break;
-                    }
-                    message.namespace = reader.string();
+                    message.permissions.push(GrpcDtoPermission.decode(reader, reader.uint32()));
                     continue;
             }
             if ((tag & 7) === 4 || tag === 0) {
@@ -403,26 +349,23 @@ export const GrpcDtoService = {
         return message;
     },
 };
-function createBaseGrpcDtoSession() {
-    return { publicId: "" };
+function createBaseGrpcDtoPermissionsPaginated() {
+    return { items: [] };
 }
-export const GrpcDtoSession = {
+export const GrpcDtoPermissionsPaginated = {
     encode(message, writer = _m0.Writer.create()) {
-        if (message.publicId !== "") {
-            writer.uint32(10).string(message.publicId);
-        }
-        if (message.service !== undefined) {
-            GrpcDtoService.encode(message.service, writer.uint32(18).fork()).ldelim();
+        if (message.meta !== undefined) {
+            GrpcDtoPagination.encode(message.meta, writer.uint32(10).fork()).ldelim();
         }
-        if (message.user !== undefined) {
-            GrpcDtoUser.encode(message.user, writer.uint32(26).fork()).ldelim();
+        for (const v of message.items) {
+            GrpcDtoPermission.encode(v, writer.uint32(18).fork()).ldelim();
         }
         return writer;
     },
     decode(input, length) {
         const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
         let end = length === undefined ? reader.len : reader.pos + length;
-        const message = createBaseGrpcDtoSession();
+        const message = createBaseGrpcDtoPermissionsPaginated();
         while (reader.pos < end) {
             const tag = reader.uint32();
             switch (tag >>> 3) {
@@ -430,19 +373,13 @@ export const GrpcDtoSession = {
                     if (tag !== 10) {
                         break;
                     }
-                    message.publicId = reader.string();
+                    message.meta = GrpcDtoPagination.decode(reader, reader.uint32());
                     continue;
                 case 2:
                     if (tag !== 18) {
                         break;
                     }
-                    message.service = GrpcDtoService.decode(reader, reader.uint32());
-                    continue;
-                case 3:
-                    if (tag !== 26) {
-                        break;
-                    }
-                    message.user = GrpcDtoUser.decode(reader, reader.uint32());
+                    message.items.push(GrpcDtoPermission.decode(reader, reader.uint32()));
                     continue;
             }
             if ((tag & 7) === 4 || tag === 0) {
@@ -453,46 +390,109 @@ export const GrpcDtoSession = {
         return message;
     },
 };
-function createBaseGrpcDtoAuthenticate() {
-    return {};
+function createBaseGrpcDtoGeoCurrency() {
+    return { publicId: "", code: "", name: "", symbol: "", isBase: "", isActive: "", exchangeRate: "" };
 }
-export const GrpcDtoAuthenticate = {
+export const GrpcDtoGeoCurrency = {
     encode(message, writer = _m0.Writer.create()) {
-        if (message.valid !== undefined) {
-            writer.uint32(8).bool(message.valid);
+        if (message.publicId !== "") {
+            writer.uint32(10).string(message.publicId);
         }
-        if (message.reason !== undefined) {
-            writer.uint32(18).string(message.reason);
+        if (message.code !== "") {
+            writer.uint32(18).string(message.code);
         }
-        if (message.session !== undefined) {
-            GrpcDtoSession.encode(message.session, writer.uint32(26).fork()).ldelim();
+        if (message.name !== "") {
+            writer.uint32(26).string(message.name);
+        }
+        if (message.symbol !== "") {
+            writer.uint32(34).string(message.symbol);
+        }
+        if (message.isBase !== "") {
+            writer.uint32(42).string(message.isBase);
+        }
+        if (message.isActive !== "") {
+            writer.uint32(50).string(message.isActive);
+        }
+        if (message.exchangeRate !== "") {
+            writer.uint32(58).string(message.exchangeRate);
+        }
+        if (message.createdAt !== undefined) {
+            Timestamp.encode(message.createdAt, writer.uint32(66).fork()).ldelim();
+        }
+        if (message.updatedAt !== undefined) {
+            Timestamp.encode(message.updatedAt, writer.uint32(74).fork()).ldelim();
+        }
+        if (message.deletedAt !== undefined) {
+            Timestamp.encode(message.deletedAt, writer.uint32(82).fork()).ldelim();
         }
         return writer;
     },
     decode(input, length) {
         const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
         let end = length === undefined ? reader.len : reader.pos + length;
-        const message = createBaseGrpcDtoAuthenticate();
+        const message = createBaseGrpcDtoGeoCurrency();
         while (reader.pos < end) {
             const tag = reader.uint32();
             switch (tag >>> 3) {
                 case 1:
-                    if (tag !== 8) {
+                    if (tag !== 10) {
                         break;
                     }
-                    message.valid = reader.bool();
+                    message.publicId = reader.string();
                     continue;
                 case 2:
                     if (tag !== 18) {
                         break;
                     }
-                    message.reason = reader.string();
+                    message.code = reader.string();
                     continue;
                 case 3:
                     if (tag !== 26) {
                         break;
                     }
-                    message.session = GrpcDtoSession.decode(reader, reader.uint32());
+                    message.name = reader.string();
+                    continue;
+                case 4:
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.symbol = reader.string();
+                    continue;
+                case 5:
+                    if (tag !== 42) {
+                        break;
+                    }
+                    message.isBase = reader.string();
+                    continue;
+                case 6:
+                    if (tag !== 50) {
+                        break;
+                    }
+                    message.isActive = reader.string();
+                    continue;
+                case 7:
+                    if (tag !== 58) {
+                        break;
+                    }
+                    message.exchangeRate = reader.string();
+                    continue;
+                case 8:
+                    if (tag !== 66) {
+                        break;
+                    }
+                    message.createdAt = Timestamp.decode(reader, reader.uint32());
+                    continue;
+                case 9:
+                    if (tag !== 74) {
+                        break;
+                    }
+                    message.updatedAt = Timestamp.decode(reader, reader.uint32());
+                    continue;
+                case 10:
+                    if (tag !== 82) {
+                        break;
+                    }
+                    message.deletedAt = Timestamp.decode(reader, reader.uint32());
                     continue;
             }
             if ((tag & 7) === 4 || tag === 0) {
@@ -503,37 +503,91 @@ export const GrpcDtoAuthenticate = {
         return message;
     },
 };
-function createBaseGrpcDtoAuthorize() {
-    return { allowed: false, reason: "" };
+function createBaseGrpcDtoGeoLanguage() {
+    return { publicId: "", iso6391: "", iso6392: "", name: "", isActive: "" };
 }
-export const GrpcDtoAuthorize = {
+export const GrpcDtoGeoLanguage = {
     encode(message, writer = _m0.Writer.create()) {
-        if (message.allowed !== false) {
-            writer.uint32(8).bool(message.allowed);
+        if (message.publicId !== "") {
+            writer.uint32(10).string(message.publicId);
         }
-        if (message.reason !== "") {
-            writer.uint32(18).string(message.reason);
+        if (message.iso6391 !== "") {
+            writer.uint32(18).string(message.iso6391);
+        }
+        if (message.iso6392 !== "") {
+            writer.uint32(26).string(message.iso6392);
+        }
+        if (message.name !== "") {
+            writer.uint32(34).string(message.name);
+        }
+        if (message.isActive !== "") {
+            writer.uint32(42).string(message.isActive);
+        }
+        if (message.createdAt !== undefined) {
+            Timestamp.encode(message.createdAt, writer.uint32(50).fork()).ldelim();
+        }
+        if (message.updatedAt !== undefined) {
+            Timestamp.encode(message.updatedAt, writer.uint32(58).fork()).ldelim();
+        }
+        if (message.deletedAt !== undefined) {
+            Timestamp.encode(message.deletedAt, writer.uint32(66).fork()).ldelim();
         }
         return writer;
     },
     decode(input, length) {
         const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
         let end = length === undefined ? reader.len : reader.pos + length;
-        const message = createBaseGrpcDtoAuthorize();
+        const message = createBaseGrpcDtoGeoLanguage();
         while (reader.pos < end) {
             const tag = reader.uint32();
             switch (tag >>> 3) {
                 case 1:
-                    if (tag !== 8) {
+                    if (tag !== 10) {
                         break;
                     }
-                    message.allowed = reader.bool();
+                    message.publicId = reader.string();
                     continue;
                 case 2:
                     if (tag !== 18) {
                         break;
                     }
-                    message.reason = reader.string();
+                    message.iso6391 = reader.string();
+                    continue;
+                case 3:
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.iso6392 = reader.string();
+                    continue;
+                case 4:
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.name = reader.string();
+                    continue;
+                case 5:
+                    if (tag !== 42) {
+                        break;
+                    }
+                    message.isActive = reader.string();
+                    continue;
+                case 6:
+                    if (tag !== 50) {
+                        break;
+                    }
+                    message.createdAt = Timestamp.decode(reader, reader.uint32());
+                    continue;
+                case 7:
+                    if (tag !== 58) {
+                        break;
+                    }
+                    message.updatedAt = Timestamp.decode(reader, reader.uint32());
+                    continue;
+                case 8:
+                    if (tag !== 66) {
+                        break;
+                    }
+                    message.deletedAt = Timestamp.decode(reader, reader.uint32());
                     continue;
             }
             if ((tag & 7) === 4 || tag === 0) {
@@ -544,26 +598,32 @@ export const GrpcDtoAuthorize = {
         return message;
     },
 };
-function createBaseGrpcInputAuthenticate() {
-    return { accessToken: "", userAgent: "", ip: "" };
+function createBaseGrpcDtoGeoTimezone() {
+    return { publicId: "", iana: "" };
 }
-export const GrpcInputAuthenticate = {
+export const GrpcDtoGeoTimezone = {
     encode(message, writer = _m0.Writer.create()) {
-        if (message.accessToken !== "") {
-            writer.uint32(10).string(message.accessToken);
+        if (message.publicId !== "") {
+            writer.uint32(10).string(message.publicId);
         }
-        if (message.userAgent !== "") {
-            writer.uint32(18).string(message.userAgent);
+        if (message.iana !== "") {
+            writer.uint32(18).string(message.iana);
         }
-        if (message.ip !== "") {
-            writer.uint32(26).string(message.ip);
+        if (message.createdAt !== undefined) {
+            Timestamp.encode(message.createdAt, writer.uint32(26).fork()).ldelim();
+        }
+        if (message.updatedAt !== undefined) {
+            Timestamp.encode(message.updatedAt, writer.uint32(34).fork()).ldelim();
+        }
+        if (message.deletedAt !== undefined) {
+            Timestamp.encode(message.deletedAt, writer.uint32(42).fork()).ldelim();
         }
         return writer;
     },
     decode(input, length) {
         const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
         let end = length === undefined ? reader.len : reader.pos + length;
-        const message = createBaseGrpcInputAuthenticate();
+        const message = createBaseGrpcDtoGeoTimezone();
         while (reader.pos < end) {
             const tag = reader.uint32();
             switch (tag >>> 3) {
@@ -571,19 +631,31 @@ export const GrpcInputAuthenticate = {
                     if (tag !== 10) {
                         break;
                     }
-                    message.accessToken = reader.string();
+                    message.publicId = reader.string();
                     continue;
                 case 2:
                     if (tag !== 18) {
                         break;
                     }
-                    message.userAgent = reader.string();
+                    message.iana = reader.string();
                     continue;
                 case 3:
                     if (tag !== 26) {
                         break;
                     }
-                    message.ip = reader.string();
+                    message.createdAt = Timestamp.decode(reader, reader.uint32());
+                    continue;
+                case 4:
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.updatedAt = Timestamp.decode(reader, reader.uint32());
+                    continue;
+                case 5:
+                    if (tag !== 42) {
+                        break;
+                    }
+                    message.deletedAt = Timestamp.decode(reader, reader.uint32());
                     continue;
             }
             if ((tag & 7) === 4 || tag === 0) {
@@ -594,43 +666,32 @@ export const GrpcInputAuthenticate = {
         return message;
     },
 };
-function createBaseGrpcInputAuthorize() {
-    return {};
-}
-export const GrpcInputAuthorize = {
-    encode(_, writer = _m0.Writer.create()) {
-        return writer;
-    },
-    decode(input, length) {
-        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
-        let end = length === undefined ? reader.len : reader.pos + length;
-        const message = createBaseGrpcInputAuthorize();
-        while (reader.pos < end) {
-            const tag = reader.uint32();
-            switch (tag >>> 3) {
-            }
-            if ((tag & 7) === 4 || tag === 0) {
-                break;
-            }
-            reader.skipType(tag & 7);
-        }
-        return message;
-    },
-};
-function createBaseGrpcInputPermission() {
-    return { publicId: "" };
+function createBaseGrpcDtoClientType() {
+    return { publicId: "", name: "" };
 }
-export const GrpcInputPermission = {
+export const GrpcDtoClientType = {
     encode(message, writer = _m0.Writer.create()) {
         if (message.publicId !== "") {
             writer.uint32(10).string(message.publicId);
         }
+        if (message.name !== "") {
+            writer.uint32(18).string(message.name);
+        }
+        if (message.createdAt !== undefined) {
+            Timestamp.encode(message.createdAt, writer.uint32(26).fork()).ldelim();
+        }
+        if (message.updatedAt !== undefined) {
+            Timestamp.encode(message.updatedAt, writer.uint32(34).fork()).ldelim();
+        }
+        if (message.deletedAt !== undefined) {
+            Timestamp.encode(message.deletedAt, writer.uint32(42).fork()).ldelim();
+        }
         return writer;
     },
     decode(input, length) {
         const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
         let end = length === undefined ? reader.len : reader.pos + length;
-        const message = createBaseGrpcInputPermission();
+        const message = createBaseGrpcDtoClientType();
         while (reader.pos < end) {
             const tag = reader.uint32();
             switch (tag >>> 3) {
@@ -640,6 +701,30 @@ export const GrpcInputPermission = {
                     }
                     message.publicId = reader.string();
                     continue;
+                case 2:
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.name = reader.string();
+                    continue;
+                case 3:
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.createdAt = Timestamp.decode(reader, reader.uint32());
+                    continue;
+                case 4:
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.updatedAt = Timestamp.decode(reader, reader.uint32());
+                    continue;
+                case 5:
+                    if (tag !== 42) {
+                        break;
+                    }
+                    message.deletedAt = Timestamp.decode(reader, reader.uint32());
+                    continue;
             }
             if ((tag & 7) === 4 || tag === 0) {
                 break;
@@ -649,32 +734,38 @@ export const GrpcInputPermission = {
         return message;
     },
 };
-function createBaseGrpcInputPermissions() {
-    return {};
+function createBaseGrpcDtoClient() {
+    return { publicId: "", name: "" };
 }
-export const GrpcInputPermissions = {
+export const GrpcDtoClient = {
     encode(message, writer = _m0.Writer.create()) {
-        if (message.search !== undefined) {
-            writer.uint32(10).string(message.search);
+        if (message.publicId !== "") {
+            writer.uint32(10).string(message.publicId);
         }
-        if (message.page !== undefined) {
-            writer.uint32(16).int32(message.page);
+        if (message.name !== "") {
+            writer.uint32(18).string(message.name);
         }
-        if (message.pageSize !== undefined) {
-            writer.uint32(24).int32(message.pageSize);
+        if (message.description !== undefined) {
+            writer.uint32(26).string(message.description);
         }
-        if (message.sortBy !== undefined) {
-            writer.uint32(34).string(message.sortBy);
+        if (message.clientType !== undefined) {
+            GrpcDtoClientType.encode(message.clientType, writer.uint32(34).fork()).ldelim();
         }
-        if (message.sortOrder !== undefined) {
-            writer.uint32(42).string(message.sortOrder);
+        if (message.createdAt !== undefined) {
+            Timestamp.encode(message.createdAt, writer.uint32(42).fork()).ldelim();
+        }
+        if (message.updatedAt !== undefined) {
+            Timestamp.encode(message.updatedAt, writer.uint32(50).fork()).ldelim();
+        }
+        if (message.deletedAt !== undefined) {
+            Timestamp.encode(message.deletedAt, writer.uint32(58).fork()).ldelim();
         }
         return writer;
     },
     decode(input, length) {
         const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
         let end = length === undefined ? reader.len : reader.pos + length;
-        const message = createBaseGrpcInputPermissions();
+        const message = createBaseGrpcDtoClient();
         while (reader.pos < end) {
             const tag = reader.uint32();
             switch (tag >>> 3) {
@@ -682,31 +773,634 @@ export const GrpcInputPermissions = {
                     if (tag !== 10) {
                         break;
                     }
-                    message.search = reader.string();
+                    message.publicId = reader.string();
                     continue;
                 case 2:
-                    if (tag !== 16) {
+                    if (tag !== 18) {
                         break;
                     }
-                    message.page = reader.int32();
+                    message.name = reader.string();
                     continue;
                 case 3:
-                    if (tag !== 24) {
+                    if (tag !== 26) {
                         break;
                     }
-                    message.pageSize = reader.int32();
+                    message.description = reader.string();
                     continue;
                 case 4:
                     if (tag !== 34) {
                         break;
                     }
-                    message.sortBy = reader.string();
+                    message.clientType = GrpcDtoClientType.decode(reader, reader.uint32());
                     continue;
                 case 5:
                     if (tag !== 42) {
                         break;
                     }
-                    message.sortOrder = reader.string();
+                    message.createdAt = Timestamp.decode(reader, reader.uint32());
+                    continue;
+                case 6:
+                    if (tag !== 50) {
+                        break;
+                    }
+                    message.updatedAt = Timestamp.decode(reader, reader.uint32());
+                    continue;
+                case 7:
+                    if (tag !== 58) {
+                        break;
+                    }
+                    message.deletedAt = Timestamp.decode(reader, reader.uint32());
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    },
+};
+function createBaseGrpcDtoApiKey() {
+    return { publicId: "", key: "", revoked: "" };
+}
+export const GrpcDtoApiKey = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.publicId !== "") {
+            writer.uint32(10).string(message.publicId);
+        }
+        if (message.key !== "") {
+            writer.uint32(18).string(message.key);
+        }
+        if (message.scopes !== undefined) {
+            writer.uint32(26).string(message.scopes);
+        }
+        if (message.revoked !== "") {
+            writer.uint32(34).string(message.revoked);
+        }
+        if (message.expiresAt !== undefined) {
+            writer.uint32(42).string(message.expiresAt);
+        }
+        if (message.expireStatus !== undefined) {
+            writer.uint32(50).string(message.expireStatus);
+        }
+        if (message.lastUsedAt !== undefined) {
+            writer.uint32(58).string(message.lastUsedAt);
+        }
+        if (message.lastUsedIp !== undefined) {
+            writer.uint32(66).string(message.lastUsedIp);
+        }
+        if (message.createdAt !== undefined) {
+            Timestamp.encode(message.createdAt, writer.uint32(74).fork()).ldelim();
+        }
+        if (message.updatedAt !== undefined) {
+            Timestamp.encode(message.updatedAt, writer.uint32(82).fork()).ldelim();
+        }
+        if (message.deletedAt !== undefined) {
+            Timestamp.encode(message.deletedAt, writer.uint32(90).fork()).ldelim();
+        }
+        if (message.service !== undefined) {
+            GrpcDtoService.encode(message.service, writer.uint32(98).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseGrpcDtoApiKey();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.publicId = reader.string();
+                    continue;
+                case 2:
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.key = reader.string();
+                    continue;
+                case 3:
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.scopes = reader.string();
+                    continue;
+                case 4:
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.revoked = reader.string();
+                    continue;
+                case 5:
+                    if (tag !== 42) {
+                        break;
+                    }
+                    message.expiresAt = reader.string();
+                    continue;
+                case 6:
+                    if (tag !== 50) {
+                        break;
+                    }
+                    message.expireStatus = reader.string();
+                    continue;
+                case 7:
+                    if (tag !== 58) {
+                        break;
+                    }
+                    message.lastUsedAt = reader.string();
+                    continue;
+                case 8:
+                    if (tag !== 66) {
+                        break;
+                    }
+                    message.lastUsedIp = reader.string();
+                    continue;
+                case 9:
+                    if (tag !== 74) {
+                        break;
+                    }
+                    message.createdAt = Timestamp.decode(reader, reader.uint32());
+                    continue;
+                case 10:
+                    if (tag !== 82) {
+                        break;
+                    }
+                    message.updatedAt = Timestamp.decode(reader, reader.uint32());
+                    continue;
+                case 11:
+                    if (tag !== 90) {
+                        break;
+                    }
+                    message.deletedAt = Timestamp.decode(reader, reader.uint32());
+                    continue;
+                case 12:
+                    if (tag !== 98) {
+                        break;
+                    }
+                    message.service = GrpcDtoService.decode(reader, reader.uint32());
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    },
+};
+function createBaseGrpcDtoService() {
+    return {
+        publicId: "",
+        namespace: "",
+        origin: "",
+        resetPath: "",
+        captchaScoreThreshold: "",
+        captchaProvider: "",
+        apiKeys: [],
+    };
+}
+export const GrpcDtoService = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.publicId !== "") {
+            writer.uint32(10).string(message.publicId);
+        }
+        if (message.namespace !== "") {
+            writer.uint32(18).string(message.namespace);
+        }
+        if (message.origin !== "") {
+            writer.uint32(26).string(message.origin);
+        }
+        if (message.resetPath !== "") {
+            writer.uint32(34).string(message.resetPath);
+        }
+        if (message.captchaScoreThreshold !== "") {
+            writer.uint32(42).string(message.captchaScoreThreshold);
+        }
+        if (message.captchaProvider !== "") {
+            writer.uint32(50).string(message.captchaProvider);
+        }
+        if (message.description !== undefined) {
+            writer.uint32(58).string(message.description);
+        }
+        if (message.defaultCurrency !== undefined) {
+            GrpcDtoGeoCurrency.encode(message.defaultCurrency, writer.uint32(66).fork()).ldelim();
+        }
+        if (message.defaultLanguage !== undefined) {
+            GrpcDtoGeoLanguage.encode(message.defaultLanguage, writer.uint32(74).fork()).ldelim();
+        }
+        if (message.defaultTimezone !== undefined) {
+            GrpcDtoGeoTimezone.encode(message.defaultTimezone, writer.uint32(82).fork()).ldelim();
+        }
+        for (const v of message.apiKeys) {
+            GrpcDtoApiKey.encode(v, writer.uint32(90).fork()).ldelim();
+        }
+        if (message.createdAt !== undefined) {
+            Timestamp.encode(message.createdAt, writer.uint32(98).fork()).ldelim();
+        }
+        if (message.updatedAt !== undefined) {
+            Timestamp.encode(message.updatedAt, writer.uint32(106).fork()).ldelim();
+        }
+        if (message.deletedAt !== undefined) {
+            Timestamp.encode(message.deletedAt, writer.uint32(114).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseGrpcDtoService();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.publicId = reader.string();
+                    continue;
+                case 2:
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.namespace = reader.string();
+                    continue;
+                case 3:
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.origin = reader.string();
+                    continue;
+                case 4:
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.resetPath = reader.string();
+                    continue;
+                case 5:
+                    if (tag !== 42) {
+                        break;
+                    }
+                    message.captchaScoreThreshold = reader.string();
+                    continue;
+                case 6:
+                    if (tag !== 50) {
+                        break;
+                    }
+                    message.captchaProvider = reader.string();
+                    continue;
+                case 7:
+                    if (tag !== 58) {
+                        break;
+                    }
+                    message.description = reader.string();
+                    continue;
+                case 8:
+                    if (tag !== 66) {
+                        break;
+                    }
+                    message.defaultCurrency = GrpcDtoGeoCurrency.decode(reader, reader.uint32());
+                    continue;
+                case 9:
+                    if (tag !== 74) {
+                        break;
+                    }
+                    message.defaultLanguage = GrpcDtoGeoLanguage.decode(reader, reader.uint32());
+                    continue;
+                case 10:
+                    if (tag !== 82) {
+                        break;
+                    }
+                    message.defaultTimezone = GrpcDtoGeoTimezone.decode(reader, reader.uint32());
+                    continue;
+                case 11:
+                    if (tag !== 90) {
+                        break;
+                    }
+                    message.apiKeys.push(GrpcDtoApiKey.decode(reader, reader.uint32()));
+                    continue;
+                case 12:
+                    if (tag !== 98) {
+                        break;
+                    }
+                    message.createdAt = Timestamp.decode(reader, reader.uint32());
+                    continue;
+                case 13:
+                    if (tag !== 106) {
+                        break;
+                    }
+                    message.updatedAt = Timestamp.decode(reader, reader.uint32());
+                    continue;
+                case 14:
+                    if (tag !== 114) {
+                        break;
+                    }
+                    message.deletedAt = Timestamp.decode(reader, reader.uint32());
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    },
+};
+function createBaseGrpcDtoRole() {
+    return { publicId: "", isAgent: false, name: "", permissions: [], users: [] };
+}
+export const GrpcDtoRole = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.publicId !== "") {
+            writer.uint32(10).string(message.publicId);
+        }
+        if (message.isAgent !== false) {
+            writer.uint32(16).bool(message.isAgent);
+        }
+        if (message.name !== "") {
+            writer.uint32(26).string(message.name);
+        }
+        if (message.description !== undefined) {
+            writer.uint32(34).string(message.description);
+        }
+        if (message.createdAt !== undefined) {
+            Timestamp.encode(message.createdAt, writer.uint32(42).fork()).ldelim();
+        }
+        if (message.updatedAt !== undefined) {
+            Timestamp.encode(message.updatedAt, writer.uint32(50).fork()).ldelim();
+        }
+        if (message.deletedAt !== undefined) {
+            Timestamp.encode(message.deletedAt, writer.uint32(58).fork()).ldelim();
+        }
+        if (message.service !== undefined) {
+            GrpcDtoService.encode(message.service, writer.uint32(66).fork()).ldelim();
+        }
+        if (message.client !== undefined) {
+            GrpcDtoClient.encode(message.client, writer.uint32(74).fork()).ldelim();
+        }
+        for (const v of message.permissions) {
+            GrpcDtoPermission.encode(v, writer.uint32(82).fork()).ldelim();
+        }
+        for (const v of message.users) {
+            GrpcDtoUser.encode(v, writer.uint32(90).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseGrpcDtoRole();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.publicId = reader.string();
+                    continue;
+                case 2:
+                    if (tag !== 16) {
+                        break;
+                    }
+                    message.isAgent = reader.bool();
+                    continue;
+                case 3:
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.name = reader.string();
+                    continue;
+                case 4:
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.description = reader.string();
+                    continue;
+                case 5:
+                    if (tag !== 42) {
+                        break;
+                    }
+                    message.createdAt = Timestamp.decode(reader, reader.uint32());
+                    continue;
+                case 6:
+                    if (tag !== 50) {
+                        break;
+                    }
+                    message.updatedAt = Timestamp.decode(reader, reader.uint32());
+                    continue;
+                case 7:
+                    if (tag !== 58) {
+                        break;
+                    }
+                    message.deletedAt = Timestamp.decode(reader, reader.uint32());
+                    continue;
+                case 8:
+                    if (tag !== 66) {
+                        break;
+                    }
+                    message.service = GrpcDtoService.decode(reader, reader.uint32());
+                    continue;
+                case 9:
+                    if (tag !== 74) {
+                        break;
+                    }
+                    message.client = GrpcDtoClient.decode(reader, reader.uint32());
+                    continue;
+                case 10:
+                    if (tag !== 82) {
+                        break;
+                    }
+                    message.permissions.push(GrpcDtoPermission.decode(reader, reader.uint32()));
+                    continue;
+                case 11:
+                    if (tag !== 90) {
+                        break;
+                    }
+                    message.users.push(GrpcDtoUser.decode(reader, reader.uint32()));
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    },
+};
+function createBaseGrpcDtoRolePermission() {
+    return { publicId: "", source: "" };
+}
+export const GrpcDtoRolePermission = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.publicId !== "") {
+            writer.uint32(10).string(message.publicId);
+        }
+        if (message.source !== "") {
+            writer.uint32(18).string(message.source);
+        }
+        if (message.sourceFeaturePublicId !== undefined) {
+            writer.uint32(26).string(message.sourceFeaturePublicId);
+        }
+        if (message.sourceFeaturePermissionPublicId !== undefined) {
+            writer.uint32(34).string(message.sourceFeaturePermissionPublicId);
+        }
+        if (message.sourceSubscriptionPublicId !== undefined) {
+            writer.uint32(42).string(message.sourceSubscriptionPublicId);
+        }
+        if (message.createdAt !== undefined) {
+            Timestamp.encode(message.createdAt, writer.uint32(50).fork()).ldelim();
+        }
+        if (message.updatedAt !== undefined) {
+            Timestamp.encode(message.updatedAt, writer.uint32(58).fork()).ldelim();
+        }
+        if (message.deletedAt !== undefined) {
+            Timestamp.encode(message.deletedAt, writer.uint32(66).fork()).ldelim();
+        }
+        if (message.role !== undefined) {
+            GrpcDtoRole.encode(message.role, writer.uint32(74).fork()).ldelim();
+        }
+        if (message.permission !== undefined) {
+            GrpcDtoPermission.encode(message.permission, writer.uint32(82).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseGrpcDtoRolePermission();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.publicId = reader.string();
+                    continue;
+                case 2:
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.source = reader.string();
+                    continue;
+                case 3:
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.sourceFeaturePublicId = reader.string();
+                    continue;
+                case 4:
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.sourceFeaturePermissionPublicId = reader.string();
+                    continue;
+                case 5:
+                    if (tag !== 42) {
+                        break;
+                    }
+                    message.sourceSubscriptionPublicId = reader.string();
+                    continue;
+                case 6:
+                    if (tag !== 50) {
+                        break;
+                    }
+                    message.createdAt = Timestamp.decode(reader, reader.uint32());
+                    continue;
+                case 7:
+                    if (tag !== 58) {
+                        break;
+                    }
+                    message.updatedAt = Timestamp.decode(reader, reader.uint32());
+                    continue;
+                case 8:
+                    if (tag !== 66) {
+                        break;
+                    }
+                    message.deletedAt = Timestamp.decode(reader, reader.uint32());
+                    continue;
+                case 9:
+                    if (tag !== 74) {
+                        break;
+                    }
+                    message.role = GrpcDtoRole.decode(reader, reader.uint32());
+                    continue;
+                case 10:
+                    if (tag !== 82) {
+                        break;
+                    }
+                    message.permission = GrpcDtoPermission.decode(reader, reader.uint32());
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    },
+};
+function createBaseGrpcDtoUserRole() {
+    return { publicId: "" };
+}
+export const GrpcDtoUserRole = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.publicId !== "") {
+            writer.uint32(10).string(message.publicId);
+        }
+        if (message.user !== undefined) {
+            GrpcDtoUser.encode(message.user, writer.uint32(18).fork()).ldelim();
+        }
+        if (message.role !== undefined) {
+            GrpcDtoRole.encode(message.role, writer.uint32(26).fork()).ldelim();
+        }
+        if (message.createdAt !== undefined) {
+            Timestamp.encode(message.createdAt, writer.uint32(34).fork()).ldelim();
+        }
+        if (message.updatedAt !== undefined) {
+            Timestamp.encode(message.updatedAt, writer.uint32(42).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseGrpcDtoUserRole();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.publicId = reader.string();
+                    continue;
+                case 2:
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.user = GrpcDtoUser.decode(reader, reader.uint32());
+                    continue;
+                case 3:
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.role = GrpcDtoRole.decode(reader, reader.uint32());
+                    continue;
+                case 4:
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.createdAt = Timestamp.decode(reader, reader.uint32());
+                    continue;
+                case 5:
+                    if (tag !== 42) {
+                        break;
+                    }
+                    message.updatedAt = Timestamp.decode(reader, reader.uint32());
                     continue;
             }
             if ((tag & 7) === 4 || tag === 0) {
@@ -717,20 +1411,32 @@ export const GrpcInputPermissions = {
         return message;
     },
 };
-function createBaseGrpcInputRolePermissions() {
-    return { rolePublicId: "" };
+function createBaseGrpcDtoUserAccountType() {
+    return { publicId: "", name: "" };
 }
-export const GrpcInputRolePermissions = {
+export const GrpcDtoUserAccountType = {
     encode(message, writer = _m0.Writer.create()) {
-        if (message.rolePublicId !== "") {
-            writer.uint32(10).string(message.rolePublicId);
+        if (message.publicId !== "") {
+            writer.uint32(10).string(message.publicId);
+        }
+        if (message.name !== "") {
+            writer.uint32(18).string(message.name);
+        }
+        if (message.createdAt !== undefined) {
+            Timestamp.encode(message.createdAt, writer.uint32(26).fork()).ldelim();
+        }
+        if (message.updatedAt !== undefined) {
+            Timestamp.encode(message.updatedAt, writer.uint32(34).fork()).ldelim();
+        }
+        if (message.deletedAt !== undefined) {
+            Timestamp.encode(message.deletedAt, writer.uint32(42).fork()).ldelim();
         }
         return writer;
     },
     decode(input, length) {
         const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
         let end = length === undefined ? reader.len : reader.pos + length;
-        const message = createBaseGrpcInputRolePermissions();
+        const message = createBaseGrpcDtoUserAccountType();
         while (reader.pos < end) {
             const tag = reader.uint32();
             switch (tag >>> 3) {
@@ -738,7 +1444,31 @@ export const GrpcInputRolePermissions = {
                     if (tag !== 10) {
                         break;
                     }
-                    message.rolePublicId = reader.string();
+                    message.publicId = reader.string();
+                    continue;
+                case 2:
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.name = reader.string();
+                    continue;
+                case 3:
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.createdAt = Timestamp.decode(reader, reader.uint32());
+                    continue;
+                case 4:
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.updatedAt = Timestamp.decode(reader, reader.uint32());
+                    continue;
+                case 5:
+                    if (tag !== 42) {
+                        break;
+                    }
+                    message.deletedAt = Timestamp.decode(reader, reader.uint32());
                     continue;
             }
             if ((tag & 7) === 4 || tag === 0) {
@@ -749,20 +1479,254 @@ export const GrpcInputRolePermissions = {
         return message;
     },
 };
-function createBaseGrpcInputSeedPermission() {
-    return { name: "" };
+function createBaseGrpcDtoUser() {
+    return {
+        publicId: "",
+        email: "",
+        phone: "",
+        name: "",
+        status: "",
+        isEmailVerified: false,
+        isPhoneVerified: false,
+        mfaEnabled: false,
+        roles: [],
+    };
 }
-export const GrpcInputSeedPermission = {
+export const GrpcDtoUser = {
     encode(message, writer = _m0.Writer.create()) {
+        if (message.publicId !== "") {
+            writer.uint32(10).string(message.publicId);
+        }
+        if (message.email !== "") {
+            writer.uint32(18).string(message.email);
+        }
+        if (message.phone !== "") {
+            writer.uint32(26).string(message.phone);
+        }
         if (message.name !== "") {
-            writer.uint32(10).string(message.name);
+            writer.uint32(34).string(message.name);
+        }
+        if (message.status !== "") {
+            writer.uint32(42).string(message.status);
+        }
+        if (message.lockedAt !== undefined) {
+            writer.uint32(50).string(message.lockedAt);
+        }
+        if (message.lockReason !== undefined) {
+            writer.uint32(58).string(message.lockReason);
+        }
+        if (message.lastLoginAt !== undefined) {
+            writer.uint32(66).string(message.lastLoginAt);
+        }
+        if (message.lastPasswordChangeAt !== undefined) {
+            writer.uint32(74).string(message.lastPasswordChangeAt);
+        }
+        if (message.isEmailVerified !== false) {
+            writer.uint32(80).bool(message.isEmailVerified);
+        }
+        if (message.isPhoneVerified !== false) {
+            writer.uint32(88).bool(message.isPhoneVerified);
+        }
+        if (message.mfaEnabled !== false) {
+            writer.uint32(96).bool(message.mfaEnabled);
+        }
+        if (message.userCanEdit !== undefined) {
+            writer.uint32(104).bool(message.userCanEdit);
+        }
+        if (message.createdAt !== undefined) {
+            Timestamp.encode(message.createdAt, writer.uint32(114).fork()).ldelim();
+        }
+        if (message.updatedAt !== undefined) {
+            Timestamp.encode(message.updatedAt, writer.uint32(122).fork()).ldelim();
+        }
+        if (message.deletedAt !== undefined) {
+            Timestamp.encode(message.deletedAt, writer.uint32(130).fork()).ldelim();
+        }
+        if (message.service !== undefined) {
+            GrpcDtoService.encode(message.service, writer.uint32(138).fork()).ldelim();
+        }
+        if (message.userAccountType !== undefined) {
+            GrpcDtoUserAccountType.encode(message.userAccountType, writer.uint32(146).fork()).ldelim();
+        }
+        if (message.language !== undefined) {
+            GrpcDtoGeoLanguage.encode(message.language, writer.uint32(154).fork()).ldelim();
+        }
+        if (message.timezone !== undefined) {
+            GrpcDtoGeoTimezone.encode(message.timezone, writer.uint32(162).fork()).ldelim();
+        }
+        if (message.client !== undefined) {
+            GrpcDtoClient.encode(message.client, writer.uint32(170).fork()).ldelim();
+        }
+        for (const v of message.roles) {
+            GrpcDtoUserRole.encode(v, writer.uint32(178).fork()).ldelim();
         }
         return writer;
     },
     decode(input, length) {
         const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
         let end = length === undefined ? reader.len : reader.pos + length;
-        const message = createBaseGrpcInputSeedPermission();
+        const message = createBaseGrpcDtoUser();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.publicId = reader.string();
+                    continue;
+                case 2:
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.email = reader.string();
+                    continue;
+                case 3:
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.phone = reader.string();
+                    continue;
+                case 4:
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.name = reader.string();
+                    continue;
+                case 5:
+                    if (tag !== 42) {
+                        break;
+                    }
+                    message.status = reader.string();
+                    continue;
+                case 6:
+                    if (tag !== 50) {
+                        break;
+                    }
+                    message.lockedAt = reader.string();
+                    continue;
+                case 7:
+                    if (tag !== 58) {
+                        break;
+                    }
+                    message.lockReason = reader.string();
+                    continue;
+                case 8:
+                    if (tag !== 66) {
+                        break;
+                    }
+                    message.lastLoginAt = reader.string();
+                    continue;
+                case 9:
+                    if (tag !== 74) {
+                        break;
+                    }
+                    message.lastPasswordChangeAt = reader.string();
+                    continue;
+                case 10:
+                    if (tag !== 80) {
+                        break;
+                    }
+                    message.isEmailVerified = reader.bool();
+                    continue;
+                case 11:
+                    if (tag !== 88) {
+                        break;
+                    }
+                    message.isPhoneVerified = reader.bool();
+                    continue;
+                case 12:
+                    if (tag !== 96) {
+                        break;
+                    }
+                    message.mfaEnabled = reader.bool();
+                    continue;
+                case 13:
+                    if (tag !== 104) {
+                        break;
+                    }
+                    message.userCanEdit = reader.bool();
+                    continue;
+                case 14:
+                    if (tag !== 114) {
+                        break;
+                    }
+                    message.createdAt = Timestamp.decode(reader, reader.uint32());
+                    continue;
+                case 15:
+                    if (tag !== 122) {
+                        break;
+                    }
+                    message.updatedAt = Timestamp.decode(reader, reader.uint32());
+                    continue;
+                case 16:
+                    if (tag !== 130) {
+                        break;
+                    }
+                    message.deletedAt = Timestamp.decode(reader, reader.uint32());
+                    continue;
+                case 17:
+                    if (tag !== 138) {
+                        break;
+                    }
+                    message.service = GrpcDtoService.decode(reader, reader.uint32());
+                    continue;
+                case 18:
+                    if (tag !== 146) {
+                        break;
+                    }
+                    message.userAccountType = GrpcDtoUserAccountType.decode(reader, reader.uint32());
+                    continue;
+                case 19:
+                    if (tag !== 154) {
+                        break;
+                    }
+                    message.language = GrpcDtoGeoLanguage.decode(reader, reader.uint32());
+                    continue;
+                case 20:
+                    if (tag !== 162) {
+                        break;
+                    }
+                    message.timezone = GrpcDtoGeoTimezone.decode(reader, reader.uint32());
+                    continue;
+                case 21:
+                    if (tag !== 170) {
+                        break;
+                    }
+                    message.client = GrpcDtoClient.decode(reader, reader.uint32());
+                    continue;
+                case 22:
+                    if (tag !== 178) {
+                        break;
+                    }
+                    message.roles.push(GrpcDtoUserRole.decode(reader, reader.uint32()));
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    },
+};
+function createBaseGrpcDtoRoles() {
+    return { items: [] };
+}
+export const GrpcDtoRoles = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.meta !== undefined) {
+            GrpcDtoPagination.encode(message.meta, writer.uint32(10).fork()).ldelim();
+        }
+        for (const v of message.items) {
+            GrpcDtoRole.encode(v, writer.uint32(18).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseGrpcDtoRoles();
         while (reader.pos < end) {
             const tag = reader.uint32();
             switch (tag >>> 3) {
@@ -770,7 +1734,13 @@ export const GrpcInputSeedPermission = {
                     if (tag !== 10) {
                         break;
                     }
-                    message.name = reader.string();
+                    message.meta = GrpcDtoPagination.decode(reader, reader.uint32());
+                    continue;
+                case 2:
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.items.push(GrpcDtoRole.decode(reader, reader.uint32()));
                     continue;
             }
             if ((tag & 7) === 4 || tag === 0) {
@@ -781,20 +1751,20 @@ export const GrpcInputSeedPermission = {
         return message;
     },
 };
-function createBaseGrpcInputSeedPermissions() {
-    return { permissions: [] };
+function createBaseGrpcInputRole() {
+    return { publicId: "" };
 }
-export const GrpcInputSeedPermissions = {
+export const GrpcInputRole = {
     encode(message, writer = _m0.Writer.create()) {
-        for (const v of message.permissions) {
-            GrpcInputSeedPermission.encode(v, writer.uint32(10).fork()).ldelim();
+        if (message.publicId !== "") {
+            writer.uint32(10).string(message.publicId);
         }
         return writer;
     },
     decode(input, length) {
         const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
         let end = length === undefined ? reader.len : reader.pos + length;
-        const message = createBaseGrpcInputSeedPermissions();
+        const message = createBaseGrpcInputRole();
         while (reader.pos < end) {
             const tag = reader.uint32();
             switch (tag >>> 3) {
@@ -802,7 +1772,7 @@ export const GrpcInputSeedPermissions = {
                     if (tag !== 10) {
                         break;
                     }
-                    message.permissions.push(GrpcInputSeedPermission.decode(reader, reader.uint32()));
+                    message.publicId = reader.string();
                     continue;
             }
             if ((tag & 7) === 4 || tag === 0) {
@@ -813,13 +1783,13 @@ export const GrpcInputSeedPermissions = {
         return message;
     },
 };
-function createBaseGrpcInputVendorFeatures() {
-    return { vendorPublicId: "" };
+function createBaseGrpcInputRoles() {
+    return {};
 }
-export const GrpcInputVendorFeatures = {
+export const GrpcInputRoles = {
     encode(message, writer = _m0.Writer.create()) {
-        if (message.vendorPublicId !== "") {
-            writer.uint32(10).string(message.vendorPublicId);
+        if (message.clientPublicId !== undefined) {
+            writer.uint32(10).string(message.clientPublicId);
         }
         if (message.search !== undefined) {
             writer.uint32(18).string(message.search);
@@ -841,7 +1811,7 @@ export const GrpcInputVendorFeatures = {
     decode(input, length) {
         const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
         let end = length === undefined ? reader.len : reader.pos + length;
-        const message = createBaseGrpcInputVendorFeatures();
+        const message = createBaseGrpcInputRoles();
         while (reader.pos < end) {
             const tag = reader.uint32();
             switch (tag >>> 3) {
@@ -849,7 +1819,7 @@ export const GrpcInputVendorFeatures = {
                     if (tag !== 10) {
                         break;
                     }
-                    message.vendorPublicId = reader.string();
+                    message.clientPublicId = reader.string();
                     continue;
                 case 2:
                     if (tag !== 18) {
@@ -890,35 +1860,20 @@ export const GrpcInputVendorFeatures = {
         return message;
     },
 };
-function createBaseGrpcInputGetFeaturePermissions() {
-    return { featurePublicId: "" };
+function createBaseGrpcInputPermission() {
+    return { publicId: "" };
 }
-export const GrpcInputGetFeaturePermissions = {
+export const GrpcInputPermission = {
     encode(message, writer = _m0.Writer.create()) {
-        if (message.featurePublicId !== "") {
-            writer.uint32(10).string(message.featurePublicId);
-        }
-        if (message.search !== undefined) {
-            writer.uint32(18).string(message.search);
-        }
-        if (message.page !== undefined) {
-            writer.uint32(24).int32(message.page);
-        }
-        if (message.pageSize !== undefined) {
-            writer.uint32(32).int32(message.pageSize);
-        }
-        if (message.sortBy !== undefined) {
-            writer.uint32(42).string(message.sortBy);
-        }
-        if (message.sortOrder !== undefined) {
-            writer.uint32(50).string(message.sortOrder);
+        if (message.publicId !== "") {
+            writer.uint32(10).string(message.publicId);
         }
         return writer;
     },
     decode(input, length) {
         const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
         let end = length === undefined ? reader.len : reader.pos + length;
-        const message = createBaseGrpcInputGetFeaturePermissions();
+        const message = createBaseGrpcInputPermission();
         while (reader.pos < end) {
             const tag = reader.uint32();
             switch (tag >>> 3) {
@@ -926,37 +1881,71 @@ export const GrpcInputGetFeaturePermissions = {
                     if (tag !== 10) {
                         break;
                     }
-                    message.featurePublicId = reader.string();
-                    continue;
-                case 2:
-                    if (tag !== 18) {
-                        break;
-                    }
-                    message.search = reader.string();
-                    continue;
-                case 3:
-                    if (tag !== 24) {
-                        break;
-                    }
-                    message.page = reader.int32();
-                    continue;
-                case 4:
-                    if (tag !== 32) {
-                        break;
-                    }
-                    message.pageSize = reader.int32();
+                    message.publicId = reader.string();
                     continue;
-                case 5:
-                    if (tag !== 42) {
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    },
+};
+function createBaseGrpcInputRolePermissions() {
+    return { rolePublicId: "" };
+}
+export const GrpcInputRolePermissions = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.rolePublicId !== "") {
+            writer.uint32(10).string(message.rolePublicId);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseGrpcInputRolePermissions();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
                         break;
                     }
-                    message.sortBy = reader.string();
+                    message.rolePublicId = reader.string();
                     continue;
-                case 6:
-                    if (tag !== 50) {
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    },
+};
+function createBaseGrpcDtoRolePermissions() {
+    return { rolePermissions: [] };
+}
+export const GrpcDtoRolePermissions = {
+    encode(message, writer = _m0.Writer.create()) {
+        for (const v of message.rolePermissions) {
+            GrpcDtoRolePermission.encode(v, writer.uint32(10).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseGrpcDtoRolePermissions();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
                         break;
                     }
-                    message.sortOrder = reader.string();
+                    message.rolePermissions.push(GrpcDtoRolePermission.decode(reader, reader.uint32()));
                     continue;
             }
             if ((tag & 7) === 4 || tag === 0) {
@@ -967,20 +1956,29 @@ export const GrpcInputGetFeaturePermissions = {
         return message;
     },
 };
-function createBaseGrpcDtoPermissions() {
-    return { permissions: [] };
+function createBaseGrpcInputRoleCreate() {
+    return { name: "" };
 }
-export const GrpcDtoPermissions = {
+export const GrpcInputRoleCreate = {
     encode(message, writer = _m0.Writer.create()) {
-        for (const v of message.permissions) {
-            GrpcDtoPermission.encode(v, writer.uint32(10).fork()).ldelim();
+        if (message.name !== "") {
+            writer.uint32(10).string(message.name);
+        }
+        if (message.description !== undefined) {
+            writer.uint32(18).string(message.description);
+        }
+        if (message.isAgent !== undefined) {
+            writer.uint32(24).bool(message.isAgent);
+        }
+        if (message.clientPublicId !== undefined) {
+            writer.uint32(34).string(message.clientPublicId);
         }
         return writer;
     },
     decode(input, length) {
         const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
         let end = length === undefined ? reader.len : reader.pos + length;
-        const message = createBaseGrpcDtoPermissions();
+        const message = createBaseGrpcInputRoleCreate();
         while (reader.pos < end) {
             const tag = reader.uint32();
             switch (tag >>> 3) {
@@ -988,7 +1986,25 @@ export const GrpcDtoPermissions = {
                     if (tag !== 10) {
                         break;
                     }
-                    message.permissions.push(GrpcDtoPermission.decode(reader, reader.uint32()));
+                    message.name = reader.string();
+                    continue;
+                case 2:
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.description = reader.string();
+                    continue;
+                case 3:
+                    if (tag !== 24) {
+                        break;
+                    }
+                    message.isAgent = reader.bool();
+                    continue;
+                case 4:
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.clientPublicId = reader.string();
                     continue;
             }
             if ((tag & 7) === 4 || tag === 0) {
@@ -999,26 +2015,29 @@ export const GrpcDtoPermissions = {
         return message;
     },
 };
-function createBaseGrpcDtoRolePermission() {
+function createBaseGrpcInputRoleUpdate() {
     return { publicId: "" };
 }
-export const GrpcDtoRolePermission = {
+export const GrpcInputRoleUpdate = {
     encode(message, writer = _m0.Writer.create()) {
         if (message.publicId !== "") {
             writer.uint32(10).string(message.publicId);
         }
-        if (message.permission !== undefined) {
-            GrpcDtoPermission.encode(message.permission, writer.uint32(18).fork()).ldelim();
+        if (message.name !== undefined) {
+            writer.uint32(18).string(message.name);
         }
-        if (message.role !== undefined) {
-            GrpcDtoRole.encode(message.role, writer.uint32(26).fork()).ldelim();
+        if (message.description !== undefined) {
+            writer.uint32(26).string(message.description);
+        }
+        if (message.isAgent !== undefined) {
+            writer.uint32(32).bool(message.isAgent);
         }
         return writer;
     },
     decode(input, length) {
         const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
         let end = length === undefined ? reader.len : reader.pos + length;
-        const message = createBaseGrpcDtoRolePermission();
+        const message = createBaseGrpcInputRoleUpdate();
         while (reader.pos < end) {
             const tag = reader.uint32();
             switch (tag >>> 3) {
@@ -1032,13 +2051,19 @@ export const GrpcDtoRolePermission = {
                     if (tag !== 18) {
                         break;
                     }
-                    message.permission = GrpcDtoPermission.decode(reader, reader.uint32());
+                    message.name = reader.string();
                     continue;
                 case 3:
                     if (tag !== 26) {
                         break;
                     }
-                    message.role = GrpcDtoRole.decode(reader, reader.uint32());
+                    message.description = reader.string();
+                    continue;
+                case 4:
+                    if (tag !== 32) {
+                        break;
+                    }
+                    message.isAgent = reader.bool();
                     continue;
             }
             if ((tag & 7) === 4 || tag === 0) {
@@ -1049,20 +2074,20 @@ export const GrpcDtoRolePermission = {
         return message;
     },
 };
-function createBaseGrpcDtoRolePermissions() {
-    return { rolePermissions: [] };
+function createBaseGrpcInputRoleRecycle() {
+    return { publicIds: [] };
 }
-export const GrpcDtoRolePermissions = {
+export const GrpcInputRoleRecycle = {
     encode(message, writer = _m0.Writer.create()) {
-        for (const v of message.rolePermissions) {
-            GrpcDtoRolePermission.encode(v, writer.uint32(10).fork()).ldelim();
+        for (const v of message.publicIds) {
+            writer.uint32(10).string(v);
         }
         return writer;
     },
     decode(input, length) {
         const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
         let end = length === undefined ? reader.len : reader.pos + length;
-        const message = createBaseGrpcDtoRolePermissions();
+        const message = createBaseGrpcInputRoleRecycle();
         while (reader.pos < end) {
             const tag = reader.uint32();
             switch (tag >>> 3) {
@@ -1070,7 +2095,7 @@ export const GrpcDtoRolePermissions = {
                     if (tag !== 10) {
                         break;
                     }
-                    message.rolePermissions.push(GrpcDtoRolePermission.decode(reader, reader.uint32()));
+                    message.publicIds.push(reader.string());
                     continue;
             }
             if ((tag & 7) === 4 || tag === 0) {
@@ -1081,23 +2106,20 @@ export const GrpcDtoRolePermissions = {
         return message;
     },
 };
-function createBaseGrpcDtoPermissionsPaginated() {
-    return { items: [] };
+function createBaseGrpcInputRoleRestore() {
+    return { publicIds: [] };
 }
-export const GrpcDtoPermissionsPaginated = {
+export const GrpcInputRoleRestore = {
     encode(message, writer = _m0.Writer.create()) {
-        for (const v of message.items) {
-            GrpcDtoPermission.encode(v, writer.uint32(10).fork()).ldelim();
-        }
-        if (message.meta !== undefined) {
-            GrpcDtoPagination.encode(message.meta, writer.uint32(18).fork()).ldelim();
+        for (const v of message.publicIds) {
+            writer.uint32(10).string(v);
         }
         return writer;
     },
     decode(input, length) {
         const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
         let end = length === undefined ? reader.len : reader.pos + length;
-        const message = createBaseGrpcDtoPermissionsPaginated();
+        const message = createBaseGrpcInputRoleRestore();
         while (reader.pos < end) {
             const tag = reader.uint32();
             switch (tag >>> 3) {
@@ -1105,13 +2127,7 @@ export const GrpcDtoPermissionsPaginated = {
                     if (tag !== 10) {
                         break;
                     }
-                    message.items.push(GrpcDtoPermission.decode(reader, reader.uint32()));
-                    continue;
-                case 2:
-                    if (tag !== 18) {
-                        break;
-                    }
-                    message.meta = GrpcDtoPagination.decode(reader, reader.uint32());
+                    message.publicIds.push(reader.string());
                     continue;
             }
             if ((tag & 7) === 4 || tag === 0) {
@@ -1122,29 +2138,32 @@ export const GrpcDtoPermissionsPaginated = {
         return message;
     },
 };
-function createBaseGrpcDtoVendorFeature() {
-    return { publicId: "", name: "" };
+function createBaseGrpcInputRolePermissionsAdd() {
+    return { publicId: "", permissionIds: [], sourceFeaturePermissionPublicIds: [] };
 }
-export const GrpcDtoVendorFeature = {
+export const GrpcInputRolePermissionsAdd = {
     encode(message, writer = _m0.Writer.create()) {
         if (message.publicId !== "") {
             writer.uint32(10).string(message.publicId);
         }
-        if (message.name !== "") {
-            writer.uint32(18).string(message.name);
+        if (message.source !== undefined) {
+            writer.uint32(18).string(message.source);
         }
-        if (message.description !== undefined) {
-            writer.uint32(26).string(message.description);
+        if (message.sourceFeaturePublicId !== undefined) {
+            writer.uint32(26).string(message.sourceFeaturePublicId);
         }
-        if (message.permissionsCount !== undefined) {
-            writer.uint32(32).int32(message.permissionsCount);
+        for (const v of message.permissionIds) {
+            writer.uint32(34).string(v);
+        }
+        for (const v of message.sourceFeaturePermissionPublicIds) {
+            writer.uint32(42).string(v);
         }
         return writer;
     },
     decode(input, length) {
         const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
         let end = length === undefined ? reader.len : reader.pos + length;
-        const message = createBaseGrpcDtoVendorFeature();
+        const message = createBaseGrpcInputRolePermissionsAdd();
         while (reader.pos < end) {
             const tag = reader.uint32();
             switch (tag >>> 3) {
@@ -1158,19 +2177,25 @@ export const GrpcDtoVendorFeature = {
                     if (tag !== 18) {
                         break;
                     }
-                    message.name = reader.string();
+                    message.source = reader.string();
                     continue;
                 case 3:
                     if (tag !== 26) {
                         break;
                     }
-                    message.description = reader.string();
+                    message.sourceFeaturePublicId = reader.string();
                     continue;
                 case 4:
-                    if (tag !== 32) {
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.permissionIds.push(reader.string());
+                    continue;
+                case 5:
+                    if (tag !== 42) {
                         break;
                     }
-                    message.permissionsCount = reader.int32();
+                    message.sourceFeaturePermissionPublicIds.push(reader.string());
                     continue;
             }
             if ((tag & 7) === 4 || tag === 0) {
@@ -1181,23 +2206,20 @@ export const GrpcDtoVendorFeature = {
         return message;
     },
 };
-function createBaseGrpcDtoVendorFeatures() {
-    return { items: [] };
+function createBaseGrpcDtoPermissionsAdd() {
+    return { permissions: [] };
 }
-export const GrpcDtoVendorFeatures = {
+export const GrpcDtoPermissionsAdd = {
     encode(message, writer = _m0.Writer.create()) {
-        for (const v of message.items) {
-            GrpcDtoVendorFeature.encode(v, writer.uint32(10).fork()).ldelim();
-        }
-        if (message.meta !== undefined) {
-            GrpcDtoPagination.encode(message.meta, writer.uint32(18).fork()).ldelim();
+        for (const v of message.permissions) {
+            GrpcDtoPermission.encode(v, writer.uint32(10).fork()).ldelim();
         }
         return writer;
     },
     decode(input, length) {
         const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
         let end = length === undefined ? reader.len : reader.pos + length;
-        const message = createBaseGrpcDtoVendorFeatures();
+        const message = createBaseGrpcDtoPermissionsAdd();
         while (reader.pos < end) {
             const tag = reader.uint32();
             switch (tag >>> 3) {
@@ -1205,13 +2227,7 @@ export const GrpcDtoVendorFeatures = {
                     if (tag !== 10) {
                         break;
                     }
-                    message.items.push(GrpcDtoVendorFeature.decode(reader, reader.uint32()));
-                    continue;
-                case 2:
-                    if (tag !== 18) {
-                        break;
-                    }
-                    message.meta = GrpcDtoPagination.decode(reader, reader.uint32());
+                    message.permissions.push(GrpcDtoPermission.decode(reader, reader.uint32()));
                     continue;
             }
             if ((tag & 7) === 4 || tag === 0) {
@@ -1222,23 +2238,23 @@ export const GrpcDtoVendorFeatures = {
         return message;
     },
 };
-function createBaseGrpcDtoFeaturePermissions() {
-    return { items: [] };
+function createBaseGrpcInputRolePermissionsRemove() {
+    return { publicRolePermissionIds: [], reason: "" };
 }
-export const GrpcDtoFeaturePermissions = {
+export const GrpcInputRolePermissionsRemove = {
     encode(message, writer = _m0.Writer.create()) {
-        for (const v of message.items) {
-            GrpcDtoPermission.encode(v, writer.uint32(10).fork()).ldelim();
+        for (const v of message.publicRolePermissionIds) {
+            writer.uint32(10).string(v);
         }
-        if (message.meta !== undefined) {
-            GrpcDtoPagination.encode(message.meta, writer.uint32(18).fork()).ldelim();
+        if (message.reason !== "") {
+            writer.uint32(18).string(message.reason);
         }
         return writer;
     },
     decode(input, length) {
         const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
         let end = length === undefined ? reader.len : reader.pos + length;
-        const message = createBaseGrpcDtoFeaturePermissions();
+        const message = createBaseGrpcInputRolePermissionsRemove();
         while (reader.pos < end) {
             const tag = reader.uint32();
             switch (tag >>> 3) {
@@ -1246,13 +2262,13 @@ export const GrpcDtoFeaturePermissions = {
                     if (tag !== 10) {
                         break;
                     }
-                    message.items.push(GrpcDtoPermission.decode(reader, reader.uint32()));
+                    message.publicRolePermissionIds.push(reader.string());
                     continue;
                 case 2:
                     if (tag !== 18) {
                         break;
                     }
-                    message.meta = GrpcDtoPagination.decode(reader, reader.uint32());
+                    message.reason = reader.string();
                     continue;
             }
             if ((tag & 7) === 4 || tag === 0) {
@@ -1263,35 +2279,29 @@ export const GrpcDtoFeaturePermissions = {
         return message;
     },
 };
-function createBaseGrpcInputRoles() {
-    return { page: 0, pageSize: 0 };
+function createBaseGrpcInputAuthNZ() {
+    return { userAgent: "", ip: "", permissionName: "", permissionScopes: [] };
 }
-export const GrpcInputRoles = {
+export const GrpcInputAuthNZ = {
     encode(message, writer = _m0.Writer.create()) {
-        if (message.clientPublicId !== undefined) {
-            writer.uint32(10).string(message.clientPublicId);
-        }
-        if (message.search !== undefined) {
-            writer.uint32(18).string(message.search);
-        }
-        if (message.page !== 0) {
-            writer.uint32(24).int32(message.page);
+        if (message.userAgent !== "") {
+            writer.uint32(10).string(message.userAgent);
         }
-        if (message.pageSize !== 0) {
-            writer.uint32(32).int32(message.pageSize);
+        if (message.ip !== "") {
+            writer.uint32(18).string(message.ip);
         }
-        if (message.sortBy !== undefined) {
-            writer.uint32(42).string(message.sortBy);
+        if (message.permissionName !== "") {
+            writer.uint32(26).string(message.permissionName);
         }
-        if (message.sortOrder !== undefined) {
-            writer.uint32(50).string(message.sortOrder);
+        for (const v of message.permissionScopes) {
+            writer.uint32(34).string(v);
         }
         return writer;
     },
     decode(input, length) {
         const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
         let end = length === undefined ? reader.len : reader.pos + length;
-        const message = createBaseGrpcInputRoles();
+        const message = createBaseGrpcInputAuthNZ();
         while (reader.pos < end) {
             const tag = reader.uint32();
             switch (tag >>> 3) {
@@ -1299,37 +2309,25 @@ export const GrpcInputRoles = {
                     if (tag !== 10) {
                         break;
                     }
-                    message.clientPublicId = reader.string();
+                    message.userAgent = reader.string();
                     continue;
                 case 2:
                     if (tag !== 18) {
                         break;
                     }
-                    message.search = reader.string();
+                    message.ip = reader.string();
                     continue;
                 case 3:
-                    if (tag !== 24) {
+                    if (tag !== 26) {
                         break;
                     }
-                    message.page = reader.int32();
+                    message.permissionName = reader.string();
                     continue;
                 case 4:
-                    if (tag !== 32) {
-                        break;
-                    }
-                    message.pageSize = reader.int32();
-                    continue;
-                case 5:
-                    if (tag !== 42) {
-                        break;
-                    }
-                    message.sortBy = reader.string();
-                    continue;
-                case 6:
-                    if (tag !== 50) {
+                    if (tag !== 34) {
                         break;
                     }
-                    message.sortOrder = reader.string();
+                    message.permissionScopes.push(reader.string());
                     continue;
             }
             if ((tag & 7) === 4 || tag === 0) {
@@ -1340,28 +2338,46 @@ export const GrpcInputRoles = {
         return message;
     },
 };
-function createBaseGrpcInputRole() {
-    return { publicId: "" };
+function createBaseGrpcDtoAuthNZ() {
+    return {};
 }
-export const GrpcInputRole = {
+export const GrpcDtoAuthNZ = {
     encode(message, writer = _m0.Writer.create()) {
-        if (message.publicId !== "") {
-            writer.uint32(10).string(message.publicId);
+        if (message.valid !== undefined) {
+            writer.uint32(8).bool(message.valid);
+        }
+        if (message.reason !== undefined) {
+            writer.uint32(18).string(message.reason);
+        }
+        if (message.identity !== undefined) {
+            GrpcDtoIdentity.encode(message.identity, writer.uint32(26).fork()).ldelim();
         }
         return writer;
     },
     decode(input, length) {
         const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
         let end = length === undefined ? reader.len : reader.pos + length;
-        const message = createBaseGrpcInputRole();
+        const message = createBaseGrpcDtoAuthNZ();
         while (reader.pos < end) {
             const tag = reader.uint32();
             switch (tag >>> 3) {
                 case 1:
-                    if (tag !== 10) {
+                    if (tag !== 8) {
                         break;
                     }
-                    message.publicId = reader.string();
+                    message.valid = reader.bool();
+                    continue;
+                case 2:
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.reason = reader.string();
+                    continue;
+                case 3:
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.identity = GrpcDtoIdentity.decode(reader, reader.uint32());
                     continue;
             }
             if ((tag & 7) === 4 || tag === 0) {
@@ -1372,29 +2388,35 @@ export const GrpcInputRole = {
         return message;
     },
 };
-function createBaseGrpcInputRoleCreate() {
-    return { name: "" };
+function createBaseGrpcDtoIdentity() {
+    return { roles: [] };
 }
-export const GrpcInputRoleCreate = {
+export const GrpcDtoIdentity = {
     encode(message, writer = _m0.Writer.create()) {
-        if (message.name !== "") {
-            writer.uint32(10).string(message.name);
+        if (message.session !== undefined) {
+            GrpcDtoIdentitySession.encode(message.session, writer.uint32(10).fork()).ldelim();
         }
-        if (message.description !== undefined) {
-            writer.uint32(18).string(message.description);
+        if (message.service !== undefined) {
+            GrpcDtoIdentityService.encode(message.service, writer.uint32(18).fork()).ldelim();
         }
-        if (message.isAgent !== undefined) {
-            writer.uint32(24).bool(message.isAgent);
+        if (message.user !== undefined) {
+            GrpcDtoIdentityUser.encode(message.user, writer.uint32(26).fork()).ldelim();
         }
-        if (message.clientPublicId !== undefined) {
-            writer.uint32(34).string(message.clientPublicId);
+        if (message.agent !== undefined) {
+            GrpcDtoIdentityAgent.encode(message.agent, writer.uint32(34).fork()).ldelim();
+        }
+        if (message.client !== undefined) {
+            GrpcDtoIdentityClient.encode(message.client, writer.uint32(42).fork()).ldelim();
+        }
+        for (const v of message.roles) {
+            GrpcDtoIdentityRole.encode(v, writer.uint32(50).fork()).ldelim();
         }
         return writer;
     },
     decode(input, length) {
         const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
         let end = length === undefined ? reader.len : reader.pos + length;
-        const message = createBaseGrpcInputRoleCreate();
+        const message = createBaseGrpcDtoIdentity();
         while (reader.pos < end) {
             const tag = reader.uint32();
             switch (tag >>> 3) {
@@ -1402,25 +2424,37 @@ export const GrpcInputRoleCreate = {
                     if (tag !== 10) {
                         break;
                     }
-                    message.name = reader.string();
+                    message.session = GrpcDtoIdentitySession.decode(reader, reader.uint32());
                     continue;
                 case 2:
                     if (tag !== 18) {
                         break;
                     }
-                    message.description = reader.string();
+                    message.service = GrpcDtoIdentityService.decode(reader, reader.uint32());
                     continue;
                 case 3:
-                    if (tag !== 24) {
+                    if (tag !== 26) {
                         break;
                     }
-                    message.isAgent = reader.bool();
+                    message.user = GrpcDtoIdentityUser.decode(reader, reader.uint32());
                     continue;
                 case 4:
                     if (tag !== 34) {
                         break;
                     }
-                    message.clientPublicId = reader.string();
+                    message.agent = GrpcDtoIdentityAgent.decode(reader, reader.uint32());
+                    continue;
+                case 5:
+                    if (tag !== 42) {
+                        break;
+                    }
+                    message.client = GrpcDtoIdentityClient.decode(reader, reader.uint32());
+                    continue;
+                case 6:
+                    if (tag !== 50) {
+                        break;
+                    }
+                    message.roles.push(GrpcDtoIdentityRole.decode(reader, reader.uint32()));
                     continue;
             }
             if ((tag & 7) === 4 || tag === 0) {
@@ -1431,29 +2465,23 @@ export const GrpcInputRoleCreate = {
         return message;
     },
 };
-function createBaseGrpcInputRoleUpdate() {
+function createBaseGrpcDtoIdentitySession() {
     return { publicId: "" };
 }
-export const GrpcInputRoleUpdate = {
+export const GrpcDtoIdentitySession = {
     encode(message, writer = _m0.Writer.create()) {
         if (message.publicId !== "") {
             writer.uint32(10).string(message.publicId);
         }
-        if (message.name !== undefined) {
-            writer.uint32(18).string(message.name);
-        }
-        if (message.description !== undefined) {
-            writer.uint32(26).string(message.description);
-        }
-        if (message.isAgent !== undefined) {
-            writer.uint32(32).bool(message.isAgent);
+        if (message.expiresAt !== undefined) {
+            Timestamp.encode(message.expiresAt, writer.uint32(18).fork()).ldelim();
         }
         return writer;
     },
     decode(input, length) {
         const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
         let end = length === undefined ? reader.len : reader.pos + length;
-        const message = createBaseGrpcInputRoleUpdate();
+        const message = createBaseGrpcDtoIdentitySession();
         while (reader.pos < end) {
             const tag = reader.uint32();
             switch (tag >>> 3) {
@@ -1467,19 +2495,7 @@ export const GrpcInputRoleUpdate = {
                     if (tag !== 18) {
                         break;
                     }
-                    message.name = reader.string();
-                    continue;
-                case 3:
-                    if (tag !== 26) {
-                        break;
-                    }
-                    message.description = reader.string();
-                    continue;
-                case 4:
-                    if (tag !== 32) {
-                        break;
-                    }
-                    message.isAgent = reader.bool();
+                    message.expiresAt = Timestamp.decode(reader, reader.uint32());
                     continue;
             }
             if ((tag & 7) === 4 || tag === 0) {
@@ -1490,20 +2506,32 @@ export const GrpcInputRoleUpdate = {
         return message;
     },
 };
-function createBaseGrpcInputRoleRecycle() {
-    return { publicIds: [] };
+function createBaseGrpcDtoIdentityService() {
+    return { publicId: "", namespace: "" };
 }
-export const GrpcInputRoleRecycle = {
+export const GrpcDtoIdentityService = {
     encode(message, writer = _m0.Writer.create()) {
-        for (const v of message.publicIds) {
-            writer.uint32(10).string(v);
+        if (message.publicId !== "") {
+            writer.uint32(10).string(message.publicId);
+        }
+        if (message.namespace !== "") {
+            writer.uint32(18).string(message.namespace);
+        }
+        if (message.defaultLanguage !== undefined) {
+            GrpcDtoIdentityGeoLanguage.encode(message.defaultLanguage, writer.uint32(26).fork()).ldelim();
+        }
+        if (message.defaultTimezone !== undefined) {
+            GrpcDtoIdentityGeoTimezone.encode(message.defaultTimezone, writer.uint32(34).fork()).ldelim();
+        }
+        if (message.defaultCurrency !== undefined) {
+            GrpcDtoIdentityGeoCurrency.encode(message.defaultCurrency, writer.uint32(42).fork()).ldelim();
         }
         return writer;
     },
     decode(input, length) {
         const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
         let end = length === undefined ? reader.len : reader.pos + length;
-        const message = createBaseGrpcInputRoleRecycle();
+        const message = createBaseGrpcDtoIdentityService();
         while (reader.pos < end) {
             const tag = reader.uint32();
             switch (tag >>> 3) {
@@ -1511,7 +2539,31 @@ export const GrpcInputRoleRecycle = {
                     if (tag !== 10) {
                         break;
                     }
-                    message.publicIds.push(reader.string());
+                    message.publicId = reader.string();
+                    continue;
+                case 2:
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.namespace = reader.string();
+                    continue;
+                case 3:
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.defaultLanguage = GrpcDtoIdentityGeoLanguage.decode(reader, reader.uint32());
+                    continue;
+                case 4:
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.defaultTimezone = GrpcDtoIdentityGeoTimezone.decode(reader, reader.uint32());
+                    continue;
+                case 5:
+                    if (tag !== 42) {
+                        break;
+                    }
+                    message.defaultCurrency = GrpcDtoIdentityGeoCurrency.decode(reader, reader.uint32());
                     continue;
             }
             if ((tag & 7) === 4 || tag === 0) {
@@ -1522,20 +2574,26 @@ export const GrpcInputRoleRecycle = {
         return message;
     },
 };
-function createBaseGrpcInputRoleRestore() {
-    return { publicIds: [] };
+function createBaseGrpcDtoIdentityGeoLanguage() {
+    return { publicId: "", iso6391: "", name: "" };
 }
-export const GrpcInputRoleRestore = {
+export const GrpcDtoIdentityGeoLanguage = {
     encode(message, writer = _m0.Writer.create()) {
-        for (const v of message.publicIds) {
-            writer.uint32(10).string(v);
+        if (message.publicId !== "") {
+            writer.uint32(10).string(message.publicId);
+        }
+        if (message.iso6391 !== "") {
+            writer.uint32(18).string(message.iso6391);
+        }
+        if (message.name !== "") {
+            writer.uint32(26).string(message.name);
         }
         return writer;
     },
     decode(input, length) {
         const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
         let end = length === undefined ? reader.len : reader.pos + length;
-        const message = createBaseGrpcInputRoleRestore();
+        const message = createBaseGrpcDtoIdentityGeoLanguage();
         while (reader.pos < end) {
             const tag = reader.uint32();
             switch (tag >>> 3) {
@@ -1543,7 +2601,19 @@ export const GrpcInputRoleRestore = {
                     if (tag !== 10) {
                         break;
                     }
-                    message.publicIds.push(reader.string());
+                    message.publicId = reader.string();
+                    continue;
+                case 2:
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.iso6391 = reader.string();
+                    continue;
+                case 3:
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.name = reader.string();
                     continue;
             }
             if ((tag & 7) === 4 || tag === 0) {
@@ -1554,32 +2624,23 @@ export const GrpcInputRoleRestore = {
         return message;
     },
 };
-function createBaseGrpcInputRolePermissionsAdd() {
-    return { publicId: "", permissionIds: [], sourceFeaturePermissionPublicIds: [] };
+function createBaseGrpcDtoIdentityGeoTimezone() {
+    return { publicId: "", iana: "" };
 }
-export const GrpcInputRolePermissionsAdd = {
+export const GrpcDtoIdentityGeoTimezone = {
     encode(message, writer = _m0.Writer.create()) {
         if (message.publicId !== "") {
             writer.uint32(10).string(message.publicId);
         }
-        for (const v of message.permissionIds) {
-            writer.uint32(18).string(v);
-        }
-        if (message.source !== undefined) {
-            writer.uint32(26).string(message.source);
-        }
-        if (message.sourceFeaturePublicId !== undefined) {
-            writer.uint32(34).string(message.sourceFeaturePublicId);
-        }
-        for (const v of message.sourceFeaturePermissionPublicIds) {
-            writer.uint32(42).string(v);
+        if (message.iana !== "") {
+            writer.uint32(18).string(message.iana);
         }
         return writer;
     },
     decode(input, length) {
         const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
         let end = length === undefined ? reader.len : reader.pos + length;
-        const message = createBaseGrpcInputRolePermissionsAdd();
+        const message = createBaseGrpcDtoIdentityGeoTimezone();
         while (reader.pos < end) {
             const tag = reader.uint32();
             switch (tag >>> 3) {
@@ -1593,25 +2654,7 @@ export const GrpcInputRolePermissionsAdd = {
                     if (tag !== 18) {
                         break;
                     }
-                    message.permissionIds.push(reader.string());
-                    continue;
-                case 3:
-                    if (tag !== 26) {
-                        break;
-                    }
-                    message.source = reader.string();
-                    continue;
-                case 4:
-                    if (tag !== 34) {
-                        break;
-                    }
-                    message.sourceFeaturePublicId = reader.string();
-                    continue;
-                case 5:
-                    if (tag !== 42) {
-                        break;
-                    }
-                    message.sourceFeaturePermissionPublicIds.push(reader.string());
+                    message.iana = reader.string();
                     continue;
             }
             if ((tag & 7) === 4 || tag === 0) {
@@ -1622,20 +2665,29 @@ export const GrpcInputRolePermissionsAdd = {
         return message;
     },
 };
-function createBaseGrpcInputRolePermissionsRemove() {
-    return { publicRolePermissionIds: [] };
+function createBaseGrpcDtoIdentityGeoCurrency() {
+    return { publicId: "", code: "", name: "" };
 }
-export const GrpcInputRolePermissionsRemove = {
+export const GrpcDtoIdentityGeoCurrency = {
     encode(message, writer = _m0.Writer.create()) {
-        for (const v of message.publicRolePermissionIds) {
-            writer.uint32(10).string(v);
+        if (message.publicId !== "") {
+            writer.uint32(10).string(message.publicId);
+        }
+        if (message.code !== "") {
+            writer.uint32(18).string(message.code);
+        }
+        if (message.name !== "") {
+            writer.uint32(26).string(message.name);
+        }
+        if (message.symbol !== undefined) {
+            writer.uint32(34).string(message.symbol);
         }
         return writer;
     },
     decode(input, length) {
         const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
         let end = length === undefined ? reader.len : reader.pos + length;
-        const message = createBaseGrpcInputRolePermissionsRemove();
+        const message = createBaseGrpcDtoIdentityGeoCurrency();
         while (reader.pos < end) {
             const tag = reader.uint32();
             switch (tag >>> 3) {
@@ -1643,7 +2695,25 @@ export const GrpcInputRolePermissionsRemove = {
                     if (tag !== 10) {
                         break;
                     }
-                    message.publicRolePermissionIds.push(reader.string());
+                    message.publicId = reader.string();
+                    continue;
+                case 2:
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.code = reader.string();
+                    continue;
+                case 3:
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.name = reader.string();
+                    continue;
+                case 4:
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.symbol = reader.string();
                     continue;
             }
             if ((tag & 7) === 4 || tag === 0) {
@@ -1654,10 +2724,10 @@ export const GrpcInputRolePermissionsRemove = {
         return message;
     },
 };
-function createBaseGrpcDtoRole() {
-    return { publicId: "", name: "", isAgent: false, permissions: [], users: [] };
+function createBaseGrpcDtoIdentityUser() {
+    return { publicId: "", name: "", status: "" };
 }
-export const GrpcDtoRole = {
+export const GrpcDtoIdentityUser = {
     encode(message, writer = _m0.Writer.create()) {
         if (message.publicId !== "") {
             writer.uint32(10).string(message.publicId);
@@ -1665,39 +2735,24 @@ export const GrpcDtoRole = {
         if (message.name !== "") {
             writer.uint32(18).string(message.name);
         }
-        if (message.isAgent !== false) {
-            writer.uint32(24).bool(message.isAgent);
-        }
-        if (message.description !== undefined) {
-            writer.uint32(34).string(message.description);
-        }
-        if (message.createdAt !== undefined) {
-            Timestamp.encode(message.createdAt, writer.uint32(42).fork()).ldelim();
-        }
-        if (message.updatedAt !== undefined) {
-            Timestamp.encode(message.updatedAt, writer.uint32(50).fork()).ldelim();
+        if (message.status !== "") {
+            writer.uint32(26).string(message.status);
         }
-        if (message.deletedAt !== undefined) {
-            Timestamp.encode(message.deletedAt, writer.uint32(58).fork()).ldelim();
-        }
-        if (message.service !== undefined) {
-            GrpcDtoService.encode(message.service, writer.uint32(66).fork()).ldelim();
-        }
-        if (message.client !== undefined) {
-            GrpcDtoClient.encode(message.client, writer.uint32(74).fork()).ldelim();
+        if (message.language !== undefined) {
+            GrpcDtoIdentityGeoLanguage.encode(message.language, writer.uint32(34).fork()).ldelim();
         }
-        for (const v of message.permissions) {
-            GrpcDtoPermission.encode(v, writer.uint32(82).fork()).ldelim();
+        if (message.timezone !== undefined) {
+            GrpcDtoIdentityGeoTimezone.encode(message.timezone, writer.uint32(42).fork()).ldelim();
         }
-        for (const v of message.users) {
-            GrpcDtoUser.encode(v, writer.uint32(90).fork()).ldelim();
+        if (message.accountType !== undefined) {
+            GrpcDtoIdentityAccountType.encode(message.accountType, writer.uint32(50).fork()).ldelim();
         }
         return writer;
     },
     decode(input, length) {
         const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
         let end = length === undefined ? reader.len : reader.pos + length;
-        const message = createBaseGrpcDtoRole();
+        const message = createBaseGrpcDtoIdentityUser();
         while (reader.pos < end) {
             const tag = reader.uint32();
             switch (tag >>> 3) {
@@ -1714,58 +2769,69 @@ export const GrpcDtoRole = {
                     message.name = reader.string();
                     continue;
                 case 3:
-                    if (tag !== 24) {
+                    if (tag !== 26) {
                         break;
                     }
-                    message.isAgent = reader.bool();
+                    message.status = reader.string();
                     continue;
                 case 4:
                     if (tag !== 34) {
                         break;
                     }
-                    message.description = reader.string();
+                    message.language = GrpcDtoIdentityGeoLanguage.decode(reader, reader.uint32());
                     continue;
                 case 5:
                     if (tag !== 42) {
                         break;
                     }
-                    message.createdAt = Timestamp.decode(reader, reader.uint32());
+                    message.timezone = GrpcDtoIdentityGeoTimezone.decode(reader, reader.uint32());
                     continue;
                 case 6:
                     if (tag !== 50) {
                         break;
                     }
-                    message.updatedAt = Timestamp.decode(reader, reader.uint32());
-                    continue;
-                case 7:
-                    if (tag !== 58) {
-                        break;
-                    }
-                    message.deletedAt = Timestamp.decode(reader, reader.uint32());
-                    continue;
-                case 8:
-                    if (tag !== 66) {
-                        break;
-                    }
-                    message.service = GrpcDtoService.decode(reader, reader.uint32());
-                    continue;
-                case 9:
-                    if (tag !== 74) {
-                        break;
-                    }
-                    message.client = GrpcDtoClient.decode(reader, reader.uint32());
+                    message.accountType = GrpcDtoIdentityAccountType.decode(reader, reader.uint32());
                     continue;
-                case 10:
-                    if (tag !== 82) {
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    },
+};
+function createBaseGrpcDtoIdentityAccountType() {
+    return { publicId: "", name: "" };
+}
+export const GrpcDtoIdentityAccountType = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.publicId !== "") {
+            writer.uint32(10).string(message.publicId);
+        }
+        if (message.name !== "") {
+            writer.uint32(18).string(message.name);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseGrpcDtoIdentityAccountType();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
                         break;
                     }
-                    message.permissions.push(GrpcDtoPermission.decode(reader, reader.uint32()));
+                    message.publicId = reader.string();
                     continue;
-                case 11:
-                    if (tag !== 90) {
+                case 2:
+                    if (tag !== 18) {
                         break;
                     }
-                    message.users.push(GrpcDtoUser.decode(reader, reader.uint32()));
+                    message.name = reader.string();
                     continue;
             }
             if ((tag & 7) === 4 || tag === 0) {
@@ -1776,23 +2842,23 @@ export const GrpcDtoRole = {
         return message;
     },
 };
-function createBaseGrpcDtoRoles() {
-    return { items: [] };
+function createBaseGrpcDtoIdentityRole() {
+    return { publicId: "", name: "" };
 }
-export const GrpcDtoRoles = {
+export const GrpcDtoIdentityRole = {
     encode(message, writer = _m0.Writer.create()) {
-        for (const v of message.items) {
-            GrpcDtoRole.encode(v, writer.uint32(10).fork()).ldelim();
+        if (message.publicId !== "") {
+            writer.uint32(10).string(message.publicId);
         }
-        if (message.meta !== undefined) {
-            GrpcDtoPagination.encode(message.meta, writer.uint32(18).fork()).ldelim();
+        if (message.name !== "") {
+            writer.uint32(18).string(message.name);
         }
         return writer;
     },
     decode(input, length) {
         const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
         let end = length === undefined ? reader.len : reader.pos + length;
-        const message = createBaseGrpcDtoRoles();
+        const message = createBaseGrpcDtoIdentityRole();
         while (reader.pos < end) {
             const tag = reader.uint32();
             switch (tag >>> 3) {
@@ -1800,13 +2866,13 @@ export const GrpcDtoRoles = {
                     if (tag !== 10) {
                         break;
                     }
-                    message.items.push(GrpcDtoRole.decode(reader, reader.uint32()));
+                    message.publicId = reader.string();
                     continue;
                 case 2:
                     if (tag !== 18) {
                         break;
                     }
-                    message.meta = GrpcDtoPagination.decode(reader, reader.uint32());
+                    message.name = reader.string();
                     continue;
             }
             if ((tag & 7) === 4 || tag === 0) {
@@ -1817,20 +2883,20 @@ export const GrpcDtoRoles = {
         return message;
     },
 };
-function createBaseGrpcDtoUserRole() {
-    return {};
+function createBaseGrpcDtoIdentityAgent() {
+    return { userPublicId: "" };
 }
-export const GrpcDtoUserRole = {
+export const GrpcDtoIdentityAgent = {
     encode(message, writer = _m0.Writer.create()) {
-        if (message.role !== undefined) {
-            GrpcDtoRole.encode(message.role, writer.uint32(10).fork()).ldelim();
+        if (message.userPublicId !== "") {
+            writer.uint32(10).string(message.userPublicId);
         }
         return writer;
     },
     decode(input, length) {
         const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
         let end = length === undefined ? reader.len : reader.pos + length;
-        const message = createBaseGrpcDtoUserRole();
+        const message = createBaseGrpcDtoIdentityAgent();
         while (reader.pos < end) {
             const tag = reader.uint32();
             switch (tag >>> 3) {
@@ -1838,7 +2904,7 @@ export const GrpcDtoUserRole = {
                     if (tag !== 10) {
                         break;
                     }
-                    message.role = GrpcDtoRole.decode(reader, reader.uint32());
+                    message.userPublicId = reader.string();
                     continue;
             }
             if ((tag & 7) === 4 || tag === 0) {
@@ -1849,44 +2915,35 @@ export const GrpcDtoUserRole = {
         return message;
     },
 };
-function createBaseGrpcDtoUser() {
-    return { publicId: "", email: "", phone: "", isEmailVerified: false, roles: [] };
+function createBaseGrpcDtoIdentityClient() {
+    return { publicId: "", name: "", type: "", managingVendors: [] };
 }
-export const GrpcDtoUser = {
+export const GrpcDtoIdentityClient = {
     encode(message, writer = _m0.Writer.create()) {
         if (message.publicId !== "") {
             writer.uint32(10).string(message.publicId);
         }
-        if (message.email !== "") {
-            writer.uint32(18).string(message.email);
-        }
-        if (message.phone !== "") {
-            writer.uint32(26).string(message.phone);
-        }
-        if (message.isEmailVerified !== false) {
-            writer.uint32(32).bool(message.isEmailVerified);
-        }
-        if (message.displayName !== undefined) {
-            writer.uint32(42).string(message.displayName);
+        if (message.name !== "") {
+            writer.uint32(18).string(message.name);
         }
-        if (message.createdAt !== undefined) {
-            Timestamp.encode(message.createdAt, writer.uint32(50).fork()).ldelim();
+        if (message.type !== "") {
+            writer.uint32(26).string(message.type);
         }
-        if (message.updatedAt !== undefined) {
-            Timestamp.encode(message.updatedAt, writer.uint32(58).fork()).ldelim();
+        if (message.isIndependentVendor !== undefined) {
+            writer.uint32(34).string(message.isIndependentVendor);
         }
-        if (message.deletedAt !== undefined) {
-            Timestamp.encode(message.deletedAt, writer.uint32(66).fork()).ldelim();
+        if (message.managedBy !== undefined) {
+            GrpcDtoIdentityManagedBy.encode(message.managedBy, writer.uint32(42).fork()).ldelim();
         }
-        for (const v of message.roles) {
-            GrpcDtoUserRole.encode(v, writer.uint32(74).fork()).ldelim();
+        for (const v of message.managingVendors) {
+            GrpcDtoIdentityManagingVendor.encode(v, writer.uint32(50).fork()).ldelim();
         }
         return writer;
     },
     decode(input, length) {
         const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
         let end = length === undefined ? reader.len : reader.pos + length;
-        const message = createBaseGrpcDtoUser();
+        const message = createBaseGrpcDtoIdentityClient();
         while (reader.pos < end) {
             const tag = reader.uint32();
             switch (tag >>> 3) {
@@ -1900,49 +2957,95 @@ export const GrpcDtoUser = {
                     if (tag !== 18) {
                         break;
                     }
-                    message.email = reader.string();
+                    message.name = reader.string();
                     continue;
                 case 3:
                     if (tag !== 26) {
                         break;
                     }
-                    message.phone = reader.string();
+                    message.type = reader.string();
                     continue;
                 case 4:
-                    if (tag !== 32) {
+                    if (tag !== 34) {
                         break;
                     }
-                    message.isEmailVerified = reader.bool();
+                    message.isIndependentVendor = reader.string();
                     continue;
                 case 5:
                     if (tag !== 42) {
                         break;
                     }
-                    message.displayName = reader.string();
+                    message.managedBy = GrpcDtoIdentityManagedBy.decode(reader, reader.uint32());
                     continue;
                 case 6:
                     if (tag !== 50) {
                         break;
                     }
-                    message.createdAt = Timestamp.decode(reader, reader.uint32());
-                    continue;
-                case 7:
-                    if (tag !== 58) {
-                        break;
-                    }
-                    message.updatedAt = Timestamp.decode(reader, reader.uint32());
+                    message.managingVendors.push(GrpcDtoIdentityManagingVendor.decode(reader, reader.uint32()));
                     continue;
-                case 8:
-                    if (tag !== 66) {
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    },
+};
+function createBaseGrpcDtoIdentityManagedBy() {
+    return { clientPublicId: "" };
+}
+export const GrpcDtoIdentityManagedBy = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.clientPublicId !== "") {
+            writer.uint32(10).string(message.clientPublicId);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseGrpcDtoIdentityManagedBy();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
                         break;
                     }
-                    message.deletedAt = Timestamp.decode(reader, reader.uint32());
+                    message.clientPublicId = reader.string();
                     continue;
-                case 9:
-                    if (tag !== 74) {
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    },
+};
+function createBaseGrpcDtoIdentityManagingVendor() {
+    return { userPublicId: "" };
+}
+export const GrpcDtoIdentityManagingVendor = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.userPublicId !== "") {
+            writer.uint32(10).string(message.userPublicId);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseGrpcDtoIdentityManagingVendor();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
                         break;
                     }
-                    message.roles.push(GrpcDtoUserRole.decode(reader, reader.uint32()));
+                    message.userPublicId = reader.string();
                     continue;
             }
             if ((tag & 7) === 4 || tag === 0) {
@@ -1956,22 +3059,19 @@ export const GrpcDtoUser = {
 export function AuthServiceControllerMethods() {
     return function (constructor) {
         const grpcMethods = [
-            "authenticate",
-            "authorize",
             "permissionsSeed",
             "permissions",
             "permission",
-            "getVendorFeatures",
-            "getFeaturePermissions",
             "roles",
             "role",
+            "rolePermissions",
             "roleCreate",
             "roleUpdate",
             "rolesRecycle",
             "rolesRestore",
-            "rolePermissions",
             "rolePermissionsAdd",
             "rolePermissionsRemove",
+            "authNz",
         ];
         for (const method of grpcMethods) {
             const descriptor = Reflect.getOwnPropertyDescriptor(constructor.prototype, method);
@@ -1986,26 +3086,7 @@ export function AuthServiceControllerMethods() {
 }
 export const AUTH_SERVICE_NAME = "AuthService";
 export const AuthServiceService = {
-    /** --- authz --- */
-    authenticate: {
-        path: "/aegis.auth.v1.AuthService/Authenticate",
-        requestStream: false,
-        responseStream: false,
-        requestSerialize: (value) => Buffer.from(GrpcInputAuthenticate.encode(value).finish()),
-        requestDeserialize: (value) => GrpcInputAuthenticate.decode(value),
-        responseSerialize: (value) => Buffer.from(GrpcDtoAuthenticate.encode(value).finish()),
-        responseDeserialize: (value) => GrpcDtoAuthenticate.decode(value),
-    },
-    authorize: {
-        path: "/aegis.auth.v1.AuthService/Authorize",
-        requestStream: false,
-        responseStream: false,
-        requestSerialize: (value) => Buffer.from(GrpcInputAuthorize.encode(value).finish()),
-        requestDeserialize: (value) => GrpcInputAuthorize.decode(value),
-        responseSerialize: (value) => Buffer.from(GrpcDtoAuthorize.encode(value).finish()),
-        responseDeserialize: (value) => GrpcDtoAuthorize.decode(value),
-    },
-    /** --- permission --- */
+    /** PERMISSION */
     permissionsSeed: {
         path: "/aegis.auth.v1.AuthService/PermissionsSeed",
         requestStream: false,
@@ -2033,25 +3114,7 @@ export const AuthServiceService = {
         responseSerialize: (value) => Buffer.from(GrpcDtoPermission.encode(value).finish()),
         responseDeserialize: (value) => GrpcDtoPermission.decode(value),
     },
-    getVendorFeatures: {
-        path: "/aegis.auth.v1.AuthService/GetVendorFeatures",
-        requestStream: false,
-        responseStream: false,
-        requestSerialize: (value) => Buffer.from(GrpcInputVendorFeatures.encode(value).finish()),
-        requestDeserialize: (value) => GrpcInputVendorFeatures.decode(value),
-        responseSerialize: (value) => Buffer.from(GrpcDtoVendorFeatures.encode(value).finish()),
-        responseDeserialize: (value) => GrpcDtoVendorFeatures.decode(value),
-    },
-    getFeaturePermissions: {
-        path: "/aegis.auth.v1.AuthService/GetFeaturePermissions",
-        requestStream: false,
-        responseStream: false,
-        requestSerialize: (value) => Buffer.from(GrpcInputGetFeaturePermissions.encode(value).finish()),
-        requestDeserialize: (value) => GrpcInputGetFeaturePermissions.decode(value),
-        responseSerialize: (value) => Buffer.from(GrpcDtoFeaturePermissions.encode(value).finish()),
-        responseDeserialize: (value) => GrpcDtoFeaturePermissions.decode(value),
-    },
-    /** --- role --- */
+    /** ROLE */
     roles: {
         path: "/aegis.auth.v1.AuthService/Roles",
         requestStream: false,
@@ -2070,6 +3133,15 @@ export const AuthServiceService = {
         responseSerialize: (value) => Buffer.from(GrpcDtoRole.encode(value).finish()),
         responseDeserialize: (value) => GrpcDtoRole.decode(value),
     },
+    rolePermissions: {
+        path: "/aegis.auth.v1.AuthService/RolePermissions",
+        requestStream: false,
+        responseStream: false,
+        requestSerialize: (value) => Buffer.from(GrpcInputRolePermissions.encode(value).finish()),
+        requestDeserialize: (value) => GrpcInputRolePermissions.decode(value),
+        responseSerialize: (value) => Buffer.from(GrpcDtoRolePermissions.encode(value).finish()),
+        responseDeserialize: (value) => GrpcDtoRolePermissions.decode(value),
+    },
     roleCreate: {
         path: "/aegis.auth.v1.AuthService/RoleCreate",
         requestStream: false,
@@ -2106,15 +3178,6 @@ export const AuthServiceService = {
         responseSerialize: (value) => Buffer.from(GrpcDtoMessage.encode(value).finish()),
         responseDeserialize: (value) => GrpcDtoMessage.decode(value),
     },
-    rolePermissions: {
-        path: "/aegis.auth.v1.AuthService/RolePermissions",
-        requestStream: false,
-        responseStream: false,
-        requestSerialize: (value) => Buffer.from(GrpcInputRolePermissions.encode(value).finish()),
-        requestDeserialize: (value) => GrpcInputRolePermissions.decode(value),
-        responseSerialize: (value) => Buffer.from(GrpcDtoRolePermissions.encode(value).finish()),
-        responseDeserialize: (value) => GrpcDtoRolePermissions.decode(value),
-    },
     rolePermissionsAdd: {
         path: "/aegis.auth.v1.AuthService/RolePermissionsAdd",
         requestStream: false,
@@ -2133,4 +3196,14 @@ export const AuthServiceService = {
         responseSerialize: (value) => Buffer.from(GrpcDtoMessage.encode(value).finish()),
         responseDeserialize: (value) => GrpcDtoMessage.decode(value),
     },
+    /** AUTH-Z */
+    authNz: {
+        path: "/aegis.auth.v1.AuthService/AuthNZ",
+        requestStream: false,
+        responseStream: false,
+        requestSerialize: (value) => Buffer.from(GrpcInputAuthNZ.encode(value).finish()),
+        requestDeserialize: (value) => GrpcInputAuthNZ.decode(value),
+        responseSerialize: (value) => Buffer.from(GrpcDtoAuthNZ.encode(value).finish()),
+        responseDeserialize: (value) => GrpcDtoAuthNZ.decode(value),
+    },
 };