@acequants/aegis-contracts 0.1.32 → 0.1.34

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

@@ -1328,6 +1328,597 @@ export const GrpcDtoFeaturePermissions = {
         return message;
     },
 };
+function createBaseGrpcInputClientCreate() {
+    return { clientTypePublicId: "", name: "" };
+}
+export const GrpcInputClientCreate = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.clientTypePublicId !== "") {
+            writer.uint32(10).string(message.clientTypePublicId);
+        }
+        if (message.name !== "") {
+            writer.uint32(18).string(message.name);
+        }
+        if (message.managerPublicId !== undefined) {
+            writer.uint32(26).string(message.managerPublicId);
+        }
+        if (message.description !== undefined) {
+            writer.uint32(34).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 = createBaseGrpcInputClientCreate();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.clientTypePublicId = reader.string();
+                    continue;
+                case 2:
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.name = reader.string();
+                    continue;
+                case 3:
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.managerPublicId = reader.string();
+                    continue;
+                case 4:
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.description = reader.string();
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    },
+};
+function createBaseGrpcInputClientUpdate() {
+    return { publicId: "" };
+}
+export const GrpcInputClientUpdate = {
+    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.clientTypePublicId !== undefined) {
+            writer.uint32(34).string(message.clientTypePublicId);
+        }
+        if (message.managerPublicId !== undefined) {
+            writer.uint32(42).string(message.managerPublicId);
+        }
+        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 = createBaseGrpcInputClientUpdate();
+        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.clientTypePublicId = reader.string();
+                    continue;
+                case 5:
+                    if (tag !== 42) {
+                        break;
+                    }
+                    message.managerPublicId = reader.string();
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    },
+};
+function createBaseGrpcInputClientFeaturesAdd() {
+    return { publicId: "", featureIds: [] };
+}
+export const GrpcInputClientFeaturesAdd = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.publicId !== "") {
+            writer.uint32(10).string(message.publicId);
+        }
+        for (const v of message.featureIds) {
+            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 = createBaseGrpcInputClientFeaturesAdd();
+        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.featureIds.push(reader.string());
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    },
+};
+function createBaseGrpcInputClientFeaturesRemove() {
+    return { publicClientFeatureIds: [] };
+}
+export const GrpcInputClientFeaturesRemove = {
+    encode(message, writer = _m0.Writer.create()) {
+        for (const v of message.publicClientFeatureIds) {
+            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 = createBaseGrpcInputClientFeaturesRemove();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.publicClientFeatureIds.push(reader.string());
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    },
+};
+function createBaseGrpcInputClient() {
+    return { publicId: "" };
+}
+export const GrpcInputClient = {
+    encode(message, writer = _m0.Writer.create()) {
+        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 = createBaseGrpcInputClient();
+        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;
+    },
+};
+function createBaseGrpcInputClientFeatures() {
+    return { clientPublicId: "" };
+}
+export const GrpcInputClientFeatures = {
+    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 = createBaseGrpcInputClientFeatures();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.clientPublicId = reader.string();
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    },
+};
+function createBaseGrpcInputClients() {
+    return {};
+}
+export const GrpcInputClients = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.clientTypePublicId !== undefined) {
+            writer.uint32(10).string(message.clientTypePublicId);
+        }
+        if (message.managerPublicId !== undefined) {
+            writer.uint32(18).string(message.managerPublicId);
+        }
+        if (message.search !== undefined) {
+            writer.uint32(26).string(message.search);
+        }
+        if (message.page !== undefined) {
+            writer.uint32(32).int32(message.page);
+        }
+        if (message.pageSize !== undefined) {
+            writer.uint32(40).int32(message.pageSize);
+        }
+        if (message.sortBy !== undefined) {
+            writer.uint32(50).string(message.sortBy);
+        }
+        if (message.sortOrder !== undefined) {
+            writer.uint32(58).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 = createBaseGrpcInputClients();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.clientTypePublicId = reader.string();
+                    continue;
+                case 2:
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.managerPublicId = reader.string();
+                    continue;
+                case 3:
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.search = reader.string();
+                    continue;
+                case 4:
+                    if (tag !== 32) {
+                        break;
+                    }
+                    message.page = reader.int32();
+                    continue;
+                case 5:
+                    if (tag !== 40) {
+                        break;
+                    }
+                    message.pageSize = reader.int32();
+                    continue;
+                case 6:
+                    if (tag !== 50) {
+                        break;
+                    }
+                    message.sortBy = reader.string();
+                    continue;
+                case 7:
+                    if (tag !== 58) {
+                        break;
+                    }
+                    message.sortOrder = reader.string();
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    },
+};
+function createBaseGrpcDtoClient() {
+    return { publicId: "", name: "" };
+}
+export const GrpcDtoClient = {
+    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.clientType !== undefined) {
+            GrpcDtoClientType.encode(message.clientType, writer.uint32(34).fork()).ldelim();
+        }
+        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 = createBaseGrpcDtoClient();
+        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.clientType = GrpcDtoClientType.decode(reader, reader.uint32());
+                    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;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    },
+};
+function createBaseGrpcDtoClients() {
+    return { items: [] };
+}
+export const GrpcDtoClients = {
+    encode(message, writer = _m0.Writer.create()) {
+        for (const v of message.items) {
+            GrpcDtoClient.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 = createBaseGrpcDtoClients();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.items.push(GrpcDtoClient.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 createBaseGrpcDtoFeaturesAdd() {
+    return { features: [] };
+}
+export const GrpcDtoFeaturesAdd = {
+    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 = createBaseGrpcDtoFeaturesAdd();
+        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 createBaseGrpcDtoClientFeature() {
+    return { publicId: "" };
+}
+export const GrpcDtoClientFeature = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.publicId !== "") {
+            writer.uint32(10).string(message.publicId);
+        }
+        if (message.feature !== undefined) {
+            GrpcDtoFeature.encode(message.feature, writer.uint32(18).fork()).ldelim();
+        }
+        if (message.client !== undefined) {
+            GrpcDtoClient.encode(message.client, 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 = createBaseGrpcDtoClientFeature();
+        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.feature = GrpcDtoFeature.decode(reader, reader.uint32());
+                    continue;
+                case 3:
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.client = GrpcDtoClient.decode(reader, reader.uint32());
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    },
+};
+function createBaseGrpcDtoClientFeatures() {
+    return { clientFeatures: [] };
+}
+export const GrpcDtoClientFeatures = {
+    encode(message, writer = _m0.Writer.create()) {
+        for (const v of message.clientFeatures) {
+            GrpcDtoClientFeature.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 = createBaseGrpcDtoClientFeatures();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.clientFeatures.push(GrpcDtoClientFeature.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 = [
@@ -1343,6 +1934,13 @@ export function SystemServiceControllerMethods() {
             "featurePermissions",
             "featurePermissionsAdd",
             "featurePermissionsRemove",
+            "clientCreate",
+            "clientUpdate",
+            "clients",
+            "client",
+            "clientFeaturesAdd",
+            "clientFeaturesRemove",
+            "clientFeatures",
         ];
         for (const method of grpcMethods) {
             const descriptor = Reflect.getOwnPropertyDescriptor(constructor.prototype, method);
@@ -1468,4 +2066,68 @@ export const SystemServiceService = {
         responseSerialize: (value) => Buffer.from(GrpcDtoMessage.encode(value).finish()),
         responseDeserialize: (value) => GrpcDtoMessage.decode(value),
     },
+    /** --- Client --- */
+    clientCreate: {
+        path: "/aegis.system.v1.SystemService/ClientCreate",
+        requestStream: false,
+        responseStream: false,
+        requestSerialize: (value) => Buffer.from(GrpcInputClientCreate.encode(value).finish()),
+        requestDeserialize: (value) => GrpcInputClientCreate.decode(value),
+        responseSerialize: (value) => Buffer.from(GrpcDtoClient.encode(value).finish()),
+        responseDeserialize: (value) => GrpcDtoClient.decode(value),
+    },
+    clientUpdate: {
+        path: "/aegis.system.v1.SystemService/ClientUpdate",
+        requestStream: false,
+        responseStream: false,
+        requestSerialize: (value) => Buffer.from(GrpcInputClientUpdate.encode(value).finish()),
+        requestDeserialize: (value) => GrpcInputClientUpdate.decode(value),
+        responseSerialize: (value) => Buffer.from(GrpcDtoClient.encode(value).finish()),
+        responseDeserialize: (value) => GrpcDtoClient.decode(value),
+    },
+    clients: {
+        path: "/aegis.system.v1.SystemService/Clients",
+        requestStream: false,
+        responseStream: false,
+        requestSerialize: (value) => Buffer.from(GrpcInputClients.encode(value).finish()),
+        requestDeserialize: (value) => GrpcInputClients.decode(value),
+        responseSerialize: (value) => Buffer.from(GrpcDtoClients.encode(value).finish()),
+        responseDeserialize: (value) => GrpcDtoClients.decode(value),
+    },
+    client: {
+        path: "/aegis.system.v1.SystemService/Client",
+        requestStream: false,
+        responseStream: false,
+        requestSerialize: (value) => Buffer.from(GrpcInputClient.encode(value).finish()),
+        requestDeserialize: (value) => GrpcInputClient.decode(value),
+        responseSerialize: (value) => Buffer.from(GrpcDtoClient.encode(value).finish()),
+        responseDeserialize: (value) => GrpcDtoClient.decode(value),
+    },
+    clientFeaturesAdd: {
+        path: "/aegis.system.v1.SystemService/ClientFeaturesAdd",
+        requestStream: false,
+        responseStream: false,
+        requestSerialize: (value) => Buffer.from(GrpcInputClientFeaturesAdd.encode(value).finish()),
+        requestDeserialize: (value) => GrpcInputClientFeaturesAdd.decode(value),
+        responseSerialize: (value) => Buffer.from(GrpcDtoFeaturesAdd.encode(value).finish()),
+        responseDeserialize: (value) => GrpcDtoFeaturesAdd.decode(value),
+    },
+    clientFeaturesRemove: {
+        path: "/aegis.system.v1.SystemService/ClientFeaturesRemove",
+        requestStream: false,
+        responseStream: false,
+        requestSerialize: (value) => Buffer.from(GrpcInputClientFeaturesRemove.encode(value).finish()),
+        requestDeserialize: (value) => GrpcInputClientFeaturesRemove.decode(value),
+        responseSerialize: (value) => Buffer.from(GrpcDtoMessage.encode(value).finish()),
+        responseDeserialize: (value) => GrpcDtoMessage.decode(value),
+    },
+    clientFeatures: {
+        path: "/aegis.system.v1.SystemService/ClientFeatures",
+        requestStream: false,
+        responseStream: false,
+        requestSerialize: (value) => Buffer.from(GrpcInputClientFeatures.encode(value).finish()),
+        requestDeserialize: (value) => GrpcInputClientFeatures.decode(value),
+        responseSerialize: (value) => Buffer.from(GrpcDtoClientFeatures.encode(value).finish()),
+        responseDeserialize: (value) => GrpcDtoClientFeatures.decode(value),
+    },
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@acequants/aegis-contracts",
-  "version": "0.1.32",
+  "version": "0.1.34",
   "private": false,
   "license": "MIT",
   "type": "module",