universal-mcp 0.1.9rc1__py3-none-any.whl → 0.1.10__py3-none-any.whl

universal_mcp/applications/clickup/app.py

@@ -6,25 +6,27 @@ from universal_mcp.integrations import Integration
 
 class ClickupApp(APIApplication):
     def __init__(self, integration: Integration = None, **kwargs) -> None:
-        super().__init__(name='clickup', integration=integration, **kwargs)
+        super().__init__(name="clickup", integration=integration, **kwargs)
         self.base_url = "https://api.clickup.com/api/v2"
 
-    def authorization_get_access_token(self, client_id, client_secret, code) -> dict[str, Any]:
+    def authorization_get_access_token(
+        self, client_id, client_secret, code
+    ) -> dict[str, Any]:
         """
         Exchanges an authorization code for an access token using OAuth2 credentials.
-        
+
         Args:
             client_id: The client identifier string obtained from the OAuth provider.
             client_secret: The client secret string associated with the client_id.
             code: The authorization code received after user consent.
-        
+
         Returns:
             A dictionary containing the access token and related response data from the OAuth provider.
-        
+
         Raises:
             ValueError: If 'client_id', 'client_secret', or 'code' is missing or None.
             HTTPError: If the HTTP request to the OAuth token endpoint fails with a non-success status code.
-        
+
         Tags:
             authorization, oauth2, get, access-token
         """
@@ -35,24 +37,34 @@ class ClickupApp(APIApplication):
         if code is None:
             raise ValueError("Missing required parameter 'code'")
         url = f"{self.base_url}/oauth/token"
-        query_params = {k: v for k, v in [('client_id', client_id), ('client_secret', client_secret), ('code', code)] if v is not None}
+        query_params = {
+            k: v
+            for k, v in [
+                ("client_id", client_id),
+                ("client_secret", client_secret),
+                ("code", code),
+            ]
+            if v is not None
+        }
         response = self._post(url, data={}, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def authorization_view_account_details(self, ) -> dict[str, Any]:
+    def authorization_view_account_details(
+        self,
+    ) -> dict[str, Any]:
         """
         Retrieves the current authenticated user's account details from the authorization service.
-        
+
         Args:
             None: This function takes no arguments
-        
+
         Returns:
             dict: A dictionary containing the authenticated user's account information as returned by the authorization service.
-        
+
         Raises:
             requests.HTTPError: If the GET request to fetch user details returns an unsuccessful HTTP status code.
-        
+
         Tags:
             authorization, view, account, details, api
         """
@@ -62,19 +74,21 @@ class ClickupApp(APIApplication):
         response.raise_for_status()
         return response.json()
 
-    def authorization_get_workspace_list(self, ) -> dict[str, Any]:
+    def authorization_get_workspace_list(
+        self,
+    ) -> dict[str, Any]:
         """
         Retrieves a list of workspaces accessible to the authorized user from the authorization service.
-        
+
         Args:
             None: This function takes no arguments
-        
+
         Returns:
             dict: A dictionary containing workspace information for the user, as returned by the authorization service.
-        
+
         Raises:
             requests.HTTPError: If the HTTP request to the authorization service fails or returns a non-success status code.
-        
+
         Tags:
             get, list, workspaces, authorization
         """
@@ -84,23 +98,25 @@ class ClickupApp(APIApplication):
         response.raise_for_status()
         return response.json()
 
-    def task_checklists_create_new_checklist(self, task_id, name, custom_task_ids=None, team_id=None) -> dict[str, Any]:
+    def task_checklists_create_new_checklist(
+        self, task_id, name, custom_task_ids=None, team_id=None
+    ) -> dict[str, Any]:
         """
         Creates a new checklist for a given task and returns the created checklist details as a dictionary.
-        
+
         Args:
             task_id: str. The unique identifier of the task for which the checklist will be created.
             name: str. The name of the new checklist.
             custom_task_ids: Optional[list[str]]. A list of custom task IDs to associate with the checklist. Defaults to None.
             team_id: Optional[str]. The ID of the team to associate with the checklist. Defaults to None.
-        
+
         Returns:
             dict[str, Any]: A dictionary containing the details of the newly created checklist from the API response.
-        
+
         Raises:
             ValueError: If 'task_id' or 'name' is not provided.
             requests.HTTPError: If the API request fails or returns an unsuccessful status code.
-        
+
         Tags:
             create, checklist, task-management, api
         """
@@ -109,39 +125,45 @@ class ClickupApp(APIApplication):
         if name is None:
             raise ValueError("Missing required parameter 'name'")
         request_body = {
-            'name': name,
+            "name": name,
         }
         request_body = {k: v for k, v in request_body.items() if v is not None}
         url = f"{self.base_url}/task/{task_id}/checklist"
-        query_params = {k: v for k, v in [('custom_task_ids', custom_task_ids), ('team_id', team_id)] if v is not None}
+        query_params = {
+            k: v
+            for k, v in [("custom_task_ids", custom_task_ids), ("team_id", team_id)]
+            if v is not None
+        }
         response = self._post(url, data=request_body, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def task_checklists_update_checklist(self, checklist_id, name=None, position=None) -> dict[str, Any]:
+    def task_checklists_update_checklist(
+        self, checklist_id, name=None, position=None
+    ) -> dict[str, Any]:
         """
         Updates a checklist's name and/or position by sending a PUT request to the checklist API endpoint.
-        
+
         Args:
             checklist_id: str. The unique identifier of the checklist to update. Required.
             name: str or None. The new name for the checklist. Optional.
             position: int or None. The new position of the checklist. Optional.
-        
+
         Returns:
             dict[str, Any]: A dictionary containing the updated checklist data returned by the API.
-        
+
         Raises:
             ValueError: Raised if the required parameter 'checklist_id' is None.
             HTTPError: Raised if the HTTP response contains an unsuccessful status code.
-        
+
         Tags:
             update, checklist, management, api
         """
         if checklist_id is None:
             raise ValueError("Missing required parameter 'checklist_id'")
         request_body = {
-            'name': name,
-            'position': position,
+            "name": name,
+            "position": position,
         }
         request_body = {k: v for k, v in request_body.items() if v is not None}
         url = f"{self.base_url}/checklist/{checklist_id}"
@@ -153,17 +175,17 @@ class ClickupApp(APIApplication):
     def task_checklists_remove_checklist(self, checklist_id) -> dict[str, Any]:
         """
         Removes a checklist by its ID using a DELETE request to the API.
-        
+
         Args:
             checklist_id: The unique identifier of the checklist to be removed. Must not be None.
-        
+
         Returns:
             A dictionary containing the JSON response from the API after the checklist has been removed.
-        
+
         Raises:
             ValueError: If 'checklist_id' is None.
             HTTPError: If the HTTP request to delete the checklist fails (non-2xx status code).
-        
+
         Tags:
             remove, checklist, delete, management
         """
@@ -175,30 +197,32 @@ class ClickupApp(APIApplication):
         response.raise_for_status()
         return response.json()
 
-    def task_checklists_add_line_item(self, checklist_id, name=None, assignee=None) -> dict[str, Any]:
+    def task_checklists_add_line_item(
+        self, checklist_id, name=None, assignee=None
+    ) -> dict[str, Any]:
         """
         Adds a new line item to a specified task checklist.
-        
+
         Args:
             checklist_id: str. Unique identifier of the checklist to which the line item will be added.
             name: Optional[str]. Name of the checklist line item to be added.
             assignee: Optional[str]. Identifier of the user to assign the line item to.
-        
+
         Returns:
             dict[str, Any]: Dictionary containing the details of the newly created checklist line item as returned by the API.
-        
+
         Raises:
             ValueError: Raised if the required parameter 'checklist_id' is not provided.
             requests.HTTPError: Raised if the HTTP request to add the checklist item fails.
-        
+
         Tags:
             add, checklist, line-item, management
         """
         if checklist_id is None:
             raise ValueError("Missing required parameter 'checklist_id'")
         request_body = {
-            'name': name,
-            'assignee': assignee,
+            "name": name,
+            "assignee": assignee,
         }
         request_body = {k: v for k, v in request_body.items() if v is not None}
         url = f"{self.base_url}/checklist/{checklist_id}/checklist_item"
@@ -207,10 +231,18 @@ class ClickupApp(APIApplication):
         response.raise_for_status()
         return response.json()
 
-    def task_checklists_update_checklist_item(self, checklist_id, checklist_item_id, name=None, assignee=None, resolved=None, parent=None) -> dict[str, Any]:
+    def task_checklists_update_checklist_item(
+        self,
+        checklist_id,
+        checklist_item_id,
+        name=None,
+        assignee=None,
+        resolved=None,
+        parent=None,
+    ) -> dict[str, Any]:
         """
         Updates a checklist item with new details such as name, assignee, resolution status, or parent within a specified checklist.
-        
+
         Args:
             checklist_id: str. Unique identifier for the checklist containing the item to update.
             checklist_item_id: str. Unique identifier for the checklist item to be updated.
@@ -218,14 +250,14 @@ class ClickupApp(APIApplication):
             assignee: str, optional. Identifier of the user assigned to this checklist item. If None, the assignee remains unchanged.
             resolved: bool, optional. Resolution status to set for the checklist item. If None, the resolved status remains unchanged.
             parent: str, optional. Identifier of the parent checklist item, if setting or updating a parent-child relationship. If None, the parent remains unchanged.
-        
+
         Returns:
             dict[str, Any]: The updated checklist item as a dictionary parsed from the server response.
-        
+
         Raises:
             ValueError: Raised if either 'checklist_id' or 'checklist_item_id' is None.
             requests.HTTPError: Raised if the API request fails or the server returns an unsuccessful status code.
-        
+
         Tags:
             update, checklist, management, item
         """
@@ -234,10 +266,10 @@ class ClickupApp(APIApplication):
         if checklist_item_id is None:
             raise ValueError("Missing required parameter 'checklist_item_id'")
         request_body = {
-            'name': name,
-            'assignee': assignee,
-            'resolved': resolved,
-            'parent': parent,
+            "name": name,
+            "assignee": assignee,
+            "resolved": resolved,
+            "parent": parent,
         }
         request_body = {k: v for k, v in request_body.items() if v is not None}
         url = f"{self.base_url}/checklist/{checklist_id}/checklist_item/{checklist_item_id}"
@@ -246,21 +278,23 @@ class ClickupApp(APIApplication):
         response.raise_for_status()
         return response.json()
 
-    def task_checklists_remove_checklist_item(self, checklist_id, checklist_item_id) -> dict[str, Any]:
+    def task_checklists_remove_checklist_item(
+        self, checklist_id, checklist_item_id
+    ) -> dict[str, Any]:
         """
         Removes a specific checklist item from a checklist by issuing a DELETE request to the appropriate API endpoint.
-        
+
         Args:
             checklist_id: The unique identifier of the checklist containing the item to remove.
             checklist_item_id: The unique identifier of the checklist item to be removed.
-        
+
         Returns:
             A dictionary containing the API response data after attempting to remove the checklist item.
-        
+
         Raises:
             ValueError: Raised if either 'checklist_id' or 'checklist_item_id' is None.
             requests.HTTPError: Raised if the HTTP request to delete the checklist item fails (e.g., due to network issues, authorization problems, or the item not existing).
-        
+
         Tags:
             remove, checklist, delete, management
         """
@@ -274,39 +308,58 @@ class ClickupApp(APIApplication):
         response.raise_for_status()
         return response.json()
 
-    def comments_get_task_comments(self, task_id, custom_task_ids=None, team_id=None, start=None, start_id=None) -> dict[str, Any]:
+    def comments_get_task_comments(
+        self, task_id, custom_task_ids=None, team_id=None, start=None, start_id=None
+    ) -> dict[str, Any]:
         """
         Retrieve all comments associated with a specific task.
-        
+
         Args:
             task_id: str. The unique identifier for the task whose comments are to be retrieved. Required.
             custom_task_ids: Optional[str]. An alternative unique identifier for the task, useful when using custom task ID schemes. Defaults to None.
             team_id: Optional[str]. The identifier of the team associated with the task. Used to limit the search to a specific team. Defaults to None.
             start: Optional[int]. The position offset for pagination, specifying where to start retrieving comments. Defaults to None.
             start_id: Optional[str]. The ID of the first comment from which to start retrieving (for pagination). Defaults to None.
-        
+
         Returns:
             dict[str, Any]: A dictionary containing the list of comments and associated metadata for the specified task.
-        
+
         Raises:
             ValueError: If 'task_id' is not provided.
             requests.HTTPError: If the HTTP request to retrieve comments fails (e.g., due to network errors or server-side issues).
-        
+
         Tags:
             list, comments, task, search, management
         """
         if task_id is None:
             raise ValueError("Missing required parameter 'task_id'")
         url = f"{self.base_url}/task/{task_id}/comment"
-        query_params = {k: v for k, v in [('custom_task_ids', custom_task_ids), ('team_id', team_id), ('start', start), ('start_id', start_id)] if v is not None}
+        query_params = {
+            k: v
+            for k, v in [
+                ("custom_task_ids", custom_task_ids),
+                ("team_id", team_id),
+                ("start", start),
+                ("start_id", start_id),
+            ]
+            if v is not None
+        }
         response = self._get(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def comments_create_new_task_comment(self, task_id, comment_text, assignee, notify_all, custom_task_ids=None, team_id=None) -> dict[str, Any]:
+    def comments_create_new_task_comment(
+        self,
+        task_id,
+        comment_text,
+        assignee,
+        notify_all,
+        custom_task_ids=None,
+        team_id=None,
+    ) -> dict[str, Any]:
         """
         Creates a new comment on the specified task, assigning it to a user and controlling notification behavior.
-        
+
         Args:
             task_id: str. Unique identifier of the task to comment on.
             comment_text: str. The text content of the comment to be added.
@@ -314,14 +367,14 @@ class ClickupApp(APIApplication):
             notify_all: bool. Determines whether all users associated with the task should be notified.
             custom_task_ids: Optional[str]. Custom identifier for the task, if applicable.
             team_id: Optional[str]. Identifier of the team to which the task belongs, if applicable.
-        
+
         Returns:
             dict[str, Any]: A dictionary containing the created comment data as returned by the API.
-        
+
         Raises:
             ValueError: Raised if any of the required parameters ('task_id', 'comment_text', 'assignee', or 'notify_all') are missing.
             requests.HTTPError: Raised if the HTTP request to create the comment fails or the response status indicates an error.
-        
+
         Tags:
             create, comment, task, api, management
         """
@@ -334,60 +387,70 @@ class ClickupApp(APIApplication):
         if notify_all is None:
             raise ValueError("Missing required parameter 'notify_all'")
         request_body = {
-            'comment_text': comment_text,
-            'assignee': assignee,
-            'notify_all': notify_all,
+            "comment_text": comment_text,
+            "assignee": assignee,
+            "notify_all": notify_all,
         }
         request_body = {k: v for k, v in request_body.items() if v is not None}
         url = f"{self.base_url}/task/{task_id}/comment"
-        query_params = {k: v for k, v in [('custom_task_ids', custom_task_ids), ('team_id', team_id)] if v is not None}
+        query_params = {
+            k: v
+            for k, v in [("custom_task_ids", custom_task_ids), ("team_id", team_id)]
+            if v is not None
+        }
         response = self._post(url, data=request_body, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def comments_get_view_comments(self, view_id, start=None, start_id=None) -> dict[str, Any]:
+    def comments_get_view_comments(
+        self, view_id, start=None, start_id=None
+    ) -> dict[str, Any]:
         """
         Retrieve comments for a specific view, supporting optional pagination parameters.
-        
+
         Args:
             view_id: The unique identifier of the view to retrieve comments for.
             start: Optional; the zero-based index or offset for pagination (default is None).
             start_id: Optional; the comment ID to start pagination from (default is None).
-        
+
         Returns:
             A dictionary containing the list of comments and associated metadata for the specified view.
-        
+
         Raises:
             ValueError: Raised if 'view_id' is None.
             requests.HTTPError: Raised if the HTTP request for comments fails (e.g., connection errors, non-2xx response).
-        
+
         Tags:
             get, comments, view, api, pagination
         """
         if view_id is None:
             raise ValueError("Missing required parameter 'view_id'")
         url = f"{self.base_url}/view/{view_id}/comment"
-        query_params = {k: v for k, v in [('start', start), ('start_id', start_id)] if v is not None}
+        query_params = {
+            k: v for k, v in [("start", start), ("start_id", start_id)] if v is not None
+        }
         response = self._get(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def comments_create_chat_view_comment(self, view_id, comment_text, notify_all) -> dict[str, Any]:
+    def comments_create_chat_view_comment(
+        self, view_id, comment_text, notify_all
+    ) -> dict[str, Any]:
         """
         Creates a new comment on a chat view and optionally notifies all participants.
-        
+
         Args:
             view_id: str. The unique identifier of the chat view to which the comment will be added.
             comment_text: str. The text content of the comment to post.
             notify_all: bool. Whether to notify all participants in the chat about the new comment.
-        
+
         Returns:
             dict. The response from the API containing details about the created comment.
-        
+
         Raises:
             ValueError: If any of 'view_id', 'comment_text', or 'notify_all' is None.
             requests.HTTPError: If the HTTP request to create the comment fails.
-        
+
         Tags:
             comments, create, chat, api
         """
@@ -398,8 +461,8 @@ class ClickupApp(APIApplication):
         if notify_all is None:
             raise ValueError("Missing required parameter 'notify_all'")
         request_body = {
-            'comment_text': comment_text,
-            'notify_all': notify_all,
+            "comment_text": comment_text,
+            "notify_all": notify_all,
         }
         request_body = {k: v for k, v in request_body.items() if v is not None}
         url = f"{self.base_url}/view/{view_id}/comment"
@@ -408,50 +471,56 @@ class ClickupApp(APIApplication):
         response.raise_for_status()
         return response.json()
 
-    def comments_get_list_comments(self, list_id, start=None, start_id=None) -> dict[str, Any]:
+    def comments_get_list_comments(
+        self, list_id, start=None, start_id=None
+    ) -> dict[str, Any]:
         """
         Retrieve a list of comments associated with a specific list, supporting optional pagination.
-        
+
         Args:
             list_id: The unique identifier of the list for which comments are to be retrieved.
             start: Optional; An integer specifying the offset from which to start returning comments.
             start_id: Optional; An identifier to continue retrieving comments from a specific comment onward.
-        
+
         Returns:
             A dictionary containing the list of comments and associated metadata as returned by the API.
-        
+
         Raises:
             ValueError: If 'list_id' is not provided.
             requests.HTTPError: If the HTTP request to the API fails with an error status code.
-        
+
         Tags:
             comments, list, retrieve, api, batch
         """
         if list_id is None:
             raise ValueError("Missing required parameter 'list_id'")
         url = f"{self.base_url}/list/{list_id}/comment"
-        query_params = {k: v for k, v in [('start', start), ('start_id', start_id)] if v is not None}
+        query_params = {
+            k: v for k, v in [("start", start), ("start_id", start_id)] if v is not None
+        }
         response = self._get(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def comments_add_to_list_comment(self, list_id, comment_text, assignee, notify_all) -> dict[str, Any]:
+    def comments_add_to_list_comment(
+        self, list_id, comment_text, assignee, notify_all
+    ) -> dict[str, Any]:
         """
         Adds a comment to a specified list, assigns it to a given user, and optionally notifies all stakeholders.
-        
+
         Args:
             list_id: The unique identifier of the list to which the comment will be added.
             comment_text: The text of the comment to be posted.
             assignee: The user assigned to the comment.
             notify_all: Boolean indicating whether all stakeholders should be notified of the new comment.
-        
+
         Returns:
             A dictionary containing the response data from the API after adding the comment.
-        
+
         Raises:
             ValueError: If any of the required parameters ('list_id', 'comment_text', 'assignee', or 'notify_all') are None.
             requests.HTTPError: If the HTTP request to the API fails or an unsuccessful status code is returned.
-        
+
         Tags:
             add, comment, list, assignment, notify, api
         """
@@ -464,9 +533,9 @@ class ClickupApp(APIApplication):
         if notify_all is None:
             raise ValueError("Missing required parameter 'notify_all'")
         request_body = {
-            'comment_text': comment_text,
-            'assignee': assignee,
-            'notify_all': notify_all,
+            "comment_text": comment_text,
+            "assignee": assignee,
+            "notify_all": notify_all,
         }
         request_body = {k: v for k, v in request_body.items() if v is not None}
         url = f"{self.base_url}/list/{list_id}/comment"
@@ -475,23 +544,25 @@ class ClickupApp(APIApplication):
         response.raise_for_status()
         return response.json()
 
-    def comments_update_task_comment(self, comment_id, comment_text, assignee, resolved) -> dict[str, Any]:
+    def comments_update_task_comment(
+        self, comment_id, comment_text, assignee, resolved
+    ) -> dict[str, Any]:
         """
         Updates an existing task comment with new text, assignee, and resolution status.
-        
+
         Args:
             comment_id: str. The unique identifier of the comment to update.
             comment_text: str. The new text content for the comment.
             assignee: str. The user assigned to the comment.
             resolved: bool. Indicates whether the comment has been marked as resolved.
-        
+
         Returns:
             dict[str, Any]: The updated comment details as returned by the server.
-        
+
         Raises:
             ValueError: Raised if any of the required parameters ('comment_id', 'comment_text', 'assignee', 'resolved') are None.
             requests.HTTPError: Raised if the HTTP request to update the comment fails.
-        
+
         Tags:
             update, comment, task-management, api
         """
@@ -504,9 +575,9 @@ class ClickupApp(APIApplication):
         if resolved is None:
             raise ValueError("Missing required parameter 'resolved'")
         request_body = {
-            'comment_text': comment_text,
-            'assignee': assignee,
-            'resolved': resolved,
+            "comment_text": comment_text,
+            "assignee": assignee,
+            "resolved": resolved,
         }
         request_body = {k: v for k, v in request_body.items() if v is not None}
         url = f"{self.base_url}/comment/{comment_id}"
@@ -518,17 +589,17 @@ class ClickupApp(APIApplication):
     def comments_delete_task_comment(self, comment_id) -> dict[str, Any]:
         """
         Deletes a task comment by its ID.
-        
+
         Args:
             comment_id: The unique identifier of the comment to be deleted.
-        
+
         Returns:
             Dictionary containing the response data from the server after deleting the comment.
-        
+
         Raises:
             ValueError: When the required parameter 'comment_id' is None.
             HTTPError: When the HTTP request to delete the comment fails.
-        
+
         Tags:
             delete, comment, task-management, api
         """
@@ -543,17 +614,17 @@ class ClickupApp(APIApplication):
     def custom_fields_get_list_fields(self, list_id) -> dict[str, Any]:
         """
         Retrieves a list of custom fields associated with a specified list by its ID.
-        
+
         Args:
             list_id: The unique identifier of the list for which to fetch custom fields. Must not be None.
-        
+
         Returns:
             A dictionary containing the custom fields for the specified list, as returned by the API.
-        
+
         Raises:
             ValueError: Raised if 'list_id' is None.
             requests.HTTPError: Raised if the HTTP request fails with an error status code.
-        
+
         Tags:
             get, list, custom-fields, api
         """
@@ -565,23 +636,25 @@ class ClickupApp(APIApplication):
         response.raise_for_status()
         return response.json()
 
-    def custom_fields_remove_field_value(self, task_id, field_id, custom_task_ids=None, team_id=None) -> dict[str, Any]:
+    def custom_fields_remove_field_value(
+        self, task_id, field_id, custom_task_ids=None, team_id=None
+    ) -> dict[str, Any]:
         """
         Removes a specific custom field value from a given task.
-        
+
         Args:
             task_id: str. The unique identifier of the task from which the field value will be removed.
             field_id: str. The unique identifier of the custom field to remove.
             custom_task_ids: Optional[list or str]. Additional task IDs to include in the operation. Defaults to None.
             team_id: Optional[str]. The ID of the team context for the operation. Defaults to None.
-        
+
         Returns:
             dict[str, Any]: The API response as a dictionary containing the result of the remove operation.
-        
+
         Raises:
             ValueError: If either 'task_id' or 'field_id' is not provided.
             requests.HTTPError: If the HTTP request to remove the field value fails.
-        
+
         Tags:
             custom-fields, remove, task-management, api
         """
@@ -590,63 +663,80 @@ class ClickupApp(APIApplication):
         if field_id is None:
             raise ValueError("Missing required parameter 'field_id'")
         url = f"{self.base_url}/task/{task_id}/field/{field_id}"
-        query_params = {k: v for k, v in [('custom_task_ids', custom_task_ids), ('team_id', team_id)] if v is not None}
+        query_params = {
+            k: v
+            for k, v in [("custom_task_ids", custom_task_ids), ("team_id", team_id)]
+            if v is not None
+        }
         response = self._delete(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def task_relationships_add_dependency(self, task_id, custom_task_ids=None, team_id=None, depends_on=None, depedency_of=None) -> dict[str, Any]:
+    def task_relationships_add_dependency(
+        self,
+        task_id,
+        custom_task_ids=None,
+        team_id=None,
+        depends_on=None,
+        depedency_of=None,
+    ) -> dict[str, Any]:
         """
         Adds a dependency relationship to a specified task, allowing you to define predecessor or dependent tasks within a project management system.
-        
+
         Args:
             task_id: str. The ID of the task for which the dependency is being added. Must not be None.
             custom_task_ids: Optional[list[str]]. List of custom task IDs, if applicable, to use for the operation.
             team_id: Optional[str]. Identifier for the team, if restricting the dependency operation to a specific team context.
             depends_on: Optional[list[str]]. List of task IDs that the specified task depends on.
             depedency_of: Optional[list[str]]. List of task IDs that depend on the specified task.
-        
+
         Returns:
             dict[str, Any]: The API response as a dictionary containing the updated dependency information for the task.
-        
+
         Raises:
             ValueError: Raised if 'task_id' is None.
             requests.HTTPError: Raised if the HTTP request to add the dependency fails or returns an error status.
-        
+
         Tags:
             add, task-relationship, dependency, management
         """
         if task_id is None:
             raise ValueError("Missing required parameter 'task_id'")
         request_body = {
-            'depends_on': depends_on,
-            'depedency_of': depedency_of,
+            "depends_on": depends_on,
+            "depedency_of": depedency_of,
         }
         request_body = {k: v for k, v in request_body.items() if v is not None}
         url = f"{self.base_url}/task/{task_id}/dependency"
-        query_params = {k: v for k, v in [('custom_task_ids', custom_task_ids), ('team_id', team_id)] if v is not None}
+        query_params = {
+            k: v
+            for k, v in [("custom_task_ids", custom_task_ids), ("team_id", team_id)]
+            if v is not None
+        }
         response = self._post(url, data=request_body, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def task_relationships_remove_dependency(self, task_id, depends_on, dependency_of, custom_task_ids=None, team_id=None) -> dict[str, Any]:
+    def task_relationships_remove_dependency(
+        self, task_id, depends_on, dependency_of, custom_task_ids=None, team_id=None
+    ) -> dict[str, Any]:
         """
         Removes a dependency relationship between tasks by calling the API endpoint.
-        
+
         Args:
             task_id: The ID of the task from which the dependency is being removed.
             depends_on: The ID of the task that the main task depends on.
             dependency_of: The ID of the task that depends on the main task.
             custom_task_ids: Optional flag to indicate if the provided IDs are custom task IDs.
             team_id: Optional team ID to specify which team the tasks belong to.
-        
+
         Returns:
             A dictionary containing the API response after removing the dependency.
-        
+
         Raises:
             ValueError: Raised when any of the required parameters (task_id, depends_on, dependency_of) are None.
             HTTPError: Raised when the API request fails based on the call to raise_for_status().
-        
+
         Tags:
             remove, dependency, task-management, relationship
         """
@@ -657,28 +747,39 @@ class ClickupApp(APIApplication):
         if dependency_of is None:
             raise ValueError("Missing required parameter 'dependency_of'")
         url = f"{self.base_url}/task/{task_id}/dependency"
-        query_params = {k: v for k, v in [('depends_on', depends_on), ('dependency_of', dependency_of), ('custom_task_ids', custom_task_ids), ('team_id', team_id)] if v is not None}
+        query_params = {
+            k: v
+            for k, v in [
+                ("depends_on", depends_on),
+                ("dependency_of", dependency_of),
+                ("custom_task_ids", custom_task_ids),
+                ("team_id", team_id),
+            ]
+            if v is not None
+        }
         response = self._delete(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def task_relationships_link_tasks(self, task_id, links_to, custom_task_ids=None, team_id=None) -> dict[str, Any]:
+    def task_relationships_link_tasks(
+        self, task_id, links_to, custom_task_ids=None, team_id=None
+    ) -> dict[str, Any]:
         """
         Links one task to another by creating a relationship between the source and target task IDs, with optional custom task and team identifiers.
-        
+
         Args:
             task_id: str. ID of the source task to be linked. Required.
             links_to: str. ID of the target task to which the source task will be linked. Required.
             custom_task_ids: Optional[list[str]]. List of custom task IDs to use for identification within a broader context. Defaults to None.
             team_id: Optional[str]. ID of the team associated with the tasks. Defaults to None.
-        
+
         Returns:
             dict[str, Any]: A dictionary containing the API response data for the task linking operation.
-        
+
         Raises:
             ValueError: If 'task_id' or 'links_to' is None.
             HTTPError: If the HTTP request to link tasks fails (non-2xx response).
-        
+
         Tags:
             link, task-relationship, api, management
         """
@@ -687,28 +788,34 @@ class ClickupApp(APIApplication):
         if links_to is None:
             raise ValueError("Missing required parameter 'links_to'")
         url = f"{self.base_url}/task/{task_id}/link/{links_to}"
-        query_params = {k: v for k, v in [('custom_task_ids', custom_task_ids), ('team_id', team_id)] if v is not None}
+        query_params = {
+            k: v
+            for k, v in [("custom_task_ids", custom_task_ids), ("team_id", team_id)]
+            if v is not None
+        }
         response = self._post(url, data={}, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def task_relationships_remove_link_between_tasks(self, task_id, links_to, custom_task_ids=None, team_id=None) -> dict[str, Any]:
+    def task_relationships_remove_link_between_tasks(
+        self, task_id, links_to, custom_task_ids=None, team_id=None
+    ) -> dict[str, Any]:
         """
         Removes a link between two specified tasks within the task management system.
-        
+
         Args:
             task_id: str. The unique identifier of the source task whose link is to be removed.
             links_to: str. The unique identifier of the linked task to be unlinked.
             custom_task_ids: Optional[list[str]]. A list of custom task IDs to be used in the request, if applicable.
             team_id: Optional[str]. The team ID associated with the tasks, if applicable.
-        
+
         Returns:
             dict[str, Any]: The JSON response from the API after removing the link, parsed into a dictionary.
-        
+
         Raises:
             ValueError: Raised if 'task_id' or 'links_to' is not provided.
             requests.HTTPError: Raised if the HTTP request fails or the API returns an error status code.
-        
+
         Tags:
             remove, task-relationships, api, management
         """
@@ -717,7 +824,11 @@ class ClickupApp(APIApplication):
         if links_to is None:
             raise ValueError("Missing required parameter 'links_to'")
         url = f"{self.base_url}/task/{task_id}/link/{links_to}"
-        query_params = {k: v for k, v in [('custom_task_ids', custom_task_ids), ('team_id', team_id)] if v is not None}
+        query_params = {
+            k: v
+            for k, v in [("custom_task_ids", custom_task_ids), ("team_id", team_id)]
+            if v is not None
+        }
         response = self._delete(url, params=query_params)
         response.raise_for_status()
         return response.json()
@@ -725,25 +836,25 @@ class ClickupApp(APIApplication):
     def folders_get_contents_of(self, space_id, archived=None) -> dict[str, Any]:
         """
         Retrieves the contents of all folders within a specified space, with optional filtering for archived folders.
-        
+
         Args:
             space_id: str. The unique identifier of the space whose folders' contents are to be retrieved.
             archived: Optional[bool]. If set, filters folders by their archived status. If None, retrieves all folders regardless of archived state.
-        
+
         Returns:
             dict[str, Any]: A dictionary containing the contents of each folder in the specified space, as returned by the API.
-        
+
         Raises:
             ValueError: Raised if 'space_id' is None.
             requests.HTTPError: Raised if the HTTP request to the backend API fails.
-        
+
         Tags:
             get, list, folders, contents, management, api
         """
         if space_id is None:
             raise ValueError("Missing required parameter 'space_id'")
         url = f"{self.base_url}/space/{space_id}/folder"
-        query_params = {k: v for k, v in [('archived', archived)] if v is not None}
+        query_params = {k: v for k, v in [("archived", archived)] if v is not None}
         response = self._get(url, params=query_params)
         response.raise_for_status()
         return response.json()
@@ -751,18 +862,18 @@ class ClickupApp(APIApplication):
     def folders_create_new_folder(self, space_id, name) -> dict[str, Any]:
         """
         Creates a new folder within a specified space.
-        
+
         Args:
             space_id: The unique identifier of the space where the folder will be created.
             name: The name to be assigned to the new folder.
-        
+
         Returns:
             A dictionary containing information about the newly created folder.
-        
+
         Raises:
             ValueError: Raised when either 'space_id' or 'name' parameter is None.
             HTTPError: Raised when the HTTP request to create the folder fails.
-        
+
         Tags:
             create, folder, management
         """
@@ -771,7 +882,7 @@ class ClickupApp(APIApplication):
         if name is None:
             raise ValueError("Missing required parameter 'name'")
         request_body = {
-            'name': name,
+            "name": name,
         }
         request_body = {k: v for k, v in request_body.items() if v is not None}
         url = f"{self.base_url}/space/{space_id}/folder"
@@ -783,17 +894,17 @@ class ClickupApp(APIApplication):
     def folders_get_folder_content(self, folder_id) -> dict[str, Any]:
         """
         Retrieves the contents of a specified folder by its ID.
-        
+
         Args:
             folder_id: str. The unique identifier of the folder whose content is to be retrieved.
-        
+
         Returns:
             dict[str, Any]: A dictionary containing the contents of the specified folder as returned by the API.
-        
+
         Raises:
             ValueError: Raised if 'folder_id' is None, indicating a required parameter is missing.
             requests.HTTPError: Raised if the HTTP request to retrieve the folder content fails with an unsuccessful status code.
-        
+
         Tags:
             get, folder, content, api
         """
@@ -808,18 +919,18 @@ class ClickupApp(APIApplication):
     def folders_rename_folder(self, folder_id, name) -> dict[str, Any]:
         """
         Renames an existing folder by updating its name using the specified folder ID.
-        
+
         Args:
             folder_id: str. The unique identifier of the folder to be renamed.
             name: str. The new name to assign to the folder.
-        
+
         Returns:
             dict[str, Any]: The JSON response from the API containing updated folder information.
-        
+
         Raises:
             ValueError: If 'folder_id' or 'name' is None.
             requests.HTTPError: If the HTTP request to update the folder fails.
-        
+
         Tags:
             rename, folder-management, put, api
         """
@@ -828,7 +939,7 @@ class ClickupApp(APIApplication):
         if name is None:
             raise ValueError("Missing required parameter 'name'")
         request_body = {
-            'name': name,
+            "name": name,
         }
         request_body = {k: v for k, v in request_body.items() if v is not None}
         url = f"{self.base_url}/folder/{folder_id}"
@@ -840,17 +951,17 @@ class ClickupApp(APIApplication):
     def folders_remove_folder(self, folder_id) -> dict[str, Any]:
         """
         Removes a folder with the specified folder ID by sending a DELETE request to the API.
-        
+
         Args:
             folder_id: The unique identifier of the folder to be removed. Must not be None.
-        
+
         Returns:
             A dictionary containing the JSON response from the API after the folder is deleted.
-        
+
         Raises:
             ValueError: If 'folder_id' is None.
             requests.HTTPError: If the API response contains an HTTP error status code.
-        
+
         Tags:
             remove, folder-management, api
         """
@@ -862,36 +973,42 @@ class ClickupApp(APIApplication):
         response.raise_for_status()
         return response.json()
 
-    def goals_get_workspace_goals(self, team_id, include_completed=None) -> dict[str, Any]:
+    def goals_get_workspace_goals(
+        self, team_id, include_completed=None
+    ) -> dict[str, Any]:
         """
         Retrieves all workspace goals for a specified team, optionally including completed goals.
-        
+
         Args:
             team_id: str. Unique identifier of the team whose workspace goals are to be retrieved.
             include_completed: Optional[bool]. Whether to include completed goals in the results. If None, only active goals are returned.
-        
+
         Returns:
             dict[str, Any]: A dictionary containing the workspace goals data for the specified team.
-        
+
         Raises:
             ValueError: Raised when the required parameter 'team_id' is None.
             requests.HTTPError: Raised if the HTTP request to the backend API fails with a non-success status.
-        
+
         Tags:
             get, list, goal-management, fetch
         """
         if team_id is None:
             raise ValueError("Missing required parameter 'team_id'")
         url = f"{self.base_url}/team/{team_id}/goal"
-        query_params = {k: v for k, v in [('include_completed', include_completed)] if v is not None}
+        query_params = {
+            k: v for k, v in [("include_completed", include_completed)] if v is not None
+        }
         response = self._get(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def goals_add_new_goal_to_workspace(self, team_id, description, name, due_date, multiple_owners, owners, color) -> dict[str, Any]:
+    def goals_add_new_goal_to_workspace(
+        self, team_id, description, name, due_date, multiple_owners, owners, color
+    ) -> dict[str, Any]:
         """
         Adds a new goal to the specified team workspace.
-        
+
         Args:
             team_id: The ID of the team to which the new goal is added.
             description: A brief description of the goal.
@@ -900,13 +1017,13 @@ class ClickupApp(APIApplication):
             multiple_owners: Indicates whether the goal can have multiple owners.
             owners: A list of owners for the goal.
             color: The color associated with the goal.
-        
+
         Returns:
             A dictionary containing the newly added goal's details.
-        
+
         Raises:
             ValueError: Raised when any required parameter ('team_id', 'description', 'name', 'due_date', 'multiple_owners', 'owners', 'color') is missing.
-        
+
         Tags:
             manage, goals, create, team-management
         """
@@ -925,12 +1042,12 @@ class ClickupApp(APIApplication):
         if color is None:
             raise ValueError("Missing required parameter 'color'")
         request_body = {
-            'description': description,
-            'name': name,
-            'due_date': due_date,
-            'multiple_owners': multiple_owners,
-            'owners': owners,
-            'color': color,
+            "description": description,
+            "name": name,
+            "due_date": due_date,
+            "multiple_owners": multiple_owners,
+            "owners": owners,
+            "color": color,
         }
         request_body = {k: v for k, v in request_body.items() if v is not None}
         url = f"{self.base_url}/team/{team_id}/goal"
@@ -942,16 +1059,16 @@ class ClickupApp(APIApplication):
     def goals_get_details(self, goal_id) -> dict[str, Any]:
         """
         Retrieves detailed information about a goal based on the provided goal ID.
-        
+
         Args:
             goal_id: ID of the goal to retrieve details for.
-        
+
         Returns:
             A dictionary containing detailed information about the goal.
-        
+
         Raises:
             ValueError: Raised when the goal_id parameter is missing.
-        
+
         Tags:
             get, details, management
         """
@@ -963,10 +1080,12 @@ class ClickupApp(APIApplication):
         response.raise_for_status()
         return response.json()
 
-    def goals_update_goal_details(self, goal_id, description, name, due_date, rem_owners, add_owners, color) -> dict[str, Any]:
+    def goals_update_goal_details(
+        self, goal_id, description, name, due_date, rem_owners, add_owners, color
+    ) -> dict[str, Any]:
         """
         Updates the details of an existing goal with new information, including description, name, due date, owners, and color.
-        
+
         Args:
             goal_id: str. The unique identifier of the goal to update.
             description: str. The updated description for the goal.
@@ -975,14 +1094,14 @@ class ClickupApp(APIApplication):
             rem_owners: list. List of owner identifiers to remove from the goal.
             add_owners: list. List of owner identifiers to add to the goal.
             color: str. The color code or name representing the goal's new color.
-        
+
         Returns:
             dict[str, Any]: A dictionary containing the updated goal details as returned by the server.
-        
+
         Raises:
             ValueError: If any of the required parameters ('goal_id', 'description', 'name', 'due_date', 'rem_owners', 'add_owners', 'color') is None.
             requests.HTTPError: If the server returns an unsuccessful status code during the update request.
-        
+
         Tags:
             update, goal-management, async_job
         """
@@ -1001,12 +1120,12 @@ class ClickupApp(APIApplication):
         if color is None:
             raise ValueError("Missing required parameter 'color'")
         request_body = {
-            'description': description,
-            'name': name,
-            'due_date': due_date,
-            'rem_owners': rem_owners,
-            'add_owners': add_owners,
-            'color': color,
+            "description": description,
+            "name": name,
+            "due_date": due_date,
+            "rem_owners": rem_owners,
+            "add_owners": add_owners,
+            "color": color,
         }
         request_body = {k: v for k, v in request_body.items() if v is not None}
         url = f"{self.base_url}/goal/{goal_id}"
@@ -1018,17 +1137,17 @@ class ClickupApp(APIApplication):
     def goals_remove_goal(self, goal_id) -> dict[str, Any]:
         """
         Removes a goal from the system using the specified goal ID.
-        
+
         Args:
             goal_id: The unique identifier of the goal to be removed. Cannot be None.
-        
+
         Returns:
             A dictionary containing the API response after goal deletion.
-        
+
         Raises:
             ValueError: Raised when the required goal_id parameter is None.
             HTTPError: Raised when the HTTP request to delete the goal fails.
-        
+
         Tags:
             remove, delete, goal, management
         """
@@ -1040,10 +1159,21 @@ class ClickupApp(APIApplication):
         response.raise_for_status()
         return response.json()
 
-    def goals_add_key_result(self, goal_id, name, owners, type, steps_start, steps_end, unit, task_ids, list_ids) -> dict[str, Any]:
+    def goals_add_key_result(
+        self,
+        goal_id,
+        name,
+        owners,
+        type,
+        steps_start,
+        steps_end,
+        unit,
+        task_ids,
+        list_ids,
+    ) -> dict[str, Any]:
         """
         Creates and adds a new key result to a specified goal with the provided details and associated tasks/lists.
-        
+
         Args:
             goal_id: str. Unique identifier of the goal to which the key result will be added.
             name: str. Name of the key result.
@@ -1054,14 +1184,14 @@ class ClickupApp(APIApplication):
             unit: str. Unit of measurement for the key result's progress (e.g., 'percent', 'tasks').
             task_ids: list. List of task IDs associated with the key result.
             list_ids: list. List of list IDs to associate with the key result.
-        
+
         Returns:
             dict. The JSON response containing details of the newly created key result.
-        
+
         Raises:
             ValueError: Raised if any required parameter (goal_id, name, owners, type, steps_start, steps_end, unit, task_ids, list_ids) is None.
             requests.HTTPError: Raised if the HTTP request fails (non-success response status).
-        
+
         Tags:
             add, key-result, goals, management
         """
@@ -1084,14 +1214,14 @@ class ClickupApp(APIApplication):
         if list_ids is None:
             raise ValueError("Missing required parameter 'list_ids'")
         request_body = {
-            'name': name,
-            'owners': owners,
-            'type': type,
-            'steps_start': steps_start,
-            'steps_end': steps_end,
-            'unit': unit,
-            'task_ids': task_ids,
-            'list_ids': list_ids,
+            "name": name,
+            "owners": owners,
+            "type": type,
+            "steps_start": steps_start,
+            "steps_end": steps_end,
+            "unit": unit,
+            "task_ids": task_ids,
+            "list_ids": list_ids,
         }
         request_body = {k: v for k, v in request_body.items() if v is not None}
         url = f"{self.base_url}/goal/{goal_id}/key_result"
@@ -1100,22 +1230,24 @@ class ClickupApp(APIApplication):
         response.raise_for_status()
         return response.json()
 
-    def goals_update_key_result(self, key_result_id, steps_current, note) -> dict[str, Any]:
+    def goals_update_key_result(
+        self, key_result_id, steps_current, note
+    ) -> dict[str, Any]:
         """
         Updates the current number of steps and note for a specific key result.
-        
+
         Args:
             key_result_id: The unique identifier of the key result to update.
             steps_current: The current number of steps achieved for the key result.
             note: A note or comment associated with the update.
-        
+
         Returns:
             A dictionary containing the updated key result data as returned by the server.
-        
+
         Raises:
             ValueError: If any of 'key_result_id', 'steps_current', or 'note' is None.
             requests.HTTPError: If the HTTP PUT request fails (non-success response from the server).
-        
+
         Tags:
             update, goals, management, key-result
         """
@@ -1126,8 +1258,8 @@ class ClickupApp(APIApplication):
         if note is None:
             raise ValueError("Missing required parameter 'note'")
         request_body = {
-            'steps_current': steps_current,
-            'note': note,
+            "steps_current": steps_current,
+            "note": note,
         }
         request_body = {k: v for k, v in request_body.items() if v is not None}
         url = f"{self.base_url}/key_result/{key_result_id}"
@@ -1139,17 +1271,17 @@ class ClickupApp(APIApplication):
     def goals_remove_target(self, key_result_id) -> dict[str, Any]:
         """
         Removes the target associated with a specified key result by sending a DELETE request to the API.
-        
+
         Args:
             key_result_id: The unique identifier of the key result whose target is to be removed.
-        
+
         Returns:
             A dictionary representing the JSON response from the API after the target is removed.
-        
+
         Raises:
             ValueError: If 'key_result_id' is None.
             requests.HTTPError: If the DELETE HTTP request fails or returns an error status.
-        
+
         Tags:
             remove, management, api
         """
@@ -1161,10 +1293,19 @@ class ClickupApp(APIApplication):
         response.raise_for_status()
         return response.json()
 
-    def guests_invite_to_workspace(self, team_id, email, can_edit_tags, can_see_time_spent, can_see_time_estimated, can_create_views, custom_role_id) -> dict[str, Any]:
+    def guests_invite_to_workspace(
+        self,
+        team_id,
+        email,
+        can_edit_tags,
+        can_see_time_spent,
+        can_see_time_estimated,
+        can_create_views,
+        custom_role_id,
+    ) -> dict[str, Any]:
         """
         Invites a guest to a workspace with specific permissions.
-        
+
         Args:
             team_id: The unique identifier of the team/workspace.
             email: Email address of the guest to invite.
@@ -1173,14 +1314,14 @@ class ClickupApp(APIApplication):
             can_see_time_estimated: Boolean indicating if the guest can see estimated time for tasks.
             can_create_views: Boolean indicating if the guest can create views.
             custom_role_id: The ID of the custom role to assign to the guest.
-        
+
         Returns:
             A dictionary containing the response data from the API.
-        
+
         Raises:
             ValueError: Raised when any required parameter is None.
             HTTPError: Raised when the API request fails.
-        
+
         Tags:
             invite, guest, workspace, permission, management
         """
@@ -1199,12 +1340,12 @@ class ClickupApp(APIApplication):
         if custom_role_id is None:
             raise ValueError("Missing required parameter 'custom_role_id'")
         request_body = {
-            'email': email,
-            'can_edit_tags': can_edit_tags,
-            'can_see_time_spent': can_see_time_spent,
-            'can_see_time_estimated': can_see_time_estimated,
-            'can_create_views': can_create_views,
-            'custom_role_id': custom_role_id,
+            "email": email,
+            "can_edit_tags": can_edit_tags,
+            "can_see_time_spent": can_see_time_spent,
+            "can_see_time_estimated": can_see_time_estimated,
+            "can_create_views": can_create_views,
+            "custom_role_id": custom_role_id,
         }
         request_body = {k: v for k, v in request_body.items() if v is not None}
         url = f"{self.base_url}/team/{team_id}/guest"
@@ -1216,17 +1357,17 @@ class ClickupApp(APIApplication):
     def guests_get_guest_information(self, team_id, guest_id) -> dict[str, Any]:
         """
         Fetches guest information for a specific guest in a team.
-        
+
         Args:
             team_id: The ID of the team.
             guest_id: The ID of the guest.
-        
+
         Returns:
             A dictionary containing the guest information.
-        
+
         Raises:
             ValueError: Raised when either team_id or guest_id is missing.
-        
+
         Tags:
             fetch, guest, management
         """
@@ -1240,10 +1381,20 @@ class ClickupApp(APIApplication):
         response.raise_for_status()
         return response.json()
 
-    def guests_edit_guest_on_workspace(self, team_id, guest_id, username, can_edit_tags, can_see_time_spent, can_see_time_estimated, can_create_views, custom_role_id) -> dict[str, Any]:
+    def guests_edit_guest_on_workspace(
+        self,
+        team_id,
+        guest_id,
+        username,
+        can_edit_tags,
+        can_see_time_spent,
+        can_see_time_estimated,
+        can_create_views,
+        custom_role_id,
+    ) -> dict[str, Any]:
         """
         Edits a guest user's permissions and role within a specified workspace team.
-        
+
         Args:
             team_id: str. The unique identifier of the workspace team.
             guest_id: str. The unique identifier of the guest user to edit.
@@ -1253,14 +1404,14 @@ class ClickupApp(APIApplication):
             can_see_time_estimated: bool. Whether the guest can view estimated time information.
             can_create_views: bool. Whether the guest can create new views in the workspace.
             custom_role_id: str. Identifier for a custom role to assign to the guest user.
-        
+
         Returns:
             dict[str, Any]: A dictionary representing the updated guest user resource as returned by the workspace API.
-        
+
         Raises:
             ValueError: If any of the required parameters ('team_id', 'guest_id', 'username', 'can_edit_tags', 'can_see_time_spent', 'can_see_time_estimated', 'can_create_views', 'custom_role_id') are None.
             requests.HTTPError: If the HTTP request to update the guest fails (e.g., due to network errors or unsuccessful response status).
-        
+
         Tags:
             edit, guest-management, workspace, api, permissions
         """
@@ -1281,12 +1432,12 @@ class ClickupApp(APIApplication):
         if custom_role_id is None:
             raise ValueError("Missing required parameter 'custom_role_id'")
         request_body = {
-            'username': username,
-            'can_edit_tags': can_edit_tags,
-            'can_see_time_spent': can_see_time_spent,
-            'can_see_time_estimated': can_see_time_estimated,
-            'can_create_views': can_create_views,
-            'custom_role_id': custom_role_id,
+            "username": username,
+            "can_edit_tags": can_edit_tags,
+            "can_see_time_spent": can_see_time_spent,
+            "can_see_time_estimated": can_see_time_estimated,
+            "can_create_views": can_create_views,
+            "custom_role_id": custom_role_id,
         }
         request_body = {k: v for k, v in request_body.items() if v is not None}
         url = f"{self.base_url}/team/{team_id}/guest/{guest_id}"
@@ -1295,21 +1446,23 @@ class ClickupApp(APIApplication):
         response.raise_for_status()
         return response.json()
 
-    def guests_revoke_guest_access_to_workspace(self, team_id, guest_id) -> dict[str, Any]:
+    def guests_revoke_guest_access_to_workspace(
+        self, team_id, guest_id
+    ) -> dict[str, Any]:
         """
         Revokes a guest's access to a workspace for a specified team.
-        
+
         Args:
             team_id: str. The unique identifier of the team whose workspace the guest will lose access to.
             guest_id: str. The unique identifier of the guest whose access is being revoked.
-        
+
         Returns:
             dict[str, Any]: The response data from the API, typically containing details about the revoked guest access.
-        
+
         Raises:
             ValueError: Raised if 'team_id' or 'guest_id' is None.
             requests.HTTPError: Raised if the HTTP request fails (non-2xx response).
-        
+
         Tags:
             revoke, access-control, guest-management, workspace
         """
@@ -1323,10 +1476,18 @@ class ClickupApp(APIApplication):
         response.raise_for_status()
         return response.json()
 
-    def guests_add_to_task(self, task_id, guest_id, permission_level, include_shared=None, custom_task_ids=None, team_id=None) -> dict[str, Any]:
+    def guests_add_to_task(
+        self,
+        task_id,
+        guest_id,
+        permission_level,
+        include_shared=None,
+        custom_task_ids=None,
+        team_id=None,
+    ) -> dict[str, Any]:
         """
         Adds a guest to a task with specified permission level and optional parameters.
-        
+
         Args:
             task_id: The ID of the task to which the guest is being added.
             guest_id: The ID of the guest to add to the task.
@@ -1334,13 +1495,13 @@ class ClickupApp(APIApplication):
             include_shared: Optional parameter to include shared tasks.
             custom_task_ids: Optional list of custom task IDs.
             team_id: Optional ID of the team related to the task.
-        
+
         Returns:
             A dictionary containing the response from adding a guest to the task.
-        
+
         Raises:
             ValueError: Raised when task_id, guest_id, or permission_level is missing.
-        
+
         Tags:
             add, manage, task, guest, permission, async_job
         """
@@ -1351,33 +1512,43 @@ class ClickupApp(APIApplication):
         if permission_level is None:
             raise ValueError("Missing required parameter 'permission_level'")
         request_body = {
-            'permission_level': permission_level,
+            "permission_level": permission_level,
         }
         request_body = {k: v for k, v in request_body.items() if v is not None}
         url = f"{self.base_url}/task/{task_id}/guest/{guest_id}"
-        query_params = {k: v for k, v in [('include_shared', include_shared), ('custom_task_ids', custom_task_ids), ('team_id', team_id)] if v is not None}
+        query_params = {
+            k: v
+            for k, v in [
+                ("include_shared", include_shared),
+                ("custom_task_ids", custom_task_ids),
+                ("team_id", team_id),
+            ]
+            if v is not None
+        }
         response = self._post(url, data=request_body, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def guests_revoke_access_to_task(self, task_id, guest_id, include_shared=None, custom_task_ids=None, team_id=None) -> dict[str, Any]:
+    def guests_revoke_access_to_task(
+        self, task_id, guest_id, include_shared=None, custom_task_ids=None, team_id=None
+    ) -> dict[str, Any]:
         """
         Revokes a guest user's access to a specific task, with options to customize the revocation scope.
-        
+
         Args:
             task_id: str. The unique identifier of the task from which guest access is being revoked.
             guest_id: str. The unique identifier of the guest whose access will be revoked.
             include_shared: Optional[bool]. Whether to include shared tasks in the revocation process.
             custom_task_ids: Optional[list or str]. Custom task identifiers to further specify which tasks to affect.
             team_id: Optional[str]. The identifier of the team if the task is associated with a team context.
-        
+
         Returns:
             dict[str, Any]: A dictionary containing the API response data after revoking access.
-        
+
         Raises:
             ValueError: If either 'task_id' or 'guest_id' is not provided.
             HTTPError: If the API request to revoke access fails.
-        
+
         Tags:
             guests, revoke, access, task, management
         """
@@ -1386,28 +1557,38 @@ class ClickupApp(APIApplication):
         if guest_id is None:
             raise ValueError("Missing required parameter 'guest_id'")
         url = f"{self.base_url}/task/{task_id}/guest/{guest_id}"
-        query_params = {k: v for k, v in [('include_shared', include_shared), ('custom_task_ids', custom_task_ids), ('team_id', team_id)] if v is not None}
+        query_params = {
+            k: v
+            for k, v in [
+                ("include_shared", include_shared),
+                ("custom_task_ids", custom_task_ids),
+                ("team_id", team_id),
+            ]
+            if v is not None
+        }
         response = self._delete(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def guests_share_list_with(self, list_id, guest_id, permission_level, include_shared=None) -> dict[str, Any]:
+    def guests_share_list_with(
+        self, list_id, guest_id, permission_level, include_shared=None
+    ) -> dict[str, Any]:
         """
         Shares a list with a specified guest by assigning a permission level and optionally including shared items.
-        
+
         Args:
             list_id: The unique identifier of the list to be shared.
             guest_id: The unique identifier of the guest with whom the list will be shared.
             permission_level: The access level to grant the guest (e.g., 'read', 'edit').
             include_shared: Optional; if provided, specifies whether to include items already shared with the guest.
-        
+
         Returns:
             A dictionary containing the response data from the share operation, typically including sharing status and permissions.
-        
+
         Raises:
             ValueError: If any of the required parameters ('list_id', 'guest_id', or 'permission_level') are missing.
             requests.HTTPError: If the HTTP request to share the list fails (e.g., due to network issues or invalid input).
-        
+
         Tags:
             share, list, permission-management, guest
         """
@@ -1418,31 +1599,35 @@ class ClickupApp(APIApplication):
         if permission_level is None:
             raise ValueError("Missing required parameter 'permission_level'")
         request_body = {
-            'permission_level': permission_level,
+            "permission_level": permission_level,
         }
         request_body = {k: v for k, v in request_body.items() if v is not None}
         url = f"{self.base_url}/list/{list_id}/guest/{guest_id}"
-        query_params = {k: v for k, v in [('include_shared', include_shared)] if v is not None}
+        query_params = {
+            k: v for k, v in [("include_shared", include_shared)] if v is not None
+        }
         response = self._post(url, data=request_body, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def guests_remove_from_list(self, list_id, guest_id, include_shared=None) -> dict[str, Any]:
+    def guests_remove_from_list(
+        self, list_id, guest_id, include_shared=None
+    ) -> dict[str, Any]:
         """
         Removes a guest from a specified list, optionally including shared guests in the operation.
-        
+
         Args:
             list_id: The unique identifier of the list from which the guest will be removed. Must not be None.
             guest_id: The unique identifier of the guest to remove. Must not be None.
             include_shared: Optional; if provided, determines whether shared guests should be included in the removal.
-        
+
         Returns:
             A dictionary containing the response data from the removal operation.
-        
+
         Raises:
             ValueError: Raised if 'list_id' or 'guest_id' is None.
             requests.HTTPError: Raised if the HTTP request to remove the guest fails.
-        
+
         Tags:
             guests, remove, management, list
         """
@@ -1451,28 +1636,32 @@ class ClickupApp(APIApplication):
         if guest_id is None:
             raise ValueError("Missing required parameter 'guest_id'")
         url = f"{self.base_url}/list/{list_id}/guest/{guest_id}"
-        query_params = {k: v for k, v in [('include_shared', include_shared)] if v is not None}
+        query_params = {
+            k: v for k, v in [("include_shared", include_shared)] if v is not None
+        }
         response = self._delete(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def guests_add_guest_to_folder(self, folder_id, guest_id, permission_level, include_shared=None) -> dict[str, Any]:
+    def guests_add_guest_to_folder(
+        self, folder_id, guest_id, permission_level, include_shared=None
+    ) -> dict[str, Any]:
         """
         Adds a guest to a specified folder with a given permission level, optionally including shared folders.
-        
+
         Args:
             folder_id: str. The unique identifier of the folder to which the guest will be added.
             guest_id: str. The unique identifier of the guest user to add to the folder.
             permission_level: str. The permission level to assign to the guest (e.g., 'read', 'write').
             include_shared: Optional[bool]. If True, includes shared folders in the operation. Defaults to None.
-        
+
         Returns:
             dict[str, Any]: The server response as a dictionary containing the details of the updated folder and guest permissions.
-        
+
         Raises:
             ValueError: If 'folder_id', 'guest_id', or 'permission_level' is None.
             requests.HTTPError: If the HTTP request to the server fails or returns an error status.
-        
+
         Tags:
             add, guest-management, folder-permissions, api-call
         """
@@ -1483,31 +1672,35 @@ class ClickupApp(APIApplication):
         if permission_level is None:
             raise ValueError("Missing required parameter 'permission_level'")
         request_body = {
-            'permission_level': permission_level,
+            "permission_level": permission_level,
         }
         request_body = {k: v for k, v in request_body.items() if v is not None}
         url = f"{self.base_url}/folder/{folder_id}/guest/{guest_id}"
-        query_params = {k: v for k, v in [('include_shared', include_shared)] if v is not None}
+        query_params = {
+            k: v for k, v in [("include_shared", include_shared)] if v is not None
+        }
         response = self._post(url, data=request_body, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def guests_revoke_access_from_folder(self, folder_id, guest_id, include_shared=None) -> dict[str, Any]:
+    def guests_revoke_access_from_folder(
+        self, folder_id, guest_id, include_shared=None
+    ) -> dict[str, Any]:
         """
         Revokes a guest's access from a specified folder, with optional inclusion of shared resources.
-        
+
         Args:
             folder_id: str. The unique identifier of the folder from which to revoke access.
             guest_id: str. The unique identifier of the guest whose access will be revoked.
             include_shared: Optional[bool]. If True, also revokes access from shared resources. Defaults to None.
-        
+
         Returns:
             dict[str, Any]: A dictionary containing the API response to the revoke operation.
-        
+
         Raises:
             ValueError: Raised if 'folder_id' or 'guest_id' is not provided.
             requests.HTTPError: Raised if the HTTP request to revoke access fails.
-        
+
         Tags:
             guests, revoke, access, folder-management, api
         """
@@ -1516,7 +1709,9 @@ class ClickupApp(APIApplication):
         if guest_id is None:
             raise ValueError("Missing required parameter 'guest_id'")
         url = f"{self.base_url}/folder/{folder_id}/guest/{guest_id}"
-        query_params = {k: v for k, v in [('include_shared', include_shared)] if v is not None}
+        query_params = {
+            k: v for k, v in [("include_shared", include_shared)] if v is not None
+        }
         response = self._delete(url, params=query_params)
         response.raise_for_status()
         return response.json()
@@ -1524,33 +1719,43 @@ class ClickupApp(APIApplication):
     def lists_get_folder_lists(self, folder_id, archived=None) -> dict[str, Any]:
         """
         Retrieves all lists contained within a specified folder, with optional filtering for archived lists.
-        
+
         Args:
             folder_id: The unique identifier of the folder whose lists are to be retrieved.
             archived: Optional; if provided, filters lists by their archived status (e.g., True for archived, False for active, None for all).
-        
+
         Returns:
             A dictionary containing the folder's lists and associated metadata as provided by the API.
-        
+
         Raises:
             ValueError: Raised if 'folder_id' is not provided.
             requests.HTTPError: Raised if the HTTP request to fetch the folder's lists fails (e.g., non-2xx response).
-        
+
         Tags:
             list, get, folder, search, api , important
         """
         if folder_id is None:
             raise ValueError("Missing required parameter 'folder_id'")
         url = f"{self.base_url}/folder/{folder_id}/list"
-        query_params = {k: v for k, v in [('archived', archived)] if v is not None}
+        query_params = {k: v for k, v in [("archived", archived)] if v is not None}
         response = self._get(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def lists_add_to_folder(self, folder_id, name, content=None, due_date=None, due_date_time=None, priority=None, assignee=None, status=None) -> dict[str, Any]:
+    def lists_add_to_folder(
+        self,
+        folder_id,
+        name,
+        content=None,
+        due_date=None,
+        due_date_time=None,
+        priority=None,
+        assignee=None,
+        status=None,
+    ) -> dict[str, Any]:
         """
         Creates a new list in the specified folder with the given name and optional attributes.
-        
+
         Args:
             folder_id: str. Unique identifier of the folder to which the list will be added.
             name: str. Name of the list to create in the folder.
@@ -1560,14 +1765,14 @@ class ClickupApp(APIApplication):
             priority: Optional[int]. Priority level assigned to the list.
             assignee: Optional[str]. User assigned to the list.
             status: Optional[str]. Status of the list (e.g., 'active', 'completed').
-        
+
         Returns:
             dict. The API response containing details of the newly created list.
-        
+
         Raises:
             ValueError: If 'folder_id' or 'name' is not provided.
             HTTPError: If the API request fails or returns an error status code.
-        
+
         Tags:
             list, add, folder, management, api
         """
@@ -1576,13 +1781,13 @@ class ClickupApp(APIApplication):
         if name is None:
             raise ValueError("Missing required parameter 'name'")
         request_body = {
-            'name': name,
-            'content': content,
-            'due_date': due_date,
-            'due_date_time': due_date_time,
-            'priority': priority,
-            'assignee': assignee,
-            'status': status,
+            "name": name,
+            "content": content,
+            "due_date": due_date,
+            "due_date_time": due_date_time,
+            "priority": priority,
+            "assignee": assignee,
+            "status": status,
         }
         request_body = {k: v for k, v in request_body.items() if v is not None}
         url = f"{self.base_url}/folder/{folder_id}/list"
@@ -1594,33 +1799,43 @@ class ClickupApp(APIApplication):
     def lists_get_folderless(self, space_id, archived=None) -> dict[str, Any]:
         """
         Retrieves all lists within the specified space that are not associated with a folder.
-        
+
         Args:
             space_id: str. The unique identifier for the space from which to fetch folderless lists.
             archived: Optional[bool]. If provided, filters the results to include only archived or non-archived lists.
-        
+
         Returns:
             dict[str, Any]: A dictionary containing the API response with details of folderless lists for the specified space.
-        
+
         Raises:
             ValueError: Raised if 'space_id' is None.
             HTTPError: Raised if the HTTP request to the API fails with a status error.
-        
+
         Tags:
             list, fetch, management, api, important
         """
         if space_id is None:
             raise ValueError("Missing required parameter 'space_id'")
         url = f"{self.base_url}/space/{space_id}/list"
-        query_params = {k: v for k, v in [('archived', archived)] if v is not None}
+        query_params = {k: v for k, v in [("archived", archived)] if v is not None}
         response = self._get(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def lists_create_folderless_list(self, space_id, name, content=None, due_date=None, due_date_time=None, priority=None, assignee=None, status=None) -> dict[str, Any]:
+    def lists_create_folderless_list(
+        self,
+        space_id,
+        name,
+        content=None,
+        due_date=None,
+        due_date_time=None,
+        priority=None,
+        assignee=None,
+        status=None,
+    ) -> dict[str, Any]:
         """
         Creates a new list within a specified space without associating it with a folder.
-        
+
         Args:
             space_id: str. The unique identifier of the space in which to create the list.
             name: str. The name of the list to be created.
@@ -1630,14 +1845,14 @@ class ClickupApp(APIApplication):
             priority: Optional[int]. Numeric priority value for the list, where higher values indicate higher priority.
             assignee: Optional[str]. Identifier of the user assigned to the list, if any.
             status: Optional[str]. Status of the list (e.g., 'active', 'completed').
-        
+
         Returns:
             dict[str, Any]: The JSON response from the API containing the details of the newly created list.
-        
+
         Raises:
             ValueError: If 'space_id' or 'name' is not provided.
             requests.HTTPError: If the API request fails with an HTTP error status.
-        
+
         Tags:
             list, create, management, api
         """
@@ -1646,13 +1861,13 @@ class ClickupApp(APIApplication):
         if name is None:
             raise ValueError("Missing required parameter 'name'")
         request_body = {
-            'name': name,
-            'content': content,
-            'due_date': due_date,
-            'due_date_time': due_date_time,
-            'priority': priority,
-            'assignee': assignee,
-            'status': status,
+            "name": name,
+            "content": content,
+            "due_date": due_date,
+            "due_date_time": due_date_time,
+            "priority": priority,
+            "assignee": assignee,
+            "status": status,
         }
         request_body = {k: v for k, v in request_body.items() if v is not None}
         url = f"{self.base_url}/space/{space_id}/list"
@@ -1664,17 +1879,17 @@ class ClickupApp(APIApplication):
     def lists_get_list_details(self, list_id) -> dict[str, Any]:
         """
         Retrieves the details of a specific list by its unique identifier.
-        
+
         Args:
             list_id: The unique identifier of the list to retrieve details for.
-        
+
         Returns:
             A dictionary containing the details of the specified list as returned by the API.
-        
+
         Raises:
             ValueError: If 'list_id' is None.
             requests.HTTPError: If the HTTP request fails or the response contains an unsuccessful status code.
-        
+
         Tags:
             get, list, details, api
         """
@@ -1686,10 +1901,21 @@ class ClickupApp(APIApplication):
         response.raise_for_status()
         return response.json()
 
-    def lists_update_list_info_due_date_priority_assignee_color(self, list_id, name, content, due_date, due_date_time, priority, assignee, status, unset_status) -> dict[str, Any]:
+    def lists_update_list_info_due_date_priority_assignee_color(
+        self,
+        list_id,
+        name,
+        content,
+        due_date,
+        due_date_time,
+        priority,
+        assignee,
+        status,
+        unset_status,
+    ) -> dict[str, Any]:
         """
         Updates the information of a list, including name, content, due date, priority, assignee, status, and color attributes.
-        
+
         Args:
             list_id: The unique identifier of the list to update.
             name: The new name of the list.
@@ -1700,14 +1926,14 @@ class ClickupApp(APIApplication):
             assignee: The user or entity assigned to the list item.
             status: The status to set for the list item.
             unset_status: Whether to unset the current status (boolean or flag).
-        
+
         Returns:
             A dictionary containing the updated list information as returned by the API.
-        
+
         Raises:
             ValueError: If any required parameter is missing.
             requests.HTTPError: If the HTTP request fails or returns an error status code.
-        
+
         Tags:
             update, list-management, async-job, api
         """
@@ -1730,14 +1956,14 @@ class ClickupApp(APIApplication):
         if unset_status is None:
             raise ValueError("Missing required parameter 'unset_status'")
         request_body = {
-            'name': name,
-            'content': content,
-            'due_date': due_date,
-            'due_date_time': due_date_time,
-            'priority': priority,
-            'assignee': assignee,
-            'status': status,
-            'unset_status': unset_status,
+            "name": name,
+            "content": content,
+            "due_date": due_date,
+            "due_date_time": due_date_time,
+            "priority": priority,
+            "assignee": assignee,
+            "status": status,
+            "unset_status": unset_status,
         }
         request_body = {k: v for k, v in request_body.items() if v is not None}
         url = f"{self.base_url}/list/{list_id}"
@@ -1749,17 +1975,17 @@ class ClickupApp(APIApplication):
     def lists_remove_list(self, list_id) -> dict[str, Any]:
         """
         Removes a list with the specified list ID via an HTTP DELETE request and returns the API response as a dictionary.
-        
+
         Args:
             list_id: The unique identifier of the list to remove. Must not be None.
-        
+
         Returns:
             A dictionary representing the JSON response from the API after deleting the specified list.
-        
+
         Raises:
             ValueError: If 'list_id' is None.
             HTTPError: If the HTTP DELETE request fails with an error status code.
-        
+
         Tags:
             remove, list, delete, management, api
         """
@@ -1774,18 +2000,18 @@ class ClickupApp(APIApplication):
     def lists_add_task_to_list(self, list_id, task_id) -> dict[str, Any]:
         """
         Adds a task to a specified list.
-        
+
         Args:
             list_id: The unique identifier of the list to which the task will be added.
             task_id: The unique identifier of the task to be added to the list.
-        
+
         Returns:
             A dictionary containing the API response data after the task has been added to the list.
-        
+
         Raises:
             ValueError: If either list_id or task_id is None.
             HTTPError: If the HTTP request returns an unsuccessful status code.
-        
+
         Tags:
             add, task, list, management
         """
@@ -1802,18 +2028,18 @@ class ClickupApp(APIApplication):
     def lists_remove_task_from_list(self, list_id, task_id) -> dict[str, Any]:
         """
         Removes a specific task from a list by sending a DELETE request to the appropriate API endpoint.
-        
+
         Args:
             list_id: The unique identifier of the list from which the task will be removed.
             task_id: The unique identifier of the task to be removed from the list.
-        
+
         Returns:
             A dictionary containing the API response data after removing the task.
-        
+
         Raises:
             ValueError: Raised if 'list_id' or 'task_id' is None.
             requests.HTTPError: Raised if the HTTP request to remove the task fails.
-        
+
         Tags:
             remove, task, list, api, management
         """
@@ -1830,17 +2056,17 @@ class ClickupApp(APIApplication):
     def members_get_task_access(self, task_id) -> dict[str, Any]:
         """
         Retrieves a list of members who have access to the specified task.
-        
+
         Args:
             task_id: The unique identifier of the task for which to fetch member access (str or int).
-        
+
         Returns:
             A dictionary containing information about the members with access to the specified task.
-        
+
         Raises:
             ValueError: Raised if 'task_id' is None.
             HTTPError: Raised if the HTTP request to retrieve the task members fails.
-        
+
         Tags:
             members, get, task, access, fetch
         """
@@ -1855,17 +2081,17 @@ class ClickupApp(APIApplication):
     def members_get_list_users(self, list_id) -> dict[str, Any]:
         """
         Retrieves the list of users who are members of the specified list.
-        
+
         Args:
             list_id: The unique identifier of the list for which to retrieve member users.
-        
+
         Returns:
             A dictionary containing the response data with user membership details for the specified list.
-        
+
         Raises:
             ValueError: If 'list_id' is None.
             requests.HTTPError: If the HTTP request to fetch the list members fails.
-        
+
         Tags:
             get, list, users, management
         """
@@ -1877,27 +2103,31 @@ class ClickupApp(APIApplication):
         response.raise_for_status()
         return response.json()
 
-    def roles_list_available_custom_roles(self, team_id, include_members=None) -> dict[str, Any]:
+    def roles_list_available_custom_roles(
+        self, team_id, include_members=None
+    ) -> dict[str, Any]:
         """
         Retrieves a list of available custom roles for a specified team, optionally including role members.
-        
+
         Args:
             team_id: The ID of the team for which to retrieve custom roles.
             include_members: Optional flag indicating whether to include role members in the response. Defaults to None.
-        
+
         Returns:
             A dictionary containing custom roles with optional member details.
-        
+
         Raises:
             ValueError: Raised when the 'team_id' parameter is missing.
-        
+
         Tags:
             list, custom-roles, team-management
         """
         if team_id is None:
             raise ValueError("Missing required parameter 'team_id'")
         url = f"{self.base_url}/team/{team_id}/customroles"
-        query_params = {k: v for k, v in [('include_members', include_members)] if v is not None}
+        query_params = {
+            k: v for k, v in [("include_members", include_members)] if v is not None
+        }
         response = self._get(url, params=query_params)
         response.raise_for_status()
         return response.json()
@@ -1905,17 +2135,17 @@ class ClickupApp(APIApplication):
     def shared_hierarchy_view_tasks_lists_folders(self, team_id) -> dict[str, Any]:
         """
         Retrieves the shared hierarchy view including tasks, lists, and folders for a specified team.
-        
+
         Args:
             team_id: The unique identifier of the team whose shared hierarchy is being retrieved. Cannot be None.
-        
+
         Returns:
             A dictionary containing the shared hierarchy data with tasks, lists, and folders for the specified team.
-        
+
         Raises:
             ValueError: Raised when the required team_id parameter is None.
             HTTPError: Raised when the HTTP request fails (via raise_for_status()).
-        
+
         Tags:
             retrieve, view, hierarchy, team, shared
         """
@@ -1930,46 +2160,48 @@ class ClickupApp(APIApplication):
     def spaces_get_space_details(self, team_id, archived=None) -> dict[str, Any]:
         """
         Retrieves details about spaces within a specified team, optionally filtering by archived status.
-        
+
         Args:
             team_id: str. Unique identifier for the team whose space details are to be retrieved.
             archived: Optional[bool]. If provided, filters the results to include only archived or non-archived spaces.
-        
+
         Returns:
             dict[str, Any]: A dictionary containing the space details returned by the API.
-        
+
         Raises:
             ValueError: Raised if 'team_id' is None.
             requests.HTTPError: Raised if the HTTP request to the API endpoint fails.
-        
+
         Tags:
             get, spaces, team-management, api-call
         """
         if team_id is None:
             raise ValueError("Missing required parameter 'team_id'")
         url = f"{self.base_url}/team/{team_id}/space"
-        query_params = {k: v for k, v in [('archived', archived)] if v is not None}
+        query_params = {k: v for k, v in [("archived", archived)] if v is not None}
         response = self._get(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def spaces_add_new_space_to_workspace(self, team_id, name, multiple_assignees, features) -> dict[str, Any]:
+    def spaces_add_new_space_to_workspace(
+        self, team_id, name, multiple_assignees, features
+    ) -> dict[str, Any]:
         """
         Creates a new space within a specified workspace team, configuring assignment settings and desired features.
-        
+
         Args:
             team_id: str. The unique identifier of the workspace team in which to create the new space.
             name: str. The name to assign to the new space.
             multiple_assignees: bool. Indicates whether tasks in the new space can have multiple assignees.
             features: Any. Features to enable for the new space. The exact type and structure may depend on the underlying API.
-        
+
         Returns:
             dict[str, Any]: A dictionary containing the details of the newly created space, as returned by the API.
-        
+
         Raises:
             ValueError: Raised if any of the required parameters ('team_id', 'name', 'multiple_assignees', or 'features') is None.
             requests.HTTPError: Raised if the POST request to the API endpoint fails or returns an unsuccessful status code.
-        
+
         Tags:
             add, create, space, workspace, management, api
         """
@@ -1982,9 +2214,9 @@ class ClickupApp(APIApplication):
         if features is None:
             raise ValueError("Missing required parameter 'features'")
         request_body = {
-            'name': name,
-            'multiple_assignees': multiple_assignees,
-            'features': features,
+            "name": name,
+            "multiple_assignees": multiple_assignees,
+            "features": features,
         }
         request_body = {k: v for k, v in request_body.items() if v is not None}
         url = f"{self.base_url}/team/{team_id}/space"
@@ -1996,17 +2228,17 @@ class ClickupApp(APIApplication):
     def spaces_get_details(self, space_id) -> dict[str, Any]:
         """
         Retrieves the details of a specified space by its unique identifier.
-        
+
         Args:
             space_id: str. The unique identifier of the space to retrieve details for.
-        
+
         Returns:
             dict[str, Any]. A dictionary containing the details of the requested space as returned by the API.
-        
+
         Raises:
             ValueError: If the 'space_id' parameter is None.
             requests.HTTPError: If the HTTP request to retrieve the space details fails.
-        
+
         Tags:
             get, details, space, api
         """
@@ -2018,10 +2250,19 @@ class ClickupApp(APIApplication):
         response.raise_for_status()
         return response.json()
 
-    def spaces_update_details_and_enable_click_apps(self, space_id, name, color, private, admin_can_manage, multiple_assignees, features) -> dict[str, Any]:
+    def spaces_update_details_and_enable_click_apps(
+        self,
+        space_id,
+        name,
+        color,
+        private,
+        admin_can_manage,
+        multiple_assignees,
+        features,
+    ) -> dict[str, Any]:
         """
         Updates the details of a specific space and enables click apps by sending a PUT request with the provided attributes.
-        
+
         Args:
             space_id: str. The unique identifier of the space to update.
             name: str. The new name to assign to the space.
@@ -2030,14 +2271,14 @@ class ClickupApp(APIApplication):
             admin_can_manage: bool. Specifies if admins can manage the space.
             multiple_assignees: bool. Allow multiple users to be assigned to tasks in the space.
             features: Any. Additional features or settings to enable for the space.
-        
+
         Returns:
             dict[str, Any]: The updated space details as returned by the server.
-        
+
         Raises:
             ValueError: If any required parameter (space_id, name, color, private, admin_can_manage, multiple_assignees, or features) is None.
             requests.HTTPError: If the server returns an error response status.
-        
+
         Tags:
             update, spaces, management, http, api
         """
@@ -2056,12 +2297,12 @@ class ClickupApp(APIApplication):
         if features is None:
             raise ValueError("Missing required parameter 'features'")
         request_body = {
-            'name': name,
-            'color': color,
-            'private': private,
-            'admin_can_manage': admin_can_manage,
-            'multiple_assignees': multiple_assignees,
-            'features': features,
+            "name": name,
+            "color": color,
+            "private": private,
+            "admin_can_manage": admin_can_manage,
+            "multiple_assignees": multiple_assignees,
+            "features": features,
         }
         request_body = {k: v for k, v in request_body.items() if v is not None}
         url = f"{self.base_url}/space/{space_id}"
@@ -2073,17 +2314,17 @@ class ClickupApp(APIApplication):
     def spaces_remove_space(self, space_id) -> dict[str, Any]:
         """
         Removes a space identified by the given space_id.
-        
+
         Args:
             space_id: The unique identifier of the space to be removed. Cannot be None.
-        
+
         Returns:
             A dictionary containing the JSON response from the server after space deletion.
-        
+
         Raises:
             ValueError: Raised when space_id is None.
             HTTPError: Raised when the HTTP request fails or returns an error status code.
-        
+
         Tags:
             remove, delete, space, management
         """
@@ -2098,17 +2339,17 @@ class ClickupApp(APIApplication):
     def tags_get_space(self, space_id) -> dict[str, Any]:
         """
         Retrieves all tags associated with a specific space by its unique identifier.
-        
+
         Args:
             space_id: str. The unique identifier of the space whose tags are to be retrieved.
-        
+
         Returns:
             dict[str, Any]: A dictionary containing the tags for the specified space, as parsed from the JSON response.
-        
+
         Raises:
             ValueError: If the 'space_id' parameter is None.
             requests.HTTPError: If the HTTP request to retrieve tags fails (non-2xx response).
-        
+
         Tags:
             get, list, space, tags, api
         """
@@ -2123,18 +2364,18 @@ class ClickupApp(APIApplication):
     def tags_create_space_tag(self, space_id, tag) -> dict[str, Any]:
         """
         Creates a new tag for a specified space by sending a POST request to the space tag API endpoint.
-        
+
         Args:
             space_id: The unique identifier of the space to which the tag will be added. Must not be None.
             tag: The tag to associate with the specified space. Must not be None.
-        
+
         Returns:
             A dictionary containing the API response representing the created tag.
-        
+
         Raises:
             ValueError: If 'space_id' or 'tag' is None.
             requests.HTTPError: If the HTTP request to the API endpoint returns an unsuccessful status code.
-        
+
         Tags:
             create, tag, space, api
         """
@@ -2143,7 +2384,7 @@ class ClickupApp(APIApplication):
         if tag is None:
             raise ValueError("Missing required parameter 'tag'")
         request_body = {
-            'tag': tag,
+            "tag": tag,
         }
         request_body = {k: v for k, v in request_body.items() if v is not None}
         url = f"{self.base_url}/space/{space_id}/tag"
@@ -2155,19 +2396,19 @@ class ClickupApp(APIApplication):
     def tags_update_space_tag(self, space_id, tag_name, tag) -> dict[str, Any]:
         """
         Updates a tag for a specified space by sending a PUT request with the provided tag data.
-        
+
         Args:
             space_id: str. The unique identifier of the space whose tag is to be updated.
             tag_name: str. The name of the tag to update for the specified space.
             tag: Any. The new value or data for the tag to be updated.
-        
+
         Returns:
             dict[str, Any]: The response payload from the API after updating the tag, parsed as a dictionary.
-        
+
         Raises:
             ValueError: If 'space_id', 'tag_name', or 'tag' is None.
             requests.HTTPError: If the HTTP request returns an unsuccessful status code.
-        
+
         Tags:
             update, tag, api, space-management
         """
@@ -2178,7 +2419,7 @@ class ClickupApp(APIApplication):
         if tag is None:
             raise ValueError("Missing required parameter 'tag'")
         request_body = {
-            'tag': tag,
+            "tag": tag,
         }
         request_body = {k: v for k, v in request_body.items() if v is not None}
         url = f"{self.base_url}/space/{space_id}/tag/{tag_name}"
@@ -2190,19 +2431,19 @@ class ClickupApp(APIApplication):
     def tags_remove_space_tag(self, space_id, tag_name, tag) -> dict[str, Any]:
         """
         Removes a specified tag from a given space by tag name.
-        
+
         Args:
             space_id: The unique identifier of the space from which the tag will be removed.
             tag_name: The name of the tag group or category under which the tag exists.
             tag: The tag to be removed from the specified space.
-        
+
         Returns:
             A dictionary containing the response data from the API after removing the tag.
-        
+
         Raises:
             ValueError: Raised if 'space_id', 'tag_name', or 'tag' is None.
             requests.HTTPError: Raised if the HTTP request to remove the tag fails (non-2xx response).
-        
+
         Tags:
             tag-remove, space-management, api
         """
@@ -2213,7 +2454,7 @@ class ClickupApp(APIApplication):
         if tag is None:
             raise ValueError("Missing required parameter 'tag'")
         request_body = {
-            'tag': tag,
+            "tag": tag,
         }
         request_body = {k: v for k, v in request_body.items() if v is not None}
         url = f"{self.base_url}/space/{space_id}/tag/{tag_name}"
@@ -2222,23 +2463,25 @@ class ClickupApp(APIApplication):
         response.raise_for_status()
         return response.json()
 
-    def tags_add_to_task(self, task_id, tag_name, custom_task_ids=None, team_id=None) -> dict[str, Any]:
+    def tags_add_to_task(
+        self, task_id, tag_name, custom_task_ids=None, team_id=None
+    ) -> dict[str, Any]:
         """
         Adds a tag to a specific task.
-        
+
         Args:
             task_id: The unique identifier of the task to which the tag will be added.
             tag_name: The name of the tag to add to the task.
             custom_task_ids: Optional flag to indicate if task_id is a custom identifier rather than a system-generated ID.
             team_id: Optional identifier for a specific team context.
-        
+
         Returns:
             A dictionary containing the response data from the API about the tag operation.
-        
+
         Raises:
             ValueError: Raised when required parameters 'task_id' or 'tag_name' are None.
             HTTPError: Raised when the API request fails.
-        
+
         Tags:
             add, tag, task, management
         """
@@ -2247,27 +2490,33 @@ class ClickupApp(APIApplication):
         if tag_name is None:
             raise ValueError("Missing required parameter 'tag_name'")
         url = f"{self.base_url}/task/{task_id}/tag/{tag_name}"
-        query_params = {k: v for k, v in [('custom_task_ids', custom_task_ids), ('team_id', team_id)] if v is not None}
+        query_params = {
+            k: v
+            for k, v in [("custom_task_ids", custom_task_ids), ("team_id", team_id)]
+            if v is not None
+        }
         response = self._post(url, data={}, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def tags_remove_from_task(self, task_id, tag_name, custom_task_ids=None, team_id=None) -> dict[str, Any]:
+    def tags_remove_from_task(
+        self, task_id, tag_name, custom_task_ids=None, team_id=None
+    ) -> dict[str, Any]:
         """
         Removes a specific tag from a task by ID, with optional filtering by custom task IDs and team ID.
-        
+
         Args:
             task_id: The ID of the task from which the tag is to be removed.
             tag_name: The name of the tag to be removed.
             custom_task_ids: Optional; a list of custom task IDs to filter by.
             team_id: Optional; the ID of the team to which the task belongs.
-        
+
         Returns:
             A dictionary containing the response after removing the tag from the task.
-        
+
         Raises:
             ValueError: Raised when either 'task_id' or 'tag_name' is missing.
-        
+
         Tags:
             remove, task, management, tag
         """
@@ -2276,15 +2525,42 @@ class ClickupApp(APIApplication):
         if tag_name is None:
             raise ValueError("Missing required parameter 'tag_name'")
         url = f"{self.base_url}/task/{task_id}/tag/{tag_name}"
-        query_params = {k: v for k, v in [('custom_task_ids', custom_task_ids), ('team_id', team_id)] if v is not None}
+        query_params = {
+            k: v
+            for k, v in [("custom_task_ids", custom_task_ids), ("team_id", team_id)]
+            if v is not None
+        }
         response = self._delete(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def tasks_get_list_tasks(self, list_id, archived=None, include_markdown_description=None, page=None, order_by=None, reverse=None, subtasks=None, statuses=None, include_closed=None, assignees=None, tags=None, due_date_gt=None, due_date_lt=None, date_created_gt=None, date_created_lt=None, date_updated_gt=None, date_updated_lt=None, date_done_gt=None, date_done_lt=None, custom_fields=None, custom_items=None) -> dict[str, Any]:
+    def tasks_get_list_tasks(
+        self,
+        list_id,
+        archived=None,
+        include_markdown_description=None,
+        page=None,
+        order_by=None,
+        reverse=None,
+        subtasks=None,
+        statuses=None,
+        include_closed=None,
+        assignees=None,
+        tags=None,
+        due_date_gt=None,
+        due_date_lt=None,
+        date_created_gt=None,
+        date_created_lt=None,
+        date_updated_gt=None,
+        date_updated_lt=None,
+        date_done_gt=None,
+        date_done_lt=None,
+        custom_fields=None,
+        custom_items=None,
+    ) -> dict[str, Any]:
         """
         Retrieves a list of tasks from a specified list with optional filters such as archived status, pagination, sorting, subtask inclusion, status, assignees, tags, date ranges, and custom fields.
-        
+
         Args:
             list_id: str. The unique identifier of the list from which to retrieve tasks. Required.
             archived: Optional[bool]. If set, filter tasks by archived status.
@@ -2307,29 +2583,76 @@ class ClickupApp(APIApplication):
             date_done_lt: Optional[str]. Include tasks completed before this date (ISO 8601 format).
             custom_fields: Optional[dict[str, Any]]. Filter tasks by specified custom fields.
             custom_items: Optional[list[str]]. Filter tasks by custom items.
-        
+
         Returns:
             dict[str, Any]: A dictionary containing the list of tasks matching the filters and additional metadata as provided by the API response.
-        
+
         Raises:
             ValueError: If 'list_id' is not provided.
             requests.HTTPError: If the HTTP request fails or the API responds with an error status code.
-        
+
         Tags:
             list, tasks, fetch, filter, api, management, important
         """
         if list_id is None:
             raise ValueError("Missing required parameter 'list_id'")
         url = f"{self.base_url}/list/{list_id}/task"
-        query_params = {k: v for k, v in [('archived', archived), ('include_markdown_description', include_markdown_description), ('page', page), ('order_by', order_by), ('reverse', reverse), ('subtasks', subtasks), ('statuses', statuses), ('include_closed', include_closed), ('assignees', assignees), ('tags', tags), ('due_date_gt', due_date_gt), ('due_date_lt', due_date_lt), ('date_created_gt', date_created_gt), ('date_created_lt', date_created_lt), ('date_updated_gt', date_updated_gt), ('date_updated_lt', date_updated_lt), ('date_done_gt', date_done_gt), ('date_done_lt', date_done_lt), ('custom_fields', custom_fields), ('custom_items', custom_items)] if v is not None}
+        query_params = {
+            k: v
+            for k, v in [
+                ("archived", archived),
+                ("include_markdown_description", include_markdown_description),
+                ("page", page),
+                ("order_by", order_by),
+                ("reverse", reverse),
+                ("subtasks", subtasks),
+                ("statuses", statuses),
+                ("include_closed", include_closed),
+                ("assignees", assignees),
+                ("tags", tags),
+                ("due_date_gt", due_date_gt),
+                ("due_date_lt", due_date_lt),
+                ("date_created_gt", date_created_gt),
+                ("date_created_lt", date_created_lt),
+                ("date_updated_gt", date_updated_gt),
+                ("date_updated_lt", date_updated_lt),
+                ("date_done_gt", date_done_gt),
+                ("date_done_lt", date_done_lt),
+                ("custom_fields", custom_fields),
+                ("custom_items", custom_items),
+            ]
+            if v is not None
+        }
         response = self._get(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def tasks_create_new_task(self, list_id, name, custom_task_ids=None, team_id=None, tags=None, description=None, assignees=None, status=None, priority=None, due_date=None, due_date_time=None, time_estimate=None, start_date=None, start_date_time=None, notify_all=None, parent=None, links_to=None, check_required_custom_fields=None, custom_fields=None, custom_item_id=None) -> dict[str, Any]:
+    def tasks_create_new_task(
+        self,
+        list_id,
+        name,
+        custom_task_ids=None,
+        team_id=None,
+        tags=None,
+        description=None,
+        assignees=None,
+        status=None,
+        priority=None,
+        due_date=None,
+        due_date_time=None,
+        time_estimate=None,
+        start_date=None,
+        start_date_time=None,
+        notify_all=None,
+        parent=None,
+        links_to=None,
+        check_required_custom_fields=None,
+        custom_fields=None,
+        custom_item_id=None,
+    ) -> dict[str, Any]:
         """
         Creates a new task in the specified list with optional attributes including tags, assignees, status, priority, dates, and custom fields.
-        
+
         Args:
             list_id: str. The unique identifier of the list where the task will be created. Required.
             name: str. The name or title of the new task. Required.
@@ -2351,14 +2674,14 @@ class ClickupApp(APIApplication):
             check_required_custom_fields: Optional[bool]. If True, validates that all required custom fields are set.
             custom_fields: Optional[dict]. Dictionary of custom field values for the task.
             custom_item_id: Optional[str]. Identifier for a custom item type.
-        
+
         Returns:
             dict[str, Any]: The JSON response representing the created task.
-        
+
         Raises:
             ValueError: Raised if 'list_id' or 'name' is None.
             requests.HTTPError: Raised if the HTTP request to create the task fails.
-        
+
         Tags:
             create, task, management, api, important
         """
@@ -2367,64 +2690,102 @@ class ClickupApp(APIApplication):
         if name is None:
             raise ValueError("Missing required parameter 'name'")
         request_body = {
-            'tags': tags,
-            'description': description,
-            'name': name,
-            'assignees': assignees,
-            'status': status,
-            'priority': priority,
-            'due_date': due_date,
-            'due_date_time': due_date_time,
-            'time_estimate': time_estimate,
-            'start_date': start_date,
-            'start_date_time': start_date_time,
-            'notify_all': notify_all,
-            'parent': parent,
-            'links_to': links_to,
-            'check_required_custom_fields': check_required_custom_fields,
-            'custom_fields': custom_fields,
-            'custom_item_id': custom_item_id,
+            "tags": tags,
+            "description": description,
+            "name": name,
+            "assignees": assignees,
+            "status": status,
+            "priority": priority,
+            "due_date": due_date,
+            "due_date_time": due_date_time,
+            "time_estimate": time_estimate,
+            "start_date": start_date,
+            "start_date_time": start_date_time,
+            "notify_all": notify_all,
+            "parent": parent,
+            "links_to": links_to,
+            "check_required_custom_fields": check_required_custom_fields,
+            "custom_fields": custom_fields,
+            "custom_item_id": custom_item_id,
         }
         request_body = {k: v for k, v in request_body.items() if v is not None}
         url = f"{self.base_url}/list/{list_id}/task"
-        query_params = {k: v for k, v in [('custom_task_ids', custom_task_ids), ('team_id', team_id)] if v is not None}
+        query_params = {
+            k: v
+            for k, v in [("custom_task_ids", custom_task_ids), ("team_id", team_id)]
+            if v is not None
+        }
         response = self._post(url, data=request_body, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def tasks_get_task_details(self, task_id, custom_task_ids=None, team_id=None, include_subtasks=None, include_markdown_description=None) -> dict[str, Any]:
+    def tasks_get_task_details(
+        self,
+        task_id,
+        custom_task_ids=None,
+        team_id=None,
+        include_subtasks=None,
+        include_markdown_description=None,
+    ) -> dict[str, Any]:
         """
         Retrieves detailed information about a specific task, with options to include subtasks, use custom task IDs, filter by team, and specify description formatting.
-        
+
         Args:
             task_id: The unique identifier of the task to retrieve. Required.
             custom_task_ids: Optional; a list or string of custom task IDs to use for lookup instead of standard IDs.
             team_id: Optional; the ID of the team to filter task lookup by team context.
             include_subtasks: Optional; if True, include details of subtasks in the response.
             include_markdown_description: Optional; if True, return the task description in Markdown format.
-        
+
         Returns:
             A dictionary containing the details of the requested task, including optional subtasks and formatted description if requested.
-        
+
         Raises:
             ValueError: Raised if 'task_id' is not provided.
             requests.HTTPError: Raised if the HTTP request for task details fails due to a client or server error.
-        
+
         Tags:
             get, task, details, status, management
         """
         if task_id is None:
             raise ValueError("Missing required parameter 'task_id'")
         url = f"{self.base_url}/task/{task_id}"
-        query_params = {k: v for k, v in [('custom_task_ids', custom_task_ids), ('team_id', team_id), ('include_subtasks', include_subtasks), ('include_markdown_description', include_markdown_description)] if v is not None}
+        query_params = {
+            k: v
+            for k, v in [
+                ("custom_task_ids", custom_task_ids),
+                ("team_id", team_id),
+                ("include_subtasks", include_subtasks),
+                ("include_markdown_description", include_markdown_description),
+            ]
+            if v is not None
+        }
         response = self._get(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def tasks_update_task_fields(self, task_id, custom_task_ids=None, team_id=None, description=None, custom_item_id=None, name=None, status=None, priority=None, due_date=None, due_date_time=None, parent=None, time_estimate=None, start_date=None, start_date_time=None, assignees=None, archived=None) -> dict[str, Any]:
+    def tasks_update_task_fields(
+        self,
+        task_id,
+        custom_task_ids=None,
+        team_id=None,
+        description=None,
+        custom_item_id=None,
+        name=None,
+        status=None,
+        priority=None,
+        due_date=None,
+        due_date_time=None,
+        parent=None,
+        time_estimate=None,
+        start_date=None,
+        start_date_time=None,
+        assignees=None,
+        archived=None,
+    ) -> dict[str, Any]:
         """
         Updates specified fields of an existing task with provided values.
-        
+
         Args:
             task_id: str. The unique identifier of the task to update. Required.
             custom_task_ids: Optional[str]. Specifies whether custom task IDs are used. Defaults to None.
@@ -2442,72 +2803,110 @@ class ClickupApp(APIApplication):
             start_date_time: Optional[str]. The start date and time in ISO 8601 format. Defaults to None.
             assignees: Optional[list[str]]. A list of user IDs to assign to the task. Defaults to None.
             archived: Optional[bool]. Whether the task should be archived. Defaults to None.
-        
+
         Returns:
             dict[str, Any]: A dictionary containing the updated task details as returned by the API.
-        
+
         Raises:
             ValueError: If the 'task_id' parameter is not provided or is None.
             requests.HTTPError: If the HTTP request to update the task fails.
-        
+
         Tags:
             update, task, management, api
         """
         if task_id is None:
             raise ValueError("Missing required parameter 'task_id'")
         request_body = {
-            'description': description,
-            'custom_item_id': custom_item_id,
-            'name': name,
-            'status': status,
-            'priority': priority,
-            'due_date': due_date,
-            'due_date_time': due_date_time,
-            'parent': parent,
-            'time_estimate': time_estimate,
-            'start_date': start_date,
-            'start_date_time': start_date_time,
-            'assignees': assignees,
-            'archived': archived,
+            "description": description,
+            "custom_item_id": custom_item_id,
+            "name": name,
+            "status": status,
+            "priority": priority,
+            "due_date": due_date,
+            "due_date_time": due_date_time,
+            "parent": parent,
+            "time_estimate": time_estimate,
+            "start_date": start_date,
+            "start_date_time": start_date_time,
+            "assignees": assignees,
+            "archived": archived,
         }
         request_body = {k: v for k, v in request_body.items() if v is not None}
         url = f"{self.base_url}/task/{task_id}"
-        query_params = {k: v for k, v in [('custom_task_ids', custom_task_ids), ('team_id', team_id)] if v is not None}
+        query_params = {
+            k: v
+            for k, v in [("custom_task_ids", custom_task_ids), ("team_id", team_id)]
+            if v is not None
+        }
         response = self._put(url, data=request_body, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def tasks_remove_task_by_id(self, task_id, custom_task_ids=None, team_id=None) -> dict[str, Any]:
+    def tasks_remove_task_by_id(
+        self, task_id, custom_task_ids=None, team_id=None
+    ) -> dict[str, Any]:
         """
         Removes a specific task by its unique task ID, optionally filtering by custom task IDs and team ID.
-        
+
         Args:
             task_id: str. The unique identifier of the task to remove. Required.
             custom_task_ids: Optional[List[str]]. A list of custom task IDs to further specify which tasks to remove. Defaults to None.
             team_id: Optional[str]. The team identifier to specify the context for task removal. Defaults to None.
-        
+
         Returns:
             dict[str, Any]: A dictionary containing the JSON response from the API after task removal.
-        
+
         Raises:
             ValueError: If 'task_id' is not provided.
             requests.HTTPError: If the HTTP request to remove the task fails (non-success response status).
-        
+
         Tags:
             remove, task, management, api
         """
         if task_id is None:
             raise ValueError("Missing required parameter 'task_id'")
         url = f"{self.base_url}/task/{task_id}"
-        query_params = {k: v for k, v in [('custom_task_ids', custom_task_ids), ('team_id', team_id)] if v is not None}
+        query_params = {
+            k: v
+            for k, v in [("custom_task_ids", custom_task_ids), ("team_id", team_id)]
+            if v is not None
+        }
         response = self._delete(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def tasks_filter_team_tasks(self, team_Id, page=None, order_by=None, reverse=None, subtasks=None, space_ids=None, project_ids=None, list_ids=None, statuses=None, include_closed=None, assignees=None, tags=None, due_date_gt=None, due_date_lt=None, date_created_gt=None, date_created_lt=None, date_updated_gt=None, date_updated_lt=None, date_done_gt=None, date_done_lt=None, custom_fields=None, custom_task_ids=None, team_id=None, parent=None, include_markdown_description=None, custom_items=None) -> dict[str, Any]:
+    def tasks_filter_team_tasks(
+        self,
+        team_Id,
+        page=None,
+        order_by=None,
+        reverse=None,
+        subtasks=None,
+        space_ids=None,
+        project_ids=None,
+        list_ids=None,
+        statuses=None,
+        include_closed=None,
+        assignees=None,
+        tags=None,
+        due_date_gt=None,
+        due_date_lt=None,
+        date_created_gt=None,
+        date_created_lt=None,
+        date_updated_gt=None,
+        date_updated_lt=None,
+        date_done_gt=None,
+        date_done_lt=None,
+        custom_fields=None,
+        custom_task_ids=None,
+        team_id=None,
+        parent=None,
+        include_markdown_description=None,
+        custom_items=None,
+    ) -> dict[str, Any]:
         """
         Retrieves a filtered list of tasks assigned to a specific team, supporting various filtering options such as assignees, statuses, lists, projects, tags, due dates, custom fields, and more.
-        
+
         Args:
             team_Id: str. The unique identifier of the team for which to filter tasks. Required.
             page: Optional[int]. The page number for paginated results.
@@ -2535,75 +2934,121 @@ class ClickupApp(APIApplication):
             parent: Optional[str]. Filter tasks by a parent task ID.
             include_markdown_description: Optional[bool]. Whether to include the markdown-formatted description in tasks.
             custom_items: Optional[bool]. Whether to include custom items in the response.
-        
+
         Returns:
             dict[str, Any]: The parsed JSON response from the API containing filtered team tasks.
-        
+
         Raises:
             ValueError: If the required 'team_Id' parameter is not provided.
             HTTPError: If the HTTP request fails or the API returns an unsuccessful status code.
-        
+
         Tags:
             filter, tasks, list, team, management, api
         """
         if team_Id is None:
             raise ValueError("Missing required parameter 'team_Id'")
         url = f"{self.base_url}/team/{team_Id}/task"
-        query_params = {k: v for k, v in [('page', page), ('order_by', order_by), ('reverse', reverse), ('subtasks', subtasks), ('space_ids', space_ids), ('project_ids', project_ids), ('list_ids', list_ids), ('statuses', statuses), ('include_closed', include_closed), ('assignees', assignees), ('tags', tags), ('due_date_gt', due_date_gt), ('due_date_lt', due_date_lt), ('date_created_gt', date_created_gt), ('date_created_lt', date_created_lt), ('date_updated_gt', date_updated_gt), ('date_updated_lt', date_updated_lt), ('date_done_gt', date_done_gt), ('date_done_lt', date_done_lt), ('custom_fields', custom_fields), ('custom_task_ids', custom_task_ids), ('team_id', team_id), ('parent', parent), ('include_markdown_description', include_markdown_description), ('custom_items', custom_items)] if v is not None}
+        query_params = {
+            k: v
+            for k, v in [
+                ("page", page),
+                ("order_by", order_by),
+                ("reverse", reverse),
+                ("subtasks", subtasks),
+                ("space_ids", space_ids),
+                ("project_ids", project_ids),
+                ("list_ids", list_ids),
+                ("statuses", statuses),
+                ("include_closed", include_closed),
+                ("assignees", assignees),
+                ("tags", tags),
+                ("due_date_gt", due_date_gt),
+                ("due_date_lt", due_date_lt),
+                ("date_created_gt", date_created_gt),
+                ("date_created_lt", date_created_lt),
+                ("date_updated_gt", date_updated_gt),
+                ("date_updated_lt", date_updated_lt),
+                ("date_done_gt", date_done_gt),
+                ("date_done_lt", date_done_lt),
+                ("custom_fields", custom_fields),
+                ("custom_task_ids", custom_task_ids),
+                ("team_id", team_id),
+                ("parent", parent),
+                ("include_markdown_description", include_markdown_description),
+                ("custom_items", custom_items),
+            ]
+            if v is not None
+        }
         response = self._get(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def tasks_get_time_in_status(self, task_id, custom_task_ids=None, team_id=None) -> dict[str, Any]:
+    def tasks_get_time_in_status(
+        self, task_id, custom_task_ids=None, team_id=None
+    ) -> dict[str, Any]:
         """
         Retrieves the amount of time a specified task has spent in each status, with optional filters for custom task IDs and team ID.
-        
+
         Args:
             task_id: str. The unique identifier of the task whose time in status is to be retrieved.
             custom_task_ids: Optional[str]. Custom identifiers for filtering tasks; if provided, limits results to these IDs.
             team_id: Optional[str]. The unique identifier of the team; if provided, filters results to this team.
-        
+
         Returns:
             dict[str, Any]: A dictionary containing the time spent by the specified task in each status.
-        
+
         Raises:
             ValueError: If 'task_id' is not provided.
             requests.HTTPError: If the HTTP request to the server fails or returns an unsuccessful status code.
-        
+
         Tags:
             get, task, status, management
         """
         if task_id is None:
             raise ValueError("Missing required parameter 'task_id'")
         url = f"{self.base_url}/task/{task_id}/time_in_status"
-        query_params = {k: v for k, v in [('custom_task_ids', custom_task_ids), ('team_id', team_id)] if v is not None}
+        query_params = {
+            k: v
+            for k, v in [("custom_task_ids", custom_task_ids), ("team_id", team_id)]
+            if v is not None
+        }
         response = self._get(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def tasks_get_time_in_status_bulk(self, task_ids, custom_task_ids=None, team_id=None) -> dict[str, Any]:
+    def tasks_get_time_in_status_bulk(
+        self, task_ids, custom_task_ids=None, team_id=None
+    ) -> dict[str, Any]:
         """
         Retrieves the time each specified task has spent in various statuses, in bulk, based on provided task identifiers.
-        
+
         Args:
             task_ids: list or str. A list of task IDs or a comma-separated string of task IDs to query. Required.
             custom_task_ids: list or str, optional. A list or comma-separated string of custom task identifiers to filter the tasks.
             team_id: str, optional. The team ID to scope the task status retrieval.
-        
+
         Returns:
             dict. A dictionary mapping each requested task ID to a breakdown of time spent in each status.
-        
+
         Raises:
             ValueError: Raised if 'task_ids' is None.
             HTTPError: Raised if the HTTP request to the API fails (e.g., non-2xx response code).
-        
+
         Tags:
             get, task-management, status, bulk
         """
         if task_ids is None:
             raise ValueError("Missing required parameter 'task_ids'")
         url = f"{self.base_url}/task/bulk_time_in_status/task_ids"
-        query_params = {k: v for k, v in [('task_ids', task_ids), ('custom_task_ids', custom_task_ids), ('team_id', team_id)] if v is not None}
+        query_params = {
+            k: v
+            for k, v in [
+                ("task_ids", task_ids),
+                ("custom_task_ids", custom_task_ids),
+                ("team_id", team_id),
+            ]
+            if v is not None
+        }
         response = self._get(url, params=query_params)
         response.raise_for_status()
         return response.json()
@@ -2611,18 +3056,18 @@ class ClickupApp(APIApplication):
     def task_templates_get_templates(self, team_id, page) -> dict[str, Any]:
         """
         Retrieves a paginated list of task templates for a given team.
-        
+
         Args:
             team_id: str. The unique identifier of the team for which to fetch task templates.
             page: int. The page number of task templates to retrieve.
-        
+
         Returns:
             dict[str, Any]: A dictionary containing the paginated task template data for the specified team.
-        
+
         Raises:
             ValueError: Raised if 'team_id' or 'page' is None.
             requests.HTTPError: Raised if the HTTP request returns an unsuccessful status code.
-        
+
         Tags:
             get, list, task-templates, team
         """
@@ -2631,27 +3076,29 @@ class ClickupApp(APIApplication):
         if page is None:
             raise ValueError("Missing required parameter 'page'")
         url = f"{self.base_url}/team/{team_id}/taskTemplate"
-        query_params = {k: v for k, v in [('page', page)] if v is not None}
+        query_params = {k: v for k, v in [("page", page)] if v is not None}
         response = self._get(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def task_templates_create_from_template(self, list_id, template_id, name) -> dict[str, Any]:
+    def task_templates_create_from_template(
+        self, list_id, template_id, name
+    ) -> dict[str, Any]:
         """
         Creates a new task template instance in a specific list by cloning from an existing task template.
-        
+
         Args:
             list_id: The unique identifier of the list in which to create the new task template (str).
             template_id: The unique identifier of the task template to clone from (str).
             name: The name to assign to the newly created task template (str).
-        
+
         Returns:
             dict[str, Any]: A dictionary containing the details of the newly created task template as returned by the API.
-        
+
         Raises:
             ValueError: Raised if any of the required parameters ('list_id', 'template_id', or 'name') are None.
             requests.HTTPError: Raised if the HTTP request to create the task template fails.
-        
+
         Tags:
             create, task-template, list, api
         """
@@ -2662,7 +3109,7 @@ class ClickupApp(APIApplication):
         if name is None:
             raise ValueError("Missing required parameter 'name'")
         request_body = {
-            'name': name,
+            "name": name,
         }
         request_body = {k: v for k, v in request_body.items() if v is not None}
         url = f"{self.base_url}/list/{list_id}/taskTemplate/{template_id}"
@@ -2674,17 +3121,17 @@ class ClickupApp(APIApplication):
     def teams_workspaces_get_workspace_seats(self, team_id) -> dict[str, Any]:
         """
         Retrieves detailed seat allocation information for a specific workspace team.
-        
+
         Args:
             team_id: The unique identifier of the team whose workspace seats are to be fetched.
-        
+
         Returns:
             A dictionary containing seat allocation details for the specified team.
-        
+
         Raises:
             ValueError: If 'team_id' is None.
             requests.HTTPError: If the HTTP request to fetch seat information fails.
-        
+
         Tags:
             get, workspace, seats, team, api, management
         """
@@ -2699,17 +3146,17 @@ class ClickupApp(APIApplication):
     def teams_workspaces_get_workspace_plan(self, team_id) -> dict[str, Any]:
         """
         Retrieves the plan details for a workspace associated with the specified team.
-        
+
         Args:
             team_id: The unique identifier of the team whose workspace plan is to be retrieved.
-        
+
         Returns:
             A dictionary containing the workspace plan details for the given team.
-        
+
         Raises:
             ValueError: Raised if the team_id parameter is None.
             requests.HTTPError: Raised if the HTTP request to retrieve the plan details fails.
-        
+
         Tags:
             get, workspace-plan, team-management
         """
@@ -2724,19 +3171,19 @@ class ClickupApp(APIApplication):
     def teams_user_groups_create_team(self, team_id, name, members) -> dict[str, Any]:
         """
         Creates a new team user group with the specified name and members under the given team.
-        
+
         Args:
             team_id: str. The unique identifier of the team under which the group will be created.
             name: str. The name of the new user group.
             members: list. The list of members to be added to the group.
-        
+
         Returns:
             dict[str, Any]: The response data containing details of the newly created team user group.
-        
+
         Raises:
             ValueError: Raised if any of the required parameters ('team_id', 'name', or 'members') are missing.
             requests.HTTPError: Raised if the HTTP request to create the group fails.
-        
+
         Tags:
             create, team-user-group, management, api
         """
@@ -2747,8 +3194,8 @@ class ClickupApp(APIApplication):
         if members is None:
             raise ValueError("Missing required parameter 'members'")
         request_body = {
-            'name': name,
-            'members': members,
+            "name": name,
+            "members": members,
         }
         request_body = {k: v for k, v in request_body.items() if v is not None}
         url = f"{self.base_url}/team/{team_id}/group"
@@ -2760,17 +3207,17 @@ class ClickupApp(APIApplication):
     def custom_task_types_get_available_task_types(self, team_id) -> dict[str, Any]:
         """
         Retrieves the available custom task types for a specified team.
-        
+
         Args:
             team_id: The unique identifier of the team for which to fetch available custom task types.
-        
+
         Returns:
             A dictionary containing the available custom task types for the specified team.
-        
+
         Raises:
             ValueError: If 'team_id' is None.
             requests.HTTPError: If the HTTP request to the server fails or returns a non-successful status code.
-        
+
         Tags:
             get, custom-task-types, list, api, management
         """
@@ -2782,32 +3229,34 @@ class ClickupApp(APIApplication):
         response.raise_for_status()
         return response.json()
 
-    def teams_user_groups_update_user_group(self, group_id, name=None, handle=None, members=None) -> dict[str, Any]:
+    def teams_user_groups_update_user_group(
+        self, group_id, name=None, handle=None, members=None
+    ) -> dict[str, Any]:
         """
         Updates the attributes of a user group in the Teams system.
-        
+
         Args:
             group_id: The unique identifier of the user group to update.
             name: Optional; The new name for the user group.
             handle: Optional; The new handle (identifier) for the user group.
             members: Optional; A list of user identifiers to set as members of the group.
-        
+
         Returns:
             A dictionary containing the updated user group details as returned by the API.
-        
+
         Raises:
             ValueError: If 'group_id' is None.
             requests.HTTPError: If the HTTP request to update the group fails.
-        
+
         Tags:
             update, group-management, teams, user-groups, api
         """
         if group_id is None:
             raise ValueError("Missing required parameter 'group_id'")
         request_body = {
-            'name': name,
-            'handle': handle,
-            'members': members,
+            "name": name,
+            "handle": handle,
+            "members": members,
         }
         request_body = {k: v for k, v in request_body.items() if v is not None}
         url = f"{self.base_url}/group/{group_id}"
@@ -2819,17 +3268,17 @@ class ClickupApp(APIApplication):
     def teams_user_groups_remove_group(self, group_id) -> dict[str, Any]:
         """
         Removes a user group from the Teams service by group ID.
-        
+
         Args:
             group_id: str. The unique identifier of the group to be removed.
-        
+
         Returns:
             dict[str, Any]: The JSON response from the server after the group deletion.
-        
+
         Raises:
             ValueError: If the 'group_id' parameter is None.
             requests.HTTPError: If the HTTP request to delete the group fails with an error status code.
-        
+
         Tags:
             remove, group-management, teams, http-delete
         """
@@ -2841,60 +3290,74 @@ class ClickupApp(APIApplication):
         response.raise_for_status()
         return response.json()
 
-    def teams_user_groups_get_user_groups(self, team_id=None, group_ids=None) -> dict[str, Any]:
+    def teams_user_groups_get_user_groups(
+        self, team_id=None, group_ids=None
+    ) -> dict[str, Any]:
         """
         Retrieves user group information for a specified team and/or group IDs from the remote service.
-        
+
         Args:
             team_id: Optional; the identifier of the team to filter user groups (str or None).
             group_ids: Optional; a list of group IDs to filter the results (iterable or None).
-        
+
         Returns:
             A dictionary containing the JSON response with user group details from the remote service.
-        
+
         Raises:
             requests.HTTPError: If the HTTP request fails or the response status indicates an error.
-        
+
         Tags:
             get, user-groups, team-management, api
         """
         url = f"{self.base_url}/group"
-        query_params = {k: v for k, v in [('team_id', team_id), ('group_ids', group_ids)] if v is not None}
+        query_params = {
+            k: v
+            for k, v in [("team_id", team_id), ("group_ids", group_ids)]
+            if v is not None
+        }
         response = self._get(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def time_tracking_legacy_get_tracked_time(self, task_id, custom_task_ids=None, team_id=None) -> dict[str, Any]:
+    def time_tracking_legacy_get_tracked_time(
+        self, task_id, custom_task_ids=None, team_id=None
+    ) -> dict[str, Any]:
         """
         Retrieves time tracking data for a specific task.
-        
+
         Args:
             task_id: The unique identifier of the task for which time tracking data is requested. Required.
             custom_task_ids: Optional flag to include custom task identifiers in the response.
             team_id: Optional team identifier to filter the time tracking data by team.
-        
+
         Returns:
             A dictionary containing time tracking information for the specified task.
-        
+
         Raises:
             ValueError: Raised when the required 'task_id' parameter is None.
             HTTPError: Raised when the API request fails (via raise_for_status()).
-        
+
         Tags:
             get, retrieve, time-tracking, task, legacy
         """
         if task_id is None:
             raise ValueError("Missing required parameter 'task_id'")
         url = f"{self.base_url}/task/{task_id}/time"
-        query_params = {k: v for k, v in [('custom_task_ids', custom_task_ids), ('team_id', team_id)] if v is not None}
+        query_params = {
+            k: v
+            for k, v in [("custom_task_ids", custom_task_ids), ("team_id", team_id)]
+            if v is not None
+        }
         response = self._get(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def time_tracking_legacy_record_time_for_task(self, task_id, start, end, time, custom_task_ids=None, team_id=None) -> dict[str, Any]:
+    def time_tracking_legacy_record_time_for_task(
+        self, task_id, start, end, time, custom_task_ids=None, team_id=None
+    ) -> dict[str, Any]:
         """
         Records time for a task in the legacy system.
-        
+
         Args:
             task_id: The ID of the task to record time for.
             start: The start time of the time entry.
@@ -2902,13 +3365,13 @@ class ClickupApp(APIApplication):
             time: The duration of the time entry.
             custom_task_ids: Optional list of custom task IDs.
             team_id: Optional team ID.
-        
+
         Returns:
             A dictionary containing the response from the server.
-        
+
         Raises:
             ValueError: Raised if any of the required parameters (task_id, start, end, time) are missing.
-        
+
         Tags:
             record, time-tracking, legacy
         """
@@ -2921,21 +3384,27 @@ class ClickupApp(APIApplication):
         if time is None:
             raise ValueError("Missing required parameter 'time'")
         request_body = {
-            'start': start,
-            'end': end,
-            'time': time,
+            "start": start,
+            "end": end,
+            "time": time,
         }
         request_body = {k: v for k, v in request_body.items() if v is not None}
         url = f"{self.base_url}/task/{task_id}/time"
-        query_params = {k: v for k, v in [('custom_task_ids', custom_task_ids), ('team_id', team_id)] if v is not None}
+        query_params = {
+            k: v
+            for k, v in [("custom_task_ids", custom_task_ids), ("team_id", team_id)]
+            if v is not None
+        }
         response = self._post(url, data=request_body, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def time_tracking_legacy_edit_time_tracked(self, task_id, interval_id, start, end, time, custom_task_ids=None, team_id=None) -> dict[str, Any]:
+    def time_tracking_legacy_edit_time_tracked(
+        self, task_id, interval_id, start, end, time, custom_task_ids=None, team_id=None
+    ) -> dict[str, Any]:
         """
         Edits a tracked time interval for a specific task using legacy time tracking, updating start, end, and time values.
-        
+
         Args:
             task_id: str. Unique identifier of the task whose time interval is being edited.
             interval_id: str. Identifier of the specific time interval to edit.
@@ -2944,14 +3413,14 @@ class ClickupApp(APIApplication):
             time: int. The updated duration for the time interval, typically in seconds.
             custom_task_ids: Optional[str]. Custom task identifier(s), if applicable. Defaults to None.
             team_id: Optional[str]. Team identifier, if relevant to the time tracking operation. Defaults to None.
-        
+
         Returns:
             dict[str, Any]: The response from the server as a dictionary containing the updated interval information.
-        
+
         Raises:
             ValueError: If any of the required parameters (task_id, interval_id, start, end, time) are missing.
             requests.HTTPError: If the HTTP request fails or the server responds with an error status code.
-        
+
         Tags:
             edit, time-tracking, task-management, api, update
         """
@@ -2966,33 +3435,39 @@ class ClickupApp(APIApplication):
         if time is None:
             raise ValueError("Missing required parameter 'time'")
         request_body = {
-            'start': start,
-            'end': end,
-            'time': time,
+            "start": start,
+            "end": end,
+            "time": time,
         }
         request_body = {k: v for k, v in request_body.items() if v is not None}
         url = f"{self.base_url}/task/{task_id}/time/{interval_id}"
-        query_params = {k: v for k, v in [('custom_task_ids', custom_task_ids), ('team_id', team_id)] if v is not None}
+        query_params = {
+            k: v
+            for k, v in [("custom_task_ids", custom_task_ids), ("team_id", team_id)]
+            if v is not None
+        }
         response = self._put(url, data=request_body, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def time_tracking_legacy_remove_tracked_time(self, task_id, interval_id, custom_task_ids=None, team_id=None) -> dict[str, Any]:
+    def time_tracking_legacy_remove_tracked_time(
+        self, task_id, interval_id, custom_task_ids=None, team_id=None
+    ) -> dict[str, Any]:
         """
         Removes tracked time from a time-tracking interval associated with a specific task.
-        
+
         Args:
             task_id: The ID of the task from which tracked time will be removed.
             interval_id: The ID of the time interval to remove tracked time from.
             custom_task_ids: Optional list of custom task IDs for filtering.
             team_id: Optional team ID for filtering.
-        
+
         Returns:
             A dictionary containing the result of removing tracked time.
-        
+
         Raises:
             ValueError: Raised if either 'task_id' or 'interval_id' is missing.
-        
+
         Tags:
             remove, time-tracking, task-management, async_job
         """
@@ -3001,15 +3476,33 @@ class ClickupApp(APIApplication):
         if interval_id is None:
             raise ValueError("Missing required parameter 'interval_id'")
         url = f"{self.base_url}/task/{task_id}/time/{interval_id}"
-        query_params = {k: v for k, v in [('custom_task_ids', custom_task_ids), ('team_id', team_id)] if v is not None}
+        query_params = {
+            k: v
+            for k, v in [("custom_task_ids", custom_task_ids), ("team_id", team_id)]
+            if v is not None
+        }
         response = self._delete(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def time_tracking_get_time_entries_within_date_range(self, team_Id, start_date=None, end_date=None, assignee=None, include_task_tags=None, include_location_names=None, space_id=None, folder_id=None, list_id=None, task_id=None, custom_task_ids=None, team_id=None) -> dict[str, Any]:
+    def time_tracking_get_time_entries_within_date_range(
+        self,
+        team_Id,
+        start_date=None,
+        end_date=None,
+        assignee=None,
+        include_task_tags=None,
+        include_location_names=None,
+        space_id=None,
+        folder_id=None,
+        list_id=None,
+        task_id=None,
+        custom_task_ids=None,
+        team_id=None,
+    ) -> dict[str, Any]:
         """
         Retrieves time entries for a specified team within an optional date range and optional filters such as assignee, tags, locations, spaces, folders, lists, or tasks.
-        
+
         Args:
             team_Id: str. The unique identifier of the team whose time entries are to be retrieved. Required.
             start_date: str or None. The start date for filtering time entries (ISO 8601 format). Optional.
@@ -3023,29 +3516,59 @@ class ClickupApp(APIApplication):
             task_id: str or None. Filter time entries by a specific task ID. Optional.
             custom_task_ids: str or None. Filter time entries using custom task IDs. Optional.
             team_id: str or None. Filter time entries by an alternative team ID (if distinct from team_Id). Optional.
-        
+
         Returns:
             dict[str, Any]: A dictionary containing the queried time entry data for the specified team and filters.
-        
+
         Raises:
             ValueError: Raised if the required parameter 'team_Id' is not provided.
             requests.HTTPError: Raised if the HTTP request to the API fails (e.g., due to network issues or API errors).
-        
+
         Tags:
             get, list, time-tracking, management, filter, api
         """
         if team_Id is None:
             raise ValueError("Missing required parameter 'team_Id'")
         url = f"{self.base_url}/team/{team_Id}/time_entries"
-        query_params = {k: v for k, v in [('start_date', start_date), ('end_date', end_date), ('assignee', assignee), ('include_task_tags', include_task_tags), ('include_location_names', include_location_names), ('space_id', space_id), ('folder_id', folder_id), ('list_id', list_id), ('task_id', task_id), ('custom_task_ids', custom_task_ids), ('team_id', team_id)] if v is not None}
+        query_params = {
+            k: v
+            for k, v in [
+                ("start_date", start_date),
+                ("end_date", end_date),
+                ("assignee", assignee),
+                ("include_task_tags", include_task_tags),
+                ("include_location_names", include_location_names),
+                ("space_id", space_id),
+                ("folder_id", folder_id),
+                ("list_id", list_id),
+                ("task_id", task_id),
+                ("custom_task_ids", custom_task_ids),
+                ("team_id", team_id),
+            ]
+            if v is not None
+        }
         response = self._get(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def time_tracking_create_time_entry(self, team_Id, start, duration, custom_task_ids=None, team_id=None, tags=None, description=None, stop=None, end=None, billable=None, assignee=None, tid=None) -> dict[str, Any]:
+    def time_tracking_create_time_entry(
+        self,
+        team_Id,
+        start,
+        duration,
+        custom_task_ids=None,
+        team_id=None,
+        tags=None,
+        description=None,
+        stop=None,
+        end=None,
+        billable=None,
+        assignee=None,
+        tid=None,
+    ) -> dict[str, Any]:
         """
         Creates a time tracking entry for a specified team.
-        
+
         Args:
             team_Id: Required. The unique identifier of the team for which the time entry is being created.
             start: Required. The start time of the time entry.
@@ -3059,14 +3582,14 @@ class ClickupApp(APIApplication):
             billable: Optional. Boolean indicating if the time entry is billable.
             assignee: Optional. The user to whom the time entry is assigned.
             tid: Optional. Task identifier associated with the time entry.
-        
+
         Returns:
             Dictionary containing the created time entry data from the API response.
-        
+
         Raises:
             ValueError: Raised when required parameters (team_Id, start, or duration) are missing.
             HTTPError: Raised when the API request fails.
-        
+
         Tags:
             create, time-entry, tracking, api-interaction, team
         """
@@ -3077,39 +3600,45 @@ class ClickupApp(APIApplication):
         if duration is None:
             raise ValueError("Missing required parameter 'duration'")
         request_body = {
-            'tags': tags,
-            'description': description,
-            'start': start,
-            'stop': stop,
-            'end': end,
-            'billable': billable,
-            'duration': duration,
-            'assignee': assignee,
-            'tid': tid,
+            "tags": tags,
+            "description": description,
+            "start": start,
+            "stop": stop,
+            "end": end,
+            "billable": billable,
+            "duration": duration,
+            "assignee": assignee,
+            "tid": tid,
         }
         request_body = {k: v for k, v in request_body.items() if v is not None}
         url = f"{self.base_url}/team/{team_Id}/time_entries"
-        query_params = {k: v for k, v in [('custom_task_ids', custom_task_ids), ('team_id', team_id)] if v is not None}
+        query_params = {
+            k: v
+            for k, v in [("custom_task_ids", custom_task_ids), ("team_id", team_id)]
+            if v is not None
+        }
         response = self._post(url, data=request_body, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def time_tracking_get_single_time_entry(self, team_id, timer_id, include_task_=None, include_location_names=None) -> dict[str, Any]:
+    def time_tracking_get_single_time_entry(
+        self, team_id, timer_id, include_task_=None, include_location_names=None
+    ) -> dict[str, Any]:
         """
         Retrieves a single time entry by team and timer ID.
-        
+
         Args:
             team_id: The ID of the team for which to retrieve the time entry.
             timer_id: The ID of the timer for which to retrieve the time entry.
             include_task_: Optional flag to include task details in the response.
             include_location_names: Optional flag to include location names in the response.
-        
+
         Returns:
             A dictionary containing the time entry details.
-        
+
         Raises:
             ValueError: Raised if 'team_id' or 'timer_id' is None.
-        
+
         Tags:
             time-tracking, get, async-job, management
         """
@@ -3118,7 +3647,14 @@ class ClickupApp(APIApplication):
         if timer_id is None:
             raise ValueError("Missing required parameter 'timer_id'")
         url = f"{self.base_url}/team/{team_id}/time_entries/{timer_id}"
-        query_params = {k: v for k, v in [('include_task_', include_task_), ('include_location_names', include_location_names)] if v is not None}
+        query_params = {
+            k: v
+            for k, v in [
+                ("include_task_", include_task_),
+                ("include_location_names", include_location_names),
+            ]
+            if v is not None
+        }
         response = self._get(url, params=query_params)
         response.raise_for_status()
         return response.json()
@@ -3126,18 +3662,18 @@ class ClickupApp(APIApplication):
     def time_tracking_remove_entry(self, team_id, timer_id) -> dict[str, Any]:
         """
         Removes a specific time tracking entry for a team by deleting the corresponding timer record.
-        
+
         Args:
             team_id: The unique identifier of the team from which the time entry will be removed.
             timer_id: The unique identifier of the time entry (timer) to be deleted.
-        
+
         Returns:
             A dictionary containing the JSON response from the API after successful removal of the time entry.
-        
+
         Raises:
             ValueError: Raised if either 'team_id' or 'timer_id' is None.
             requests.HTTPError: Raised if the API request to delete the time entry fails.
-        
+
         Tags:
             remove, time-tracking, management, api
         """
@@ -3151,10 +3687,23 @@ class ClickupApp(APIApplication):
         response.raise_for_status()
         return response.json()
 
-    def time_tracking_update_time_entry_details(self, team_id, timer_id, tags, custom_task_ids=None, description=None, tag_action=None, start=None, end=None, tid=None, billable=None, duration=None) -> dict[str, Any]:
+    def time_tracking_update_time_entry_details(
+        self,
+        team_id,
+        timer_id,
+        tags,
+        custom_task_ids=None,
+        description=None,
+        tag_action=None,
+        start=None,
+        end=None,
+        tid=None,
+        billable=None,
+        duration=None,
+    ) -> dict[str, Any]:
         """
         Updates time entry details by sending a PUT request to the server.
-        
+
         Args:
             team_id: ID of the team for which the time entry is being updated
             timer_id: ID of the time entry to update
@@ -3167,13 +3716,13 @@ class ClickupApp(APIApplication):
             tid: Optional TID associated with the time entry
             billable: Optional billability status of the time entry
             duration: Optional duration of the time entry
-        
+
         Returns:
             Dictionary containing the updated time entry details
-        
+
         Raises:
             ValueError: Raised when required parameters (team_id, timer_id, tags) are missing
-        
+
         Tags:
             update, time-entry, management
         """
@@ -3184,18 +3733,22 @@ class ClickupApp(APIApplication):
         if tags is None:
             raise ValueError("Missing required parameter 'tags'")
         request_body = {
-            'tags': tags,
-            'description': description,
-            'tag_action': tag_action,
-            'start': start,
-            'end': end,
-            'tid': tid,
-            'billable': billable,
-            'duration': duration,
+            "tags": tags,
+            "description": description,
+            "tag_action": tag_action,
+            "start": start,
+            "end": end,
+            "tid": tid,
+            "billable": billable,
+            "duration": duration,
         }
         request_body = {k: v for k, v in request_body.items() if v is not None}
         url = f"{self.base_url}/team/{team_id}/time_entries/{timer_id}"
-        query_params = {k: v for k, v in [('custom_task_ids', custom_task_ids), ('team_id', team_id)] if v is not None}
+        query_params = {
+            k: v
+            for k, v in [("custom_task_ids", custom_task_ids), ("team_id", team_id)]
+            if v is not None
+        }
         response = self._put(url, data=request_body, params=query_params)
         response.raise_for_status()
         return response.json()
@@ -3203,18 +3756,18 @@ class ClickupApp(APIApplication):
     def time_tracking_get_time_entry_history(self, team_id, timer_id) -> dict[str, Any]:
         """
         Retrieves the history of a specific time entry for a given team from the time tracking service.
-        
+
         Args:
             team_id: The unique identifier of the team whose time entry history is to be retrieved.
             timer_id: The unique identifier of the time entry (timer) for which the history is requested.
-        
+
         Returns:
             A dictionary containing the historical records of the specified time entry.
-        
+
         Raises:
             ValueError: Raised if 'team_id' or 'timer_id' is None.
             requests.HTTPError: Raised if the HTTP request to the time tracking service fails with an error status.
-        
+
         Tags:
             get, time-tracking, history, api
         """
@@ -3228,48 +3781,52 @@ class ClickupApp(APIApplication):
         response.raise_for_status()
         return response.json()
 
-    def time_tracking_get_current_time_entry(self, team_id, assignee=None) -> dict[str, Any]:
+    def time_tracking_get_current_time_entry(
+        self, team_id, assignee=None
+    ) -> dict[str, Any]:
         """
         Retrieves the current time entry for a specified team, optionally filtered by assignee.
-        
+
         Args:
             team_id: The unique identifier of the team to fetch the current time entry for.
             assignee: Optional; the identifier of the assignee to filter the current time entry.
-        
+
         Returns:
             A dictionary containing the current time entry details for the specified team and, if provided, assignee.
-        
+
         Raises:
             ValueError: If 'team_id' is None.
             requests.HTTPError: If the HTTP request to the API fails with an unsuccessful status code.
-        
+
         Tags:
             get, time-tracking, current-status, api, management
         """
         if team_id is None:
             raise ValueError("Missing required parameter 'team_id'")
         url = f"{self.base_url}/team/{team_id}/time_entries/current"
-        query_params = {k: v for k, v in [('assignee', assignee)] if v is not None}
+        query_params = {k: v for k, v in [("assignee", assignee)] if v is not None}
         response = self._get(url, params=query_params)
         response.raise_for_status()
         return response.json()
 
-    def time_tracking_remove_tags_from_time_entries(self, team_id, tags, time_entry_ids) -> dict[str, Any]:
+    def time_tracking_remove_tags_from_time_entries(
+        self, team_id, tags, time_entry_ids
+    ) -> dict[str, Any]:
         """
         Removes specified tags from multiple time entries for a given team.
-        
+
         Args:
             team_id: str. Unique identifier of the team whose time entries will be updated.
             tags: list[str]. List of tag names to remove from the specified time entries.
             time_entry_ids: list[str]. List of time entry IDs from which the tags will be removed.
-        
+
         Returns:
             dict[str, Any]: The API response as a dictionary containing the result of the tag removal operation.
-        
+
         Raises:
             ValueError: Raised if 'team_id', 'tags', or 'time_entry_ids' are None.
             requests.HTTPError: Raised if the API request fails or returns an unsuccessful HTTP status.
-        
+
         Tags:
             remove, tags, time-entries, management, batch
         """
@@ -3280,8 +3837,8 @@ class ClickupApp(APIApplication):
         if time_entry_ids is None:
             raise ValueError("Missing required parameter 'time_entry_ids'")
         request_body = {
-            'tags': tags,
-            'time_entry_ids': time_entry_ids,
+            "tags": tags,
+            "time_entry_ids": time_entry_ids,
         }
         request_body = {k: v for k, v in request_body.items() if v is not None}
         url = f"{self.base_url}/team/{team_id}/time_entries/tags"
@@ -3293,17 +3850,17 @@ class ClickupApp(APIApplication):
     def time_tracking_get_all_tags_from_time_entries(self, team_id) -> dict[str, Any]:
         """
         Retrieves all tags associated with time entries for a specified team.
-        
+
         Args:
             team_id: str. The unique identifier of the team whose time entry tags are to be retrieved.
-        
+
         Returns:
             dict[str, Any]: A dictionary containing the tags extracted from the team's time entries.
-        
+
         Raises:
             ValueError: If 'team_id' is None.
             requests.HTTPError: If the HTTP request to the server fails or returns an unsuccessful status code.
-        
+
         Tags:
             get, list, tags, time-tracking, management
         """
@@ -3315,22 +3872,24 @@ class ClickupApp(APIApplication):
         response.raise_for_status()
         return response.json()
 
-    def time_tracking_add_tags_from_time_entries(self, team_id, tags, time_entry_ids) -> dict[str, Any]:
+    def time_tracking_add_tags_from_time_entries(
+        self, team_id, tags, time_entry_ids
+    ) -> dict[str, Any]:
         """
         Adds tags to specified time entries for a team.
-        
+
         Args:
             team_id: The unique identifier of the team.
             tags: List of tags to be added to the time entries.
             time_entry_ids: List of time entry identifiers to which tags will be added.
-        
+
         Returns:
             Dictionary containing the API response after adding tags to time entries.
-        
+
         Raises:
             ValueError: Raised when any of the required parameters (team_id, tags, or time_entry_ids) is None.
             HTTPError: Raised when the API request fails.
-        
+
         Tags:
             add, tags, time-entries, management
         """
@@ -3341,8 +3900,8 @@ class ClickupApp(APIApplication):
         if time_entry_ids is None:
             raise ValueError("Missing required parameter 'time_entry_ids'")
         request_body = {
-            'tags': tags,
-            'time_entry_ids': time_entry_ids,
+            "tags": tags,
+            "time_entry_ids": time_entry_ids,
         }
         request_body = {k: v for k, v in request_body.items() if v is not None}
         url = f"{self.base_url}/team/{team_id}/time_entries/tags"
@@ -3351,24 +3910,26 @@ class ClickupApp(APIApplication):
         response.raise_for_status()
         return response.json()
 
-    def time_tracking_change_tag_names(self, team_id, name, new_name, tag_bg, tag_fg) -> dict[str, Any]:
+    def time_tracking_change_tag_names(
+        self, team_id, name, new_name, tag_bg, tag_fg
+    ) -> dict[str, Any]:
         """
         Updates the name and visual properties of a time tracking tag for a specified team.
-        
+
         Args:
             team_id: str. The unique identifier of the team whose tag is to be updated.
             name: str. The current name of the tag to be changed.
             new_name: str. The new name to assign to the tag.
             tag_bg: str. The new background color for the tag, typically in hexadecimal format.
             tag_fg: str. The new foreground (text) color for the tag, typically in hexadecimal format.
-        
+
         Returns:
             dict. The server response containing the updated tag details.
-        
+
         Raises:
             ValueError: If any required parameter ('team_id', 'name', 'new_name', 'tag_bg', or 'tag_fg') is None.
             requests.HTTPError: If the HTTP request to update the tag fails.
-        
+
         Tags:
             update, tag-management, time-tracking, team, api
         """
@@ -3383,10 +3944,10 @@ class ClickupApp(APIApplication):
         if tag_fg is None:
             raise ValueError("Missing required parameter 'tag_fg'")
         request_body = {
-            'name': name,
-            'new_name': new_name,
-            'tag_bg': tag_bg,
-            'tag_fg': tag_fg,
+            "name": name,
+            "new_name": new_name,
+            "tag_bg": tag_bg,
+            "tag_fg": tag_fg,
         }
         request_body = {k: v for k, v in request_body.items() if v is not None}
         url = f"{self.base_url}/team/{team_id}/time_entries/tags"
@@ -3395,10 +3956,19 @@ class ClickupApp(APIApplication):
         response.raise_for_status()
         return response.json()
 
-    def time_tracking_start_timer(self, team_Id, custom_task_ids=None, team_id=None, tags=None, description=None, tid=None, billable=None) -> dict[str, Any]:
+    def time_tracking_start_timer(
+        self,
+        team_Id,
+        custom_task_ids=None,
+        team_id=None,
+        tags=None,
+        description=None,
+        tid=None,
+        billable=None,
+    ) -> dict[str, Any]:
         """
         Starts a new time tracking timer for a specified team and task with optional metadata such as tags, description, and billable status.
-        
+
         Args:
             team_Id: str. The unique identifier of the team for which to start the timer. This parameter is required.
             custom_task_ids: Optional[list[str]]. A list of custom task IDs to associate with the timer entry.
@@ -3407,28 +3977,32 @@ class ClickupApp(APIApplication):
             description: Optional[str]. A text description for the time entry providing further details.
             tid: Optional[str]. The task identifier to be tracked.
             billable: Optional[bool]. Indicates whether the time entry should be marked as billable.
-        
+
         Returns:
             dict[str, Any]: A dictionary containing the response data of the newly started time entry from the API.
-        
+
         Raises:
             ValueError: Raised if the required parameter 'team_Id' is not provided.
             requests.HTTPError: Raised if the API request fails or returns a non-success status code.
-        
+
         Tags:
             start, timer, time-tracking, async-job, team-management
         """
         if team_Id is None:
             raise ValueError("Missing required parameter 'team_Id'")
         request_body = {
-            'tags': tags,
-            'description': description,
-            'tid': tid,
-            'billable': billable,
+            "tags": tags,
+            "description": description,
+            "tid": tid,
+            "billable": billable,
         }
         request_body = {k: v for k, v in request_body.items() if v is not None}
         url = f"{self.base_url}/team/{team_Id}/time_entries/start"
-        query_params = {k: v for k, v in [('custom_task_ids', custom_task_ids), ('team_id', team_id)] if v is not None}
+        query_params = {
+            k: v
+            for k, v in [("custom_task_ids", custom_task_ids), ("team_id", team_id)]
+            if v is not None
+        }
         response = self._post(url, data=request_body, params=query_params)
         response.raise_for_status()
         return response.json()
@@ -3436,17 +4010,17 @@ class ClickupApp(APIApplication):
     def time_tracking_stop_time_entry(self, team_id) -> dict[str, Any]:
         """
         Stops the currently active time entry for the specified team.
-        
+
         Args:
             team_id: The unique identifier of the team whose active time entry should be stopped.
-        
+
         Returns:
             A dictionary containing the response data from the stop time entry request.
-        
+
         Raises:
             ValueError: Raised if 'team_id' is None.
             requests.HTTPError: Raised if the HTTP request to stop the time entry fails.
-        
+
         Tags:
             time-tracking, stop, management
         """
@@ -3458,23 +4032,25 @@ class ClickupApp(APIApplication):
         response.raise_for_status()
         return response.json()
 
-    def users_invite_user_to_workspace(self, team_id, email, admin, custom_role_id=None) -> dict[str, Any]:
+    def users_invite_user_to_workspace(
+        self, team_id, email, admin, custom_role_id=None
+    ) -> dict[str, Any]:
         """
         Invites a user to a workspace by sending an invitation to their email address.
-        
+
         Args:
             team_id: The unique identifier of the workspace/team to invite the user to.
             email: The email address of the user being invited to the workspace.
             admin: Boolean flag indicating whether the user should have admin privileges.
             custom_role_id: Optional. The ID of a custom role to assign to the invited user.
-        
+
         Returns:
             A dictionary containing the API response with details of the created invitation.
-        
+
         Raises:
             ValueError: Raised when any of the required parameters (team_id, email, admin) are None.
             HTTPError: Raised when the API request fails or returns an error status code.
-        
+
         Tags:
             invite, user, workspace, team, management
         """
@@ -3485,9 +4061,9 @@ class ClickupApp(APIApplication):
         if admin is None:
             raise ValueError("Missing required parameter 'admin'")
         request_body = {
-            'email': email,
-            'admin': admin,
-            'custom_role_id': custom_role_id,
+            "email": email,
+            "admin": admin,
+            "custom_role_id": custom_role_id,
         }
         request_body = {k: v for k, v in request_body.items() if v is not None}
         url = f"{self.base_url}/team/{team_id}/user"
@@ -3499,18 +4075,18 @@ class ClickupApp(APIApplication):
     def users_get_user_details(self, team_id, user_id) -> dict[str, Any]:
         """
         Retrieves detailed information about a specific user within a given team.
-        
+
         Args:
             team_id: The unique identifier of the team to which the user belongs. Must not be None.
             user_id: The unique identifier of the user whose details are to be retrieved. Must not be None.
-        
+
         Returns:
             A dictionary containing the user's details as returned by the API.
-        
+
         Raises:
             ValueError: Raised if either 'team_id' or 'user_id' is None.
             requests.HTTPError: Raised if the HTTP request to the API endpoint fails with a response error status.
-        
+
         Tags:
             get, user-details, api, management, important
         """
@@ -3524,24 +4100,26 @@ class ClickupApp(APIApplication):
         response.raise_for_status()
         return response.json()
 
-    def users_update_user_details(self, team_id, user_id, username, admin, custom_role_id) -> dict[str, Any]:
+    def users_update_user_details(
+        self, team_id, user_id, username, admin, custom_role_id
+    ) -> dict[str, Any]:
         """
         Updates the details of a user in a specified team.
-        
+
         Args:
             team_id: str. The unique identifier of the team containing the user to update.
             user_id: str. The unique identifier of the user whose details will be updated.
             username: str. The new username to assign to the user.
             admin: bool. Whether the user should have admin privileges.
             custom_role_id: str. The identifier of a custom role to assign to the user.
-        
+
         Returns:
             dict[str, Any]: A dictionary containing the updated user details as returned by the server.
-        
+
         Raises:
             ValueError: If any of the required parameters ('team_id', 'user_id', 'username', 'admin', or 'custom_role_id') are None.
             requests.HTTPError: If the HTTP request to update the user fails.
-        
+
         Tags:
             update, user-management, api
         """
@@ -3556,9 +4134,9 @@ class ClickupApp(APIApplication):
         if custom_role_id is None:
             raise ValueError("Missing required parameter 'custom_role_id'")
         request_body = {
-            'username': username,
-            'admin': admin,
-            'custom_role_id': custom_role_id,
+            "username": username,
+            "admin": admin,
+            "custom_role_id": custom_role_id,
         }
         request_body = {k: v for k, v in request_body.items() if v is not None}
         url = f"{self.base_url}/team/{team_id}/user/{user_id}"
@@ -3570,18 +4148,18 @@ class ClickupApp(APIApplication):
     def users_deactivate_from_workspace(self, team_id, user_id) -> dict[str, Any]:
         """
         Deactivates a user from the specified workspace (team) by sending a DELETE request to the API.
-        
+
         Args:
             team_id: The unique identifier of the team (workspace) from which the user will be deactivated.
             user_id: The unique identifier of the user to deactivate from the workspace.
-        
+
         Returns:
             A dictionary containing the response data from the API after the user has been deactivated.
-        
+
         Raises:
             ValueError: Raised if either 'team_id' or 'user_id' is None.
             HTTPError: Raised if the API request fails (non-2xx status code).
-        
+
         Tags:
             deactivate, user-management, api
         """
@@ -3598,17 +4176,17 @@ class ClickupApp(APIApplication):
     def views_get_everything_level(self, team_id) -> dict[str, Any]:
         """
         Retrieves all view-level data for a specified team.
-        
+
         Args:
             team_id: The unique identifier of the team for which to fetch all view data.
-        
+
         Returns:
             A dictionary containing all data at the 'view' level for the specified team.
-        
+
         Raises:
             ValueError: If 'team_id' is None.
             requests.HTTPError: If the HTTP request to fetch the data fails.
-        
+
         Tags:
             get, views, team, api
         """
@@ -3620,10 +4198,22 @@ class ClickupApp(APIApplication):
         response.raise_for_status()
         return response.json()
 
-    def views_create_workspace_view_everything_level(self, team_id, name, type, grouping, divide, sorting, filters, columns, team_sidebar, settings) -> dict[str, Any]:
+    def views_create_workspace_view_everything_level(
+        self,
+        team_id,
+        name,
+        type,
+        grouping,
+        divide,
+        sorting,
+        filters,
+        columns,
+        team_sidebar,
+        settings,
+    ) -> dict[str, Any]:
         """
         Creates a new 'everything-level' view within a specified workspace team with custom configuration options.
-        
+
         Args:
             team_id: str. Unique identifier of the team where the view will be created.
             name: str. Name of the new workspace view.
@@ -3635,14 +4225,14 @@ class ClickupApp(APIApplication):
             columns: Any. Specifies which columns will be included in the view.
             team_sidebar: Any. Configuration for the team sidebar appearance or content.
             settings: Any. Additional settings for the workspace view.
-        
+
         Returns:
             dict[str, Any]: A dictionary representing the API response containing details of the newly created workspace view.
-        
+
         Raises:
             ValueError: Raised if any required parameter is None.
             requests.HTTPError: Raised if the HTTP request to the backend fails (e.g., non-2xx response code).
-        
+
         Tags:
             create, workspace-view, management, api
         """
@@ -3667,15 +4257,15 @@ class ClickupApp(APIApplication):
         if settings is None:
             raise ValueError("Missing required parameter 'settings'")
         request_body = {
-            'name': name,
-            'type': type,
-            'grouping': grouping,
-            'divide': divide,
-            'sorting': sorting,
-            'filters': filters,
-            'columns': columns,
-            'team_sidebar': team_sidebar,
-            'settings': settings,
+            "name": name,
+            "type": type,
+            "grouping": grouping,
+            "divide": divide,
+            "sorting": sorting,
+            "filters": filters,
+            "columns": columns,
+            "team_sidebar": team_sidebar,
+            "settings": settings,
         }
         request_body = {k: v for k, v in request_body.items() if v is not None}
         url = f"{self.base_url}/team/{team_id}/view"
@@ -3687,17 +4277,17 @@ class ClickupApp(APIApplication):
     def views_space_views_get(self, space_id) -> dict[str, Any]:
         """
         Retrieves the view details for a specified space by its ID.
-        
+
         Args:
             space_id: str. The unique identifier of the space whose view information is to be fetched.
-        
+
         Returns:
             dict[str, Any]: A dictionary containing the space view information returned by the API.
-        
+
         Raises:
             ValueError: If 'space_id' is None.
             requests.HTTPError: If the HTTP request to the API endpoint fails or returns an unsuccessful status code.
-        
+
         Tags:
             get, view, space, management, api
         """
@@ -3709,10 +4299,22 @@ class ClickupApp(APIApplication):
         response.raise_for_status()
         return response.json()
 
-    def views_add_view_to_space(self, space_id, name, type, grouping, divide, sorting, filters, columns, team_sidebar, settings) -> dict[str, Any]:
+    def views_add_view_to_space(
+        self,
+        space_id,
+        name,
+        type,
+        grouping,
+        divide,
+        sorting,
+        filters,
+        columns,
+        team_sidebar,
+        settings,
+    ) -> dict[str, Any]:
         """
         Creates a new view in the specified space with the given configuration parameters.
-        
+
         Args:
             space_id: str. The unique identifier of the space where the view will be added.
             name: str. The name of the new view.
@@ -3724,14 +4326,14 @@ class ClickupApp(APIApplication):
             columns: Any. Column configuration for the view (structure depends on implementation).
             team_sidebar: Any. Team sidebar configuration for the view (structure depends on implementation).
             settings: Any. Additional settings for the view (structure depends on implementation).
-        
+
         Returns:
             dict[str, Any]: The JSON response from the server containing details of the newly created view.
-        
+
         Raises:
             ValueError: If any required parameter is missing (i.e., any of the arguments is None).
             requests.HTTPError: If the HTTP request to create the view fails (non-2xx response).
-        
+
         Tags:
             add, view, space, management, api
         """
@@ -3756,15 +4358,15 @@ class ClickupApp(APIApplication):
         if settings is None:
             raise ValueError("Missing required parameter 'settings'")
         request_body = {
-            'name': name,
-            'type': type,
-            'grouping': grouping,
-            'divide': divide,
-            'sorting': sorting,
-            'filters': filters,
-            'columns': columns,
-            'team_sidebar': team_sidebar,
-            'settings': settings,
+            "name": name,
+            "type": type,
+            "grouping": grouping,
+            "divide": divide,
+            "sorting": sorting,
+            "filters": filters,
+            "columns": columns,
+            "team_sidebar": team_sidebar,
+            "settings": settings,
         }
         request_body = {k: v for k, v in request_body.items() if v is not None}
         url = f"{self.base_url}/space/{space_id}/view"
@@ -3776,17 +4378,17 @@ class ClickupApp(APIApplication):
     def views_folder_views_get(self, folder_id) -> dict[str, Any]:
         """
         Retrieves the views associated with a specified folder by its folder ID.
-        
+
         Args:
             folder_id: The unique identifier of the folder to retrieve views for.
-        
+
         Returns:
             A dictionary containing the JSON response with the folder's views data.
-        
+
         Raises:
             ValueError: Raised if the required parameter 'folder_id' is None.
             requests.HTTPError: Raised if the HTTP request to retrieve the folder views fails.
-        
+
         Tags:
             get, views, folder, api
         """
@@ -3798,10 +4400,22 @@ class ClickupApp(APIApplication):
         response.raise_for_status()
         return response.json()
 
-    def views_add_view_to_folder(self, folder_id, name, type, grouping, divide, sorting, filters, columns, team_sidebar, settings) -> dict[str, Any]:
+    def views_add_view_to_folder(
+        self,
+        folder_id,
+        name,
+        type,
+        grouping,
+        divide,
+        sorting,
+        filters,
+        columns,
+        team_sidebar,
+        settings,
+    ) -> dict[str, Any]:
         """
         Adds a new view to a specified folder with the provided configuration details.
-        
+
         Args:
             folder_id: The unique identifier of the folder to which the view will be added.
             name: The name of the view to create.
@@ -3813,14 +4427,14 @@ class ClickupApp(APIApplication):
             columns: Column definitions to display in the view.
             team_sidebar: Sidebar configuration for team access and visibility.
             settings: Additional view settings and preferences.
-        
+
         Returns:
             dict[str, Any]: A dictionary containing the details of the newly created view as returned by the API.
-        
+
         Raises:
             ValueError: Raised if any required parameter is missing (i.e., has the value None).
             requests.HTTPError: Raised if the HTTP request to the API fails.
-        
+
         Tags:
             add, view, management, api
         """
@@ -3845,15 +4459,15 @@ class ClickupApp(APIApplication):
         if settings is None:
             raise ValueError("Missing required parameter 'settings'")
         request_body = {
-            'name': name,
-            'type': type,
-            'grouping': grouping,
-            'divide': divide,
-            'sorting': sorting,
-            'filters': filters,
-            'columns': columns,
-            'team_sidebar': team_sidebar,
-            'settings': settings,
+            "name": name,
+            "type": type,
+            "grouping": grouping,
+            "divide": divide,
+            "sorting": sorting,
+            "filters": filters,
+            "columns": columns,
+            "team_sidebar": team_sidebar,
+            "settings": settings,
         }
         request_body = {k: v for k, v in request_body.items() if v is not None}
         url = f"{self.base_url}/folder/{folder_id}/view"
@@ -3865,17 +4479,17 @@ class ClickupApp(APIApplication):
     def views_get_list_views(self, list_id) -> dict[str, Any]:
         """
         Retrieves all views associated with the specified list.
-        
+
         Args:
             list_id: The unique identifier of the list whose views are to be fetched.
-        
+
         Returns:
             A dictionary containing data for all views related to the given list.
-        
+
         Raises:
             ValueError: Raised when 'list_id' is None.
             requests.HTTPError: Raised if the HTTP request to fetch views fails.
-        
+
         Tags:
             list, views, fetch, api
         """
@@ -3887,10 +4501,22 @@ class ClickupApp(APIApplication):
         response.raise_for_status()
         return response.json()
 
-    def views_add_view_to_list(self, list_id, name, type, grouping, divide, sorting, filters, columns, team_sidebar, settings) -> dict[str, Any]:
+    def views_add_view_to_list(
+        self,
+        list_id,
+        name,
+        type,
+        grouping,
+        divide,
+        sorting,
+        filters,
+        columns,
+        team_sidebar,
+        settings,
+    ) -> dict[str, Any]:
         """
         Creates a new view for a specified list with the provided configuration and returns the resulting view data.
-        
+
         Args:
             list_id: The unique identifier of the list to which the new view will be added.
             name: The name of the new view.
@@ -3902,14 +4528,14 @@ class ClickupApp(APIApplication):
             columns: Columns to be displayed in the view.
             team_sidebar: Configuration determining if or how the view appears in the team sidebar.
             settings: Additional settings and options for the new view.
-        
+
         Returns:
             A dictionary containing the details of the newly created view as returned by the API.
-        
+
         Raises:
             ValueError: Raised if any required parameter is missing (i.e., if one of the parameters is None).
             requests.HTTPError: Raised if the HTTP request to create the view fails (e.g., due to a network error or invalid response).
-        
+
         Tags:
             add, view, list, api, management
         """
@@ -3934,15 +4560,15 @@ class ClickupApp(APIApplication):
         if settings is None:
             raise ValueError("Missing required parameter 'settings'")
         request_body = {
-            'name': name,
-            'type': type,
-            'grouping': grouping,
-            'divide': divide,
-            'sorting': sorting,
-            'filters': filters,
-            'columns': columns,
-            'team_sidebar': team_sidebar,
-            'settings': settings,
+            "name": name,
+            "type": type,
+            "grouping": grouping,
+            "divide": divide,
+            "sorting": sorting,
+            "filters": filters,
+            "columns": columns,
+            "team_sidebar": team_sidebar,
+            "settings": settings,
         }
         request_body = {k: v for k, v in request_body.items() if v is not None}
         url = f"{self.base_url}/list/{list_id}/view"
@@ -3954,17 +4580,17 @@ class ClickupApp(APIApplication):
     def views_get_view_info(self, view_id) -> dict[str, Any]:
         """
         Retrieves detailed information about a specific view by its identifier.
-        
+
         Args:
             view_id: str. The unique identifier of the view to retrieve information for.
-        
+
         Returns:
             dict[str, Any]: A dictionary containing the view's information as returned by the API.
-        
+
         Raises:
             ValueError: Raised if 'view_id' is None.
             requests.HTTPError: Raised if the HTTP request to fetch the view information fails with a non-success status code.
-        
+
         Tags:
             get, view-info, api
         """
@@ -3976,10 +4602,23 @@ class ClickupApp(APIApplication):
         response.raise_for_status()
         return response.json()
 
-    def views_update_view_details(self, view_id, name, type, parent, grouping, divide, sorting, filters, columns, team_sidebar, settings) -> dict[str, Any]:
+    def views_update_view_details(
+        self,
+        view_id,
+        name,
+        type,
+        parent,
+        grouping,
+        divide,
+        sorting,
+        filters,
+        columns,
+        team_sidebar,
+        settings,
+    ) -> dict[str, Any]:
         """
         Updates the details of an existing view with the specified parameters.
-        
+
         Args:
             view_id: str. The unique identifier of the view to update.
             name: str. The new name for the view.
@@ -3992,14 +4631,14 @@ class ClickupApp(APIApplication):
             columns: Any. The column configurations for the view.
             team_sidebar: Any. The sidebar settings for team visibility in the view.
             settings: Any. Additional settings or metadata for the view.
-        
+
         Returns:
             dict[str, Any]: The updated view details as returned by the API.
-        
+
         Raises:
             ValueError: If any required parameter is None.
             HTTPError: If the API request fails and returns a non-success status code.
-        
+
         Tags:
             update, view-management, api
         """
@@ -4026,16 +4665,16 @@ class ClickupApp(APIApplication):
         if settings is None:
             raise ValueError("Missing required parameter 'settings'")
         request_body = {
-            'name': name,
-            'type': type,
-            'parent': parent,
-            'grouping': grouping,
-            'divide': divide,
-            'sorting': sorting,
-            'filters': filters,
-            'columns': columns,
-            'team_sidebar': team_sidebar,
-            'settings': settings,
+            "name": name,
+            "type": type,
+            "parent": parent,
+            "grouping": grouping,
+            "divide": divide,
+            "sorting": sorting,
+            "filters": filters,
+            "columns": columns,
+            "team_sidebar": team_sidebar,
+            "settings": settings,
         }
         request_body = {k: v for k, v in request_body.items() if v is not None}
         url = f"{self.base_url}/view/{view_id}"
@@ -4047,17 +4686,17 @@ class ClickupApp(APIApplication):
     def views_delete_view_by_id(self, view_id) -> dict[str, Any]:
         """
         Deletes a view by its ID.
-        
+
         Args:
             view_id: The unique identifier of the view to be deleted.
-        
+
         Returns:
             A dictionary containing the API response data from the deletion operation.
-        
+
         Raises:
             ValueError: Raised when the required parameter 'view_id' is None.
             HTTPError: Raised when the API request fails or returns an error status code.
-        
+
         Tags:
             delete, view, management
         """
@@ -4072,18 +4711,18 @@ class ClickupApp(APIApplication):
     def views_get_tasks_in_view(self, view_id, page) -> dict[str, Any]:
         """
         Retrieves a paginated list of tasks associated with a specific view.
-        
+
         Args:
             view_id: The unique identifier of the view to retrieve tasks for. Must not be None.
             page: The page number of tasks to retrieve. Must not be None.
-        
+
         Ret
             A dictionary containing the JSON response with the tasks for the specified view and page.
-        
+
         Raises:
             ValueError: Raised if either 'view_id' or 'page' is None.
             HTTPError: Raised if the HTTP request to retrieve tasks fails.
-        
+
         Tags:
             get, list, tasks, view, pagination
         """
@@ -4092,7 +4731,7 @@ class ClickupApp(APIApplication):
         if page is None:
             raise ValueError("Missing required parameter 'page'")
         url = f"{self.base_url}/view/{view_id}/task"
-        query_params = {k: v for k, v in [('page', page)] if v is not None}
+        query_params = {k: v for k, v in [("page", page)] if v is not None}
         response = self._get(url, params=query_params)
         response.raise_for_status()
         return response.json()
@@ -4100,17 +4739,17 @@ class ClickupApp(APIApplication):
     def webhooks_workspace_get(self, team_id) -> dict[str, Any]:
         """
         Retrieves webhook configurations for a specified workspace team.
-        
+
         Args:
             team_id: str. The unique identifier of the workspace team whose webhooks are to be retrieved.
-        
+
         Returns:
             dict[str, Any]: A dictionary containing the webhook configuration data associated with the given team.
-        
+
         Raises:
             ValueError: Raised if 'team_id' is None.
             requests.HTTPError: Raised if the HTTP request to the server fails or an error response is received.
-        
+
         Tags:
             get, webhooks, workspace, management
         """
@@ -4122,10 +4761,19 @@ class ClickupApp(APIApplication):
         response.raise_for_status()
         return response.json()
 
-    def webhooks_create_webhook(self, team_id, endpoint, events, space_id=None, folder_id=None, list_id=None, task_id=None) -> dict[str, Any]:
+    def webhooks_create_webhook(
+        self,
+        team_id,
+        endpoint,
+        events,
+        space_id=None,
+        folder_id=None,
+        list_id=None,
+        task_id=None,
+    ) -> dict[str, Any]:
         """
         Creates a webhook for a team by sending a POST request to the specified endpoint.
-        
+
         Args:
             team_id: The ID of the team for which the webhook is being created.
             endpoint: The URL where events will be posted.
@@ -4134,13 +4782,13 @@ class ClickupApp(APIApplication):
             folder_id: Optional folder ID to which the webhook is associated.
             list_id: Optional list ID to which the webhook is associated.
             task_id: Optional task ID to which the webhook is associated.
-        
+
         Returns:
             A dictionary containing the created webhook details.
-        
+
         Raises:
             ValueError: Raised when required parameters 'team_id', 'endpoint', or 'events' are missing.
-        
+
         Tags:
             webhook, create, api-call
         """
@@ -4151,12 +4799,12 @@ class ClickupApp(APIApplication):
         if events is None:
             raise ValueError("Missing required parameter 'events'")
         request_body = {
-            'endpoint': endpoint,
-            'events': events,
-            'space_id': space_id,
-            'folder_id': folder_id,
-            'list_id': list_id,
-            'task_id': task_id,
+            "endpoint": endpoint,
+            "events": events,
+            "space_id": space_id,
+            "folder_id": folder_id,
+            "list_id": list_id,
+            "task_id": task_id,
         }
         request_body = {k: v for k, v in request_body.items() if v is not None}
         url = f"{self.base_url}/team/{team_id}/webhook"
@@ -4165,23 +4813,25 @@ class ClickupApp(APIApplication):
         response.raise_for_status()
         return response.json()
 
-    def webhooks_update_events_to_monitor(self, webhook_id, endpoint, events, status) -> dict[str, Any]:
+    def webhooks_update_events_to_monitor(
+        self, webhook_id, endpoint, events, status
+    ) -> dict[str, Any]:
         """
         Updates the monitored events, endpoint, and status for a specified webhook.
-        
+
         Args:
             webhook_id: str. Unique identifier of the webhook to update.
             endpoint: str. The URL endpoint where webhook notifications will be sent.
             events: list or str. Events to monitor for this webhook.
             status: str. The desired status for the webhook (e.g., 'active', 'inactive').
-        
+
         Returns:
             dict. Parsed JSON response from the server after updating the webhook.
-        
+
         Raises:
             ValueError: Raised if any of 'webhook_id', 'endpoint', 'events', or 'status' is None.
             requests.HTTPError: Raised if the HTTP request to update the webhook fails (non-2xx status code).
-        
+
         Tags:
             update, webhook, management
         """
@@ -4194,9 +4844,9 @@ class ClickupApp(APIApplication):
         if status is None:
             raise ValueError("Missing required parameter 'status'")
         request_body = {
-            'endpoint': endpoint,
-            'events': events,
-            'status': status,
+            "endpoint": endpoint,
+            "events": events,
+            "status": status,
         }
         request_body = {k: v for k, v in request_body.items() if v is not None}
         url = f"{self.base_url}/webhook/{webhook_id}"
@@ -4208,17 +4858,17 @@ class ClickupApp(APIApplication):
     def webhooks_remove_webhook_by_id(self, webhook_id) -> dict[str, Any]:
         """
         Removes a webhook by ID.
-        
+
         Args:
             webhook_id: The unique identifier of the webhook to be removed.
-        
+
         Returns:
             A dictionary containing the API response after webhook deletion.
-        
+
         Raises:
             ValueError: If webhook_id is None or not provided.
             HTTPError: If the API request fails or returns an error status code.
-        
+
         Tags:
             remove, delete, webhook, management
         """
@@ -4355,5 +5005,5 @@ class ClickupApp(APIApplication):
             self.webhooks_workspace_get,
             self.webhooks_create_webhook,
             self.webhooks_update_events_to_monitor,
-            self.webhooks_remove_webhook_by_id
+            self.webhooks_remove_webhook_by_id,
         ]