universal-mcp-applications 0.1.30rc1__py3-none-any.whl → 0.1.36rc1__py3-none-any.whl

universal_mcp/applications/hubspot/api_segments/crm_api.py

@@ -1,5 +1,4 @@
 from typing import Any
-
 from .api_segment_base import APISegmentBase
 
 
@@ -7,7 +6,7 @@ class CrmApi(APISegmentBase):
     def __init__(self, main_app_client: Any):
         super().__init__(main_app_client)
 
-    def batch_read_emails(
+    async def batch_read_emails(
         self,
         propertiesWithHistory: list[str],
         inputs: list[dict[str, Any]],
@@ -42,20 +41,13 @@ class CrmApi(APISegmentBase):
             "inputs": inputs,
             "properties": properties,
         }
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/emails/batch/read"
         query_params = {k: v for k, v in [("archived", archived)] if v is not None}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def get_email_by_id(
+    async def get_email_by_id(
         self,
         emailId: str,
         properties: list[str] | None = None,
@@ -102,7 +94,7 @@ class CrmApi(APISegmentBase):
         response = self._get(url, params=query_params)
         return self._handle_response(response)
 
-    def delete_email_by_id(self, emailId: str) -> Any:
+    async def delete_email_by_id(self, emailId: str) -> Any:
         """
 
         Deletes an email object identified by the specified emailId from a CRM system.
@@ -126,9 +118,7 @@ class CrmApi(APISegmentBase):
         response = self._delete(url, params=query_params)
         return self._handle_response(response)
 
-    def update_email_by_id(
-        self, emailId: str, properties: dict[str, str], idProperty: str | None = None
-    ) -> dict[str, Any]:
+    async def update_email_by_id(self, emailId: str, properties: dict[str, str], idProperty: str | None = None) -> dict[str, Any]:
         """
 
         Updates specific properties of an existing email record in the CRM by its emailId using a PATCH request with JSON data.
@@ -151,17 +141,13 @@ class CrmApi(APISegmentBase):
             raise ValueError("Missing required parameter 'emailId'.")
         request_body_data = None
         request_body_data = {"properties": properties}
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/emails/{emailId}"
         query_params = {k: v for k, v in [("idProperty", idProperty)] if v is not None}
         response = self._patch(url, data=request_body_data, params=query_params)
         return self._handle_response(response)
 
-    def merge_emails_post(
-        self, objectIdToMerge: str, primaryObjectId: str
-    ) -> dict[str, Any]:
+    async def merge_emails_post(self, objectIdToMerge: str, primaryObjectId: str) -> dict[str, Any]:
         """
 
         Merges email records using the provided JSON payload, utilizing OAuth2 or private app authentication to manage contact data in the CRM system.
@@ -180,24 +166,14 @@ class CrmApi(APISegmentBase):
             Public_Object
         """
         request_body_data = None
-        request_body_data = {
-            "objectIdToMerge": objectIdToMerge,
-            "primaryObjectId": primaryObjectId,
-        }
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {"objectIdToMerge": objectIdToMerge, "primaryObjectId": primaryObjectId}
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/emails/merge"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def archive_emails_batch(self, inputs: list[dict[str, Any]]) -> Any:
+    async def archive_emails_batch(self, inputs: list[dict[str, Any]]) -> Any:
         """
 
         Archives a batch of emails by sending a POST request to the "/crm/v3/objects/emails/batch/archive" endpoint with a JSON payload containing the email IDs to be archived.
@@ -216,20 +192,13 @@ class CrmApi(APISegmentBase):
         """
         request_body_data = None
         request_body_data = {"inputs": inputs}
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/emails/batch/archive"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def create_emails_batch_post(self, inputs: list[dict[str, Any]]) -> dict[str, Any]:
+    async def create_emails_batch_post(self, inputs: list[dict[str, Any]]) -> dict[str, Any]:
         """
 
         Creates a batch of email objects in the CRM using the POST method, requiring JSON content and authorization through OAuth2 or private apps.
@@ -248,20 +217,13 @@ class CrmApi(APISegmentBase):
         """
         request_body_data = None
         request_body_data = {"inputs": inputs}
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/emails/batch/create"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def update_emails_batch(self, inputs: list[dict[str, Any]]) -> dict[str, Any]:
+    async def update_emails_batch(self, inputs: list[dict[str, Any]]) -> dict[str, Any]:
         """
 
         Updates multiple email objects in a CRM system using a batch operation via the POST method, returning status messages for each update.
@@ -280,22 +242,13 @@ class CrmApi(APISegmentBase):
         """
         request_body_data = None
         request_body_data = {"inputs": inputs}
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/emails/batch/update"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def delete_email_gdpr_data(
-        self, objectId: str, idProperty: str | None = None
-    ) -> Any:
+    async def delete_email_gdpr_data(self, objectId: str, idProperty: str | None = None) -> Any:
         """
 
         Deletes a contact and associated data from the CRM in compliance with GDPR guidelines using the provided JSON payload, requiring the "crm.objects.contacts.write" permission.
@@ -315,20 +268,13 @@ class CrmApi(APISegmentBase):
         """
         request_body_data = None
         request_body_data = {"idProperty": idProperty, "objectId": objectId}
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/emails/gdpr-delete"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def list_emails_with_filters(
+    async def list_emails_with_filters(
         self,
         limit: int | None = None,
         after: str | None = None,
@@ -374,9 +320,7 @@ class CrmApi(APISegmentBase):
         response = self._get(url, params=query_params)
         return self._handle_response(response)
 
-    def create_email(
-        self, associations: list[dict[str, Any]], properties: dict[str, str]
-    ) -> dict[str, Any]:
+    async def create_email(self, associations: list[dict[str, Any]], properties: dict[str, str]) -> dict[str, Any]:
         """
 
         Creates an email object in the CRM using the POST method, allowing for the association of metadata with the email and requiring authentication via OAuth2 or private apps to access the necessary permissions.
@@ -396,27 +340,14 @@ class CrmApi(APISegmentBase):
         """
         request_body_data = None
         request_body_data = {"associations": associations, "properties": properties}
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/emails"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def search_emails_post(
-        self,
-        limit: int,
-        after: str,
-        sorts: list[str],
-        properties: list[str],
-        filterGroups: list[dict[str, Any]],
-        query: str | None = None,
+    async def search_emails_post(
+        self, limit: int, after: str, sorts: list[str], properties: list[str], filterGroups: list[dict[str, Any]], query: str | None = None
     ) -> dict[str, Any]:
         """
 
@@ -448,20 +379,13 @@ class CrmApi(APISegmentBase):
             "properties": properties,
             "filterGroups": filterGroups,
         }
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/emails/search"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def batch_read_products_post(
+    async def batch_read_products_post(
         self,
         propertiesWithHistory: list[str],
         inputs: list[dict[str, Any]],
@@ -496,20 +420,13 @@ class CrmApi(APISegmentBase):
             "inputs": inputs,
             "properties": properties,
         }
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/products/batch/read"
         query_params = {k: v for k, v in [("archived", archived)] if v is not None}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def get_product_by_id(
+    async def get_product_by_id(
         self,
         productId: str,
         properties: list[str] | None = None,
@@ -556,7 +473,7 @@ class CrmApi(APISegmentBase):
         response = self._get(url, params=query_params)
         return self._handle_response(response)
 
-    def delete_product_by_id(self, productId: str) -> Any:
+    async def delete_product_by_id(self, productId: str) -> Any:
         """
 
         Deletes a product from the CRM using its product ID.
@@ -580,12 +497,7 @@ class CrmApi(APISegmentBase):
         response = self._delete(url, params=query_params)
         return self._handle_response(response)
 
-    def patch_product_by_id(
-        self,
-        productId: str,
-        properties: dict[str, str],
-        idProperty: str | None = None,
-    ) -> dict[str, Any]:
+    async def patch_product_by_id(self, productId: str, properties: dict[str, str], idProperty: str | None = None) -> dict[str, Any]:
         """
 
         Updates specified properties of a product identified by productId using a JSON PATCH request.
@@ -608,17 +520,13 @@ class CrmApi(APISegmentBase):
             raise ValueError("Missing required parameter 'productId'.")
         request_body_data = None
         request_body_data = {"properties": properties}
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/products/{productId}"
         query_params = {k: v for k, v in [("idProperty", idProperty)] if v is not None}
         response = self._patch(url, data=request_body_data, params=query_params)
         return self._handle_response(response)
 
-    def merge_products(
-        self, objectIdToMerge: str, primaryObjectId: str
-    ) -> dict[str, Any]:
+    async def merge_products(self, objectIdToMerge: str, primaryObjectId: str) -> dict[str, Any]:
         """
 
         Merges two or more product records in a CRM system using the POST method, allowing for the consolidation of data into a single, unified record.
@@ -637,24 +545,14 @@ class CrmApi(APISegmentBase):
             Public_Object
         """
         request_body_data = None
-        request_body_data = {
-            "objectIdToMerge": objectIdToMerge,
-            "primaryObjectId": primaryObjectId,
-        }
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {"objectIdToMerge": objectIdToMerge, "primaryObjectId": primaryObjectId}
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/products/merge"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def archive_products_batch_post(self, inputs: list[dict[str, Any]]) -> Any:
+    async def archive_products_batch_post(self, inputs: list[dict[str, Any]]) -> Any:
         """
 
         Archives a batch of products by ID using the POST method, accepting JSON-formatted request bodies and returning a 204 status upon successful execution.
@@ -673,20 +571,13 @@ class CrmApi(APISegmentBase):
         """
         request_body_data = None
         request_body_data = {"inputs": inputs}
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/products/batch/archive"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def create_products_batch(self, inputs: list[dict[str, Any]]) -> dict[str, Any]:
+    async def create_products_batch(self, inputs: list[dict[str, Any]]) -> dict[str, Any]:
         """
 
         Creates multiple product records in a single batch request within the CRM system.
@@ -705,20 +596,13 @@ class CrmApi(APISegmentBase):
         """
         request_body_data = None
         request_body_data = {"inputs": inputs}
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/products/batch/create"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def update_products_batch(self, inputs: list[dict[str, Any]]) -> dict[str, Any]:
+    async def update_products_batch(self, inputs: list[dict[str, Any]]) -> dict[str, Any]:
         """
 
         Updates multiple product records in a batch using the HubSpot CRM v3 API and returns a status response indicating success or partial failure.
@@ -737,22 +621,13 @@ class CrmApi(APISegmentBase):
         """
         request_body_data = None
         request_body_data = {"inputs": inputs}
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/products/batch/update"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def delete_product_gdpr_data(
-        self, objectId: str, idProperty: str | None = None
-    ) -> Any:
+    async def delete_product_gdpr_data(self, objectId: str, idProperty: str | None = None) -> Any:
         """
 
         Performs a GDPR-compliant deletion of product records in the CRM using the POST method, requiring a JSON request body and authentication.
@@ -772,20 +647,13 @@ class CrmApi(APISegmentBase):
         """
         request_body_data = None
         request_body_data = {"idProperty": idProperty, "objectId": objectId}
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/products/gdpr-delete"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def list_products(
+    async def list_products(
         self,
         limit: int | None = None,
         after: str | None = None,
@@ -831,9 +699,7 @@ class CrmApi(APISegmentBase):
         response = self._get(url, params=query_params)
         return self._handle_response(response)
 
-    def create_product(
-        self, associations: list[dict[str, Any]], properties: dict[str, str]
-    ) -> dict[str, Any]:
+    async def create_product(self, associations: list[dict[str, Any]], properties: dict[str, str]) -> dict[str, Any]:
         """
 
         Creates a new product in the CRM product library to manage the collection of goods and services offered by the company.
@@ -853,27 +719,14 @@ class CrmApi(APISegmentBase):
         """
         request_body_data = None
         request_body_data = {"associations": associations, "properties": properties}
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/products"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def search_products(
-        self,
-        limit: int,
-        after: str,
-        sorts: list[str],
-        properties: list[str],
-        filterGroups: list[dict[str, Any]],
-        query: str | None = None,
+    async def search_products(
+        self, limit: int, after: str, sorts: list[str], properties: list[str], filterGroups: list[dict[str, Any]], query: str | None = None
     ) -> dict[str, Any]:
         """
 
@@ -905,22 +758,13 @@ class CrmApi(APISegmentBase):
             "properties": properties,
             "filterGroups": filterGroups,
         }
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/products/search"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def get_pipeline_by_id_for_type(
-        self, objectType: str, pipelineId: str
-    ) -> dict[str, Any]:
+    async def get_pipeline_by_id_for_type(self, objectType: str, pipelineId: str) -> dict[str, Any]:
         """
 
         Retrieves details about a specific CRM pipeline by its ID and object type, providing information about the stages and records within that pipeline.
@@ -947,7 +791,7 @@ class CrmApi(APISegmentBase):
         response = self._get(url, params=query_params)
         return self._handle_response(response)
 
-    def update_pipeline(
+    async def update_pipeline(
         self,
         objectType: str,
         pipelineId: str,
@@ -984,35 +828,21 @@ class CrmApi(APISegmentBase):
         if pipelineId is None:
             raise ValueError("Missing required parameter 'pipelineId'.")
         request_body_data = None
-        request_body_data = {
-            "displayOrder": displayOrder,
-            "stages": stages,
-            "label": label,
-        }
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {"displayOrder": displayOrder, "stages": stages, "label": label}
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/pipelines/{objectType}/{pipelineId}"
         query_params = {
             k: v
             for k, v in [
                 ("validateReferencesBeforeDelete", validateReferencesBeforeDelete),
-                (
-                    "validateDealStageUsagesBeforeDelete",
-                    validateDealStageUsagesBeforeDelete,
-                ),
+                ("validateDealStageUsagesBeforeDelete", validateDealStageUsagesBeforeDelete),
             ]
             if v is not None
         }
-        response = self._put(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._put(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def delete_pipeline_by_id_and_type(
+    async def delete_pipeline_by_id_and_type(
         self,
         objectType: str,
         pipelineId: str,
@@ -1047,17 +877,14 @@ class CrmApi(APISegmentBase):
             k: v
             for k, v in [
                 ("validateReferencesBeforeDelete", validateReferencesBeforeDelete),
-                (
-                    "validateDealStageUsagesBeforeDelete",
-                    validateDealStageUsagesBeforeDelete,
-                ),
+                ("validateDealStageUsagesBeforeDelete", validateDealStageUsagesBeforeDelete),
             ]
             if v is not None
         }
         response = self._delete(url, params=query_params)
         return self._handle_response(response)
 
-    def patch_pipeline_by_object_type(
+    async def patch_pipeline_by_object_type(
         self,
         objectType: str,
         pipelineId: str,
@@ -1094,32 +921,21 @@ class CrmApi(APISegmentBase):
         if pipelineId is None:
             raise ValueError("Missing required parameter 'pipelineId'.")
         request_body_data = None
-        request_body_data = {
-            "archived": archived,
-            "displayOrder": displayOrder,
-            "label": label,
-        }
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {"archived": archived, "displayOrder": displayOrder, "label": label}
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/pipelines/{objectType}/{pipelineId}"
         query_params = {
             k: v
             for k, v in [
                 ("validateReferencesBeforeDelete", validateReferencesBeforeDelete),
-                (
-                    "validateDealStageUsagesBeforeDelete",
-                    validateDealStageUsagesBeforeDelete,
-                ),
+                ("validateDealStageUsagesBeforeDelete", validateDealStageUsagesBeforeDelete),
             ]
             if v is not None
         }
         response = self._patch(url, data=request_body_data, params=query_params)
         return self._handle_response(response)
 
-    def get_pipeline_audit_by_object_type(
-        self, objectType: str, pipelineId: str
-    ) -> dict[str, Any]:
+    async def get_pipeline_audit_by_object_type(self, objectType: str, pipelineId: str) -> dict[str, Any]:
         """
 
         Retrieves an audit of all changes to a specific pipeline in HubSpot CRM, based on the provided object type and pipeline ID.
@@ -1146,9 +962,7 @@ class CrmApi(APISegmentBase):
         response = self._get(url, params=query_params)
         return self._handle_response(response)
 
-    def get_pipeline_stages_by_object_type(
-        self, objectType: str, pipelineId: str
-    ) -> dict[str, Any]:
+    async def get_pipeline_stages_by_object_type(self, objectType: str, pipelineId: str) -> dict[str, Any]:
         """
 
         Retrieves the list of stages within a specified pipeline for a given object type in the CRM system.
@@ -1175,13 +989,8 @@ class CrmApi(APISegmentBase):
         response = self._get(url, params=query_params)
         return self._handle_response(response)
 
-    def create_pipeline_stage(
-        self,
-        objectType: str,
-        pipelineId: str,
-        metadata: dict[str, str],
-        displayOrder: int,
-        label: str,
+    async def create_pipeline_stage(
+        self, objectType: str, pipelineId: str, metadata: dict[str, str], displayOrder: int, label: str
     ) -> dict[str, Any]:
         """
 
@@ -1212,25 +1021,14 @@ class CrmApi(APISegmentBase):
         if pipelineId is None:
             raise ValueError("Missing required parameter 'pipelineId'.")
         request_body_data = None
-        request_body_data = {
-            "metadata": metadata,
-            "displayOrder": displayOrder,
-            "label": label,
-        }
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {"metadata": metadata, "displayOrder": displayOrder, "label": label}
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/pipelines/{objectType}/{pipelineId}/stages"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def list_pipelines_by_type(self, objectType: str) -> dict[str, Any]:
+    async def list_pipelines_by_type(self, objectType: str) -> dict[str, Any]:
         """
 
         Retrieves a list of pipelines for a specified object type in the CRM, allowing for the management and inspection of pipelines relevant to that object type.
@@ -1254,12 +1052,8 @@ class CrmApi(APISegmentBase):
         response = self._get(url, params=query_params)
         return self._handle_response(response)
 
-    def create_pipeline_by_object_type(
-        self,
-        objectType: str,
-        displayOrder: int,
-        stages: list[dict[str, Any]],
-        label: str,
+    async def create_pipeline_by_object_type(
+        self, objectType: str, displayOrder: int, stages: list[dict[str, Any]], label: str
     ) -> dict[str, Any]:
         """
 
@@ -1283,27 +1077,14 @@ class CrmApi(APISegmentBase):
         if objectType is None:
             raise ValueError("Missing required parameter 'objectType'.")
         request_body_data = None
-        request_body_data = {
-            "displayOrder": displayOrder,
-            "stages": stages,
-            "label": label,
-        }
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {"displayOrder": displayOrder, "stages": stages, "label": label}
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/pipelines/{objectType}"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def get_pipeline_stage_by_id(
-        self, objectType: str, pipelineId: str, stageId: str
-    ) -> dict[str, Any]:
+    async def get_pipeline_stage_by_id(self, objectType: str, pipelineId: str, stageId: str) -> dict[str, Any]:
         """
 
         Retrieves detailed information about a specific stage within a given pipeline and object type in the CRM system.
@@ -1333,14 +1114,8 @@ class CrmApi(APISegmentBase):
         response = self._get(url, params=query_params)
         return self._handle_response(response)
 
-    def update_pipeline_stage_by_id(
-        self,
-        objectType: str,
-        pipelineId: str,
-        stageId: str,
-        metadata: dict[str, str],
-        displayOrder: int,
-        label: str,
+    async def update_pipeline_stage_by_id(
+        self, objectType: str, pipelineId: str, stageId: str, metadata: dict[str, str], displayOrder: int, label: str
     ) -> dict[str, Any]:
         """
 
@@ -1374,27 +1149,14 @@ class CrmApi(APISegmentBase):
         if stageId is None:
             raise ValueError("Missing required parameter 'stageId'.")
         request_body_data = None
-        request_body_data = {
-            "metadata": metadata,
-            "displayOrder": displayOrder,
-            "label": label,
-        }
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {"metadata": metadata, "displayOrder": displayOrder, "label": label}
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/pipelines/{objectType}/{pipelineId}/stages/{stageId}"
         query_params = {}
-        response = self._put(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._put(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def delete_pipeline_stage_by_id(
-        self, objectType: str, pipelineId: str, stageId: str
-    ) -> Any:
+    async def delete_pipeline_stage_by_id(self, objectType: str, pipelineId: str, stageId: str) -> Any:
         """
 
         Deletes a specific stage from a pipeline for the given object type in the CRM system.
@@ -1424,7 +1186,7 @@ class CrmApi(APISegmentBase):
         response = self._delete(url, params=query_params)
         return self._handle_response(response)
 
-    def update_pipeline_stage(
+    async def update_pipeline_stage(
         self,
         objectType: str,
         pipelineId: str,
@@ -1467,21 +1229,14 @@ class CrmApi(APISegmentBase):
         if stageId is None:
             raise ValueError("Missing required parameter 'stageId'.")
         request_body_data = None
-        request_body_data = {
-            "archived": archived,
-            "metadata": metadata,
-            "displayOrder": displayOrder,
-            "label": label,
-        }
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {"archived": archived, "metadata": metadata, "displayOrder": displayOrder, "label": label}
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/pipelines/{objectType}/{pipelineId}/stages/{stageId}"
         query_params = {}
         response = self._patch(url, data=request_body_data, params=query_params)
         return self._handle_response(response)
 
-    def batch_read_companies_post(
+    async def batch_read_companies_post(
         self,
         propertiesWithHistory: list[str],
         inputs: list[dict[str, Any]],
@@ -1516,20 +1271,13 @@ class CrmApi(APISegmentBase):
             "inputs": inputs,
             "properties": properties,
         }
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/companies/batch/read"
         query_params = {k: v for k, v in [("archived", archived)] if v is not None}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def get_company_by_id(
+    async def get_company_by_id(
         self,
         companyId: str,
         properties: list[str] | None = None,
@@ -1576,7 +1324,7 @@ class CrmApi(APISegmentBase):
         response = self._get(url, params=query_params)
         return self._handle_response(response)
 
-    def delete_company_by_id(self, companyId: str) -> Any:
+    async def delete_company_by_id(self, companyId: str) -> Any:
         """
 
         Deletes a company by its ID using the DELETE method, requiring the company ID as a path parameter and authorization through OAuth2 or private apps with the "crm.objects.companies.write" permission.
@@ -1600,12 +1348,7 @@ class CrmApi(APISegmentBase):
         response = self._delete(url, params=query_params)
         return self._handle_response(response)
 
-    def patch_company_by_id(
-        self,
-        companyId: str,
-        properties: dict[str, str],
-        idProperty: str | None = None,
-    ) -> dict[str, Any]:
+    async def patch_company_by_id(self, companyId: str, properties: dict[str, str], idProperty: str | None = None) -> dict[str, Any]:
         """
 
         Updates a company in the CRM using the PATCH method, allowing partial modifications to the company's properties.
@@ -1628,17 +1371,13 @@ class CrmApi(APISegmentBase):
             raise ValueError("Missing required parameter 'companyId'.")
         request_body_data = None
         request_body_data = {"properties": properties}
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/companies/{companyId}"
         query_params = {k: v for k, v in [("idProperty", idProperty)] if v is not None}
         response = self._patch(url, data=request_body_data, params=query_params)
         return self._handle_response(response)
 
-    def merge_companies_post(
-        self, objectIdToMerge: str, primaryObjectId: str
-    ) -> dict[str, Any]:
+    async def merge_companies_post(self, objectIdToMerge: str, primaryObjectId: str) -> dict[str, Any]:
         """
 
         Merges two or more company records into a single unified record using the CRM API, requiring a JSON payload and appropriate write permissions.
@@ -1657,24 +1396,14 @@ class CrmApi(APISegmentBase):
             Public_Object
         """
         request_body_data = None
-        request_body_data = {
-            "objectIdToMerge": objectIdToMerge,
-            "primaryObjectId": primaryObjectId,
-        }
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {"objectIdToMerge": objectIdToMerge, "primaryObjectId": primaryObjectId}
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/companies/merge"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def archive_companies_batch_post(self, inputs: list[dict[str, Any]]) -> Any:
+    async def archive_companies_batch_post(self, inputs: list[dict[str, Any]]) -> Any:
         """
 
         Archives a batch of companies using the HubSpot CRM API, requiring a JSON body and returning a 204 status on successful operation.
@@ -1693,20 +1422,13 @@ class CrmApi(APISegmentBase):
         """
         request_body_data = None
         request_body_data = {"inputs": inputs}
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/companies/batch/archive"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def create_companies_batch(self, inputs: list[dict[str, Any]]) -> dict[str, Any]:
+    async def create_companies_batch(self, inputs: list[dict[str, Any]]) -> dict[str, Any]:
         """
 
         Creates multiple company records in batch using the HubSpot CRM API and returns a status message, requiring authorization via OAuth2 or private apps.
@@ -1725,20 +1447,13 @@ class CrmApi(APISegmentBase):
         """
         request_body_data = None
         request_body_data = {"inputs": inputs}
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/companies/batch/create"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def update_companies_batch(self, inputs: list[dict[str, Any]]) -> dict[str, Any]:
+    async def update_companies_batch(self, inputs: list[dict[str, Any]]) -> dict[str, Any]:
         """
 
         Updates multiple company records in a single request using the HubSpot CRM API.
@@ -1757,22 +1472,13 @@ class CrmApi(APISegmentBase):
         """
         request_body_data = None
         request_body_data = {"inputs": inputs}
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/companies/batch/update"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def delete_company_gdpr_data(
-        self, objectId: str, idProperty: str | None = None
-    ) -> Any:
+    async def delete_company_gdpr_data(self, objectId: str, idProperty: str | None = None) -> Any:
         """
 
         Performs a GDPR-compliant deletion of a company record in the CRM, permanently removing the associated personal data.
@@ -1792,20 +1498,13 @@ class CrmApi(APISegmentBase):
         """
         request_body_data = None
         request_body_data = {"idProperty": idProperty, "objectId": objectId}
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/companies/gdpr-delete"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def get_companies(
+    async def get_companies(
         self,
         limit: int | None = None,
         after: str | None = None,
@@ -1851,9 +1550,7 @@ class CrmApi(APISegmentBase):
         response = self._get(url, params=query_params)
         return self._handle_response(response)
 
-    def create_company(
-        self, associations: list[dict[str, Any]], properties: dict[str, str]
-    ) -> dict[str, Any]:
+    async def create_company(self, associations: list[dict[str, Any]], properties: dict[str, str]) -> dict[str, Any]:
         """
 
         Creates a new company record in the CRM system using the provided JSON data and returns a 201 status code upon successful creation.
@@ -1873,27 +1570,14 @@ class CrmApi(APISegmentBase):
         """
         request_body_data = None
         request_body_data = {"associations": associations, "properties": properties}
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/companies"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def search_companies_post(
-        self,
-        limit: int,
-        after: str,
-        sorts: list[str],
-        properties: list[str],
-        filterGroups: list[dict[str, Any]],
-        query: str | None = None,
+    async def search_companies_post(
+        self, limit: int, after: str, sorts: list[str], properties: list[str], filterGroups: list[dict[str, Any]], query: str | None = None
     ) -> dict[str, Any]:
         """
 
@@ -1925,20 +1609,13 @@ class CrmApi(APISegmentBase):
             "properties": properties,
             "filterGroups": filterGroups,
         }
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/companies/search"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def get_calling_app_settings(self, appId: str) -> dict[str, Any]:
+    async def get_calling_app_settings(self, appId: str) -> dict[str, Any]:
         """
 
         Retrieves the calling settings for a specified application in HubSpot CRM using the provided app ID.
@@ -1962,7 +1639,7 @@ class CrmApi(APISegmentBase):
         response = self._get(url, params=query_params)
         return self._handle_response(response)
 
-    def update_calling_app_settings(
+    async def update_calling_app_settings(
         self,
         appId: str,
         name: str,
@@ -2005,20 +1682,13 @@ class CrmApi(APISegmentBase):
             "url": url,
             "height": height,
         }
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/extensions/calling/{appId}/settings"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def delete_calling_app_settings_by_id(self, appId: str) -> Any:
+    async def delete_calling_app_settings_by_id(self, appId: str) -> Any:
         """
 
         Deletes the settings for a specified CRM application identified by `{appId}`, returning a successful response with no content if the operation is completed.
@@ -2042,7 +1712,7 @@ class CrmApi(APISegmentBase):
         response = self._delete(url, params=query_params)
         return self._handle_response(response)
 
-    def update_calling_settings(
+    async def update_calling_settings(
         self,
         appId: str,
         supportsCustomObjects: bool | None = None,
@@ -2085,15 +1755,13 @@ class CrmApi(APISegmentBase):
             "url": url,
             "height": height,
         }
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/extensions/calling/{appId}/settings"
         query_params = {}
         response = self._patch(url, data=request_body_data, params=query_params)
         return self._handle_response(response)
 
-    def get_calling_app_recording_settings(self, appId: str) -> dict[str, Any]:
+    async def get_calling_app_recording_settings(self, appId: str) -> dict[str, Any]:
         """
 
         Retrieves the recording settings for a calling extension with the specified `appId` in the HubSpot CRM.
@@ -2117,9 +1785,7 @@ class CrmApi(APISegmentBase):
         response = self._get(url, params=query_params)
         return self._handle_response(response)
 
-    def post_calling_app_recording_settings(
-        self, appId: str, urlToRetrieveAuthedRecording: str
-    ) -> dict[str, Any]:
+    async def post_calling_app_recording_settings(self, appId: str, urlToRetrieveAuthedRecording: str) -> dict[str, Any]:
         """
 
         Configures call recording settings for a specific application ID in the CRM using a POST request to update the recording settings.
@@ -2140,25 +1806,14 @@ class CrmApi(APISegmentBase):
         if appId is None:
             raise ValueError("Missing required parameter 'appId'.")
         request_body_data = None
-        request_body_data = {
-            "urlToRetrieveAuthedRecording": urlToRetrieveAuthedRecording
-        }
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {"urlToRetrieveAuthedRecording": urlToRetrieveAuthedRecording}
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/extensions/calling/{appId}/settings/recording"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def update_recording_settings(
-        self, appId: str, urlToRetrieveAuthedRecording: str | None = None
-    ) -> dict[str, Any]:
+    async def update_recording_settings(self, appId: str, urlToRetrieveAuthedRecording: str | None = None) -> dict[str, Any]:
         """
 
         Modifies the recording settings for a specific CRM application using the provided JSON body.
@@ -2179,18 +1834,14 @@ class CrmApi(APISegmentBase):
         if appId is None:
             raise ValueError("Missing required parameter 'appId'.")
         request_body_data = None
-        request_body_data = {
-            "urlToRetrieveAuthedRecording": urlToRetrieveAuthedRecording
-        }
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {"urlToRetrieveAuthedRecording": urlToRetrieveAuthedRecording}
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/extensions/calling/{appId}/settings/recording"
         query_params = {}
         response = self._patch(url, data=request_body_data, params=query_params)
         return self._handle_response(response)
 
-    def read_quotes_batch(
+    async def read_quotes_batch(
         self,
         propertiesWithHistory: list[str],
         inputs: list[dict[str, Any]],
@@ -2225,20 +1876,13 @@ class CrmApi(APISegmentBase):
             "inputs": inputs,
             "properties": properties,
         }
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/quotes/batch/read"
         query_params = {k: v for k, v in [("archived", archived)] if v is not None}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def get_quote_by_id(
+    async def get_quote_by_id(
         self,
         quoteId: str,
         properties: list[str] | None = None,
@@ -2285,7 +1929,7 @@ class CrmApi(APISegmentBase):
         response = self._get(url, params=query_params)
         return self._handle_response(response)
 
-    def delete_quote_by_id(self, quoteId: str) -> Any:
+    async def delete_quote_by_id(self, quoteId: str) -> Any:
         """
 
         Deletes a sales quote with the specified ID using the HubSpot CRM API, requiring "crm.objects.quotes.write" permission.
@@ -2309,9 +1953,7 @@ class CrmApi(APISegmentBase):
         response = self._delete(url, params=query_params)
         return self._handle_response(response)
 
-    def update_quote(
-        self, quoteId: str, properties: dict[str, str], idProperty: str | None = None
-    ) -> dict[str, Any]:
+    async def update_quote(self, quoteId: str, properties: dict[str, str], idProperty: str | None = None) -> dict[str, Any]:
         """
 
         Updates a quote object with the specified ID in the CRM system using partial modifications, requiring a JSON body with the changes and returning a status message upon success.
@@ -2334,17 +1976,13 @@ class CrmApi(APISegmentBase):
             raise ValueError("Missing required parameter 'quoteId'.")
         request_body_data = None
         request_body_data = {"properties": properties}
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/quotes/{quoteId}"
         query_params = {k: v for k, v in [("idProperty", idProperty)] if v is not None}
         response = self._patch(url, data=request_body_data, params=query_params)
         return self._handle_response(response)
 
-    def merge_quotes(
-        self, objectIdToMerge: str, primaryObjectId: str
-    ) -> dict[str, Any]:
+    async def merge_quotes(self, objectIdToMerge: str, primaryObjectId: str) -> dict[str, Any]:
         """
 
         Merges quote objects in a CRM system using the POST method, allowing for the integration of data from multiple quotes into a single unified quote.
@@ -2363,24 +2001,14 @@ class CrmApi(APISegmentBase):
             Public_Object
         """
         request_body_data = None
-        request_body_data = {
-            "objectIdToMerge": objectIdToMerge,
-            "primaryObjectId": primaryObjectId,
-        }
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {"objectIdToMerge": objectIdToMerge, "primaryObjectId": primaryObjectId}
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/quotes/merge"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def archive_quotes_batch(self, inputs: list[dict[str, Any]]) -> Any:
+    async def archive_quotes_batch(self, inputs: list[dict[str, Any]]) -> Any:
         """
 
         Archives a batch of quotes by sending a POST request to the "/crm/v3/objects/quotes/batch/archive" endpoint, requiring a JSON body and authentication via OAuth2 or private apps with the "crm.objects.quotes.write" permission.
@@ -2399,20 +2027,13 @@ class CrmApi(APISegmentBase):
         """
         request_body_data = None
         request_body_data = {"inputs": inputs}
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/quotes/batch/archive"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def create_quote_batch(self, inputs: list[dict[str, Any]]) -> dict[str, Any]:
+    async def create_quote_batch(self, inputs: list[dict[str, Any]]) -> dict[str, Any]:
         """
 
         Creates a batch of sales quotes using the HubSpot CRM API, requiring a JSON body and returning a status message upon successful creation.
@@ -2431,20 +2052,13 @@ class CrmApi(APISegmentBase):
         """
         request_body_data = None
         request_body_data = {"inputs": inputs}
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/quotes/batch/create"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def update_quotes_batch(self, inputs: list[dict[str, Any]]) -> dict[str, Any]:
+    async def update_quotes_batch(self, inputs: list[dict[str, Any]]) -> dict[str, Any]:
         """
 
         Updates a batch of quote objects in the CRM system using a single POST request, returning a status code indicating success or partial failure.
@@ -2463,22 +2077,13 @@ class CrmApi(APISegmentBase):
         """
         request_body_data = None
         request_body_data = {"inputs": inputs}
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/quotes/batch/update"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def delete_quote_gdpr_data(
-        self, objectId: str, idProperty: str | None = None
-    ) -> Any:
+    async def delete_quote_gdpr_data(self, objectId: str, idProperty: str | None = None) -> Any:
         """
 
         Performs a GDPR-compliant deletion of a quote object in the CRM system, permanently removing the associated personal data.
@@ -2498,20 +2103,13 @@ class CrmApi(APISegmentBase):
         """
         request_body_data = None
         request_body_data = {"idProperty": idProperty, "objectId": objectId}
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/quotes/gdpr-delete"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def get_quotes(
+    async def get_quotes(
         self,
         limit: int | None = None,
         after: str | None = None,
@@ -2557,9 +2155,7 @@ class CrmApi(APISegmentBase):
         response = self._get(url, params=query_params)
         return self._handle_response(response)
 
-    def create_quote(
-        self, associations: list[dict[str, Any]], properties: dict[str, str]
-    ) -> dict[str, Any]:
+    async def create_quote(self, associations: list[dict[str, Any]], properties: dict[str, str]) -> dict[str, Any]:
         """
 
         Creates a new quote in HubSpot using the CRM API and returns a status message upon successful creation.
@@ -2579,27 +2175,14 @@ class CrmApi(APISegmentBase):
         """
         request_body_data = None
         request_body_data = {"associations": associations, "properties": properties}
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/quotes"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def search_quotes(
-        self,
-        limit: int,
-        after: str,
-        sorts: list[str],
-        properties: list[str],
-        filterGroups: list[dict[str, Any]],
-        query: str | None = None,
+    async def search_quotes(
+        self, limit: int, after: str, sorts: list[str], properties: list[str], filterGroups: list[dict[str, Any]], query: str | None = None
     ) -> dict[str, Any]:
         """
 
@@ -2631,20 +2214,13 @@ class CrmApi(APISegmentBase):
             "properties": properties,
             "filterGroups": filterGroups,
         }
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/quotes/search"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def batch_read_deals_post(
+    async def batch_read_deals_post(
         self,
         propertiesWithHistory: list[str],
         inputs: list[dict[str, Any]],
@@ -2679,20 +2255,13 @@ class CrmApi(APISegmentBase):
             "inputs": inputs,
             "properties": properties,
         }
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/deals/batch/read"
         query_params = {k: v for k, v in [("archived", archived)] if v is not None}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def get_deal_by_id(
+    async def get_deal_by_id(
         self,
         dealId: str,
         properties: list[str] | None = None,
@@ -2739,7 +2308,7 @@ class CrmApi(APISegmentBase):
         response = self._get(url, params=query_params)
         return self._handle_response(response)
 
-    def delete_deal_by_id(self, dealId: str) -> Any:
+    async def delete_deal_by_id(self, dealId: str) -> Any:
         """
 
         Deletes a specific deal by its ID from the CRM system.
@@ -2763,9 +2332,7 @@ class CrmApi(APISegmentBase):
         response = self._delete(url, params=query_params)
         return self._handle_response(response)
 
-    def update_deal_by_id(
-        self, dealId: str, properties: dict[str, str], idProperty: str | None = None
-    ) -> dict[str, Any]:
+    async def update_deal_by_id(self, dealId: str, properties: dict[str, str], idProperty: str | None = None) -> dict[str, Any]:
         """
 
         Updates an individual deal in the CRM by its record ID using the PATCH method.
@@ -2788,15 +2355,13 @@ class CrmApi(APISegmentBase):
             raise ValueError("Missing required parameter 'dealId'.")
         request_body_data = None
         request_body_data = {"properties": properties}
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/deals/{dealId}"
         query_params = {k: v for k, v in [("idProperty", idProperty)] if v is not None}
         response = self._patch(url, data=request_body_data, params=query_params)
         return self._handle_response(response)
 
-    def merge_deals(self, objectIdToMerge: str, primaryObjectId: str) -> dict[str, Any]:
+    async def merge_deals(self, objectIdToMerge: str, primaryObjectId: str) -> dict[str, Any]:
         """
 
         Merges two or more deal records into a single master deal record, consolidating data and deleting duplicates in the CRM system.
@@ -2815,24 +2380,14 @@ class CrmApi(APISegmentBase):
             Public_Object
         """
         request_body_data = None
-        request_body_data = {
-            "objectIdToMerge": objectIdToMerge,
-            "primaryObjectId": primaryObjectId,
-        }
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {"objectIdToMerge": objectIdToMerge, "primaryObjectId": primaryObjectId}
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/deals/merge"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def archive_deals_batch_post(self, inputs: list[dict[str, Any]]) -> Any:
+    async def archive_deals_batch_post(self, inputs: list[dict[str, Any]]) -> Any:
         """
 
         Archives a batch of deal records in the CRM by their IDs using the POST method.
@@ -2851,20 +2406,13 @@ class CrmApi(APISegmentBase):
         """
         request_body_data = None
         request_body_data = {"inputs": inputs}
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/deals/batch/archive"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def create_deals_batch(self, inputs: list[dict[str, Any]]) -> dict[str, Any]:
+    async def create_deals_batch(self, inputs: list[dict[str, Any]]) -> dict[str, Any]:
         """
 
         Creates multiple deals in a CRM using a batch operation via the POST method, requiring a JSON body with deal data and appropriate permissions for writing deals.
@@ -2883,20 +2431,13 @@ class CrmApi(APISegmentBase):
         """
         request_body_data = None
         request_body_data = {"inputs": inputs}
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/deals/batch/create"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def batch_update_deals(self, inputs: list[dict[str, Any]]) -> dict[str, Any]:
+    async def batch_update_deals(self, inputs: list[dict[str, Any]]) -> dict[str, Any]:
         """
 
         Updates multiple deals in HubSpot CRM in a single operation using a POST request to "/crm/v3/objects/deals/batch/update", requiring a JSON body with deal identifiers and updates, and supports OAuth2 and private app authentication for the "crm.objects.deals.write" scope.
@@ -2915,22 +2456,13 @@ class CrmApi(APISegmentBase):
         """
         request_body_data = None
         request_body_data = {"inputs": inputs}
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/deals/batch/update"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def post_deal_gdpr_delete(
-        self, objectId: str, idProperty: str | None = None
-    ) -> Any:
+    async def post_deal_gdpr_delete(self, objectId: str, idProperty: str | None = None) -> Any:
         """
 
         Deletes a deal record in compliance with GDPR requirements using the provided JSON payload, requiring a valid OAuth2 or private app authentication with the necessary write permissions.
@@ -2950,20 +2482,13 @@ class CrmApi(APISegmentBase):
         """
         request_body_data = None
         request_body_data = {"idProperty": idProperty, "objectId": objectId}
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/deals/gdpr-delete"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def list_deals(
+    async def list_deals(
         self,
         limit: int | None = None,
         after: str | None = None,
@@ -3009,9 +2534,7 @@ class CrmApi(APISegmentBase):
         response = self._get(url, params=query_params)
         return self._handle_response(response)
 
-    def create_deal(
-        self, associations: list[dict[str, Any]], properties: dict[str, str]
-    ) -> dict[str, Any]:
+    async def create_deal(self, associations: list[dict[str, Any]], properties: dict[str, str]) -> dict[str, Any]:
         """
 
         Creates a new deal object in the CRM using the HubSpot API, requiring a JSON payload and returning a status code indicating success.
@@ -3031,27 +2554,14 @@ class CrmApi(APISegmentBase):
         """
         request_body_data = None
         request_body_data = {"associations": associations, "properties": properties}
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/deals"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def search_deals(
-        self,
-        limit: int,
-        after: str,
-        sorts: list[str],
-        properties: list[str],
-        filterGroups: list[dict[str, Any]],
-        query: str | None = None,
+    async def search_deals(
+        self, limit: int, after: str, sorts: list[str], properties: list[str], filterGroups: list[dict[str, Any]], query: str | None = None
     ) -> dict[str, Any]:
         """
 
@@ -3083,20 +2593,13 @@ class CrmApi(APISegmentBase):
             "properties": properties,
             "filterGroups": filterGroups,
         }
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/deals/search"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def cancel_import_by_id(self, importId: str) -> dict[str, Any]:
+    async def cancel_import_by_id(self, importId: str) -> dict[str, Any]:
         """
 
         Cancels an active import operation in a CRM system using the provided import ID.
@@ -3118,15 +2621,10 @@ class CrmApi(APISegmentBase):
         request_body_data = None
         url = f"{self.main_app_client.base_url}/crm/v3/imports/{importId}/cancel"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def get_import_by_id(self, importId: str) -> dict[str, Any]:
+    async def get_import_by_id(self, importId: str) -> dict[str, Any]:
         """
 
         Retrieves the status and details of a specific CRM import operation identified by the import ID.
@@ -3150,9 +2648,7 @@ class CrmApi(APISegmentBase):
         response = self._get(url, params=query_params)
         return self._handle_response(response)
 
-    def get_import_errors_by_id(
-        self, importId: str, after: str | None = None, limit: int | None = None
-    ) -> dict[str, Any]:
+    async def get_import_errors_by_id(self, importId: str, after: str | None = None, limit: int | None = None) -> dict[str, Any]:
         """
 
         Retrieves a list of errors associated with a specific CRM import operation, using the import ID, and allows filtering by optional parameters such as "after" and "limit".
@@ -3174,13 +2670,11 @@ class CrmApi(APISegmentBase):
         if importId is None:
             raise ValueError("Missing required parameter 'importId'.")
         url = f"{self.main_app_client.base_url}/crm/v3/imports/{importId}/errors"
-        query_params = {
-            k: v for k, v in [("after", after), ("limit", limit)] if v is not None
-        }
+        query_params = {k: v for k, v in [("after", after), ("limit", limit)] if v is not None}
         response = self._get(url, params=query_params)
         return self._handle_response(response)
 
-    def get_schema_by_object_type(self, objectType: str) -> dict[str, Any]:
+    async def get_schema_by_object_type(self, objectType: str) -> dict[str, Any]:
         """
 
         Retrieves the schema definition for a specified CRM object type, including its properties and metadata.
@@ -3204,9 +2698,7 @@ class CrmApi(APISegmentBase):
         response = self._get(url, params=query_params)
         return self._handle_response(response)
 
-    def delete_schema_by_type(
-        self, objectType: str, archived: bool | None = None
-    ) -> Any:
+    async def delete_schema_by_type(self, objectType: str, archived: bool | None = None) -> Any:
         """
 
         Deletes the specified CRM object schema by its type, optionally including archived versions, to remove its definition from the system.
@@ -3231,7 +2723,7 @@ class CrmApi(APISegmentBase):
         response = self._delete(url, params=query_params)
         return self._handle_response(response)
 
-    def patch_crm_schema_by_object_type(
+    async def patch_crm_schema_by_object_type(
         self,
         objectType: str,
         description: str | None = None,
@@ -3277,20 +2769,14 @@ class CrmApi(APISegmentBase):
             "restorable": restorable,
             "labels": labels,
         }
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/schemas/{objectType}"
         query_params = {}
         response = self._patch(url, data=request_body_data, params=query_params)
         return self._handle_response(response)
 
-    def create_object_type_association(
-        self,
-        objectType: str,
-        fromObjectTypeId: str,
-        toObjectTypeId: str,
-        name: str | None = None,
+    async def create_object_type_association(
+        self, objectType: str, fromObjectTypeId: str, toObjectTypeId: str, name: str | None = None
     ) -> dict[str, Any]:
         """
 
@@ -3314,27 +2800,14 @@ class CrmApi(APISegmentBase):
         if objectType is None:
             raise ValueError("Missing required parameter 'objectType'.")
         request_body_data = None
-        request_body_data = {
-            "fromObjectTypeId": fromObjectTypeId,
-            "name": name,
-            "toObjectTypeId": toObjectTypeId,
-        }
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
-        url = (
-            f"{self.main_app_client.base_url}/crm/v3/schemas/{objectType}/associations"
-        )
+        request_body_data = {"fromObjectTypeId": fromObjectTypeId, "name": name, "toObjectTypeId": toObjectTypeId}
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
+        url = f"{self.main_app_client.base_url}/crm/v3/schemas/{objectType}/associations"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def delete_schema_object_type_purge(self, objectType: str) -> Any:
+    async def delete_schema_object_type_purge(self, objectType: str) -> Any:
         """
 
         Purges a schema for a specific object type in the CRM system using the DELETE method, requiring the objectType as a path parameter and a custom write permission.
@@ -3358,9 +2831,7 @@ class CrmApi(APISegmentBase):
         response = self._delete(url, params=query_params)
         return self._handle_response(response)
 
-    def delete_association_by_object_type_id(
-        self, objectType: str, associationIdentifier: str
-    ) -> Any:
+    async def delete_association_by_object_type_id(self, objectType: str, associationIdentifier: str) -> Any:
         """
 
         Removes an association identified by the associationIdentifier from a CRM object schema of the specified objectType using the HubSpot API.
@@ -3387,7 +2858,7 @@ class CrmApi(APISegmentBase):
         response = self._delete(url, params=query_params)
         return self._handle_response(response)
 
-    def list_schemas(self, archived: bool | None = None) -> dict[str, Any]:
+    async def list_schemas(self, archived: bool | None = None) -> dict[str, Any]:
         """
 
         Retrieves a list of custom object schemas in the CRM, optionally filtering by archived status, using either legacy private apps or OAuth2 credentials for authentication.
@@ -3409,7 +2880,7 @@ class CrmApi(APISegmentBase):
         response = self._get(url, params=query_params)
         return self._handle_response(response)
 
-    def create_crm_schema(
+    async def create_crm_schema(
         self,
         requiredProperties: list[str],
         name: str,
@@ -3457,22 +2928,13 @@ class CrmApi(APISegmentBase):
             "properties": properties,
             "labels": labels,
         }
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/schemas"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def archive_properties_batch_post(
-        self, objectType: str, inputs: list[dict[str, Any]]
-    ) -> Any:
+    async def archive_properties_batch_post(self, objectType: str, inputs: list[dict[str, Any]]) -> Any:
         """
 
         Archives a batch of properties for a specified object type in CRM using a POST request.
@@ -3494,20 +2956,13 @@ class CrmApi(APISegmentBase):
             raise ValueError("Missing required parameter 'objectType'.")
         request_body_data = None
         request_body_data = {"inputs": inputs}
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/properties/{objectType}/batch/archive"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def get_property_group(self, objectType: str, groupName: str) -> dict[str, Any]:
+    async def get_property_group(self, objectType: str, groupName: str) -> dict[str, Any]:
         """
 
         Retrieves details of a specified property group for a given CRM object type.
@@ -3534,7 +2989,7 @@ class CrmApi(APISegmentBase):
         response = self._get(url, params=query_params)
         return self._handle_response(response)
 
-    def remove_property_group(self, objectType: str, groupName: str) -> Any:
+    async def remove_property_group(self, objectType: str, groupName: str) -> Any:
         """
 
         Deletes a property group identified by the given object type and group name from the CRM schema.
@@ -3561,12 +3016,8 @@ class CrmApi(APISegmentBase):
         response = self._delete(url, params=query_params)
         return self._handle_response(response)
 
-    def update_property_group_by_identifier(
-        self,
-        objectType: str,
-        groupName: str,
-        displayOrder: int | None = None,
-        label: str | None = None,
+    async def update_property_group_by_identifier(
+        self, objectType: str, groupName: str, displayOrder: int | None = None, label: str | None = None
     ) -> dict[str, Any]:
         """
 
@@ -3593,20 +3044,14 @@ class CrmApi(APISegmentBase):
             raise ValueError("Missing required parameter 'groupName'.")
         request_body_data = None
         request_body_data = {"displayOrder": displayOrder, "label": label}
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/properties/{objectType}/groups/{groupName}"
         query_params = {}
         response = self._patch(url, data=request_body_data, params=query_params)
         return self._handle_response(response)
 
-    def get_crm_property(
-        self,
-        objectType: str,
-        propertyName: str,
-        archived: bool | None = None,
-        properties: str | None = None,
+    async def get_crm_property(
+        self, objectType: str, propertyName: str, archived: bool | None = None, properties: str | None = None
     ) -> dict[str, Any]:
         """
 
@@ -3632,15 +3077,11 @@ class CrmApi(APISegmentBase):
         if propertyName is None:
             raise ValueError("Missing required parameter 'propertyName'.")
         url = f"{self.main_app_client.base_url}/crm/v3/properties/{objectType}/{propertyName}"
-        query_params = {
-            k: v
-            for k, v in [("archived", archived), ("properties", properties)]
-            if v is not None
-        }
+        query_params = {k: v for k, v in [("archived", archived), ("properties", properties)] if v is not None}
         response = self._get(url, params=query_params)
         return self._handle_response(response)
 
-    def delete_property_by_object_type(self, objectType: str, propertyName: str) -> Any:
+    async def delete_property_by_object_type(self, objectType: str, propertyName: str) -> Any:
         """
 
         Deletes a specified property of a given object type in the CRM system.
@@ -3667,7 +3108,7 @@ class CrmApi(APISegmentBase):
         response = self._delete(url, params=query_params)
         return self._handle_response(response)
 
-    def patch_crm_property_by_name(
+    async def patch_crm_property_by_name(
         self,
         objectType: str,
         propertyName: str,
@@ -3726,17 +3167,13 @@ class CrmApi(APISegmentBase):
             "fieldType": fieldType,
             "formField": formField,
         }
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/properties/{objectType}/{propertyName}"
         query_params = {}
         response = self._patch(url, data=request_body_data, params=query_params)
         return self._handle_response(response)
 
-    def batch_read_properties_by_object_type(
-        self, objectType: str, archived: bool, inputs: list[dict[str, Any]]
-    ) -> dict[str, Any]:
+    async def batch_read_properties_by_object_type(self, objectType: str, archived: bool, inputs: list[dict[str, Any]]) -> dict[str, Any]:
         """
 
         Performs a batch read operation on CRM properties for a specified object type using a POST request, returning the results in a batch format.
@@ -3759,24 +3196,13 @@ class CrmApi(APISegmentBase):
             raise ValueError("Missing required parameter 'objectType'.")
         request_body_data = None
         request_body_data = {"archived": archived, "inputs": inputs}
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
-        url = (
-            f"{self.main_app_client.base_url}/crm/v3/properties/{objectType}/batch/read"
-        )
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
+        url = f"{self.main_app_client.base_url}/crm/v3/properties/{objectType}/batch/read"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def create_batch_properties(
-        self, objectType: str, inputs: list[dict[str, Any]]
-    ) -> dict[str, Any]:
+    async def create_batch_properties(self, objectType: str, inputs: list[dict[str, Any]]) -> dict[str, Any]:
         """
 
         Creates multiple properties in batches for a specified object type in the CRM using a POST request to the "/crm/v3/properties/{objectType}/batch/create" endpoint.
@@ -3798,24 +3224,14 @@ class CrmApi(APISegmentBase):
             raise ValueError("Missing required parameter 'objectType'.")
         request_body_data = None
         request_body_data = {"inputs": inputs}
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/properties/{objectType}/batch/create"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def get_properties_by_object_type(
-        self,
-        objectType: str,
-        archived: bool | None = None,
-        properties: str | None = None,
+    async def get_properties_by_object_type(
+        self, objectType: str, archived: bool | None = None, properties: str | None = None
     ) -> dict[str, Any]:
         """
 
@@ -3838,15 +3254,11 @@ class CrmApi(APISegmentBase):
         if objectType is None:
             raise ValueError("Missing required parameter 'objectType'.")
         url = f"{self.main_app_client.base_url}/crm/v3/properties/{objectType}"
-        query_params = {
-            k: v
-            for k, v in [("archived", archived), ("properties", properties)]
-            if v is not None
-        }
+        query_params = {k: v for k, v in [("archived", archived), ("properties", properties)] if v is not None}
         response = self._get(url, params=query_params)
         return self._handle_response(response)
 
-    def create_property_schema(
+    async def create_property_schema(
         self,
         objectType: str,
         label: str,
@@ -3913,20 +3325,13 @@ class CrmApi(APISegmentBase):
             "fieldType": fieldType,
             "externalOptions": externalOptions,
         }
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/properties/{objectType}"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def get_property_groups_by_object_type(self, objectType: str) -> dict[str, Any]:
+    async def get_property_groups_by_object_type(self, objectType: str) -> dict[str, Any]:
         """
 
         Retrieves a list of groups for a specified object type in the CRM using the "GET" method at the path "/crm/v3/properties/{objectType}/groups".
@@ -3950,9 +3355,7 @@ class CrmApi(APISegmentBase):
         response = self._get(url, params=query_params)
         return self._handle_response(response)
 
-    def create_property_group(
-        self, objectType: str, name: str, label: str, displayOrder: int | None = None
-    ) -> dict[str, Any]:
+    async def create_property_group(self, objectType: str, name: str, label: str, displayOrder: int | None = None) -> dict[str, Any]:
         """
 
         Creates a new property group for the specified CRM object type to organize related properties within HubSpot records.
@@ -3976,25 +3379,13 @@ class CrmApi(APISegmentBase):
             raise ValueError("Missing required parameter 'objectType'.")
         request_body_data = None
         request_body_data = {"name": name, "displayOrder": displayOrder, "label": label}
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/properties/{objectType}/groups"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def get_owner_by_id(
-        self,
-        ownerId: str,
-        idProperty: str | None = None,
-        archived: bool | None = None,
-    ) -> dict[str, Any]:
+    async def get_owner_by_id(self, ownerId: str, idProperty: str | None = None, archived: bool | None = None) -> dict[str, Any]:
         """
 
         Retrieves detailed information about a specific CRM owner by their ID using the HubSpot API.
@@ -4016,17 +3407,11 @@ class CrmApi(APISegmentBase):
         if ownerId is None:
             raise ValueError("Missing required parameter 'ownerId'.")
         url = f"{self.main_app_client.base_url}/crm/v3/owners/{ownerId}"
-        query_params = {
-            k: v
-            for k, v in [("idProperty", idProperty), ("archived", archived)]
-            if v is not None
-        }
+        query_params = {k: v for k, v in [("idProperty", idProperty), ("archived", archived)] if v is not None}
         response = self._get(url, params=query_params)
         return self._handle_response(response)
 
-    def batch_create_timeline_events(
-        self, inputs: list[dict[str, Any]]
-    ) -> dict[str, Any]:
+    async def batch_create_timeline_events(self, inputs: list[dict[str, Any]]) -> dict[str, Any]:
         """
 
         Creates multiple timeline events in a batch using the provided event templates and returns a response with the created events.
@@ -4045,22 +3430,13 @@ class CrmApi(APISegmentBase):
         """
         request_body_data = None
         request_body_data = {"inputs": inputs}
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/timeline/events/batch/create"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def get_timeline_event_template_by_id(
-        self, appId: str, eventTemplateId: str
-    ) -> dict[str, Any]:
+    async def get_timeline_event_template_by_id(self, appId: str, eventTemplateId: str) -> dict[str, Any]:
         """
 
         Retrieves a specific event template by its ID for an application in HubSpot CRM, using the provided app ID and event template ID.
@@ -4087,7 +3463,7 @@ class CrmApi(APISegmentBase):
         response = self._get(url, params=query_params)
         return self._handle_response(response)
 
-    def update_timeline_event_template_by_id(
+    async def update_timeline_event_template_by_id(
         self,
         appId: str,
         eventTemplateId: str,
@@ -4131,27 +3507,14 @@ class CrmApi(APISegmentBase):
         if eventTemplateId is None:
             raise ValueError("Missing required parameter 'eventTemplateId'.")
         request_body_data = None
-        request_body_data = {
-            "detailTemplate": detailTemplate,
-            "name": name,
-            "tokens": tokens,
-            "id": id,
-            "headerTemplate": headerTemplate,
-        }
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {"detailTemplate": detailTemplate, "name": name, "tokens": tokens, "id": id, "headerTemplate": headerTemplate}
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/timeline/{appId}/event-templates/{eventTemplateId}"
         query_params = {}
-        response = self._put(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._put(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def delete_event_template_by_id(self, appId: str, eventTemplateId: str) -> Any:
+    async def delete_event_template_by_id(self, appId: str, eventTemplateId: str) -> Any:
         """
 
         Deletes an event template with the specified `eventTemplateId` associated with the application identified by `appId` in a CRM system, returning a successful response with no content upon completion.
@@ -4178,7 +3541,7 @@ class CrmApi(APISegmentBase):
         response = self._delete(url, params=query_params)
         return self._handle_response(response)
 
-    def create_event(
+    async def create_event(
         self,
         eventTemplateId: str,
         tokens: dict[str, str],
@@ -4229,20 +3592,13 @@ class CrmApi(APISegmentBase):
             "objectId": objectId,
             "timestamp": timestamp,
         }
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/timeline/events"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def create_token_template(
+    async def create_token_template(
         self,
         appId: str,
         eventTemplateId: str,
@@ -4292,20 +3648,13 @@ class CrmApi(APISegmentBase):
             "type": type,
             "updatedAt": updatedAt,
         }
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/timeline/{appId}/event-templates/{eventTemplateId}/tokens"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def update_event_template_token(
+    async def update_event_template_token(
         self,
         appId: str,
         eventTemplateId: str,
@@ -4342,27 +3691,14 @@ class CrmApi(APISegmentBase):
         if tokenName is None:
             raise ValueError("Missing required parameter 'tokenName'.")
         request_body_data = None
-        request_body_data = {
-            "options": options,
-            "label": label,
-            "objectPropertyName": objectPropertyName,
-        }
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {"options": options, "label": label, "objectPropertyName": objectPropertyName}
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/timeline/{appId}/event-templates/{eventTemplateId}/tokens/{tokenName}"
         query_params = {}
-        response = self._put(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._put(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def delete_timeline_event_template_token(
-        self, appId: str, eventTemplateId: str, tokenName: str
-    ) -> Any:
+    async def delete_timeline_event_template_token(self, appId: str, eventTemplateId: str, tokenName: str) -> Any:
         """
 
         Deletes a token by the specified name from an event template in the CRM timeline for a given application ID.
@@ -4392,9 +3728,7 @@ class CrmApi(APISegmentBase):
         response = self._delete(url, params=query_params)
         return self._handle_response(response)
 
-    def get_timeline_event_detail_by_id(
-        self, eventTemplateId: str, eventId: str
-    ) -> dict[str, Any]:
+    async def get_timeline_event_detail_by_id(self, eventTemplateId: str, eventId: str) -> dict[str, Any]:
         """
 
         Retrieves detailed information for a specific timeline event identified by its event template ID and event ID in the CRM.
@@ -4421,9 +3755,7 @@ class CrmApi(APISegmentBase):
         response = self._get(url, params=query_params)
         return self._handle_response(response)
 
-    def get_timeline_event_by_id(
-        self, eventTemplateId: str, eventId: str
-    ) -> dict[str, Any]:
+    async def get_timeline_event_by_id(self, eventTemplateId: str, eventId: str) -> dict[str, Any]:
         """
 
         Retrieves a specific timeline event by its event template ID and event ID, returning detailed information about that event in the CRM.
@@ -4450,7 +3782,7 @@ class CrmApi(APISegmentBase):
         response = self._get(url, params=query_params)
         return self._handle_response(response)
 
-    def get_timeline_event_templates_by_app_id(self, appId: str) -> dict[str, Any]:
+    async def get_timeline_event_templates_by_app_id(self, appId: str) -> dict[str, Any]:
         """
 
         Retrieves a list of event templates for a specified app ID in the HubSpot CRM API.
@@ -4474,7 +3806,7 @@ class CrmApi(APISegmentBase):
         response = self._get(url, params=query_params)
         return self._handle_response(response)
 
-    def create_timeline_event_template(
+    async def create_timeline_event_template(
         self,
         appId: str,
         name: str,
@@ -4519,22 +3851,13 @@ class CrmApi(APISegmentBase):
             "headerTemplate": headerTemplate,
             "objectType": objectType,
         }
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/timeline/{appId}/event-templates"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def get_timeline_event_render(
-        self, eventTemplateId: str, eventId: str, detail: bool | None = None
-    ) -> Any:
+    async def get_timeline_event_render(self, eventTemplateId: str, eventId: str, detail: bool | None = None) -> Any:
         """
 
         Retrieves and renders a specific timeline event from a CRM object using an event template and event ID, allowing for optional detailed rendering.
@@ -4562,7 +3885,7 @@ class CrmApi(APISegmentBase):
         response = self._get(url, params=query_params)
         return self._handle_response(response)
 
-    def batch_read_contacts_post(
+    async def batch_read_contacts_post(
         self,
         propertiesWithHistory: list[str],
         inputs: list[dict[str, Any]],
@@ -4597,20 +3920,13 @@ class CrmApi(APISegmentBase):
             "inputs": inputs,
             "properties": properties,
         }
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/contacts/batch/read"
         query_params = {k: v for k, v in [("archived", archived)] if v is not None}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def get_contact_by_id(
+    async def get_contact_by_id(
         self,
         contactId: str,
         properties: list[str] | None = None,
@@ -4654,7 +3970,7 @@ class CrmApi(APISegmentBase):
         response = self._get(url, params=query_params)
         return self._handle_response(response)
 
-    def delete_contact_by_id(self, contactId: str) -> Any:
+    async def delete_contact_by_id(self, contactId: str) -> Any:
         """
 
         Deletes a contact by its ID from the CRM system, permanently removing all associated content in compliance with GDPR, and requires the "crm.objects.contacts.write" permission.
@@ -4678,9 +3994,7 @@ class CrmApi(APISegmentBase):
         response = self._delete(url, params=query_params)
         return self._handle_response(response)
 
-    def update_contact_by_id(
-        self, contactId: str, properties: dict[str, str]
-    ) -> dict[str, Any]:
+    async def update_contact_by_id(self, contactId: str, properties: dict[str, str]) -> dict[str, Any]:
         """
 
         Updates an individual contact by its record ID using a PATCH request to the "/crm/v3/objects/contacts/{contactId}" endpoint, requiring a JSON body with the fields to be updated.
@@ -4702,17 +4016,13 @@ class CrmApi(APISegmentBase):
             raise ValueError("Missing required parameter 'contactId'.")
         request_body_data = None
         request_body_data = {"properties": properties}
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/contacts/{contactId}"
         query_params = {}
         response = self._patch(url, data=request_body_data, params=query_params)
         return self._handle_response(response)
 
-    def merge_contacts(
-        self, objectIdToMerge: str, primaryObjectId: str
-    ) -> dict[str, Any]:
+    async def merge_contacts(self, objectIdToMerge: str, primaryObjectId: str) -> dict[str, Any]:
         """
 
         Merges two or more duplicate contact records into a single record in the CRM system, retaining the most relevant data while discarding redundant information.
@@ -4731,24 +4041,14 @@ class CrmApi(APISegmentBase):
             Public_Object
         """
         request_body_data = None
-        request_body_data = {
-            "objectIdToMerge": objectIdToMerge,
-            "primaryObjectId": primaryObjectId,
-        }
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {"objectIdToMerge": objectIdToMerge, "primaryObjectId": primaryObjectId}
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/contacts/merge"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def archive_contacts_batch_post(self, inputs: list[dict[str, Any]]) -> Any:
+    async def archive_contacts_batch_post(self, inputs: list[dict[str, Any]]) -> Any:
         """
 
         Archives a batch of contacts by ID using the HubSpot CRM API, returning a "204 No Content" response upon success.
@@ -4767,20 +4067,13 @@ class CrmApi(APISegmentBase):
         """
         request_body_data = None
         request_body_data = {"inputs": inputs}
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/contacts/batch/archive"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def create_contacts_batch(self, inputs: list[dict[str, Any]]) -> dict[str, Any]:
+    async def create_contacts_batch(self, inputs: list[dict[str, Any]]) -> dict[str, Any]:
         """
 
         Creates a batch of contacts in HubSpot using the CRM API, requiring a JSON payload and OAuth2 or private app authentication.
@@ -4799,20 +4092,13 @@ class CrmApi(APISegmentBase):
         """
         request_body_data = None
         request_body_data = {"inputs": inputs}
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/contacts/batch/create"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def batch_update_contacts(self, inputs: list[dict[str, Any]]) -> dict[str, Any]:
+    async def batch_update_contacts(self, inputs: list[dict[str, Any]]) -> dict[str, Any]:
         """
 
         Updates multiple contact records in a single request by providing their IDs or unique property values, overwriting specified properties in batch.
@@ -4831,22 +4117,13 @@ class CrmApi(APISegmentBase):
         """
         request_body_data = None
         request_body_data = {"inputs": inputs}
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/contacts/batch/update"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def delete_contact_gdpr_data(
-        self, objectId: str, idProperty: str | None = None
-    ) -> Any:
+    async def delete_contact_gdpr_data(self, objectId: str, idProperty: str | None = None) -> Any:
         """
 
         Permanently deletes a contact and all associated data from the CRM to comply with GDPR requirements.
@@ -4866,20 +4143,13 @@ class CrmApi(APISegmentBase):
         """
         request_body_data = None
         request_body_data = {"idProperty": idProperty, "objectId": objectId}
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/contacts/gdpr-delete"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def get_contacts(
+    async def get_contacts(
         self,
         limit: int | None = None,
         after: str | None = None,
@@ -4925,9 +4195,7 @@ class CrmApi(APISegmentBase):
         response = self._get(url, params=query_params)
         return self._handle_response(response)
 
-    def create_contact(
-        self, associations: list[dict[str, Any]], properties: dict[str, str]
-    ) -> dict[str, Any]:
+    async def create_contact(self, associations: list[dict[str, Any]], properties: dict[str, str]) -> dict[str, Any]:
         """
 
         Creates a new contact in the CRM system using the provided JSON data and returns a successful creation response.
@@ -4947,27 +4215,14 @@ class CrmApi(APISegmentBase):
         """
         request_body_data = None
         request_body_data = {"associations": associations, "properties": properties}
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/contacts"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def search_contacts_post(
-        self,
-        limit: int,
-        after: str,
-        sorts: list[str],
-        properties: list[str],
-        filterGroups: list[dict[str, Any]],
-        query: str | None = None,
+    async def search_contacts_post(
+        self, limit: int, after: str, sorts: list[str], properties: list[str], filterGroups: list[dict[str, Any]], query: str | None = None
     ) -> dict[str, Any]:
         """
 
@@ -4999,20 +4254,13 @@ class CrmApi(APISegmentBase):
             "properties": properties,
             "filterGroups": filterGroups,
         }
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/contacts/search"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def batch_read_feedback_submissions(
+    async def batch_read_feedback_submissions(
         self,
         propertiesWithHistory: list[str],
         inputs: list[dict[str, Any]],
@@ -5047,20 +4295,13 @@ class CrmApi(APISegmentBase):
             "inputs": inputs,
             "properties": properties,
         }
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/feedback_submissions/batch/read"
         query_params = {k: v for k, v in [("archived", archived)] if v is not None}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def get_feedback_submission_by_id(
+    async def get_feedback_submission_by_id(
         self,
         feedbackSubmissionId: str,
         properties: list[str] | None = None,
@@ -5107,7 +4348,7 @@ class CrmApi(APISegmentBase):
         response = self._get(url, params=query_params)
         return self._handle_response(response)
 
-    def delete_feedback_submission_by_id(self, feedbackSubmissionId: str) -> Any:
+    async def delete_feedback_submission_by_id(self, feedbackSubmissionId: str) -> Any:
         """
 
         Deletes a specific feedback submission identified by the provided `feedbackSubmissionId` from the CRM system.
@@ -5131,11 +4372,8 @@ class CrmApi(APISegmentBase):
         response = self._delete(url, params=query_params)
         return self._handle_response(response)
 
-    def patch_feedback_submission_by_id(
-        self,
-        feedbackSubmissionId: str,
-        properties: dict[str, str],
-        idProperty: str | None = None,
+    async def patch_feedback_submission_by_id(
+        self, feedbackSubmissionId: str, properties: dict[str, str], idProperty: str | None = None
     ) -> dict[str, Any]:
         """
 
@@ -5159,17 +4397,13 @@ class CrmApi(APISegmentBase):
             raise ValueError("Missing required parameter 'feedbackSubmissionId'.")
         request_body_data = None
         request_body_data = {"properties": properties}
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/feedback_submissions/{feedbackSubmissionId}"
         query_params = {k: v for k, v in [("idProperty", idProperty)] if v is not None}
         response = self._patch(url, data=request_body_data, params=query_params)
         return self._handle_response(response)
 
-    def merge_feedback_submissions(
-        self, objectIdToMerge: str, primaryObjectId: str
-    ) -> dict[str, Any]:
+    async def merge_feedback_submissions(self, objectIdToMerge: str, primaryObjectId: str) -> dict[str, Any]:
         """
 
         Merges feedback submission records using the POST method, requiring a JSON body and supporting OAuth2 and private apps for authentication.
@@ -5188,26 +4422,14 @@ class CrmApi(APISegmentBase):
             Public_Object
         """
         request_body_data = None
-        request_body_data = {
-            "objectIdToMerge": objectIdToMerge,
-            "primaryObjectId": primaryObjectId,
-        }
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
-        url = (
-            f"{self.main_app_client.base_url}/crm/v3/objects/feedback_submissions/merge"
-        )
+        request_body_data = {"objectIdToMerge": objectIdToMerge, "primaryObjectId": primaryObjectId}
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
+        url = f"{self.main_app_client.base_url}/crm/v3/objects/feedback_submissions/merge"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def archive_feedback_submissions_batch(self, inputs: list[dict[str, Any]]) -> Any:
+    async def archive_feedback_submissions_batch(self, inputs: list[dict[str, Any]]) -> Any:
         """
 
         Archives a batch of feedback submissions by ID using the HubSpot API and returns a status response with a 204 status code upon successful completion.
@@ -5226,22 +4448,13 @@ class CrmApi(APISegmentBase):
         """
         request_body_data = None
         request_body_data = {"inputs": inputs}
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/feedback_submissions/batch/archive"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def create_feedback_submissions_batch(
-        self, inputs: list[dict[str, Any]]
-    ) -> dict[str, Any]:
+    async def create_feedback_submissions_batch(self, inputs: list[dict[str, Any]]) -> dict[str, Any]:
         """
 
         Creates a batch of feedback submissions using the HubSpot API, allowing for the simultaneous creation of multiple feedback submissions.
@@ -5260,22 +4473,13 @@ class CrmApi(APISegmentBase):
         """
         request_body_data = None
         request_body_data = {"inputs": inputs}
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/feedback_submissions/batch/create"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def update_feedback_submissions_batch(
-        self, inputs: list[dict[str, Any]]
-    ) -> dict[str, Any]:
+    async def update_feedback_submissions_batch(self, inputs: list[dict[str, Any]]) -> dict[str, Any]:
         """
 
         Updates multiple feedback submissions in batches using the HubSpot CRM API.
@@ -5294,22 +4498,13 @@ class CrmApi(APISegmentBase):
         """
         request_body_data = None
         request_body_data = {"inputs": inputs}
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/feedback_submissions/batch/update"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def post_feedback_submissions_gdpr_delete(
-        self, objectId: str, idProperty: str | None = None
-    ) -> Any:
+    async def post_feedback_submissions_gdpr_delete(self, objectId: str, idProperty: str | None = None) -> Any:
         """
 
         Permanently deletes feedback submissions and associated data to comply with GDPR regulations using the provided JSON body.
@@ -5329,20 +4524,13 @@ class CrmApi(APISegmentBase):
         """
         request_body_data = None
         request_body_data = {"idProperty": idProperty, "objectId": objectId}
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/feedback_submissions/gdpr-delete"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def get_feedback_submissions(
+    async def get_feedback_submissions(
         self,
         limit: int | None = None,
         after: str | None = None,
@@ -5388,9 +4576,7 @@ class CrmApi(APISegmentBase):
         response = self._get(url, params=query_params)
         return self._handle_response(response)
 
-    def create_feedback_submission(
-        self, associations: list[dict[str, Any]], properties: dict[str, str]
-    ) -> dict[str, Any]:
+    async def create_feedback_submission(self, associations: list[dict[str, Any]], properties: dict[str, str]) -> dict[str, Any]:
         """
 
         Searches for feedback submissions using the HubSpot CRM API and returns relevant results.
@@ -5410,27 +4596,14 @@ class CrmApi(APISegmentBase):
         """
         request_body_data = None
         request_body_data = {"associations": associations, "properties": properties}
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/feedback_submissions"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def search_feedback_submissions(
-        self,
-        limit: int,
-        after: str,
-        sorts: list[str],
-        properties: list[str],
-        filterGroups: list[dict[str, Any]],
-        query: str | None = None,
+    async def search_feedback_submissions(
+        self, limit: int, after: str, sorts: list[str], properties: list[str], filterGroups: list[dict[str, Any]], query: str | None = None
     ) -> dict[str, Any]:
         """
 
@@ -5462,20 +4635,13 @@ class CrmApi(APISegmentBase):
             "properties": properties,
             "filterGroups": filterGroups,
         }
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/feedback_submissions/search"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def read_batch_objects(
+    async def read_batch_objects(
         self,
         objectType: str,
         propertiesWithHistory: list[str],
@@ -5514,20 +4680,13 @@ class CrmApi(APISegmentBase):
             "inputs": inputs,
             "properties": properties,
         }
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/{objectType}/batch/read"
         query_params = {k: v for k, v in [("archived", archived)] if v is not None}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def get_object_details(
+    async def get_object_details(
         self,
         objectType: str,
         objectId: str,
@@ -5578,7 +4737,7 @@ class CrmApi(APISegmentBase):
         response = self._get(url, params=query_params)
         return self._handle_response(response)
 
-    def delete_object_by_id(self, objectType: str, objectId: str) -> Any:
+    async def delete_object_by_id(self, objectType: str, objectId: str) -> Any:
         """
 
         Deletes a specified CRM object of the given type and ID using the DELETE method.
@@ -5605,12 +4764,8 @@ class CrmApi(APISegmentBase):
         response = self._delete(url, params=query_params)
         return self._handle_response(response)
 
-    def patch_object_by_id(
-        self,
-        objectType: str,
-        objectId: str,
-        properties: dict[str, str],
-        idProperty: str | None = None,
+    async def patch_object_by_id(
+        self, objectType: str, objectId: str, properties: dict[str, str], idProperty: str | None = None
     ) -> dict[str, Any]:
         """
 
@@ -5637,17 +4792,13 @@ class CrmApi(APISegmentBase):
             raise ValueError("Missing required parameter 'objectId'.")
         request_body_data = None
         request_body_data = {"properties": properties}
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/{objectType}/{objectId}"
         query_params = {k: v for k, v in [("idProperty", idProperty)] if v is not None}
         response = self._patch(url, data=request_body_data, params=query_params)
         return self._handle_response(response)
 
-    def merge_objects(
-        self, objectType: str, objectIdToMerge: str, primaryObjectId: str
-    ) -> dict[str, Any]:
+    async def merge_objects(self, objectType: str, objectIdToMerge: str, primaryObjectId: str) -> dict[str, Any]:
         """
 
         Merges duplicate records of a specified object type into a single record using the provided JSON body.
@@ -5669,26 +4820,14 @@ class CrmApi(APISegmentBase):
         if objectType is None:
             raise ValueError("Missing required parameter 'objectType'.")
         request_body_data = None
-        request_body_data = {
-            "objectIdToMerge": objectIdToMerge,
-            "primaryObjectId": primaryObjectId,
-        }
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {"objectIdToMerge": objectIdToMerge, "primaryObjectId": primaryObjectId}
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/{objectType}/merge"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def archive_batch_objects_by_type(
-        self, objectType: str, inputs: list[dict[str, Any]]
-    ) -> Any:
+    async def archive_batch_objects_by_type(self, objectType: str, inputs: list[dict[str, Any]]) -> Any:
         """
 
         Archives a batch of objects of a specified type in CRM using the POST method, requiring a JSON body and returning a 204 status code upon successful archiving.
@@ -5710,24 +4849,13 @@ class CrmApi(APISegmentBase):
             raise ValueError("Missing required parameter 'objectType'.")
         request_body_data = None
         request_body_data = {"inputs": inputs}
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
-        url = (
-            f"{self.main_app_client.base_url}/crm/v3/objects/{objectType}/batch/archive"
-        )
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
+        url = f"{self.main_app_client.base_url}/crm/v3/objects/{objectType}/batch/archive"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def batch_create_object_records(
-        self, objectType: str, inputs: list[dict[str, Any]]
-    ) -> dict[str, Any]:
+    async def batch_create_object_records(self, objectType: str, inputs: list[dict[str, Any]]) -> dict[str, Any]:
         """
 
         Creates multiple records of a specified object type in a CRM system using a single POST request, supporting batch creation and returning a status message based on the outcome.
@@ -5749,24 +4877,13 @@ class CrmApi(APISegmentBase):
             raise ValueError("Missing required parameter 'objectType'.")
         request_body_data = None
         request_body_data = {"inputs": inputs}
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
-        url = (
-            f"{self.main_app_client.base_url}/crm/v3/objects/{objectType}/batch/create"
-        )
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
+        url = f"{self.main_app_client.base_url}/crm/v3/objects/{objectType}/batch/create"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def update_batch_object(
-        self, objectType: str, inputs: list[dict[str, Any]]
-    ) -> dict[str, Any]:
+    async def update_batch_object(self, objectType: str, inputs: list[dict[str, Any]]) -> dict[str, Any]:
         """
 
         Updates multiple records of a specified object type in a CRM system using a batch operation via the POST method.
@@ -5788,24 +4905,13 @@ class CrmApi(APISegmentBase):
             raise ValueError("Missing required parameter 'objectType'.")
         request_body_data = None
         request_body_data = {"inputs": inputs}
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
-        url = (
-            f"{self.main_app_client.base_url}/crm/v3/objects/{objectType}/batch/update"
-        )
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
+        url = f"{self.main_app_client.base_url}/crm/v3/objects/{objectType}/batch/update"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def gdpr_delete_object(
-        self, objectType: str, objectId: str, idProperty: str | None = None
-    ) -> Any:
+    async def gdpr_delete_object(self, objectType: str, objectId: str, idProperty: str | None = None) -> Any:
         """
 
         Permanently deletes an object of the specified type from the CRM, adhering to GDPR guidelines for data removal, using the "POST" method with the object type specified in the path and additional details in the request body.
@@ -5828,20 +4934,13 @@ class CrmApi(APISegmentBase):
             raise ValueError("Missing required parameter 'objectType'.")
         request_body_data = None
         request_body_data = {"idProperty": idProperty, "objectId": objectId}
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/{objectType}/gdpr-delete"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def list_objects_by_type(
+    async def list_objects_by_type(
         self,
         objectType: str,
         limit: int | None = None,
@@ -5891,11 +4990,8 @@ class CrmApi(APISegmentBase):
         response = self._get(url, params=query_params)
         return self._handle_response(response)
 
-    def create_object_by_type(
-        self,
-        objectType: str,
-        associations: list[dict[str, Any]],
-        properties: dict[str, str],
+    async def create_object_by_type(
+        self, objectType: str, associations: list[dict[str, Any]], properties: dict[str, str]
     ) -> dict[str, Any]:
         """
 
@@ -5919,20 +5015,13 @@ class CrmApi(APISegmentBase):
             raise ValueError("Missing required parameter 'objectType'.")
         request_body_data = None
         request_body_data = {"associations": associations, "properties": properties}
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/{objectType}"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def search_objects_by_type_post(
+    async def search_objects_by_type_post(
         self,
         objectType: str,
         limit: int,
@@ -5975,20 +5064,13 @@ class CrmApi(APISegmentBase):
             "properties": properties,
             "filterGroups": filterGroups,
         }
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/{objectType}/search"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def get_video_conferencing_settings_by_app_id(self, appId: str) -> dict[str, Any]:
+    async def get_video_conferencing_settings_by_app_id(self, appId: str) -> dict[str, Any]:
         """
 
         Retrieves the video conferencing settings for a specific application identified by the provided appId using the HubSpot API.
@@ -6012,7 +5094,7 @@ class CrmApi(APISegmentBase):
         response = self._get(url, params=query_params)
         return self._handle_response(response)
 
-    def update_video_conferencing_settings_by_app_id(
+    async def update_video_conferencing_settings_by_app_id(
         self,
         appId: str,
         createMeetingUrl: str,
@@ -6052,20 +5134,13 @@ class CrmApi(APISegmentBase):
             "updateMeetingUrl": updateMeetingUrl,
             "deleteMeetingUrl": deleteMeetingUrl,
         }
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/extensions/videoconferencing/settings/{appId}"
         query_params = {}
-        response = self._put(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._put(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def delete_video_conf_settings_by_app_id(self, appId: str) -> Any:
+    async def delete_video_conf_settings_by_app_id(self, appId: str) -> Any:
         """
 
         Deletes the video conferencing settings for the specified app identified by the appId.
@@ -6089,7 +5164,7 @@ class CrmApi(APISegmentBase):
         response = self._delete(url, params=query_params)
         return self._handle_response(response)
 
-    def batch_read_tickets_post(
+    async def batch_read_tickets_post(
         self,
         propertiesWithHistory: list[str],
         inputs: list[dict[str, Any]],
@@ -6124,20 +5199,13 @@ class CrmApi(APISegmentBase):
             "inputs": inputs,
             "properties": properties,
         }
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/tickets/batch/read"
         query_params = {k: v for k, v in [("archived", archived)] if v is not None}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def get_ticket_by_id(
+    async def get_ticket_by_id(
         self,
         ticketId: str,
         properties: list[str] | None = None,
@@ -6184,7 +5252,7 @@ class CrmApi(APISegmentBase):
         response = self._get(url, params=query_params)
         return self._handle_response(response)
 
-    def delete_ticket_by_id(self, ticketId: str) -> Any:
+    async def delete_ticket_by_id(self, ticketId: str) -> Any:
         """
 
         Deletes a ticket by its ID using the CRM API.
@@ -6208,12 +5276,7 @@ class CrmApi(APISegmentBase):
         response = self._delete(url, params=query_params)
         return self._handle_response(response)
 
-    def update_ticket(
-        self,
-        ticketId: str,
-        properties: dict[str, str],
-        idProperty: str | None = None,
-    ) -> dict[str, Any]:
+    async def update_ticket(self, ticketId: str, properties: dict[str, str], idProperty: str | None = None) -> dict[str, Any]:
         """
 
         Updates an individual ticket by its ID using the HubSpot CRM API, allowing modification of specific fields via a JSON payload.
@@ -6236,17 +5299,13 @@ class CrmApi(APISegmentBase):
             raise ValueError("Missing required parameter 'ticketId'.")
         request_body_data = None
         request_body_data = {"properties": properties}
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/tickets/{ticketId}"
         query_params = {k: v for k, v in [("idProperty", idProperty)] if v is not None}
         response = self._patch(url, data=request_body_data, params=query_params)
         return self._handle_response(response)
 
-    def merge_tickets(
-        self, objectIdToMerge: str, primaryObjectId: str
-    ) -> dict[str, Any]:
+    async def merge_tickets(self, objectIdToMerge: str, primaryObjectId: str) -> dict[str, Any]:
         """
 
         Merges two or more tickets into a single ticket in the CRM system using the POST method, allowing for the consolidation of related customer service requests.
@@ -6265,24 +5324,14 @@ class CrmApi(APISegmentBase):
             Public_Object
         """
         request_body_data = None
-        request_body_data = {
-            "objectIdToMerge": objectIdToMerge,
-            "primaryObjectId": primaryObjectId,
-        }
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {"objectIdToMerge": objectIdToMerge, "primaryObjectId": primaryObjectId}
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/tickets/merge"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def archive_tickets_batch_post(self, inputs: list[dict[str, Any]]) -> Any:
+    async def archive_tickets_batch_post(self, inputs: list[dict[str, Any]]) -> Any:
         """
 
         Archives a batch of tickets by ID using the HubSpot API and returns a status message.
@@ -6301,20 +5350,13 @@ class CrmApi(APISegmentBase):
         """
         request_body_data = None
         request_body_data = {"inputs": inputs}
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/tickets/batch/archive"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def create_tickets_batch(self, inputs: list[dict[str, Any]]) -> dict[str, Any]:
+    async def create_tickets_batch(self, inputs: list[dict[str, Any]]) -> dict[str, Any]:
         """
 
         Creates a batch of tickets in the CRM using the HubSpot API and returns a status message.
@@ -6333,20 +5375,13 @@ class CrmApi(APISegmentBase):
         """
         request_body_data = None
         request_body_data = {"inputs": inputs}
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/tickets/batch/create"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def update_tickets_batch(self, inputs: list[dict[str, Any]]) -> dict[str, Any]:
+    async def update_tickets_batch(self, inputs: list[dict[str, Any]]) -> dict[str, Any]:
         """
 
         Updates multiple tickets in a single request using the HubSpot CRM API, returning a status message indicating the success or partial success of the operation.
@@ -6365,22 +5400,13 @@ class CrmApi(APISegmentBase):
         """
         request_body_data = None
         request_body_data = {"inputs": inputs}
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/tickets/batch/update"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def delete_ticket_gdpr(
-        self, objectId: str, idProperty: str | None = None
-    ) -> Any:
+    async def delete_ticket_gdpr(self, objectId: str, idProperty: str | None = None) -> Any:
         """
 
         Permanently deletes a ticket and associated data in compliance with GDPR guidelines using the POST method.
@@ -6400,20 +5426,13 @@ class CrmApi(APISegmentBase):
         """
         request_body_data = None
         request_body_data = {"idProperty": idProperty, "objectId": objectId}
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/tickets/gdpr-delete"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def get_tickets(
+    async def get_tickets(
         self,
         limit: int | None = None,
         after: str | None = None,
@@ -6459,9 +5478,7 @@ class CrmApi(APISegmentBase):
         response = self._get(url, params=query_params)
         return self._handle_response(response)
 
-    def create_ticket(
-        self, associations: list[dict[str, Any]], properties: dict[str, str]
-    ) -> dict[str, Any]:
+    async def create_ticket(self, associations: list[dict[str, Any]], properties: dict[str, str]) -> dict[str, Any]:
         """
 
         Creates a new ticket object in the CRM using the HubSpot API, allowing for the management of customer service requests.
@@ -6481,27 +5498,14 @@ class CrmApi(APISegmentBase):
         """
         request_body_data = None
         request_body_data = {"associations": associations, "properties": properties}
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/tickets"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def search_tickets_post(
-        self,
-        limit: int,
-        after: str,
-        sorts: list[str],
-        properties: list[str],
-        filterGroups: list[dict[str, Any]],
-        query: str | None = None,
+    async def search_tickets_post(
+        self, limit: int, after: str, sorts: list[str], properties: list[str], filterGroups: list[dict[str, Any]], query: str | None = None
     ) -> dict[str, Any]:
         """
 
@@ -6533,20 +5537,13 @@ class CrmApi(APISegmentBase):
             "properties": properties,
             "filterGroups": filterGroups,
         }
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/tickets/search"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def batch_read_line_items_post(
+    async def batch_read_line_items_post(
         self,
         propertiesWithHistory: list[str],
         inputs: list[dict[str, Any]],
@@ -6581,20 +5578,13 @@ class CrmApi(APISegmentBase):
             "inputs": inputs,
             "properties": properties,
         }
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/line_items/batch/read"
         query_params = {k: v for k, v in [("archived", archived)] if v is not None}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def get_line_item_by_id(
+    async def get_line_item_by_id(
         self,
         lineItemId: str,
         properties: list[str] | None = None,
@@ -6641,7 +5631,7 @@ class CrmApi(APISegmentBase):
         response = self._get(url, params=query_params)
         return self._handle_response(response)
 
-    def delete_line_item_by_id(self, lineItemId: str) -> Any:
+    async def delete_line_item_by_id(self, lineItemId: str) -> Any:
         """
 
         Deletes a line item from HubSpot CRM using its ID, requiring the "crm.objects.line_items.write" permission.
@@ -6665,12 +5655,7 @@ class CrmApi(APISegmentBase):
         response = self._delete(url, params=query_params)
         return self._handle_response(response)
 
-    def patch_line_item_by_id(
-        self,
-        lineItemId: str,
-        properties: dict[str, str],
-        idProperty: str | None = None,
-    ) -> dict[str, Any]:
+    async def patch_line_item_by_id(self, lineItemId: str, properties: dict[str, str], idProperty: str | None = None) -> dict[str, Any]:
         """
 
         Updates properties of a specific line item in the CRM system using a partial JSON patch request.
@@ -6693,17 +5678,13 @@ class CrmApi(APISegmentBase):
             raise ValueError("Missing required parameter 'lineItemId'.")
         request_body_data = None
         request_body_data = {"properties": properties}
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/line_items/{lineItemId}"
         query_params = {k: v for k, v in [("idProperty", idProperty)] if v is not None}
         response = self._patch(url, data=request_body_data, params=query_params)
         return self._handle_response(response)
 
-    def merge_line_items_post(
-        self, objectIdToMerge: str, primaryObjectId: str
-    ) -> dict[str, Any]:
+    async def merge_line_items_post(self, objectIdToMerge: str, primaryObjectId: str) -> dict[str, Any]:
         """
 
         Merges duplicate line items into a single instance using the specified parameters via the POST method.
@@ -6722,24 +5703,14 @@ class CrmApi(APISegmentBase):
             Public_Object
         """
         request_body_data = None
-        request_body_data = {
-            "objectIdToMerge": objectIdToMerge,
-            "primaryObjectId": primaryObjectId,
-        }
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {"objectIdToMerge": objectIdToMerge, "primaryObjectId": primaryObjectId}
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/line_items/merge"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def archive_line_items_batch_post(self, inputs: list[dict[str, Any]]) -> Any:
+    async def archive_line_items_batch_post(self, inputs: list[dict[str, Any]]) -> Any:
         """
 
         Archives a batch of line items by their IDs in the CRM using a POST request.
@@ -6758,20 +5729,13 @@ class CrmApi(APISegmentBase):
         """
         request_body_data = None
         request_body_data = {"inputs": inputs}
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/line_items/batch/archive"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def create_line_items_batch(self, inputs: list[dict[str, Any]]) -> dict[str, Any]:
+    async def create_line_items_batch(self, inputs: list[dict[str, Any]]) -> dict[str, Any]:
         """
 
         Creates a batch of line items using the HubSpot API and returns a status message upon successful creation.
@@ -6790,20 +5754,13 @@ class CrmApi(APISegmentBase):
         """
         request_body_data = None
         request_body_data = {"inputs": inputs}
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/line_items/batch/create"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def batch_update_line_items(self, inputs: list[dict[str, Any]]) -> dict[str, Any]:
+    async def batch_update_line_items(self, inputs: list[dict[str, Any]]) -> dict[str, Any]:
         """
 
         Updates a batch of line items using their internal IDs or unique property values via the POST method, requiring authentication with the "crm.objects.line_items.write" scope.
@@ -6822,22 +5779,13 @@ class CrmApi(APISegmentBase):
         """
         request_body_data = None
         request_body_data = {"inputs": inputs}
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/line_items/batch/update"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def gdpr_delete_line_items(
-        self, objectId: str, idProperty: str | None = None
-    ) -> Any:
+    async def gdpr_delete_line_items(self, objectId: str, idProperty: str | None = None) -> Any:
         """
 
         Deletes line item records from the CRM to comply with GDPR requirements, using the POST method with OAuth2 or private app authentication.
@@ -6857,20 +5805,13 @@ class CrmApi(APISegmentBase):
         """
         request_body_data = None
         request_body_data = {"idProperty": idProperty, "objectId": objectId}
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/line_items/gdpr-delete"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def list_line_items(
+    async def list_line_items(
         self,
         limit: int | None = None,
         after: str | None = None,
@@ -6916,9 +5857,7 @@ class CrmApi(APISegmentBase):
         response = self._get(url, params=query_params)
         return self._handle_response(response)
 
-    def create_line_item(
-        self, associations: list[dict[str, Any]], properties: dict[str, str]
-    ) -> dict[str, Any]:
+    async def create_line_item(self, associations: list[dict[str, Any]], properties: dict[str, str]) -> dict[str, Any]:
         """
 
         Creates a new line item in HubSpot CRM using the POST method, allowing you to add products or services to deals and quotes.
@@ -6938,27 +5877,14 @@ class CrmApi(APISegmentBase):
         """
         request_body_data = None
         request_body_data = {"associations": associations, "properties": properties}
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/line_items"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def search_line_items(
-        self,
-        limit: int,
-        after: str,
-        sorts: list[str],
-        properties: list[str],
-        filterGroups: list[dict[str, Any]],
-        query: str | None = None,
+    async def search_line_items(
+        self, limit: int, after: str, sorts: list[str], properties: list[str], filterGroups: list[dict[str, Any]], query: str | None = None
     ) -> dict[str, Any]:
         """
 
@@ -6990,25 +5916,13 @@ class CrmApi(APISegmentBase):
             "properties": properties,
             "filterGroups": filterGroups,
         }
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
         url = f"{self.main_app_client.base_url}/crm/v3/objects/line_items/search"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = self._post(url, data=request_body_data, params=query_params, content_type="application/json")
         return self._handle_response(response)
 
-    def get_crm_imports(
-        self,
-        after: str | None = None,
-        before: str | None = None,
-        limit: int | None = None,
-    ) -> dict[str, Any]:
+    async def get_crm_imports(self, after: str | None = None, before: str | None = None, limit: int | None = None) -> dict[str, Any]:
         """
 
         Retrieves a list of CRM import operations using the HubSpot API, allowing optional filtering by date and limit on the number of results returned.
@@ -7028,17 +5942,11 @@ class CrmApi(APISegmentBase):
             Core
         """
         url = f"{self.main_app_client.base_url}/crm/v3/imports"
-        query_params = {
-            k: v
-            for k, v in [("after", after), ("before", before), ("limit", limit)]
-            if v is not None
-        }
+        query_params = {k: v for k, v in [("after", after), ("before", before), ("limit", limit)] if v is not None}
         response = self._get(url, params=query_params)
         return self._handle_response(response)
 
-    def create_crm_import(
-        self, files: bytes | None = None, importRequest: str | None = None
-    ) -> dict[str, Any]:
+    async def create_crm_import(self, files: bytes | None = None, importRequest: str | None = None) -> dict[str, Any]:
         """
 
         Imports data into a HubSpot CRM using a POST request with a multipart/form-data payload, allowing bulk creation or update of records via uploaded files such as CSV or Excel.
@@ -7069,21 +5977,11 @@ class CrmApi(APISegmentBase):
             files_data = None
         url = f"{self.main_app_client.base_url}/crm/v3/imports"
         query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            files=files_data,
-            params=query_params,
-            content_type="multipart/form-data",
-        )
+        response = self._post(url, data=request_body_data, files=files_data, params=query_params, content_type="multipart/form-data")
         return self._handle_response(response)
 
-    def get_owners_list(
-        self,
-        email: str | None = None,
-        after: str | None = None,
-        limit: int | None = None,
-        archived: bool | None = None,
+    async def get_owners_list(
+        self, email: str | None = None, after: str | None = None, limit: int | None = None, archived: bool | None = None
     ) -> dict[str, Any]:
         """
 
@@ -7105,22 +6003,11 @@ class CrmApi(APISegmentBase):
             Owners
         """
         url = f"{self.main_app_client.base_url}/crm/v3/owners"
-        query_params = {
-            k: v
-            for k, v in [
-                ("email", email),
-                ("after", after),
-                ("limit", limit),
-                ("archived", archived),
-            ]
-            if v is not None
-        }
+        query_params = {k: v for k, v in [("email", email), ("after", after), ("limit", limit), ("archived", archived)] if v is not None}
         response = self._get(url, params=query_params)
         return self._handle_response(response)
 
-    def get_association_types_by_object_types(
-        self, fromObjectType: str, toObjectType: str
-    ) -> dict[str, Any]:
+    async def get_association_types_by_object_types(self, fromObjectType: str, toObjectType: str) -> dict[str, Any]:
         """
 
         Retrieves the association types between two specified object types in HubSpot CRM using the "GET" method.