@appconda/sdk 1.0.556 → 1.0.558

package/dist/modules/task/service.js

@@ -0,0 +1,193 @@
+import { ServiceClient } from "../../service-client";
+export class TaskService extends ServiceClient {
+    getServiceName() {
+        return 'com.appconda.service.task';
+    }
+    async CreateProject(payload) {
+        return await this.actionCall('projects', 'CreateProject', payload);
+    }
+    async UpdateProject(payload) {
+        return await this.actionCall('projects', 'UpdateProject', payload);
+    }
+    async CreateTask(payload) {
+        return await this.actionCall('task', 'CreateTask', payload);
+    }
+    async ChangeTaskStatus(payload) {
+        return await this.actionCall('task', 'ChangeTaskStatus', payload);
+    }
+    async GetProject(payload) {
+        return await this.actionCall('projects', 'GetProject', payload);
+    }
+    async ListProjects(payload) {
+        return await this.actionCall('projects', 'ListProjects', payload);
+    }
+    async CreateTaskList(payload) {
+        return await this.actionCall('CreateTaskList', payload);
+    }
+    async UpdateList(payload) {
+        return await this.actionCall('project', 'UpdateList', payload);
+    }
+    async GetTask(payload) {
+        return await this.actionCall('task', 'GetTask', payload);
+    }
+    async GetTaskList(payload) {
+        return await this.actionCall('projects', 'GetTaskList', payload);
+    }
+    async GetSprint(payload) {
+        return await this.actionCall('GetSprint', payload);
+    }
+    async UpdateTaskList(payload) {
+        return await this.actionCall('UpdateTaskList', payload);
+    }
+    async DeleteTaskList(payload) {
+        return await this.actionCall('DeleteTaskList', payload);
+    }
+    async CreateList(payload) {
+        return await this.actionCall('project', 'CreateList', payload);
+    }
+    async ListTaskLists(payload) {
+        return await this.actionCall('projects', 'ListTaskLists', payload);
+    }
+    async ListTasksInList(payload) {
+        return await this.actionCall('task', 'ListTasksInList', payload);
+    }
+    async MoveTask(payload) {
+        return await this.actionCall('task', 'MoveTask', payload);
+    }
+    async CreateView(payload) {
+        return await this.actionCall('project', 'CreateView', payload);
+    }
+    async UpdateView(payload) {
+        return await this.actionCall('project', 'UpdateView', payload);
+    }
+    async ListViews(payload) {
+        return await this.actionCall('project', 'ListViews', payload);
+    }
+    async ListTasks(payload) {
+        return await this.actionCall('project', 'ListTasks', payload);
+    }
+    async ChangePostCategory(payload) {
+        return await this.actionCall('feedback', 'ChangePostCategory', payload);
+    }
+    async ChangePostStatus(payload) {
+        return await this.actionCall('feedback', 'ChangePostStatus', payload);
+    }
+    async CreateBoard(payload) {
+        return await this.actionCall('feedback', 'CreateBoard', payload);
+    }
+    async GetBoard(payload) {
+        return await this.actionCall('feedback', 'GetBoard', payload);
+    }
+    async ListBoards(payload) {
+        return await this.actionCall('feedback', 'ListBoards', payload);
+    }
+    async DeleteBoard(payload) {
+        return await this.actionCall('feedback', 'DeleteBoard', payload);
+    }
+    async CreateChangelog(payload) {
+        return await this.actionCall('feedback', 'CreateChangelog', payload);
+    }
+    async CreateComment(payload) {
+        return await this.actionCall('feedback', 'CreateComment', payload);
+    }
+    async CreatePost(payload) {
+        return await this.actionCall('feedback', 'CreatePost', payload);
+    }
+    async CreatePostCategory(payload) {
+        return await this.actionCall('feedback', 'CreatePostCategory', payload);
+    }
+    async CreateRoadmap(payload) {
+        return await this.actionCall('feedback', 'CreateRoadmap', payload);
+    }
+    async CreateStatusChange(payload) {
+        return await this.actionCall('feedback', 'CreateStatusChange', payload);
+    }
+    async CreateTag(payload) {
+        return await this.actionCall('feedback', 'CreateTag', payload);
+    }
+    async CreateVote(payload) {
+        return await this.actionCall('feedback', 'CreateVote', payload);
+    }
+    async DeleteComment(payload) {
+        return await this.actionCall('feedback', 'DeleteComment', payload);
+    }
+    async DeletePostCategory(payload) {
+        return await this.actionCall('feedback', 'DeletePostCategory', payload);
+    }
+    async DeleteVote(payload) {
+        return await this.actionCall('feedback', 'DeleteVote', payload);
+    }
+    async GetChangeLog(payload) {
+        return await this.actionCall('feedback', 'GetChangeLog', payload);
+    }
+    async GetComment(payload) {
+        return await this.actionCall('feedback', 'GetComment', payload);
+    }
+    async GetPost(payload) {
+        return await this.actionCall('feedback', 'GetPost', payload);
+    }
+    async GetPostCategory(payload) {
+        return await this.actionCall('feedback', 'GetPostCategory', payload);
+    }
+    async GetRoadmap(payload) {
+        return await this.actionCall('feedback', 'GetRoadmap', payload);
+    }
+    async GetTag(payload) {
+        return await this.actionCall('feedback', 'GetTag', payload);
+    }
+    async GetVote(payload) {
+        return await this.actionCall('feedback', 'GetVote', payload);
+    }
+    async ListChangeLogs(payload) {
+        return await this.actionCall('feedback', 'ListChangeLogs', payload);
+    }
+    async ListComments(payload) {
+        return await this.actionCall('feedback', 'ListComments', payload);
+    }
+    async ListPostCategories(payload) {
+        return await this.actionCall('feedback', 'ListPostCategories', payload);
+    }
+    async ListPosts(payload) {
+        return await this.actionCall('feedback', 'ListPosts', payload);
+    }
+    async ListRoadmaps() {
+        return await this.actionCall('feedback', 'ListRoadmaps', {});
+    }
+    async ListStatusChanges() {
+        return await this.actionCall('feedback', 'ListStatusChanges', {});
+    }
+    async ListTags(payload) {
+        return await this.actionCall('feedback', 'ListTags', payload);
+    }
+    async ListVotes(payload) {
+        return await this.actionCall('feedback', 'ListVotes', payload);
+    }
+    async MoveView(payload) {
+        return await this.actionCall('project', 'MoveView', payload);
+    }
+    async CreateLabel(payload) {
+        return await this.actionCall('project', 'CreateLabel', payload);
+    }
+    async ListLabels(payload) {
+        return await this.actionCall('project', 'ListLabels', payload);
+    }
+    async DeleteLabel(payload) {
+        return await this.actionCall('project', 'DeleteLabel', payload);
+    }
+    async UpdateLabel(payload) {
+        return await this.actionCall('project', 'UpdateLabel', payload);
+    }
+    async CreateSprint(payload) {
+        return await this.actionCall('project', 'CreateSprint', payload);
+    }
+    async UpdateSprint(payload) {
+        return await this.actionCall('project', 'UpdateSprint', payload);
+    }
+    async DeleteSprint(payload) {
+        return await this.actionCall('project', 'DeleteSprint', payload);
+    }
+    async ListSprints(payload) {
+        return await this.actionCall('project', 'ListSprints', payload);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"service.js","sourceRoot":"","sources":["../../../src/modules/task/service.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAKrD,MAAM,OAAO,WAAY,SAAQ,aAAa;IAChC,cAAc;QACpB,OAAO,2BAA2B,CAAC;IACvC,CAAC;IAEM,KAAK,CAAC,aAAa,CAAC,OAA4C;QACnE,OAAO,MAAM,IAAI,CAAC,UAAU,CAAC,UAAU,EAAE,eAAe,EAAE,OAAO,CAAC,CAAC;IACvE,CAAC;IAEM,KAAK,CAAC,aAAa,CAAC,OAA4C;QACnE,OAAO,MAAM,IAAI,CAAC,UAAU,CAAC,UAAU,EAAE,eAAe,EAAE,OAAO,CAAC,CAAC;IACvE,CAAC;IAEM,KAAK,CAAC,UAAU,CAAC,OAAyC;QAC7D,OAAO,MAAM,IAAI,CAAC,UAAU,CAAC,MAAM,EAAE,YAAY,EAAE,OAAO,CAAC,CAAC;IAChE,CAAC;IAEM,KAAK,CAAC,gBAAgB,CAAC,OAA+C;QACzE,OAAO,MAAM,IAAI,CAAC,UAAU,CAAC,MAAM,EAAE,kBAAkB,EAAE,OAAO,CAAC,CAAC;IACtE,CAAC;IAEM,KAAK,CAAC,UAAU,CAAC,OAAyC;QAC7D,OAAO,MAAM,IAAI,CAAC,UAAU,CAAC,UAAU,EAAE,YAAY,EAAE,OAAO,CAAC,CAAC;IACpE,CAAC;IAEM,KAAK,CAAC,YAAY,CAAC,OAA2C;QACjE,OAAO,MAAM,IAAI,CAAC,UAAU,CAAC,UAAU,EAAE,cAAc,EAAE,OAAO,CAAC,CAAC;IACtE,CAAC;IAEM,KAAK,CAAC,cAAc,CAAC,OAA6C;QACrE,OAAO,MAAM,IAAI,CAAC,UAAU,CAAC,gBAAgB,EAAE,OAAO,CAAC,CAAC;IAC5D,CAAC;IAEM,KAAK,CAAC,UAAU,CAAC,OAAyC;QAC7D,OAAO,MAAM,IAAI,CAAC,UAAU,CAAC,SAAS,EAAC,YAAY,EAAE,OAAO,CAAC,CAAC;IAClE,CAAC;IAIM,KAAK,CAAC,OAAO,CAAC,OAAsC;QACvD,OAAO,MAAM,IAAI,CAAC,UAAU,CAAC,MAAM,EAAE,SAAS,EAAE,OAAO,CAAC,CAAC;IAC7D,CAAC;IAEM,KAAK,CAAC,WAAW,CAAC,OAA0C;QAC/D,OAAO,MAAM,IAAI,CAAC,UAAU,CAAC,UAAU,EAAE,aAAa,EAAE,OAAO,CAAC,CAAC;IACrE,CAAC;IAEM,KAAK,CAAC,SAAS,CAAC,OAAwC;QAC3D,OAAO,MAAM,IAAI,CAAC,UAAU,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC;IACvD,CAAC;IAEM,KAAK,CAAC,cAAc,CAAC,OAA6C;QACrE,OAAO,MAAM,IAAI,CAAC,UAAU,CAAC,gBAAgB,EAAE,OAAO,CAAC,CAAC;IAC5D,CAAC;IAKM,KAAK,CAAC,cAAc,CAAC,OAA6C;QACrE,OAAO,MAAM,IAAI,CAAC,UAAU,CAAC,gBAAgB,EAAE,OAAO,CAAC,CAAC;IAC5D,CAAC;IAEM,KAAK,CAAC,UAAU,CAAC,OAAyC;QAC7D,OAAO,MAAM,IAAI,CAAC,UAAU,CAAC,SAAS,EAAE,YAAY,EAAE,OAAO,CAAC,CAAC;IACnE,CAAC;IAEM,KAAK,CAAC,aAAa,CAAC,OAA4C;QACnE,OAAO,MAAM,IAAI,CAAC,UAAU,CAAC,UAAU,EAAE,eAAe,EAAE,OAAO,CAAC,CAAC;IACvE,CAAC;IAEM,KAAK,CAAC,eAAe,CAAC,OAA8C;QACvE,OAAO,MAAM,IAAI,CAAC,UAAU,CAAC,MAAM,EAAE,iBAAiB,EAAE,OAAO,CAAC,CAAC;IACrE,CAAC;IAEM,KAAK,CAAC,QAAQ,CAAC,OAAuC;QACzD,OAAO,MAAM,IAAI,CAAC,UAAU,CAAC,MAAM,EAAE,UAAU,EAAE,OAAO,CAAC,CAAC;IAC9D,CAAC;IAEM,KAAK,CAAC,UAAU,CAAC,OAAyC;QAC7D,OAAO,MAAM,IAAI,CAAC,UAAU,CAAC,SAAS,EAAE,YAAY,EAAE,OAAO,CAAC,CAAC;IACnE,CAAC;IAEM,KAAK,CAAC,UAAU,CAAC,OAAyC;QAC7D,OAAO,MAAM,IAAI,CAAC,UAAU,CAAC,SAAS,EAAE,YAAY,EAAE,OAAO,CAAC,CAAC;IACnE,CAAC;IAEM,KAAK,CAAC,SAAS,CAAC,OAAwC;QAC3D,OAAO,MAAM,IAAI,CAAC,UAAU,CAAC,SAAS,EAAE,WAAW,EAAE,OAAO,CAAC,CAAC;IAClE,CAAC;IAEM,KAAK,CAAC,SAAS,CAAC,OAAwC;QAC3D,OAAO,MAAM,IAAI,CAAC,UAAU,CAAC,SAAS,EAAE,WAAW,EAAE,OAAO,CAAC,CAAC;IAClE,CAAC;IAEM,KAAK,CAAC,kBAAkB,CAAC,OAAiD;QAC7E,OAAO,MAAM,IAAI,CAAC,UAAU,CAAC,UAAU,EAAE,oBAAoB,EAAE,OAAO,CAAC,CAAC;IAC5E,CAAC;IAEM,KAAK,CAAC,gBAAgB,CAAC,OAA+C;QACzE,OAAO,MAAM,IAAI,CAAC,UAAU,CAAC,UAAU,EAAE,kBAAkB,EAAE,OAAO,CAAC,CAAC;IAC1E,CAAC;IAEM,KAAK,CAAC,WAAW,CAAC,OAA0C;QAC/D,OAAO,MAAM,IAAI,CAAC,UAAU,CAAC,UAAU,EAAE,aAAa,EAAE,OAAO,CAAC,CAAC;IACrE,CAAC;IAEM,KAAK,CAAC,QAAQ,CAAC,OAAuC;QACzD,OAAO,MAAM,IAAI,CAAC,UAAU,CAAC,UAAU,EAAE,UAAU,EAAE,OAAO,CAAC,CAAC;IAClE,CAAC;IAEM,KAAK,CAAC,UAAU,CAAC,OAAyC;QAC7D,OAAO,MAAM,IAAI,CAAC,UAAU,CAAC,UAAU,EAAE,YAAY,EAAE,OAAO,CAAC,CAAC;IACpE,CAAC;IAEM,KAAK,CAAC,WAAW,CAAC,OAA0C;QAC/D,OAAO,MAAM,IAAI,CAAC,UAAU,CAAC,UAAU,EAAE,aAAa,EAAE,OAAO,CAAC,CAAC;IACrE,CAAC;IAEM,KAAK,CAAC,eAAe,CAAC,OAA8C;QACvE,OAAO,MAAM,IAAI,CAAC,UAAU,CAAC,UAAU,EAAE,iBAAiB,EAAE,OAAO,CAAC,CAAC;IACzE,CAAC;IAEM,KAAK,CAAC,aAAa,CAAC,OAA4C;QACnE,OAAO,MAAM,IAAI,CAAC,UAAU,CAAC,UAAU,EAAE,eAAe,EAAE,OAAO,CAAC,CAAC;IACvE,CAAC;IAEM,KAAK,CAAC,UAAU,CAAC,OAAyC;QAC7D,OAAO,MAAM,IAAI,CAAC,UAAU,CAAC,UAAU,EAAE,YAAY,EAAE,OAAO,CAAC,CAAC;IACpE,CAAC;IAEM,KAAK,CAAC,kBAAkB,CAAC,OAAiD;QAC7E,OAAO,MAAM,IAAI,CAAC,UAAU,CAAC,UAAU,EAAE,oBAAoB,EAAE,OAAO,CAAC,CAAC;IAC5E,CAAC;IAEM,KAAK,CAAC,aAAa,CAAC,OAA4C;QACnE,OAAO,MAAM,IAAI,CAAC,UAAU,CAAC,UAAU,EAAE,eAAe,EAAE,OAAO,CAAC,CAAC;IACvE,CAAC;IAEM,KAAK,CAAC,kBAAkB,CAAC,OAAiD;QAC7E,OAAO,MAAM,IAAI,CAAC,UAAU,CAAC,UAAU,EAAE,oBAAoB,EAAE,OAAO,CAAC,CAAC;IAC5E,CAAC;IAEM,KAAK,CAAC,SAAS,CAAC,OAAwC;QAC3D,OAAO,MAAM,IAAI,CAAC,UAAU,CAAC,UAAU,EAAE,WAAW,EAAE,OAAO,CAAC,CAAC;IACnE,CAAC;IAEM,KAAK,CAAC,UAAU,CAAC,OAAyC;QAC7D,OAAO,MAAM,IAAI,CAAC,UAAU,CAAC,UAAU,EAAE,YAAY,EAAE,OAAO,CAAC,CAAC;IACpE,CAAC;IAEM,KAAK,CAAC,aAAa,CAAC,OAA4C;QACnE,OAAO,MAAM,IAAI,CAAC,UAAU,CAAC,UAAU,EAAE,eAAe,EAAE,OAAO,CAAC,CAAC;IACvE,CAAC;IAEM,KAAK,CAAC,kBAAkB,CAAC,OAAiD;QAC7E,OAAO,MAAM,IAAI,CAAC,UAAU,CAAC,UAAU,EAAE,oBAAoB,EAAE,OAAO,CAAC,CAAC;IAC5E,CAAC;IAEM,KAAK,CAAC,UAAU,CAAC,OAAyC;QAC7D,OAAO,MAAM,IAAI,CAAC,UAAU,CAAC,UAAU,EAAE,YAAY,EAAE,OAAO,CAAC,CAAC;IACpE,CAAC;IAEM,KAAK,CAAC,YAAY,CAAC,OAA2C;QACjE,OAAO,MAAM,IAAI,CAAC,UAAU,CAAC,UAAU,EAAE,cAAc,EAAE,OAAO,CAAC,CAAC;IACtE,CAAC;IAEM,KAAK,CAAC,UAAU,CAAC,OAAyC;QAC7D,OAAO,MAAM,IAAI,CAAC,UAAU,CAAC,UAAU,EAAE,YAAY,EAAE,OAAO,CAAC,CAAC;IACpE,CAAC;IAEM,KAAK,CAAC,OAAO,CAAC,OAAsC;QACvD,OAAO,MAAM,IAAI,CAAC,UAAU,CAAC,UAAU,EAAE,SAAS,EAAE,OAAO,CAAC,CAAC;IACjE,CAAC;IAEM,KAAK,CAAC,eAAe,CAAC,OAA8C;QACvE,OAAO,MAAM,IAAI,CAAC,UAAU,CAAC,UAAU,EAAE,iBAAiB,EAAE,OAAO,CAAC,CAAC;IACzE,CAAC;IAEM,KAAK,CAAC,UAAU,CAAC,OAAyC;QAC7D,OAAO,MAAM,IAAI,CAAC,UAAU,CAAC,UAAU,EAAE,YAAY,EAAE,OAAO,CAAC,CAAC;IACpE,CAAC;IAEM,KAAK,CAAC,MAAM,CAAC,OAAqC;QACrD,OAAO,MAAM,IAAI,CAAC,UAAU,CAAC,UAAU,EAAE,QAAQ,EAAE,OAAO,CAAC,CAAC;IAChE,CAAC;IAEM,KAAK,CAAC,OAAO,CAAC,OAAsC;QACvD,OAAO,MAAM,IAAI,CAAC,UAAU,CAAC,UAAU,EAAE,SAAS,EAAE,OAAO,CAAC,CAAC;IACjE,CAAC;IAEM,KAAK,CAAC,cAAc,CAAC,OAA6C;QACrE,OAAO,MAAM,IAAI,CAAC,UAAU,CAAC,UAAU,EAAE,gBAAgB,EAAE,OAAO,CAAC,CAAC;IACxE,CAAC;IAEM,KAAK,CAAC,YAAY,CAAC,OAA2C;QACjE,OAAO,MAAM,IAAI,CAAC,UAAU,CAAC,UAAU,EAAE,cAAc,EAAE,OAAO,CAAC,CAAC;IACtE,CAAC;IAEM,KAAK,CAAC,kBAAkB,CAAC,OAAiD;QAC7E,OAAO,MAAM,IAAI,CAAC,UAAU,CAAC,UAAU,EAAE,oBAAoB,EAAE,OAAO,CAAC,CAAC;IAC5E,CAAC;IAEM,KAAK,CAAC,SAAS,CAAC,OAAwC;QAC3D,OAAO,MAAM,IAAI,CAAC,UAAU,CAAC,UAAU,EAAE,WAAW,EAAE,OAAO,CAAC,CAAC;IACnE,CAAC;IAEM,KAAK,CAAC,YAAY;QACrB,OAAO,MAAM,IAAI,CAAC,UAAU,CAAC,UAAU,EAAE,cAAc,EAAE,EAAE,CAAC,CAAC;IACjE,CAAC;IAEM,KAAK,CAAC,iBAAiB;QAC1B,OAAO,MAAM,IAAI,CAAC,UAAU,CAAC,UAAU,EAAE,mBAAmB,EAAE,EAAE,CAAC,CAAC;IACtE,CAAC;IAEM,KAAK,CAAC,QAAQ,CAAC,OAAuC;QACzD,OAAO,MAAM,IAAI,CAAC,UAAU,CAAC,UAAU,EAAE,UAAU,EAAE,OAAO,CAAC,CAAC;IAClE,CAAC;IAEM,KAAK,CAAC,SAAS,CAAC,OAAwC;QAC3D,OAAO,MAAM,IAAI,CAAC,UAAU,CAAC,UAAU,EAAE,WAAW,EAAE,OAAO,CAAC,CAAC;IACnE,CAAC;IAEM,KAAK,CAAC,QAAQ,CAAC,OAAuC;QACzD,OAAO,MAAM,IAAI,CAAC,UAAU,CAAC,SAAS,EAAE,UAAU,EAAE,OAAO,CAAC,CAAC;IACjE,CAAC;IAEM,KAAK,CAAC,WAAW,CAAC,OAA0C;QAC/D,OAAO,MAAM,IAAI,CAAC,UAAU,CAAC,SAAS,EAAE,aAAa,EAAE,OAAO,CAAC,CAAC;IACpE,CAAC;IAGM,KAAK,CAAC,UAAU,CAAC,OAAyC;QAC7D,OAAO,MAAM,IAAI,CAAC,UAAU,CAAC,SAAS,EAAE,YAAY,EAAE,OAAO,CAAC,CAAC;IACnE,CAAC;IAEM,KAAK,CAAC,WAAW,CAAC,OAA0C;QAC/D,OAAO,MAAM,IAAI,CAAC,UAAU,CAAC,SAAS,EAAE,aAAa,EAAE,OAAO,CAAC,CAAC;IACpE,CAAC;IAEM,KAAK,CAAC,WAAW,CAAC,OAA0C;QAC/D,OAAO,MAAM,IAAI,CAAC,UAAU,CAAC,SAAS,EAAE,aAAa,EAAE,OAAO,CAAC,CAAC;IACpE,CAAC;IAGM,KAAK,CAAC,YAAY,CAAC,OAA2C;QACjE,OAAO,MAAM,IAAI,CAAC,UAAU,CAAC,SAAS,EAAE,cAAc,EAAE,OAAO,CAAC,CAAC;IACrE,CAAC;IAEM,KAAK,CAAC,YAAY,CAAC,OAA2C;QACjE,OAAO,MAAM,IAAI,CAAC,UAAU,CAAC,SAAS,EAAE,cAAc,EAAE,OAAO,CAAC,CAAC;IACrE,CAAC;IAEM,KAAK,CAAC,YAAY,CAAC,OAA2C;QACjE,OAAO,MAAM,IAAI,CAAC,UAAU,CAAC,SAAS,EAAE,cAAc,EAAE,OAAO,CAAC,CAAC;IACrE,CAAC;IAEM,KAAK,CAAC,WAAW,CAAC,OAA0C;QAC/D,OAAO,MAAM,IAAI,CAAC,UAAU,CAAC,SAAS,EAAE,aAAa,EAAE,OAAO,CAAC,CAAC;IACpE,CAAC;CAEJ","sourcesContent":["\nimport z from \"zod\";\nimport { ServiceClient } from \"../../service-client\";\nimport { ChangePostCategorySchema, ChangePostStatusSchema, ChangeTaskStatusSchema, CreateBoardSchema, CreateChangelogSchema, CreateCommentSchema, CreateLabelSchema, CreateListSchema, CreatePostCategorySchema, CreatePostSchema, CreateProjectSchema, CreateRoadmapSchema, CreateSprintSchema, CreateStatusChangeSchema, CreateTagSchema, CreateTaskListSchema, CreateTaskSchema, CreateViewSchema, CreateVoteSchema, DeleteBoardSchema, DeleteCommentSchema, DeleteLabelSchema, DeletePostCategorySchema, DeleteSprintSchema, DeleteTaskListSchema, DeleteVoteSchema, GetBoardSchema, GetChangeLogSchema, GetCommentSchema, GetPostCategorySchema, GetPostSchema, GetProjectSchema, GetRoadmapSchema, GetSprintSchema, GetTagSchema, GetTaskListSchema, GetTaskSchema, GetVoteSchema, ListBoardsSchema, ListChangeLogsSchema, ListCommentsSchema, ListLabelsSchema, ListPostCategoriesSchema, ListPostsSchema, ListProjectsSchema, ListSprintsSchema, ListTagsSchema, ListTaskListsSchema, ListTasksInListSchema, ListTasksSchema, ListViewsSchema, ListVotesSchema, MoveTaskSchema, MoveViewSchema, UpdateLabelSchema, UpdateListSchema, UpdateProjectSchema, UpdateSprintSchema, UpdateTaskListSchema, UpdateViewSchema } from \"./schema\";\nimport { Board, Changelog, Comment, Label, Post, PostCategory, Project, Roadmap, Sprint, StatusChange, Tag, Task, TaskList, View, Vote } from \"./types\";\n\n\nexport class TaskService extends ServiceClient {\n    protected getServiceName(): string {\n        return 'com.appconda.service.task';\n    }\n\n    public async CreateProject(payload: z.infer<typeof CreateProjectSchema>): Promise<Project> {\n        return await this.actionCall('projects', 'CreateProject', payload);\n    }\n\n    public async UpdateProject(payload: z.infer<typeof UpdateProjectSchema>): Promise<Project> {\n        return await this.actionCall('projects', 'UpdateProject', payload);\n    }\n\n    public async CreateTask(payload: z.infer<typeof CreateTaskSchema>): Promise<Task> {\n        return await this.actionCall('task', 'CreateTask', payload);\n    }\n\n    public async ChangeTaskStatus(payload: z.infer<typeof ChangeTaskStatusSchema>): Promise<void> {\n        return await this.actionCall('task', 'ChangeTaskStatus', payload);\n    }\n\n    public async GetProject(payload: z.infer<typeof GetProjectSchema>): Promise<Project> {\n        return await this.actionCall('projects', 'GetProject', payload);\n    }\n\n    public async ListProjects(payload: z.infer<typeof ListProjectsSchema>): Promise<Project[]> {\n        return await this.actionCall('projects', 'ListProjects', payload);\n    }\n\n    public async CreateTaskList(payload: z.infer<typeof CreateTaskListSchema>): Promise<TaskList> {\n        return await this.actionCall('CreateTaskList', payload);\n    }\n\n    public async UpdateList(payload: z.infer<typeof UpdateListSchema>): Promise<TaskList> {\n        return await this.actionCall('project','UpdateList', payload);\n    }\n\n  \n\n    public async GetTask(payload: z.infer<typeof GetTaskSchema>): Promise<Task> {\n        return await this.actionCall('task', 'GetTask', payload);\n    }\n\n    public async GetTaskList(payload: z.infer<typeof GetTaskListSchema>): Promise<TaskList> {\n        return await this.actionCall('projects', 'GetTaskList', payload);\n    }\n\n    public async GetSprint(payload: z.infer<typeof GetSprintSchema>): Promise<Sprint> {\n        return await this.actionCall('GetSprint', payload);\n    }\n\n    public async UpdateTaskList(payload: z.infer<typeof UpdateTaskListSchema>): Promise<TaskList> {\n        return await this.actionCall('UpdateTaskList', payload);\n    }\n\n  \n\n\n    public async DeleteTaskList(payload: z.infer<typeof DeleteTaskListSchema>): Promise<void> {\n        return await this.actionCall('DeleteTaskList', payload);\n    }\n\n    public async CreateList(payload: z.infer<typeof CreateListSchema>): Promise<TaskList> {\n        return await this.actionCall('project', 'CreateList', payload);\n    }\n\n    public async ListTaskLists(payload: z.infer<typeof ListTaskListsSchema>): Promise<TaskList[]> {\n        return await this.actionCall('projects', 'ListTaskLists', payload);\n    }\n\n    public async ListTasksInList(payload: z.infer<typeof ListTasksInListSchema>): Promise<Task[]> {\n        return await this.actionCall('task', 'ListTasksInList', payload);\n    }\n\n    public async MoveTask(payload: z.infer<typeof MoveTaskSchema>): Promise<void> {\n        return await this.actionCall('task', 'MoveTask', payload);\n    }\n\n    public async CreateView(payload: z.infer<typeof CreateViewSchema>): Promise<View> {\n        return await this.actionCall('project', 'CreateView', payload);\n    }\n\n    public async UpdateView(payload: z.infer<typeof UpdateViewSchema>): Promise<View> {\n        return await this.actionCall('project', 'UpdateView', payload);\n    }\n\n    public async ListViews(payload: z.infer<typeof ListViewsSchema>): Promise<View[]> {\n        return await this.actionCall('project', 'ListViews', payload);\n    }\n\n    public async ListTasks(payload: z.infer<typeof ListTasksSchema>): Promise<Task[]> {\n        return await this.actionCall('project', 'ListTasks', payload);\n    }\n\n    public async ChangePostCategory(payload: z.infer<typeof ChangePostCategorySchema>): Promise<void> {\n        return await this.actionCall('feedback', 'ChangePostCategory', payload);\n    }\n\n    public async ChangePostStatus(payload: z.infer<typeof ChangePostStatusSchema>): Promise<void> {\n        return await this.actionCall('feedback', 'ChangePostStatus', payload);\n    }\n\n    public async CreateBoard(payload: z.infer<typeof CreateBoardSchema>): Promise<Board> {\n        return await this.actionCall('feedback', 'CreateBoard', payload);\n    }\n\n    public async GetBoard(payload: z.infer<typeof GetBoardSchema>): Promise<Board> {\n        return await this.actionCall('feedback', 'GetBoard', payload);\n    }\n\n    public async ListBoards(payload: z.infer<typeof ListBoardsSchema>): Promise<Board[]> {\n        return await this.actionCall('feedback', 'ListBoards', payload);\n    }\n\n    public async DeleteBoard(payload: z.infer<typeof DeleteBoardSchema>): Promise<void> {\n        return await this.actionCall('feedback', 'DeleteBoard', payload);\n    }\n\n    public async CreateChangelog(payload: z.infer<typeof CreateChangelogSchema>): Promise<Changelog> {\n        return await this.actionCall('feedback', 'CreateChangelog', payload);\n    }\n\n    public async CreateComment(payload: z.infer<typeof CreateCommentSchema>): Promise<Comment> {\n        return await this.actionCall('feedback', 'CreateComment', payload);\n    }\n\n    public async CreatePost(payload: z.infer<typeof CreatePostSchema>): Promise<Post> {\n        return await this.actionCall('feedback', 'CreatePost', payload);\n    }\n\n    public async CreatePostCategory(payload: z.infer<typeof CreatePostCategorySchema>): Promise<PostCategory> {\n        return await this.actionCall('feedback', 'CreatePostCategory', payload);\n    }\n\n    public async CreateRoadmap(payload: z.infer<typeof CreateRoadmapSchema>): Promise<Roadmap> {\n        return await this.actionCall('feedback', 'CreateRoadmap', payload);\n    }\n\n    public async CreateStatusChange(payload: z.infer<typeof CreateStatusChangeSchema>): Promise<void> {\n        return await this.actionCall('feedback', 'CreateStatusChange', payload);\n    }\n\n    public async CreateTag(payload: z.infer<typeof CreateTagSchema>): Promise<Tag> {\n        return await this.actionCall('feedback', 'CreateTag', payload);\n    }\n\n    public async CreateVote(payload: z.infer<typeof CreateVoteSchema>): Promise<Vote> {\n        return await this.actionCall('feedback', 'CreateVote', payload);\n    }\n\n    public async DeleteComment(payload: z.infer<typeof DeleteCommentSchema>): Promise<void> {\n        return await this.actionCall('feedback', 'DeleteComment', payload);\n    }\n\n    public async DeletePostCategory(payload: z.infer<typeof DeletePostCategorySchema>): Promise<void> {\n        return await this.actionCall('feedback', 'DeletePostCategory', payload);\n    }\n\n    public async DeleteVote(payload: z.infer<typeof DeleteVoteSchema>): Promise<void> {\n        return await this.actionCall('feedback', 'DeleteVote', payload);\n    }\n\n    public async GetChangeLog(payload: z.infer<typeof GetChangeLogSchema>): Promise<Changelog> {\n        return await this.actionCall('feedback', 'GetChangeLog', payload);\n    }\n\n    public async GetComment(payload: z.infer<typeof GetCommentSchema>): Promise<Comment> {\n        return await this.actionCall('feedback', 'GetComment', payload);\n    }\n\n    public async GetPost(payload: z.infer<typeof GetPostSchema>): Promise<Post> {\n        return await this.actionCall('feedback', 'GetPost', payload);\n    }\n\n    public async GetPostCategory(payload: z.infer<typeof GetPostCategorySchema>): Promise<PostCategory> {\n        return await this.actionCall('feedback', 'GetPostCategory', payload);\n    }\n\n    public async GetRoadmap(payload: z.infer<typeof GetRoadmapSchema>): Promise<Roadmap> {\n        return await this.actionCall('feedback', 'GetRoadmap', payload);\n    }\n\n    public async GetTag(payload: z.infer<typeof GetTagSchema>): Promise<Tag> {\n        return await this.actionCall('feedback', 'GetTag', payload);\n    }\n\n    public async GetVote(payload: z.infer<typeof GetVoteSchema>): Promise<Vote> {\n        return await this.actionCall('feedback', 'GetVote', payload);\n    }\n\n    public async ListChangeLogs(payload: z.infer<typeof ListChangeLogsSchema>): Promise<Changelog[]> {\n        return await this.actionCall('feedback', 'ListChangeLogs', payload);\n    }\n\n    public async ListComments(payload: z.infer<typeof ListCommentsSchema>): Promise<Comment[]> {\n        return await this.actionCall('feedback', 'ListComments', payload);\n    }\n\n    public async ListPostCategories(payload: z.infer<typeof ListPostCategoriesSchema>): Promise<PostCategory[]> {\n        return await this.actionCall('feedback', 'ListPostCategories', payload);\n    }\n\n    public async ListPosts(payload: z.infer<typeof ListPostsSchema>): Promise<Post[]> {\n        return await this.actionCall('feedback', 'ListPosts', payload);\n    }\n\n    public async ListRoadmaps(): Promise<Roadmap[]> {\n        return await this.actionCall('feedback', 'ListRoadmaps', {});\n    }\n\n    public async ListStatusChanges(): Promise<StatusChange[]> {\n        return await this.actionCall('feedback', 'ListStatusChanges', {});\n    }\n\n    public async ListTags(payload: z.infer<typeof ListTagsSchema>): Promise<Tag[]> {\n        return await this.actionCall('feedback', 'ListTags', payload);\n    }\n\n    public async ListVotes(payload: z.infer<typeof ListVotesSchema>): Promise<Vote[]> {\n        return await this.actionCall('feedback', 'ListVotes', payload);\n    }\n\n    public async MoveView(payload: z.infer<typeof MoveViewSchema>): Promise<void> {\n        return await this.actionCall('project', 'MoveView', payload);\n    }\n\n    public async CreateLabel(payload: z.infer<typeof CreateLabelSchema>): Promise<Label> {\n        return await this.actionCall('project', 'CreateLabel', payload);\n    }\n\n  \n    public async ListLabels(payload: z.infer<typeof ListLabelsSchema>): Promise<Label[]> {\n        return await this.actionCall('project', 'ListLabels', payload);\n    }\n\n    public async DeleteLabel(payload: z.infer<typeof DeleteLabelSchema>): Promise<void> {\n        return await this.actionCall('project', 'DeleteLabel', payload);\n    }\n\n    public async UpdateLabel(payload: z.infer<typeof UpdateLabelSchema>): Promise<Label> {\n        return await this.actionCall('project', 'UpdateLabel', payload);\n    }\n\n   \n    public async CreateSprint(payload: z.infer<typeof CreateSprintSchema>): Promise<Sprint> {\n        return await this.actionCall('project', 'CreateSprint', payload);\n    }\n \n    public async UpdateSprint(payload: z.infer<typeof UpdateSprintSchema>): Promise<Sprint> {\n        return await this.actionCall('project', 'UpdateSprint', payload);\n    }\n\n    public async DeleteSprint(payload: z.infer<typeof DeleteSprintSchema>): Promise<void> {\n        return await this.actionCall('project', 'DeleteSprint', payload);\n    }\n\n    public async ListSprints(payload: z.infer<typeof ListSprintsSchema>): Promise<Sprint[]> {\n        return await this.actionCall('project', 'ListSprints', payload);\n    }\n\n}\n"]}

package/dist/modules/task/types.d.ts

@@ -0,0 +1,293 @@
+export type TaskList = {
+    id: string;
+    title: string;
+    color?: string;
+    projectId: string;
+    listType: TaskListType;
+    listStatus: TaskListStatus;
+    isPublic: boolean;
+    createdAt: Date;
+    updatedAt: Date;
+    position: number;
+    description: string;
+    viewId?: string;
+    tasks: Task[];
+};
+export type Sprint = {
+    id: string;
+    name: string;
+    description: string;
+};
+export type Project = {
+    id: string;
+    tenantId: string;
+    picture?: string;
+    ownerId: string;
+    title: string;
+    web?: string;
+    createdDate: Date;
+    updatedDate: Date;
+    description?: string;
+    starred: number;
+    archived: boolean;
+    defaultView: boolean;
+    itemName: string;
+    itemsName: string;
+    projectType: number;
+    commentAll: number;
+    commitsVisibility: number;
+    inviteAll: boolean;
+    projectColor?: string;
+    viewTitle?: string;
+    position?: number;
+    tasks: Task[];
+};
+export interface Task {
+    id: string;
+    projectId: string;
+    project: Project;
+    milestoneId?: string;
+    milestone?: Milestone;
+    sprintId?: string;
+    sprint?: Sprint;
+    taskType: string;
+    creator: string;
+    secondId: number;
+    title: string;
+    description?: string;
+    lastPicture?: string;
+    lastPictureExternalUrl?: string;
+    createdAt: Date;
+    updatedAt: Date;
+    deadline?: Date;
+    archived: boolean;
+    color?: string;
+    estimated?: string;
+    timeTracked?: string;
+    isPublic: boolean;
+    status: TaskListStatus;
+    coverWidth?: number;
+    coverHeight?: number;
+    checklist?: string;
+    comments: number;
+    publicComments: number;
+    likes: number;
+    attachments: number;
+    commits: number;
+    supportTickets: number;
+    value?: number;
+    points?: number;
+    pointsDone?: number;
+    position?: number;
+}
+export type Milestone = {
+    id: string;
+    title: string;
+    createdAt: Date;
+    updatedAt: Date;
+    archived: boolean;
+    complete: boolean;
+    deadline: Date;
+    color?: string;
+    position: number;
+    Task: Task[];
+};
+export type View = {
+    id: string;
+    title: string;
+    projectId: string;
+    createdAt: Date;
+    updatedAt: Date;
+    active: boolean;
+    position: number;
+    lists: TaskList[];
+};
+export declare enum Roles {
+    USER = "USER",
+    ADMIN = "ADMIN"
+}
+export declare enum PostStatus {
+    OPEN = "OPEN",
+    UNDER_REVIEW = "UNDER_REVIEW",
+    PLANNED = "PLANNED",
+    IN_PROGRESS = "IN_PROGRESS",
+    COMPLETE = "COMPLETE",
+    CLOSED = "CLOSED"
+}
+export declare enum TaskListType {
+    OPEN = "OPEN",
+    CLOSED = "CLOSED",
+    REVIEW = "REVIEW",
+    FROZEN = "FROZEN"
+}
+export declare enum TaskListStatus {
+    BACKLOG = "BACKLOG",
+    OPEN = "OPEN",
+    IN_PROGRESS = "IN_PROGRESS",
+    PAUSED = "PAUSED",
+    REJECTED = "REJECTED",
+    REVIEW = "REVIEW",
+    CLOSED = "CLOSED",
+    CANCELLED = "CANCELLED"
+}
+export type Roadmap = {
+    id: string;
+    title: string;
+    createdAt: Date;
+    updatedAt: Date;
+    posts: RoadmapPost[];
+};
+export type RoadmapPost = {
+    id: string;
+    roadmapId: string;
+    roadmap: Roadmap;
+    postId: string;
+    post: Post;
+    createdAt: Date;
+    updatedAt: Date;
+};
+export type Post = {
+    id: string;
+    authorId: string;
+    by?: string;
+    boardId: string;
+    board: Board;
+    postCategoryId?: string;
+    postCategory?: PostCategory;
+    comments: Comment[];
+    votes: Vote[];
+    ChangeLogPost: ChangeLogPost[];
+    StatusHistory: StatusChange[];
+    createdAt: Date;
+    updatedAt: Date;
+    details?: string;
+    eta?: string;
+    postImages: PostImages[];
+    owner?: string;
+    roadmapPosts: RoadmapPost[];
+    score: number;
+    status: PostStatus;
+    statusChangedAt: Date;
+    title: string;
+    url?: string;
+    PostTag: PostTag[];
+};
+export type PostImages = {
+    id: string;
+    postId: string;
+    post: Post;
+    url: string;
+};
+export type Board = {
+    id: string;
+    name: string;
+    posts: Post[];
+    createdAt: Date;
+    PostCategory: PostCategory[];
+    Comment: Comment[];
+    Tag: Tag[];
+    Vote: Vote[];
+};
+export type PostCategory = {
+    id: string;
+    name: string;
+    board: Board;
+    boardId: string;
+    posts: Post[];
+    parentID?: string;
+    parent?: PostCategory;
+    children: PostCategory[];
+    subscribeAdmins: boolean;
+};
+export type Comment = {
+    id: string;
+    author: string;
+    boardId: string;
+    board: Board;
+    postId?: string;
+    post?: Post;
+    createdAt: Date;
+    updatedAt: Date;
+    images: CommentImage[];
+    internal: boolean;
+    likeCount: number;
+    mentions: CommentMention[];
+    parentID?: string;
+    parent?: Comment;
+    children: Comment[];
+    private: boolean;
+    value: string;
+};
+export type CommentImage = {
+    id: string;
+    commentId: string;
+    comment: Comment;
+    url: string;
+};
+export type CommentMention = {
+    id: string;
+    commentId: string;
+    comment: Comment;
+    userId: string;
+};
+export type Vote = {
+    id: string;
+    voterId: string;
+    by?: string;
+    boardId: string;
+    board: Board;
+    postId: string;
+    post: Post;
+    createdAt: Date;
+};
+export type Tag = {
+    id: string;
+    boardId: string;
+    board: Board;
+    name: string;
+    posts: PostTag[];
+};
+export type PostTag = {
+    id: string;
+    postId: string;
+    post: Post;
+    tagId: string;
+    tag: Tag;
+};
+export type Changelog = {
+    id: string;
+    title: string;
+    details?: string;
+    created: Date;
+    lastSaved?: Date;
+    publishedAt?: Date;
+    scheduledFor?: Date;
+    status: string;
+    url?: string;
+    type: string;
+    ChangeLogPost: ChangeLogPost[];
+};
+export type ChangeLogPost = {
+    id: string;
+    postId: string;
+    changelogId: string;
+    post: Post;
+    changelog: Changelog;
+};
+export type StatusChange = {
+    id: string;
+    changerId: string;
+    changeComment?: string;
+    postId: string;
+    post: Post;
+    status: PostStatus;
+    changedAt: Date;
+};
+export type Label = {
+    id: string;
+    title: string;
+    color: string;
+    projectId: string;
+    createdAt: Date;
+    updatedAt: Date;
+};

package/dist/modules/task/types.js

@@ -0,0 +1,37 @@
+// Prisma Modelleri için TypeScript Tipleri
+// Enum Tipleri
+export var Roles;
+(function (Roles) {
+    Roles["USER"] = "USER";
+    Roles["ADMIN"] = "ADMIN";
+})(Roles || (Roles = {}));
+export var PostStatus;
+(function (PostStatus) {
+    PostStatus["OPEN"] = "OPEN";
+    PostStatus["UNDER_REVIEW"] = "UNDER_REVIEW";
+    PostStatus["PLANNED"] = "PLANNED";
+    PostStatus["IN_PROGRESS"] = "IN_PROGRESS";
+    PostStatus["COMPLETE"] = "COMPLETE";
+    PostStatus["CLOSED"] = "CLOSED";
+})(PostStatus || (PostStatus = {}));
+export var TaskListType;
+(function (TaskListType) {
+    TaskListType["OPEN"] = "OPEN";
+    TaskListType["CLOSED"] = "CLOSED";
+    TaskListType["REVIEW"] = "REVIEW";
+    TaskListType["FROZEN"] = "FROZEN";
+})(TaskListType || (TaskListType = {}));
+;
+export var TaskListStatus;
+(function (TaskListStatus) {
+    TaskListStatus["BACKLOG"] = "BACKLOG";
+    TaskListStatus["OPEN"] = "OPEN";
+    TaskListStatus["IN_PROGRESS"] = "IN_PROGRESS";
+    TaskListStatus["PAUSED"] = "PAUSED";
+    TaskListStatus["REJECTED"] = "REJECTED";
+    TaskListStatus["REVIEW"] = "REVIEW";
+    TaskListStatus["CLOSED"] = "CLOSED";
+    TaskListStatus["CANCELLED"] = "CANCELLED";
+})(TaskListStatus || (TaskListStatus = {}));
+;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/modules/task/types.ts"],"names":[],"mappings":"AAiHA,2CAA2C;AAE3C,eAAe;AACf,MAAM,CAAN,IAAY,KAGX;AAHD,WAAY,KAAK;IACb,sBAAa,CAAA;IACb,wBAAe,CAAA;AACnB,CAAC,EAHW,KAAK,KAAL,KAAK,QAGhB;AAED,MAAM,CAAN,IAAY,UAOX;AAPD,WAAY,UAAU;IAClB,2BAAa,CAAA;IACb,2CAA6B,CAAA;IAC7B,iCAAmB,CAAA;IACnB,yCAA2B,CAAA;IAC3B,mCAAqB,CAAA;IACrB,+BAAiB,CAAA;AACrB,CAAC,EAPW,UAAU,KAAV,UAAU,QAOrB;AAED,MAAM,CAAN,IAAY,YAKX;AALD,WAAY,YAAY;IACpB,6BAAa,CAAA;IACb,iCAAiB,CAAA;IACjB,iCAAiB,CAAA;IACjB,iCAAiB,CAAA;AACrB,CAAC,EALW,YAAY,KAAZ,YAAY,QAKvB;AAAC,CAAC;AAEH,MAAM,CAAN,IAAY,cASX;AATD,WAAY,cAAc;IACtB,qCAAmB,CAAA;IACnB,+BAAa,CAAA;IACb,6CAA2B,CAAA;IAC3B,mCAAiB,CAAA;IACjB,uCAAqB,CAAA;IACrB,mCAAiB,CAAA;IACjB,mCAAiB,CAAA;IACjB,yCAAuB,CAAA;AAC3B,CAAC,EATW,cAAc,KAAd,cAAc,QASzB;AAAC,CAAC","sourcesContent":["\nexport type TaskList = {\n    id: string;\n    title: string;\n    color?: string;\n    projectId: string;\n    listType: TaskListType;\n    listStatus: TaskListStatus;\n    isPublic: boolean;\n    createdAt: Date;\n    updatedAt: Date;\n    position: number;\n    description: string;\n    viewId?: string;\n    tasks: Task[];\n}\n\nexport type Sprint = {\n    id: string;\n    name: string;\n    description: string;\n}\n\n\nexport type Project = {\n    id: string;\n    tenantId: string;\n    picture?: string;\n    ownerId: string;\n    title: string;\n    web?: string;\n    createdDate: Date;\n    updatedDate: Date;\n    description?: string;\n    starred: number;\n    archived: boolean;\n    defaultView: boolean;\n    itemName: string;\n    itemsName: string;\n    projectType: number;\n    commentAll: number;\n    commitsVisibility: number;\n    inviteAll: boolean;\n    projectColor?: string;\n    viewTitle?: string;\n    position?: number;\n    tasks: Task[];\n}\nexport interface Task {\n    id: string;\n    projectId: string;\n    project: Project;\n    milestoneId?: string;\n    milestone?: Milestone;\n    sprintId?: string;\n    sprint?: Sprint;\n    taskType: string;\n    creator: string;\n    secondId: number;\n    title: string;\n    description?: string;\n    lastPicture?: string;\n    lastPictureExternalUrl?: string;\n    createdAt: Date;\n    updatedAt: Date;\n    deadline?: Date;\n    archived: boolean;\n    color?: string;\n    estimated?: string;\n    timeTracked?: string;\n    isPublic: boolean;\n    status: TaskListStatus;\n    coverWidth?: number;\n    coverHeight?: number;\n    checklist?: string;\n    comments: number;\n    publicComments: number;\n    likes: number;\n    attachments: number;\n    commits: number;\n    supportTickets: number;\n    value?: number;\n    points?: number;\n    pointsDone?: number;\n    position?: number;\n}\n\n\n\nexport type Milestone = {\n    id: string;\n    title: string;\n    createdAt: Date;\n    updatedAt: Date;\n    archived: boolean;\n    complete: boolean;\n    deadline: Date;\n    color?: string;\n    position: number;\n    Task: Task[];\n}\n\nexport type View = {\n    id: string;\n    title: string;\n    projectId: string;\n    createdAt: Date;\n    updatedAt: Date;\n    active: boolean;\n    position: number;\n    lists: TaskList[];\n}\n\n// Prisma Modelleri için TypeScript Tipleri\n\n// Enum Tipleri\nexport enum Roles {\n    USER = 'USER',\n    ADMIN = 'ADMIN'\n}\n\nexport enum PostStatus {\n    OPEN = 'OPEN',\n    UNDER_REVIEW = 'UNDER_REVIEW',\n    PLANNED = 'PLANNED',\n    IN_PROGRESS = 'IN_PROGRESS',\n    COMPLETE = 'COMPLETE',\n    CLOSED = 'CLOSED'\n}\n\nexport enum TaskListType {\n    OPEN = 'OPEN',\n    CLOSED = 'CLOSED',\n    REVIEW = 'REVIEW',\n    FROZEN = 'FROZEN'\n} ;\n\nexport enum TaskListStatus {\n    BACKLOG = 'BACKLOG',\n    OPEN = 'OPEN',\n    IN_PROGRESS = 'IN_PROGRESS',\n    PAUSED = 'PAUSED',\n    REJECTED = 'REJECTED',\n    REVIEW = 'REVIEW',\n    CLOSED = 'CLOSED',\n    CANCELLED = 'CANCELLED'\n} ;\n\n// Model Tipleri\nexport type Roadmap = {\n    id: string;\n    title: string;\n    createdAt: Date;\n    updatedAt: Date;\n    posts: RoadmapPost[];\n}\n\nexport type RoadmapPost = {\n    id: string;\n    roadmapId: string;\n    roadmap: Roadmap;\n    postId: string;\n    post: Post;\n    createdAt: Date;\n    updatedAt: Date;\n}\n\nexport type Post = {\n    id: string;\n    authorId: string;\n    by?: string;\n    boardId: string;\n    board: Board;\n    postCategoryId?: string;\n    postCategory?: PostCategory;\n    comments: Comment[];\n    votes: Vote[];\n    ChangeLogPost: ChangeLogPost[];\n    StatusHistory: StatusChange[];\n    createdAt: Date;\n    updatedAt: Date;\n    details?: string;\n    eta?: string;\n    postImages: PostImages[];\n    owner?: string;\n    roadmapPosts: RoadmapPost[];\n    score: number;\n    status: PostStatus;\n    statusChangedAt: Date;\n    title: string;\n    url?: string;\n    PostTag: PostTag[];\n}\n\nexport type PostImages = {\n    id: string;\n    postId: string;\n    post: Post;\n    url: string;\n}\n\nexport type Board = {\n    id: string;\n    name: string;\n    posts: Post[];\n    createdAt: Date;\n    PostCategory: PostCategory[];\n    Comment: Comment[];\n    Tag: Tag[];\n    Vote: Vote[];\n}\n\nexport type PostCategory = {\n    id: string;\n    name: string;\n    board: Board;\n    boardId: string;\n    posts: Post[];\n    parentID?: string;\n    parent?: PostCategory;\n    children: PostCategory[];\n    subscribeAdmins: boolean;\n}\n\nexport type Comment = {\n    id: string;\n    author: string;\n    boardId: string;\n    board: Board;\n    postId?: string;\n    post?: Post;\n    createdAt: Date;\n    updatedAt: Date;\n    images: CommentImage[];\n    internal: boolean;\n    likeCount: number;\n    mentions: CommentMention[];\n    parentID?: string;\n    parent?: Comment;\n    children: Comment[];\n    private: boolean;\n    value: string;\n}\n\nexport type CommentImage = {\n    id: string;\n    commentId: string;\n    comment: Comment;\n    url: string;\n}\n\nexport type CommentMention = {\n    id: string;\n    commentId: string;\n    comment: Comment;\n    userId: string;\n}\n\nexport type Vote = {\n    id: string;\n    voterId: string;\n    by?: string;\n    boardId: string;\n    board: Board;\n    postId: string;\n    post: Post;\n    createdAt: Date;\n}\n\nexport type Tag = {\n    id: string;\n    boardId: string;\n    board: Board;\n    name: string;\n    posts: PostTag[];\n}\n\nexport type PostTag = {\n    id: string;\n    postId: string;\n    post: Post;\n    tagId: string;\n    tag: Tag;\n}\n\nexport type Changelog = {\n    id: string;\n    title: string;\n    details?: string;\n    created: Date;\n    lastSaved?: Date;\n    publishedAt?: Date;\n    scheduledFor?: Date;\n    status: string;\n    url?: string;\n    type: string;\n    ChangeLogPost: ChangeLogPost[];\n}\n\nexport type ChangeLogPost = {\n    id: string;\n    postId: string;\n    changelogId: string;\n    post: Post;\n    changelog: Changelog;\n}\n\nexport type StatusChange = {\n    id: string;\n    changerId: string;\n    changeComment?: string;\n    postId: string;\n    post: Post;\n    status: PostStatus;\n    changedAt: Date;\n}\n\nexport type Label = {\n    id: string;\n    title: string;\n    color: string;\n    projectId: string;\n    createdAt: Date;\n    updatedAt: Date;\n}"]}

package/dist/modules/tenant/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./service";
+export * from "./types";

package/dist/modules/tenant/index.js

@@ -0,0 +1,3 @@
+export * from "./service";
+export * from "./types";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbW9kdWxlcy90ZW5hbnQvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxXQUFXLENBQUM7QUFDMUIsY0FBYyxTQUFTLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tIFwiLi9zZXJ2aWNlXCI7XG5leHBvcnQgKiBmcm9tIFwiLi90eXBlc1wiOyJdfQ==

package/dist/modules/tenant/schema.d.ts

@@ -0,0 +1,26 @@
+import z from "zod";
+export declare const CreateTenantSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    slug: z.ZodString;
+}, z.core.$strip>;
+export declare enum TenantUserType {
+    OWNER = 0,
+    ADMIN = 1,
+    MEMBER = 2
+}
+export declare const CreateTenantUserSchema: z.ZodObject<{
+    tenantId: z.ZodString;
+    userId: z.ZodString;
+    type: z.ZodEnum<typeof TenantUserType>;
+}, z.core.$strip>;
+export declare const GetTenantByIdSchema: z.ZodObject<{
+    tenantId: z.ZodString;
+}, z.core.$strip>;
+export declare const ListTenantUsersSchema: z.ZodObject<{
+    queries: z.ZodArray<z.ZodString>;
+    search: z.ZodString;
+}, z.core.$strip>;
+export declare const ListUserTenantsSchema: z.ZodObject<{
+    userId: z.ZodString;
+}, z.core.$strip>;

package/dist/modules/tenant/schema.js

@@ -0,0 +1,28 @@
+import z from "zod";
+export const CreateTenantSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    slug: z.string()
+});
+export var TenantUserType;
+(function (TenantUserType) {
+    TenantUserType[TenantUserType["OWNER"] = 0] = "OWNER";
+    TenantUserType[TenantUserType["ADMIN"] = 1] = "ADMIN";
+    TenantUserType[TenantUserType["MEMBER"] = 2] = "MEMBER";
+})(TenantUserType || (TenantUserType = {}));
+export const CreateTenantUserSchema = z.object({
+    tenantId: z.string(),
+    userId: z.string(),
+    type: z.nativeEnum(TenantUserType)
+});
+export const GetTenantByIdSchema = z.object({
+    tenantId: z.string()
+});
+export const ListTenantUsersSchema = z.object({
+    queries: z.array(z.string()),
+    search: z.string()
+});
+export const ListUserTenantsSchema = z.object({
+    userId: z.string()
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/modules/tenant/service.d.ts

@@ -0,0 +1,14 @@
+import z from "zod";
+import { ServiceClient } from "../../service-client";
+import { TTenant, TTenantUser } from "./types";
+import { CreateTenantSchema, CreateTenantUserSchema, GetTenantByIdSchema, ListTenantUsersSchema, ListUserTenantsSchema } from "./schema";
+export declare class TenantService extends ServiceClient {
+    protected getServiceName(): string;
+    AdminGetAllTenantsIdsAndNames(): Promise<TTenant>;
+    CreateTenant(payload: z.infer<typeof CreateTenantSchema>): Promise<TTenant>;
+    CreateTenantUser(payload: z.infer<typeof CreateTenantUserSchema>): Promise<TTenantUser>;
+    GetTenantById(payload: z.infer<typeof GetTenantByIdSchema>): Promise<TTenant>;
+    ListTenants(): Promise<TTenant[]>;
+    ListTenantUsers(payload: z.infer<typeof ListTenantUsersSchema>): Promise<TTenantUser[]>;
+    ListUserTenants(payload: z.infer<typeof ListUserTenantsSchema>): Promise<TTenant[]>;
+}