@acequants/aegis-contracts 0.1.29 → 0.1.31

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

@@ -6,99 +6,9 @@
 import { GrpcMethod, GrpcStreamMethod } from "@nestjs/microservices";
 import _m0 from "protobufjs/minimal";
 import { Timestamp } from "../../google/protobuf/timestamp";
+import { GrpcDtoMessage, GrpcDtoPagination, GrpcDtoPermission, GrpcDtoPermissionsAdd } from "../../shared/v1/shared";
 export const protobufPackage = "aegis.system.v1";
 export const AEGIS_SYSTEM_V1_PACKAGE_NAME = "aegis.system.v1";
-function createBaseGrpcDtoPagination() {
-    return { totalItems: 0, totalPages: 0, currentPage: 0, pageSize: 0 };
-}
-export const GrpcDtoPagination = {
-    encode(message, writer = _m0.Writer.create()) {
-        if (message.totalItems !== 0) {
-            writer.uint32(8).int32(message.totalItems);
-        }
-        if (message.totalPages !== 0) {
-            writer.uint32(16).int32(message.totalPages);
-        }
-        if (message.currentPage !== 0) {
-            writer.uint32(24).int32(message.currentPage);
-        }
-        if (message.pageSize !== 0) {
-            writer.uint32(32).int32(message.pageSize);
-        }
-        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 = createBaseGrpcDtoPagination();
-        while (reader.pos < end) {
-            const tag = reader.uint32();
-            switch (tag >>> 3) {
-                case 1:
-                    if (tag !== 8) {
-                        break;
-                    }
-                    message.totalItems = reader.int32();
-                    continue;
-                case 2:
-                    if (tag !== 16) {
-                        break;
-                    }
-                    message.totalPages = reader.int32();
-                    continue;
-                case 3:
-                    if (tag !== 24) {
-                        break;
-                    }
-                    message.currentPage = reader.int32();
-                    continue;
-                case 4:
-                    if (tag !== 32) {
-                        break;
-                    }
-                    message.pageSize = reader.int32();
-                    continue;
-            }
-            if ((tag & 7) === 4 || tag === 0) {
-                break;
-            }
-            reader.skipType(tag & 7);
-        }
-        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 createBaseGrpcInputClientTypeSeed() {
     return { name: "" };
 }
@@ -709,83 +619,654 @@ export const GrpcDtoUserAccountTypes = {
         return message;
     },
 };
-export function SystemServiceControllerMethods() {
-    return function (constructor) {
-        const grpcMethods = [
-            "clientTypesSeed",
-            "clientTypes",
-            "clientType",
-            "userAccountTypesSeed",
-            "userAccountTypes",
-            "userAccountType",
-        ];
-        for (const method of grpcMethods) {
-            const descriptor = Reflect.getOwnPropertyDescriptor(constructor.prototype, method);
-            GrpcMethod("SystemService", method)(constructor.prototype[method], method, descriptor);
+function createBaseGrpcInputFeatureSeed() {
+    return { name: "" };
+}
+export const GrpcInputFeatureSeed = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.name !== "") {
+            writer.uint32(10).string(message.name);
         }
-        const grpcStreamMethods = [];
-        for (const method of grpcStreamMethods) {
-            const descriptor = Reflect.getOwnPropertyDescriptor(constructor.prototype, method);
-            GrpcStreamMethod("SystemService", method)(constructor.prototype[method], method, descriptor);
+        if (message.description !== undefined) {
+            writer.uint32(18).string(message.description);
         }
-    };
+        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 = createBaseGrpcInputFeatureSeed();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.name = reader.string();
+                    continue;
+                case 2:
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.description = reader.string();
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    },
+};
+function createBaseGrpcInputFeaturesSeed() {
+    return { features: [] };
 }
-export const SYSTEM_SERVICE_NAME = "SystemService";
-export const SystemServiceService = {
-    /** --- Client Type --- */
-    clientTypesSeed: {
-        path: "/aegis.system.v1.SystemService/ClientTypesSeed",
-        requestStream: false,
-        responseStream: false,
-        requestSerialize: (value) => Buffer.from(GrpcInputClientTypesSeed.encode(value).finish()),
-        requestDeserialize: (value) => GrpcInputClientTypesSeed.decode(value),
-        responseSerialize: (value) => Buffer.from(GrpcDtoClientTypesSeed.encode(value).finish()),
-        responseDeserialize: (value) => GrpcDtoClientTypesSeed.decode(value),
+export const GrpcInputFeaturesSeed = {
+    encode(message, writer = _m0.Writer.create()) {
+        for (const v of message.features) {
+            GrpcInputFeatureSeed.encode(v, writer.uint32(10).fork()).ldelim();
+        }
+        return writer;
     },
-    clientTypes: {
-        path: "/aegis.system.v1.SystemService/ClientTypes",
-        requestStream: false,
-        responseStream: false,
-        requestSerialize: (value) => Buffer.from(GrpcInputClientTypes.encode(value).finish()),
-        requestDeserialize: (value) => GrpcInputClientTypes.decode(value),
-        responseSerialize: (value) => Buffer.from(GrpcDtoClientTypes.encode(value).finish()),
-        responseDeserialize: (value) => GrpcDtoClientTypes.decode(value),
+    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 = createBaseGrpcInputFeaturesSeed();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.features.push(GrpcInputFeatureSeed.decode(reader, reader.uint32()));
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
     },
-    clientType: {
-        path: "/aegis.system.v1.SystemService/ClientType",
-        requestStream: false,
-        responseStream: false,
-        requestSerialize: (value) => Buffer.from(GrpcInputClientType.encode(value).finish()),
-        requestDeserialize: (value) => GrpcInputClientType.decode(value),
-        responseSerialize: (value) => Buffer.from(GrpcDtoClientType.encode(value).finish()),
-        responseDeserialize: (value) => GrpcDtoClientType.decode(value),
+};
+function createBaseGrpcInputFeature() {
+    return { publicId: "" };
+}
+export const GrpcInputFeature = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.publicId !== "") {
+            writer.uint32(10).string(message.publicId);
+        }
+        return writer;
     },
-    /** --- User Account Type --- */
-    userAccountTypesSeed: {
-        path: "/aegis.system.v1.SystemService/UserAccountTypesSeed",
-        requestStream: false,
-        responseStream: false,
-        requestSerialize: (value) => Buffer.from(GrpcInputUserAccountTypesSeed.encode(value).finish()),
-        requestDeserialize: (value) => GrpcInputUserAccountTypesSeed.decode(value),
-        responseSerialize: (value) => Buffer.from(GrpcDtoUserAccountTypesSeed.encode(value).finish()),
-        responseDeserialize: (value) => GrpcDtoUserAccountTypesSeed.decode(value),
+    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 = createBaseGrpcInputFeature();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.publicId = reader.string();
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
     },
-    userAccountTypes: {
-        path: "/aegis.system.v1.SystemService/UserAccountTypes",
-        requestStream: false,
-        responseStream: false,
-        requestSerialize: (value) => Buffer.from(GrpcInputUserAccountTypes.encode(value).finish()),
-        requestDeserialize: (value) => GrpcInputUserAccountTypes.decode(value),
-        responseSerialize: (value) => Buffer.from(GrpcDtoUserAccountTypes.encode(value).finish()),
-        responseDeserialize: (value) => GrpcDtoUserAccountTypes.decode(value),
+};
+function createBaseGrpcInputFeatures() {
+    return {};
+}
+export const GrpcInputFeatures = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.search !== undefined) {
+            writer.uint32(10).string(message.search);
+        }
+        if (message.page !== undefined) {
+            writer.uint32(16).int32(message.page);
+        }
+        if (message.pageSize !== undefined) {
+            writer.uint32(24).int32(message.pageSize);
+        }
+        if (message.sortBy !== undefined) {
+            writer.uint32(34).string(message.sortBy);
+        }
+        if (message.sortOrder !== undefined) {
+            writer.uint32(42).string(message.sortOrder);
+        }
+        return writer;
     },
-    userAccountType: {
-        path: "/aegis.system.v1.SystemService/UserAccountType",
-        requestStream: false,
-        responseStream: false,
-        requestSerialize: (value) => Buffer.from(GrpcInputUserAccountType.encode(value).finish()),
-        requestDeserialize: (value) => GrpcInputUserAccountType.decode(value),
-        responseSerialize: (value) => Buffer.from(GrpcDtoUserAccountType.encode(value).finish()),
-        responseDeserialize: (value) => GrpcDtoUserAccountType.decode(value),
+    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 = createBaseGrpcInputFeatures();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.search = reader.string();
+                    continue;
+                case 2:
+                    if (tag !== 16) {
+                        break;
+                    }
+                    message.page = reader.int32();
+                    continue;
+                case 3:
+                    if (tag !== 24) {
+                        break;
+                    }
+                    message.pageSize = reader.int32();
+                    continue;
+                case 4:
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.sortBy = reader.string();
+                    continue;
+                case 5:
+                    if (tag !== 42) {
+                        break;
+                    }
+                    message.sortOrder = reader.string();
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    },
+};
+function createBaseGrpcDtoFeature() {
+    return { publicId: "", name: "" };
+}
+export const GrpcDtoFeature = {
+    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.createdAt !== undefined) {
+            Timestamp.encode(message.createdAt, writer.uint32(34).fork()).ldelim();
+        }
+        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) {
+        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseGrpcDtoFeature();
+        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.name = reader.string();
+                    continue;
+                case 3:
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.description = reader.string();
+                    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;
+                case 6:
+                    if (tag !== 50) {
+                        break;
+                    }
+                    message.deletedAt = Timestamp.decode(reader, reader.uint32());
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    },
+};
+function createBaseGrpcDtoFeaturesSeed() {
+    return { features: [] };
+}
+export const GrpcDtoFeaturesSeed = {
+    encode(message, writer = _m0.Writer.create()) {
+        for (const v of message.features) {
+            GrpcDtoFeature.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 = createBaseGrpcDtoFeaturesSeed();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.features.push(GrpcDtoFeature.decode(reader, reader.uint32()));
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    },
+};
+function createBaseGrpcDtoFeatures() {
+    return { items: [] };
+}
+export const GrpcDtoFeatures = {
+    encode(message, writer = _m0.Writer.create()) {
+        for (const v of message.items) {
+            GrpcDtoFeature.encode(v, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.meta !== undefined) {
+            GrpcDtoPagination.encode(message.meta, 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 = createBaseGrpcDtoFeatures();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.items.push(GrpcDtoFeature.decode(reader, reader.uint32()));
+                    continue;
+                case 2:
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.meta = GrpcDtoPagination.decode(reader, reader.uint32());
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    },
+};
+function createBaseGrpcInputFeaturePermissionsAdd() {
+    return { publicId: "", permissionIds: [] };
+}
+export const GrpcInputFeaturePermissionsAdd = {
+    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);
+        }
+        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 = createBaseGrpcInputFeaturePermissionsAdd();
+        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.permissionIds.push(reader.string());
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    },
+};
+function createBaseGrpcInputFeaturePermissionsRemove() {
+    return { publicFeaturePermissionIds: [] };
+}
+export const GrpcInputFeaturePermissionsRemove = {
+    encode(message, writer = _m0.Writer.create()) {
+        for (const v of message.publicFeaturePermissionIds) {
+            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 = createBaseGrpcInputFeaturePermissionsRemove();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.publicFeaturePermissionIds.push(reader.string());
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    },
+};
+function createBaseGrpcInputFeaturePermissions() {
+    return { featurePublicId: "" };
+}
+export const GrpcInputFeaturePermissions = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.featurePublicId !== "") {
+            writer.uint32(10).string(message.featurePublicId);
+        }
+        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 = createBaseGrpcInputFeaturePermissions();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.featurePublicId = reader.string();
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    },
+};
+function createBaseGrpcDtoFeaturePermission() {
+    return { publicId: "" };
+}
+export const GrpcDtoFeaturePermission = {
+    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.feature !== undefined) {
+            GrpcDtoFeature.encode(message.feature, 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 = createBaseGrpcDtoFeaturePermission();
+        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.permission = GrpcDtoPermission.decode(reader, reader.uint32());
+                    continue;
+                case 3:
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.feature = GrpcDtoFeature.decode(reader, reader.uint32());
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    },
+};
+function createBaseGrpcDtoFeaturePermissions() {
+    return { featurePermissions: [] };
+}
+export const GrpcDtoFeaturePermissions = {
+    encode(message, writer = _m0.Writer.create()) {
+        for (const v of message.featurePermissions) {
+            GrpcDtoFeaturePermission.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 = createBaseGrpcDtoFeaturePermissions();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.featurePermissions.push(GrpcDtoFeaturePermission.decode(reader, reader.uint32()));
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    },
+};
+export function SystemServiceControllerMethods() {
+    return function (constructor) {
+        const grpcMethods = [
+            "clientTypesSeed",
+            "clientTypes",
+            "clientType",
+            "userAccountTypesSeed",
+            "userAccountTypes",
+            "userAccountType",
+            "featuresSeed",
+            "features",
+            "feature",
+            "featurePermissions",
+            "featurePermissionsAdd",
+            "featurePermissionsRemove",
+        ];
+        for (const method of grpcMethods) {
+            const descriptor = Reflect.getOwnPropertyDescriptor(constructor.prototype, method);
+            GrpcMethod("SystemService", method)(constructor.prototype[method], method, descriptor);
+        }
+        const grpcStreamMethods = [];
+        for (const method of grpcStreamMethods) {
+            const descriptor = Reflect.getOwnPropertyDescriptor(constructor.prototype, method);
+            GrpcStreamMethod("SystemService", method)(constructor.prototype[method], method, descriptor);
+        }
+    };
+}
+export const SYSTEM_SERVICE_NAME = "SystemService";
+export const SystemServiceService = {
+    /** --- Client Type --- */
+    clientTypesSeed: {
+        path: "/aegis.system.v1.SystemService/ClientTypesSeed",
+        requestStream: false,
+        responseStream: false,
+        requestSerialize: (value) => Buffer.from(GrpcInputClientTypesSeed.encode(value).finish()),
+        requestDeserialize: (value) => GrpcInputClientTypesSeed.decode(value),
+        responseSerialize: (value) => Buffer.from(GrpcDtoClientTypesSeed.encode(value).finish()),
+        responseDeserialize: (value) => GrpcDtoClientTypesSeed.decode(value),
+    },
+    clientTypes: {
+        path: "/aegis.system.v1.SystemService/ClientTypes",
+        requestStream: false,
+        responseStream: false,
+        requestSerialize: (value) => Buffer.from(GrpcInputClientTypes.encode(value).finish()),
+        requestDeserialize: (value) => GrpcInputClientTypes.decode(value),
+        responseSerialize: (value) => Buffer.from(GrpcDtoClientTypes.encode(value).finish()),
+        responseDeserialize: (value) => GrpcDtoClientTypes.decode(value),
+    },
+    clientType: {
+        path: "/aegis.system.v1.SystemService/ClientType",
+        requestStream: false,
+        responseStream: false,
+        requestSerialize: (value) => Buffer.from(GrpcInputClientType.encode(value).finish()),
+        requestDeserialize: (value) => GrpcInputClientType.decode(value),
+        responseSerialize: (value) => Buffer.from(GrpcDtoClientType.encode(value).finish()),
+        responseDeserialize: (value) => GrpcDtoClientType.decode(value),
+    },
+    /** --- User Account Type --- */
+    userAccountTypesSeed: {
+        path: "/aegis.system.v1.SystemService/UserAccountTypesSeed",
+        requestStream: false,
+        responseStream: false,
+        requestSerialize: (value) => Buffer.from(GrpcInputUserAccountTypesSeed.encode(value).finish()),
+        requestDeserialize: (value) => GrpcInputUserAccountTypesSeed.decode(value),
+        responseSerialize: (value) => Buffer.from(GrpcDtoUserAccountTypesSeed.encode(value).finish()),
+        responseDeserialize: (value) => GrpcDtoUserAccountTypesSeed.decode(value),
+    },
+    userAccountTypes: {
+        path: "/aegis.system.v1.SystemService/UserAccountTypes",
+        requestStream: false,
+        responseStream: false,
+        requestSerialize: (value) => Buffer.from(GrpcInputUserAccountTypes.encode(value).finish()),
+        requestDeserialize: (value) => GrpcInputUserAccountTypes.decode(value),
+        responseSerialize: (value) => Buffer.from(GrpcDtoUserAccountTypes.encode(value).finish()),
+        responseDeserialize: (value) => GrpcDtoUserAccountTypes.decode(value),
+    },
+    userAccountType: {
+        path: "/aegis.system.v1.SystemService/UserAccountType",
+        requestStream: false,
+        responseStream: false,
+        requestSerialize: (value) => Buffer.from(GrpcInputUserAccountType.encode(value).finish()),
+        requestDeserialize: (value) => GrpcInputUserAccountType.decode(value),
+        responseSerialize: (value) => Buffer.from(GrpcDtoUserAccountType.encode(value).finish()),
+        responseDeserialize: (value) => GrpcDtoUserAccountType.decode(value),
+    },
+    /** --- Feature --- */
+    featuresSeed: {
+        path: "/aegis.system.v1.SystemService/FeaturesSeed",
+        requestStream: false,
+        responseStream: false,
+        requestSerialize: (value) => Buffer.from(GrpcInputFeaturesSeed.encode(value).finish()),
+        requestDeserialize: (value) => GrpcInputFeaturesSeed.decode(value),
+        responseSerialize: (value) => Buffer.from(GrpcDtoFeaturesSeed.encode(value).finish()),
+        responseDeserialize: (value) => GrpcDtoFeaturesSeed.decode(value),
+    },
+    features: {
+        path: "/aegis.system.v1.SystemService/Features",
+        requestStream: false,
+        responseStream: false,
+        requestSerialize: (value) => Buffer.from(GrpcInputFeatures.encode(value).finish()),
+        requestDeserialize: (value) => GrpcInputFeatures.decode(value),
+        responseSerialize: (value) => Buffer.from(GrpcDtoFeatures.encode(value).finish()),
+        responseDeserialize: (value) => GrpcDtoFeatures.decode(value),
+    },
+    feature: {
+        path: "/aegis.system.v1.SystemService/Feature",
+        requestStream: false,
+        responseStream: false,
+        requestSerialize: (value) => Buffer.from(GrpcInputFeature.encode(value).finish()),
+        requestDeserialize: (value) => GrpcInputFeature.decode(value),
+        responseSerialize: (value) => Buffer.from(GrpcDtoFeature.encode(value).finish()),
+        responseDeserialize: (value) => GrpcDtoFeature.decode(value),
+    },
+    featurePermissions: {
+        path: "/aegis.system.v1.SystemService/FeaturePermissions",
+        requestStream: false,
+        responseStream: false,
+        requestSerialize: (value) => Buffer.from(GrpcInputFeaturePermissions.encode(value).finish()),
+        requestDeserialize: (value) => GrpcInputFeaturePermissions.decode(value),
+        responseSerialize: (value) => Buffer.from(GrpcDtoFeaturePermissions.encode(value).finish()),
+        responseDeserialize: (value) => GrpcDtoFeaturePermissions.decode(value),
+    },
+    featurePermissionsAdd: {
+        path: "/aegis.system.v1.SystemService/FeaturePermissionsAdd",
+        requestStream: false,
+        responseStream: false,
+        requestSerialize: (value) => Buffer.from(GrpcInputFeaturePermissionsAdd.encode(value).finish()),
+        requestDeserialize: (value) => GrpcInputFeaturePermissionsAdd.decode(value),
+        responseSerialize: (value) => Buffer.from(GrpcDtoPermissionsAdd.encode(value).finish()),
+        responseDeserialize: (value) => GrpcDtoPermissionsAdd.decode(value),
+    },
+    featurePermissionsRemove: {
+        path: "/aegis.system.v1.SystemService/FeaturePermissionsRemove",
+        requestStream: false,
+        responseStream: false,
+        requestSerialize: (value) => Buffer.from(GrpcInputFeaturePermissionsRemove.encode(value).finish()),
+        requestDeserialize: (value) => GrpcInputFeaturePermissionsRemove.decode(value),
+        responseSerialize: (value) => Buffer.from(GrpcDtoMessage.encode(value).finish()),
+        responseDeserialize: (value) => GrpcDtoMessage.decode(value),
     },
 };