ProjectManagerSdk 152.0.138__tar.gz → 154.0.181__tar.gz

{projectmanagersdk-152.0.138/src/ProjectManagerSdk.egg-info → projectmanagersdk-154.0.181}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ProjectManagerSdk
-Version: 152.0.138
+Version: 154.0.181
 Summary: Software development kit for the ProjectManager.com API for Python
 Author-email: "ProjectManager.com" <support@projectmanager.com>
 Project-URL: Homepage, https://github.com/projectmgr/projectmanager-sdk-python

{projectmanagersdk-152.0.138 → projectmanagersdk-154.0.181}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ProjectManagerSdk"
-version = "152.0.138"
+version = "154.0.181"
 authors = [
     { name = "ProjectManager.com", email = "support@projectmanager.com" }
 ]

{projectmanagersdk-152.0.138 → projectmanagersdk-154.0.181}/src/ProjectManagerSdk/__init__.py

@@ -44,6 +44,7 @@ from ProjectManagerSdk.clients.resourceteamclient import ResourceTeamClient
 from ProjectManagerSdk.clients.riskclient import RiskClient
 from ProjectManagerSdk.clients.riskfileclient import RiskFileClient
 from ProjectManagerSdk.clients.risktagclient import RiskTagClient
+from ProjectManagerSdk.clients.securityclient import SecurityClient
 from ProjectManagerSdk.clients.tagclient import TagClient
 from ProjectManagerSdk.clients.taskassigneeclient import TaskAssigneeClient
 from ProjectManagerSdk.clients.taskclient import TaskClient
@@ -66,6 +67,7 @@ from ProjectManagerSdk.models.assigneeupsertdto import AssigneeUpsertDto
 from ProjectManagerSdk.models.astroerror import AstroError
 from ProjectManagerSdk.models.astroresult import AstroResult
 from ProjectManagerSdk.models.authenticationdto import AuthenticationDto
+from ProjectManagerSdk.models.businessroleslistdto import BusinessRolesListDto
 from ProjectManagerSdk.models.changesetstatusdto import ChangeSetStatusDto
 from ProjectManagerSdk.models.connectionschemadto import ConnectionSchemaDto
 from ProjectManagerSdk.models.countrydto import CountryDto
@@ -126,7 +128,9 @@ from ProjectManagerSdk.models.nptassigneedto import NptAssigneeDto
 from ProjectManagerSdk.models.nptcreatedto import NptCreateDto
 from ProjectManagerSdk.models.nptdetailsdto import NptDetailsDto
 from ProjectManagerSdk.models.nptdto import NptDto
+from ProjectManagerSdk.models.nptstatuscreatedto import NptStatusCreateDto
 from ProjectManagerSdk.models.nptstatusdto import NptStatusDto
+from ProjectManagerSdk.models.nptstatusupdatedto import NptStatusUpdateDto
 from ProjectManagerSdk.models.nptupdatedto import NptUpdateDto
 from ProjectManagerSdk.models.partialresourcedto import PartialResourceDto
 from ProjectManagerSdk.models.pendingtimesheetapprovaldto import PendingTimeSheetApprovalDto
@@ -158,6 +162,7 @@ from ProjectManagerSdk.models.projectmemberroledto import ProjectMemberRoleDto
 from ProjectManagerSdk.models.projectmembersaccessdto import ProjectMembersAccessDto
 from ProjectManagerSdk.models.projectprioritycreatedto import ProjectPriorityCreateDto
 from ProjectManagerSdk.models.projectprioritydto import ProjectPriorityDto
+from ProjectManagerSdk.models.projectreopenstatusdto import ProjectReopenStatusDto
 from ProjectManagerSdk.models.projectrestoreprojectdto import ProjectRestoreProjectDto
 from ProjectManagerSdk.models.projectstatuscreatedto import ProjectStatusCreateDto
 from ProjectManagerSdk.models.projectstatusdto import ProjectStatusDto
@@ -191,6 +196,11 @@ from ProjectManagerSdk.models.riskexportprogressfilterdto import RiskExportProgr
 from ProjectManagerSdk.models.riskexportsettingsdto import RiskExportSettingsDto
 from ProjectManagerSdk.models.riskprojectdto import RiskProjectDto
 from ProjectManagerSdk.models.riskupdatedto import RiskUpdateDto
+from ProjectManagerSdk.models.rolecreatedto import RoleCreateDto
+from ProjectManagerSdk.models.roledto import RoleDto
+from ProjectManagerSdk.models.rolepermissionfeaturedto import RolePermissionFeatureDto
+from ProjectManagerSdk.models.roleupdatechangeitemdto import RoleUpdateChangeItemDto
+from ProjectManagerSdk.models.simpletaskfieldvaluedto import SimpleTaskFieldValueDto
 from ProjectManagerSdk.models.statedto import StateDto
 from ProjectManagerSdk.models.tagcreatedto import TagCreateDto
 from ProjectManagerSdk.models.tagdto import TagDto

{projectmanagersdk-152.0.138 → projectmanagersdk-154.0.181}/src/ProjectManagerSdk/clients/meetingsclient.py

@@ -39,6 +39,54 @@ class MeetingsClient:
     def __init__(self, client: ProjectManagerClient):
         self.client = client
 
+    def get_meetings(self, projectId: str) -> AstroResult[List[MeetingDto]]:
+        """
+        Retrieve a list of Meetings. This endpoint does not use OData.
+        If `projectId` is provided, results are limited to that Project.
+
+        Parameters
+        ----------
+        projectId : str
+            Optional project id to scope results
+        """
+        path = "/api/data/meetings"
+        queryParams = {}
+        if projectId:
+            queryParams['projectId'] = projectId
+        result = self.client.send_request("GET", path, None, queryParams, None)
+        if result.status_code >= 200 and result.status_code < 300:
+            data = []
+            for dict in json.loads(result.content)['data']:
+                data.append(dacite.from_dict(data_class=MeetingDto, data=dict))
+            return AstroResult[List[MeetingDto]](None, True, False, result.status_code, data)
+        else:
+            response = AstroResult[List[MeetingDto]](None, False, True, result.status_code, None)
+            response.load_error(result)
+            return response
+
+    def create_meeting(self, body: MeetingCreateDto) -> AstroResult[MeetingDto]:
+        """
+        Creates a new Meeting for the current user. If you specify an
+        assignee for this Meeting, that user will be assigned to it. If
+        you do not specify an assignee, the Meeting will be
+        automatically assigned to you.
+
+        Parameters
+        ----------
+        body : MeetingCreateDto
+            The data used to create the Meeting
+        """
+        path = "/api/data/meetings"
+        queryParams = {}
+        result = self.client.send_request("POST", path, remove_empty_elements(dataclasses.asdict(body)), queryParams, None)
+        if result.status_code >= 200 and result.status_code < 300:
+            data = dacite.from_dict(data_class=MeetingDto, data=json.loads(result.content)['data'])
+            return AstroResult[MeetingDto](None, True, False, result.status_code, data)
+        else:
+            response = AstroResult[MeetingDto](None, False, True, result.status_code, None)
+            response.load_error(result)
+            return response
+
     def get_meeting(self, meetingId: str) -> AstroResult[MeetingDetailsDto]:
         """
         Retrieve a Meeting by its unique identifier or by its short ID.
@@ -104,29 +152,6 @@ class MeetingsClient:
             response.load_error(result)
             return response
 
-    def create_meeting(self, body: MeetingCreateDto) -> AstroResult[MeetingDto]:
-        """
-        Creates a new Meeting for the current user. If you specify an
-        assignee for this Meeting, that user will be assigned to it. If
-        you do not specify an assignee, the Meeting will be
-        automatically assigned to you.
-
-        Parameters
-        ----------
-        body : MeetingCreateDto
-            The data used to create the Meeting
-        """
-        path = "/api/data/meetings"
-        queryParams = {}
-        result = self.client.send_request("POST", path, remove_empty_elements(dataclasses.asdict(body)), queryParams, None)
-        if result.status_code >= 200 and result.status_code < 300:
-            data = dacite.from_dict(data_class=MeetingDto, data=json.loads(result.content)['data'])
-            return AstroResult[MeetingDto](None, True, False, result.status_code, data)
-        else:
-            response = AstroResult[MeetingDto](None, False, True, result.status_code, None)
-            response.load_error(result)
-            return response
-
     def create_weekly_recurring_meetings(self, meetingId: str, body: WeeklyRecurringSettingsDto) -> AstroResult[RecurringTaskChangeSetDetails]:
         """
         Changes an existing Non-Project Task into a Recurring Task, so

{projectmanagersdk-152.0.138 → projectmanagersdk-154.0.181}/src/ProjectManagerSdk/clients/nptclient.py

@@ -31,6 +31,55 @@ class NptClient:
     def __init__(self, client: ProjectManagerClient):
         self.client = client
 
+    def get_npts(self) -> AstroResult[List[NptDto]]:
+        """
+        Retrieve a list of Non-Project Tasks (NPTs). This endpoint does
+        not use OData.
+
+        Parameters
+        ----------
+        """
+        path = "/api/data/non-project-tasks"
+        queryParams = {}
+        result = self.client.send_request("GET", path, None, queryParams, None)
+        if result.status_code >= 200 and result.status_code < 300:
+            data = []
+            for dict in json.loads(result.content)['data']:
+                data.append(dacite.from_dict(data_class=NptDto, data=dict))
+            return AstroResult[List[NptDto]](None, True, False, result.status_code, data)
+        else:
+            response = AstroResult[List[NptDto]](None, False, True, result.status_code, None)
+            response.load_error(result)
+            return response
+
+    def create_npt(self, body: NptCreateDto) -> AstroResult[NptDto]:
+        """
+        Creates a new Non-Project Task (NPT) for the current user. If
+        you specify an assignee for this NPT, that user will be assigned
+        to this task. If you do not specify an assignee, the NPT will be
+        automatically assigned to you. A Non-Project Task (NPT) is an
+        individual element of work that is outside of a project. Many
+        people use NPTs to track personal work or general administrative
+        work. NPTs have nearly all the same features as other tasks, but
+        since they are not part of a project, they can be tracked
+        separately by individuals.
+
+        Parameters
+        ----------
+        body : NptCreateDto
+            The data used to create the Npt
+        """
+        path = "/api/data/non-project-tasks"
+        queryParams = {}
+        result = self.client.send_request("POST", path, remove_empty_elements(dataclasses.asdict(body)), queryParams, None)
+        if result.status_code >= 200 and result.status_code < 300:
+            data = dacite.from_dict(data_class=NptDto, data=json.loads(result.content)['data'])
+            return AstroResult[NptDto](None, True, False, result.status_code, data)
+        else:
+            response = AstroResult[NptDto](None, False, True, result.status_code, None)
+            response.load_error(result)
+            return response
+
     def get_npt(self, nptId: str) -> AstroResult[NptDetailsDto]:
         """
         Retrieve a Non-Project Task (NPT) by its unique identifier or by
@@ -114,31 +163,3 @@ class NptClient:
             response = AstroResult[object](None, False, True, result.status_code, None)
             response.load_error(result)
             return response
-
-    def create_npt(self, body: NptCreateDto) -> AstroResult[NptDto]:
-        """
-        Creates a new Non-Project Task (NPT) for the current user. If
-        you specify an assignee for this NPT, that user will be assigned
-        to this task. If you do not specify an assignee, the NPT will be
-        automatically assigned to you. A Non-Project Task (NPT) is an
-        individual element of work that is outside of a project. Many
-        people use NPTs to track personal work or general administrative
-        work. NPTs have nearly all the same features as other tasks, but
-        since they are not part of a project, they can be tracked
-        separately by individuals.
-
-        Parameters
-        ----------
-        body : NptCreateDto
-            The data used to create the Npt
-        """
-        path = "/api/data/non-project-tasks"
-        queryParams = {}
-        result = self.client.send_request("POST", path, remove_empty_elements(dataclasses.asdict(body)), queryParams, None)
-        if result.status_code >= 200 and result.status_code < 300:
-            data = dacite.from_dict(data_class=NptDto, data=json.loads(result.content)['data'])
-            return AstroResult[NptDto](None, True, False, result.status_code, data)
-        else:
-            response = AstroResult[NptDto](None, False, True, result.status_code, None)
-            response.load_error(result)
-            return response

projectmanagersdk-154.0.181/src/ProjectManagerSdk/clients/nptstatusclient.py

@@ -0,0 +1,116 @@
+#
+# ProjectManager API for Python
+#
+# (c) ProjectManager.com, Inc.
+#
+# For the full copyright and license information, please view the LICENSE
+# file that was distributed with this source code.
+#
+# @author     ProjectManager.com <support@projectmanager.com>
+# @copyright  ProjectManager.com, Inc.
+# @link       https://github.com/projectmgr/projectmanager-sdk-python
+#
+
+from ProjectManagerSdk.models.astroresult import AstroResult
+from ProjectManagerSdk.models.nptstatuscreatedto import NptStatusCreateDto
+from ProjectManagerSdk.models.nptstatusdto import NptStatusDto
+from ProjectManagerSdk.models.nptstatusupdatedto import NptStatusUpdateDto
+from typing import List
+from ProjectManagerSdk.tools import remove_empty_elements
+import dataclasses
+import json
+import dacite
+
+class NptStatusClient:
+    """
+    API methods related to NptStatus
+    """
+    from ProjectManagerSdk.projectmanagerclient import ProjectManagerClient
+
+    def __init__(self, client: ProjectManagerClient):
+        self.client = client
+
+    def get_npt_task_statuses(self) -> AstroResult[List[NptStatusDto]]:
+        """
+        Get a list of task statuses that can be used by non-protect
+        tasks.
+
+        Parameters
+        ----------
+        """
+        path = "/api/data/non-project-tasks/statuses"
+        queryParams = {}
+        result = self.client.send_request("GET", path, None, queryParams, None)
+        if result.status_code >= 200 and result.status_code < 300:
+            data = []
+            for dict in json.loads(result.content)['data']:
+                data.append(dacite.from_dict(data_class=NptStatusDto, data=dict))
+            return AstroResult[List[NptStatusDto]](None, True, False, result.status_code, data)
+        else:
+            response = AstroResult[List[NptStatusDto]](None, False, True, result.status_code, None)
+            response.load_error(result)
+            return response
+
+    def create_npt_task_status(self, body: NptStatusCreateDto) -> AstroResult[NptStatusDto]:
+        """
+        Creates a new status level for non-project tasks.
+
+        Parameters
+        ----------
+        body : NptStatusCreateDto
+            Information about the new status level to create
+        """
+        path = "/api/data/non-project-tasks/statuses"
+        queryParams = {}
+        result = self.client.send_request("POST", path, remove_empty_elements(dataclasses.asdict(body)), queryParams, None)
+        if result.status_code >= 200 and result.status_code < 300:
+            data = dacite.from_dict(data_class=NptStatusDto, data=json.loads(result.content)['data'])
+            return AstroResult[NptStatusDto](None, True, False, result.status_code, data)
+        else:
+            response = AstroResult[NptStatusDto](None, False, True, result.status_code, None)
+            response.load_error(result)
+            return response
+
+    def update_npt_task_status(self, nptStatusId: str, body: NptStatusUpdateDto) -> AstroResult[NptStatusDto]:
+        """
+        Updates an existing status level for non-project tasks.
+
+        Parameters
+        ----------
+        nptStatusId : str
+            The unique identifier of the status to update
+        body : NptStatusUpdateDto
+            Information about the status level to update
+        """
+        path = f"/api/data/non-project-tasks/statuses/{nptStatusId}"
+        queryParams = {}
+        result = self.client.send_request("PUT", path, remove_empty_elements(dataclasses.asdict(body)), queryParams, None)
+        if result.status_code >= 200 and result.status_code < 300:
+            data = dacite.from_dict(data_class=NptStatusDto, data=json.loads(result.content)['data'])
+            return AstroResult[NptStatusDto](None, True, False, result.status_code, data)
+        else:
+            response = AstroResult[NptStatusDto](None, False, True, result.status_code, None)
+            response.load_error(result)
+            return response
+
+    def delete_npt_task_status(self, nptStatusId: str) -> AstroResult[object]:
+        """
+        Deletes an existing status level for non-project tasks. You will
+        not be able to delete a status if there are tasks assigned to it
+        or if it is the default status level.
+
+        Parameters
+        ----------
+        nptStatusId : str
+            The unique identifier of the status to delete
+        """
+        path = f"/api/data/non-project-tasks/statuses/{nptStatusId}"
+        queryParams = {}
+        result = self.client.send_request("DELETE", path, None, queryParams, None)
+        if result.status_code >= 200 and result.status_code < 300:
+            data = dacite.from_dict(data_class=object, data=json.loads(result.content)['data'])
+            return AstroResult[object](None, True, False, result.status_code, data)
+        else:
+            response = AstroResult[object](None, False, True, result.status_code, None)
+            response.load_error(result)
+            return response

{projectmanagersdk-152.0.138 → projectmanagersdk-154.0.181}/src/ProjectManagerSdk/clients/projectclient.py

@@ -14,6 +14,7 @@
 from ProjectManagerSdk.models.astroresult import AstroResult
 from ProjectManagerSdk.models.projectcreatedto import ProjectCreateDto
 from ProjectManagerSdk.models.projectdto import ProjectDto
+from ProjectManagerSdk.models.projectreopenstatusdto import ProjectReopenStatusDto
 from ProjectManagerSdk.models.projectupdatedto import ProjectUpdateDto
 from typing import List
 from ProjectManagerSdk.tools import remove_empty_elements
@@ -131,11 +132,7 @@ class ProjectClient:
         towards a goal. Within a Project, Tasks represent individual
         items of work that team members must complete. The sum total of
         Tasks within a Project represents the work to be completed for
-        that Project. Multiple users can be working on data at the same
-        time. When you call an API to update an object, this call is
-        converted into a Changeset that is then applied sequentially.
-        You can use RetrieveChangeset to see the status of an individual
-        Changeset.
+        that Project.
 
         Parameters
         ----------
@@ -184,26 +181,26 @@ class ProjectClient:
             response.load_error(result)
             return response
 
-    def restore_project(self, projectId: str) -> AstroResult[object]:
+    def reopen_project_status(self, projectId: str) -> AstroResult[ProjectReopenStatusDto]:
         """
-        Restore a soft deleted project based on its unique identifier. A
-        Project is a collection of Tasks that contributes towards a
-        goal. Within a Project, Tasks represent individual items of work
-        that team members must complete. The sum total of Tasks within a
-        Project represents the work to be completed for that Project.
+        Check if a project is in a valid state so that it can be
+        reopened without any side effects. For example, if Rates have
+        changed for this project, reopening it will result is project
+        costs being recalculated which will adjust costs. This endpoint
+        will return what side effects may occur if it is reopened.
 
         Parameters
         ----------
         projectId : str
-            The unique identifier of the Project to delete
+            The unique identifier of the project to check.
         """
-        path = f"/api/data/projects/{projectId}/restore"
+        path = f"/api/data/projects/{projectId}/reopen/status"
         queryParams = {}
-        result = self.client.send_request("PUT", path, None, queryParams, None)
+        result = self.client.send_request("GET", path, None, queryParams, None)
         if result.status_code >= 200 and result.status_code < 300:
-            data = dacite.from_dict(data_class=object, data=json.loads(result.content)['data'])
-            return AstroResult[object](None, True, False, result.status_code, data)
+            data = dacite.from_dict(data_class=ProjectReopenStatusDto, data=json.loads(result.content)['data'])
+            return AstroResult[ProjectReopenStatusDto](None, True, False, result.status_code, data)
         else:
-            response = AstroResult[object](None, False, True, result.status_code, None)
+            response = AstroResult[ProjectReopenStatusDto](None, False, True, result.status_code, None)
             response.load_error(result)
             return response

{projectmanagersdk-152.0.138 → projectmanagersdk-154.0.181}/src/ProjectManagerSdk/clients/resourceskillclient.py

@@ -97,18 +97,18 @@ class ResourceSkillClient:
             response.load_error(result)
             return response
 
-    def update_resource_skill(self, skillId: str, body: UpdateResourceSkillDto) -> AstroResult[ResourceSkillDto]:
+    def update_resource_skill(self, resourceSkillId: str, body: UpdateResourceSkillDto) -> AstroResult[ResourceSkillDto]:
         """
         Update a Resource Skill.
 
         Parameters
         ----------
-        skillId : str
+        resourceSkillId : str
             The id of the skill to update.
         body : UpdateResourceSkillDto
             The data of the skill to update.
         """
-        path = f"/api/data/resources/skills/{skillId}"
+        path = f"/api/data/resources/skills/{resourceSkillId}"
         queryParams = {}
         result = self.client.send_request("PUT", path, remove_empty_elements(dataclasses.asdict(body)), queryParams, None)
         if result.status_code >= 200 and result.status_code < 300:

{projectmanagersdk-152.0.138 → projectmanagersdk-154.0.181}/src/ProjectManagerSdk/clients/resourceteamclient.py

@@ -117,18 +117,18 @@ class ResourceTeamClient:
             response.load_error(result)
             return response
 
-    def update_resource_team(self, teamresourceId: str, body: UpdateResourceTeamDto) -> AstroResult[ResourceTeamDto]:
+    def update_resource_team(self, resourceTeamId: str, body: UpdateResourceTeamDto) -> AstroResult[ResourceTeamDto]:
         """
         Update a Resource Team.
 
         Parameters
         ----------
-        teamresourceId : str
+        resourceTeamId : str
             The id of the resource team
         body : UpdateResourceTeamDto
             The name of the team to Update.
         """
-        path = f"/api/data/resources/teams/{teamresourceId}"
+        path = f"/api/data/resources/teams/{resourceTeamId}"
         queryParams = {}
         result = self.client.send_request("PUT", path, remove_empty_elements(dataclasses.asdict(body)), queryParams, None)
         if result.status_code >= 200 and result.status_code < 300:

{projectmanagersdk-152.0.138 → projectmanagersdk-154.0.181}/src/ProjectManagerSdk/clients/riskclient.py

@@ -129,7 +129,7 @@ class RiskClient:
             response.load_error(result)
             return response
 
-    def create_risk(self, projectId: str, body: RiskCreateDto) -> AstroResult[RiskDto]:
+    def create_project_risk(self, projectId: str, body: RiskCreateDto) -> AstroResult[RiskDto]:
         """
         Creates a new Risk within the specified Project. The Risk will
         inherit Project context such as access permissions and workspace
@@ -143,7 +143,7 @@ class RiskClient:
         body : RiskCreateDto
             The data used to create the Risk
         """
-        path = f"/api/data/risks/{projectId}"
+        path = f"/api/data/risks/projects/{projectId}"
         queryParams = {}
         result = self.client.send_request("POST", path, remove_empty_elements(dataclasses.asdict(body)), queryParams, None)
         if result.status_code >= 200 and result.status_code < 300:

projectmanagersdk-154.0.181/src/ProjectManagerSdk/clients/securityclient.py

@@ -0,0 +1,146 @@
+#
+# ProjectManager API for Python
+#
+# (c) ProjectManager.com, Inc.
+#
+# For the full copyright and license information, please view the LICENSE
+# file that was distributed with this source code.
+#
+# @author     ProjectManager.com <support@projectmanager.com>
+# @copyright  ProjectManager.com, Inc.
+# @link       https://github.com/projectmgr/projectmanager-sdk-python
+#
+
+from ProjectManagerSdk.models.astroresult import AstroResult
+from ProjectManagerSdk.models.businessroleslistdto import BusinessRolesListDto
+from ProjectManagerSdk.models.rolecreatedto import RoleCreateDto
+from ProjectManagerSdk.models.roledto import RoleDto
+from ProjectManagerSdk.models.roleupdatechangeitemdto import RoleUpdateChangeItemDto
+from typing import List
+from ProjectManagerSdk.tools import remove_empty_elements
+import dataclasses
+import json
+import dacite
+
+class SecurityClient:
+    """
+    API methods related to Security
+    """
+    from ProjectManagerSdk.projectmanagerclient import ProjectManagerClient
+
+    def __init__(self, client: ProjectManagerClient):
+        self.client = client
+
+    def list_business_roles(self) -> AstroResult[BusinessRolesListDto]:
+        """
+        Returns every business role in the current workspace, including
+        built-in and custom roles. Each role includes a permissions
+        object with entitlement and grant state for the account security
+        matrix.
+
+        Parameters
+        ----------
+        """
+        path = "/api/data/security/businessroles"
+        queryParams = {}
+        result = self.client.send_request("GET", path, None, queryParams, None)
+        if result.status_code >= 200 and result.status_code < 300:
+            data = dacite.from_dict(data_class=BusinessRolesListDto, data=json.loads(result.content)['data'])
+            return AstroResult[BusinessRolesListDto](None, True, False, result.status_code, data)
+        else:
+            response = AstroResult[BusinessRolesListDto](None, False, True, result.status_code, None)
+            response.load_error(result)
+            return response
+
+    def create_business_role(self, body: RoleCreateDto) -> AstroResult[RoleDto]:
+        """
+        Chargebee entitlements are evaluated read-only when saving
+        permission grants; this call does not change subscription state.
+
+        Parameters
+        ----------
+        body : RoleCreateDto
+            Role name, optional description, and permission settings for
+            the new role.
+        """
+        path = "/api/data/security/businessroles"
+        queryParams = {}
+        result = self.client.send_request("POST", path, remove_empty_elements(dataclasses.asdict(body)), queryParams, None)
+        if result.status_code >= 200 and result.status_code < 300:
+            data = dacite.from_dict(data_class=RoleDto, data=json.loads(result.content)['data'])
+            return AstroResult[RoleDto](None, True, False, result.status_code, data)
+        else:
+            response = AstroResult[RoleDto](None, False, True, result.status_code, None)
+            response.load_error(result)
+            return response
+
+    def update_business_role(self, roleId: str, body: List[RoleUpdateChangeItemDto]) -> AstroResult[RoleDto]:
+        """
+        Send property change sets using the same pattern as other
+        workspace batch-update APIs. For permissions, include a
+        permissions property with a partial or full permissions object;
+        omitted keys are merged with the current role. Keys may use the
+        same names as GET `permissions` (e.g. `editUsers`) or RetrieveMe
+        / POST-create style (e.g. `editUser`). The response body matches
+        create when successful.
+
+        Parameters
+        ----------
+        roleId : str
+            Business role identifier.
+        body : List[RoleUpdateChangeItemDto]
+            List of property name and value pairs to apply.
+        """
+        path = f"/api/data/security/businessroles/{roleId}"
+        queryParams = {}
+        bodyArray = []
+        for item in body:
+            bodyArray.append(remove_empty_elements(dataclasses.asdict(item)))
+        result = self.client.send_request("PUT", path, bodyArray, queryParams, None)
+        if result.status_code >= 200 and result.status_code < 300:
+            data = dacite.from_dict(data_class=RoleDto, data=json.loads(result.content)['data'])
+            return AstroResult[RoleDto](None, True, False, result.status_code, data)
+        else:
+            response = AstroResult[RoleDto](None, False, True, result.status_code, None)
+            response.load_error(result)
+            return response
+
+    def delete_business_role(self, roleId: str) -> AstroResult[object]:
+        """
+        Built-in roles cannot be deleted. Users assigned to the role may
+        need to be reassigned before the role can be removed.
+
+        Parameters
+        ----------
+        roleId : str
+            Identifier of the custom role to remove.
+        """
+        path = f"/api/data/security/businessroles/{roleId}"
+        queryParams = {}
+        result = self.client.send_request("DELETE", path, None, queryParams, None)
+        if result.status_code >= 200 and result.status_code < 300:
+            data = dacite.from_dict(data_class=object, data=json.loads(result.content)['data'])
+            return AstroResult[object](None, True, False, result.status_code, data)
+        else:
+            response = AstroResult[object](None, False, True, result.status_code, None)
+            response.load_error(result)
+            return response
+
+    def resend_email_validation(self) -> AstroResult[object]:
+        """
+        Sends another validation email to the authenticated user's
+        workspace email address.
+
+        Parameters
+        ----------
+        """
+        path = "/api/data/security/email/validation/resend"
+        queryParams = {}
+        result = self.client.send_request("GET", path, None, queryParams, None)
+        if result.status_code >= 200 and result.status_code < 300:
+            data = dacite.from_dict(data_class=object, data=json.loads(result.content)['data'])
+            return AstroResult[object](None, True, False, result.status_code, data)
+        else:
+            response = AstroResult[object](None, False, True, result.status_code, None)
+            response.load_error(result)
+            return response

{projectmanagersdk-152.0.138 → projectmanagersdk-154.0.181}/src/ProjectManagerSdk/clients/tagclient.py

@@ -121,3 +121,23 @@ class TagClient:
             response = AstroResult[TagDto](None, False, True, result.status_code, None)
             response.load_error(result)
             return response
+
+    def delete_tag(self, tagId: str) -> AstroResult[object]:
+        """
+        Permanently removes the specified Tag.
+
+        Parameters
+        ----------
+        tagId : str
+            The id of the tag to delete
+        """
+        path = f"/api/data/tags/{tagId}"
+        queryParams = {}
+        result = self.client.send_request("DELETE", path, None, queryParams, None)
+        if result.status_code >= 200 and result.status_code < 300:
+            data = dacite.from_dict(data_class=object, data=json.loads(result.content)['data'])
+            return AstroResult[object](None, True, False, result.status_code, data)
+        else:
+            response = AstroResult[object](None, False, True, result.status_code, None)
+            response.load_error(result)
+            return response