pyegeria 0.6.8__py3-none-any.whl → 0.7.0__py3-none-any.whl

pyegeria/classification_manager_omvs.py

@@ -17,11 +17,6 @@ from pyegeria._client import Client, max_paging_size
 from pyegeria._globals import enable_ssl_check, default_time_out
 
 
-def jprint(info, comment=None):
-    if comment:
-        print(comment)
-    print(json.dumps(info, indent=2))
-
 
 def query_seperator(current_string):
     if current_string == "":
@@ -113,19 +108,19 @@ class ClassificationManager(Client):
     """
 
     def __init__(self, server_name: str, platform_url: str, token: str = None, user_id: str = None,
-            user_pwd: str = None, verify_flag: bool = enable_ssl_check, sync_mode: bool = True, ):
+                 user_pwd: str = None, verify_flag: bool = enable_ssl_check, sync_mode: bool = True, ):
         self.admin_command_root: str
         Client.__init__(self, server_name, platform_url, user_id=user_id, user_pwd=user_pwd, token=token,
-            async_mode=sync_mode, )
+                        async_mode=sync_mode, )
 
     #
     #   Get elements
     #
 
-
     async def _async_get_elements(self, open_metadata_type_name: str = None, effective_time: str = None,
-            for_lineage: bool = None, for_duplicate_processing: bool = None, start_from: int = 0,
-            page_size: int = max_paging_size, server_name: str = None, time_out: int = default_time_out) -> list | str:
+                                  for_lineage: bool = None, for_duplicate_processing: bool = None, start_from: int = 0,
+                                  page_size: int = max_paging_size, server_name: str = None,
+                                  time_out: int = default_time_out) -> list | str:
         """
         Retrieve elements of the requested type name. If no type name is specified, then any type of element may
         be returned.
@@ -170,10 +165,10 @@ class ClassificationManager(Client):
 
         possible_query_params = query_string(
             [("startFrom", start_from), ("pageSize", page_size), ("forLineage", for_lineage),
-                ("forDuplicateProcessing", for_duplicate_processing)])
+             ("forDuplicateProcessing", for_duplicate_processing)])
 
         body = {"class": "FindProperties", "openMetadataTypeName": open_metadata_type_name,
-            "effectiveTime": effective_time, }
+                "effectiveTime": effective_time, }
 
         url = f"{base_path(self, server_name)}/elements/by-type{possible_query_params}"
         response: Response = await self._async_make_request("POST", url, body_slimmer(body), time_out=time_out)
@@ -184,8 +179,8 @@ class ClassificationManager(Client):
         return elements
 
     def get_elements(self, open_metadata_type_name: str = None, effective_time: str = None, for_lineage: bool = None,
-            for_duplicate_processing: bool = None, start_from: int = 0, page_size: int = max_paging_size,
-            server_name: str = None, time_out: int = default_time_out) -> list | str:
+                     for_duplicate_processing: bool = None, start_from: int = 0, page_size: int = max_paging_size,
+                     server_name: str = None, time_out: int = default_time_out) -> list | str:
         """
         Retrieve elements of the requested type name. If no type name is specified, then any type of element may
         be returned.
@@ -229,13 +224,15 @@ class ClassificationManager(Client):
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
             self._async_get_elements(open_metadata_type_name, effective_time, for_lineage, for_duplicate_processing,
-                start_from, page_size, server_name, time_out))
+                                     start_from, page_size, server_name, time_out))
         return response
 
     async def _async_get_elements_by_property_value(self, property_value: str, property_names: [str],
-            open_metadata_type_name: str = None, effective_time: str = None, for_lineage: bool = None,
-            for_duplicate_processing: bool = None, start_from: int = 0, page_size: int = max_paging_size,
-            server_name: str = None, time_out: int = default_time_out) -> list | str:
+                                                    open_metadata_type_name: str = None, effective_time: str = None,
+                                                    for_lineage: bool = None, for_duplicate_processing: bool = None,
+                                                    start_from: int = 0, page_size: int = max_paging_size,
+                                                    server_name: str = None,
+                                                    time_out: int = default_time_out) -> list | str:
         """
         Retrieve elements by a value found in one of the properties specified.  The value must match exactly.
         An open metadata type name may be supplied to restrict the results. Async version.
@@ -284,10 +281,10 @@ class ClassificationManager(Client):
 
         possible_query_params = query_string(
             [("startFrom", start_from), ("pageSize", page_size), ("forLineage", for_lineage),
-                ("forDuplicateProcessing", for_duplicate_processing)])
+             ("forDuplicateProcessing", for_duplicate_processing)])
 
         body = {"class": "FindPropertyNamesProperties", "openMetadataTypeName": open_metadata_type_name,
-            "propertyValue": property_value, "propertyNames": property_names, "effectiveTime": effective_time, }
+                "propertyValue": property_value, "propertyNames": property_names, "effectiveTime": effective_time, }
 
         url = f"{base_path(self, server_name)}/elements/by-exact-property-value{possible_query_params}"
 
@@ -300,9 +297,10 @@ class ClassificationManager(Client):
         return elements
 
     def get_elements_by_property_value(self, property_value: str, property_names: [str],
-            open_metadata_type_name: str = None, effective_time: str = None, for_lineage: bool = None,
-            for_duplicate_processing: bool = None, start_from: int = 0, page_size: int = max_paging_size,
-            server_name: str = None, time_out: int = default_time_out) -> list | str:
+                                       open_metadata_type_name: str = None, effective_time: str = None,
+                                       for_lineage: bool = None, for_duplicate_processing: bool = None,
+                                       start_from: int = 0, page_size: int = max_paging_size, server_name: str = None,
+                                       time_out: int = default_time_out) -> list | str:
         """
         Retrieve elements by a value found in one of the properties specified.  The value must match exactly.
         An open metadata type name may be supplied to restrict the results.
@@ -350,13 +348,16 @@ class ClassificationManager(Client):
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
             self._async_get_elements_by_property_value(property_value, property_names, open_metadata_type_name,
-                effective_time, for_lineage, for_duplicate_processing, start_from, page_size, server_name, time_out))
+                                                       effective_time, for_lineage, for_duplicate_processing,
+                                                       start_from, page_size, server_name, time_out))
         return response
 
     async def _async_find_elements_by_property_value(self, property_value: str, property_names: [str],
-            open_metadata_type_name: str = None, effective_time: str = None, for_lineage: bool = None,
-            for_duplicate_processing: bool = None, start_from: int = 0, page_size: int = max_paging_size,
-            server_name: str = None, time_out: int = default_time_out) -> list | str:
+                                                     open_metadata_type_name: str = None, effective_time: str = None,
+                                                     for_lineage: bool = None, for_duplicate_processing: bool = None,
+                                                     start_from: int = 0, page_size: int = max_paging_size,
+                                                     server_name: str = None,
+                                                     time_out: int = default_time_out) -> list | str:
         """
         Retrieve elements by a value found in one of the properties specified.  The value must be contained in the
         properties rather than needing to be an exact match. An open metadata type name may be supplied to restrict
@@ -406,10 +407,10 @@ class ClassificationManager(Client):
 
         possible_query_params = query_string(
             [("startFrom", start_from), ("pageSize", page_size), ("forLineage", for_lineage),
-                ("forDuplicateProcessing", for_duplicate_processing)])
+             ("forDuplicateProcessing", for_duplicate_processing)])
 
         body = {"class": "FindPropertyNamesProperties", "openMetadataTypeName": open_metadata_type_name,
-            "propertyValue": property_value, "propertyNames": property_names, "effectiveTime": effective_time, }
+                "propertyValue": property_value, "propertyNames": property_names, "effectiveTime": effective_time, }
 
         url = f"{base_path(self, server_name)}/elements/by-property-value-search{possible_query_params}"
         response: Response = await self._async_make_request("POST", url, body_slimmer(body), time_out=time_out)
@@ -420,9 +421,10 @@ class ClassificationManager(Client):
         return elements
 
     def find_elements_by_property_value(self, property_value: str, property_names: [str],
-            open_metadata_type_name: str = None, effective_time: str = None, for_lineage: bool = None,
-            for_duplicate_processing: bool = None, start_from: int = 0, page_size: int = max_paging_size,
-            server_name: str = None, time_out: int = default_time_out) -> list | str:
+                                        open_metadata_type_name: str = None, effective_time: str = None,
+                                        for_lineage: bool = None, for_duplicate_processing: bool = None,
+                                        start_from: int = 0, page_size: int = max_paging_size, server_name: str = None,
+                                        time_out: int = default_time_out) -> list | str:
         """
         Retrieve elements by a value found in one of the properties specified.  The value must be contained in the
         properties rather than needing to be an exact match. An open metadata type name may be supplied to restrict
@@ -471,16 +473,18 @@ class ClassificationManager(Client):
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
             self._async_find_elements_by_property_value(property_value, property_names, open_metadata_type_name,
-                effective_time, for_lineage, for_duplicate_processing, start_from, page_size, server_name, time_out))
+                                                        effective_time, for_lineage, for_duplicate_processing,
+                                                        start_from, page_size, server_name, time_out))
         return response
 
     #
     # Elements by classification
     #
     async def _async_get_elements_by_classification(self, classification_name: str, open_metadata_type_name: str = None,
-            effective_time: str = None, for_lineage: bool = None, for_duplicate_processing: bool = None,
-            start_from: int = 0, page_size: int = max_paging_size, server_name: str = None,
-            time_out: int = default_time_out) -> list | str:
+                                                    effective_time: str = None, for_lineage: bool = None,
+                                                    for_duplicate_processing: bool = None, start_from: int = 0,
+                                                    page_size: int = max_paging_size, server_name: str = None,
+                                                    time_out: int = default_time_out) -> list | str:
         """
          Retrieve elements with the requested classification name. It is also possible to limit the results
         by specifying a type name for the elements that should be returned. If no type name is specified then
@@ -528,10 +532,10 @@ class ClassificationManager(Client):
 
         possible_query_params = query_string(
             [("startFrom", start_from), ("pageSize", page_size), ("forLineage", for_lineage),
-                ("forDuplicateProcessing", for_duplicate_processing)])
+             ("forDuplicateProcessing", for_duplicate_processing)])
 
         body = {"class": "FindProperties", "openMetadataTypeName": open_metadata_type_name,
-            "effectiveTime": effective_time, }
+                "effectiveTime": effective_time, }
 
         url = (f"{base_path(self, server_name)}/elements/by-classification/{classification_name}"
                f"{possible_query_params}")
@@ -543,9 +547,10 @@ class ClassificationManager(Client):
         return elements
 
     def get_elements_by_classification(self, classification_name: str, open_metadata_type_name: str = None,
-            effective_time: str = None, for_lineage: bool = None, for_duplicate_processing: bool = None,
-            start_from: int = 0, page_size: int = max_paging_size, server_name: str = None,
-            time_out: int = default_time_out) -> list | str:
+                                       effective_time: str = None, for_lineage: bool = None,
+                                       for_duplicate_processing: bool = None, start_from: int = 0,
+                                       page_size: int = max_paging_size, server_name: str = None,
+                                       time_out: int = default_time_out) -> list | str:
         """
         Retrieve elements with the requested classification name. It is also possible to limit the results
         by specifying a type name for the elements that should be returned. If no type name is specified then
@@ -592,13 +597,20 @@ class ClassificationManager(Client):
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
             self._async_get_elements_by_classification(classification_name, open_metadata_type_name, effective_time,
-                for_lineage, for_duplicate_processing, start_from, page_size, server_name, time_out))
+                                                       for_lineage, for_duplicate_processing, start_from, page_size,
+                                                       server_name, time_out))
         return response
 
     async def _async_get_elements_by_classification_with_property_value(self, classification_name: str,
-            property_value: str, property_names: [str], open_metadata_type_name: str = None, effective_time: str = None,
-            for_lineage: bool = None, for_duplicate_processing: bool = None, start_from: int = 0,
-            page_size: int = max_paging_size, server_name: str = None, time_out: int = default_time_out) -> list | str:
+                                                                        property_value: str, property_names: [str],
+                                                                        open_metadata_type_name: str = None,
+                                                                        effective_time: str = None,
+                                                                        for_lineage: bool = None,
+                                                                        for_duplicate_processing: bool = None,
+                                                                        start_from: int = 0,
+                                                                        page_size: int = max_paging_size,
+                                                                        server_name: str = None,
+                                                                        time_out: int = default_time_out) -> list | str:
         """
        Retrieve elements with the requested classification name and with the requested a value found in one of the
        classification's properties specified.  The value must match exactly. An open metadata type name may be supplied
@@ -650,10 +662,10 @@ class ClassificationManager(Client):
 
         possible_query_params = query_string(
             [("startFrom", start_from), ("pageSize", page_size), ("forLineage", for_lineage),
-                ("forDuplicateProcessing", for_duplicate_processing)])
+             ("forDuplicateProcessing", for_duplicate_processing)])
 
         body = {"class": "FindPropertyNamesProperties", "openMetadataTypeName": open_metadata_type_name,
-            "propertyValue": property_value, "propertyNames": property_names, "effectiveTime": effective_time, }
+                "propertyValue": property_value, "propertyNames": property_names, "effectiveTime": effective_time, }
 
         url = (f"{base_path(self, server_name)}/elements/by-classification/{classification_name}/"
                f"with-exact-property-value{possible_query_params}")
@@ -665,9 +677,11 @@ class ClassificationManager(Client):
         return elements
 
     def get_elements_by_classification_with_property_value(self, classification_name: str, property_value: str,
-            property_names: [str], open_metadata_type_name: str = None, effective_time: str = None,
-            for_lineage: bool = None, for_duplicate_processing: bool = None, start_from: int = 0,
-            page_size: int = max_paging_size, server_name: str = None, time_out: int = default_time_out) -> list | str:
+                                                           property_names: [str], open_metadata_type_name: str = None,
+                                                           effective_time: str = None, for_lineage: bool = None,
+                                                           for_duplicate_processing: bool = None, start_from: int = 0,
+                                                           page_size: int = max_paging_size, server_name: str = None,
+                                                           time_out: int = default_time_out) -> list | str:
         """
         Retrieve elements by a value found in one of the properties specified.  The value must match exactly.
         An open metadata type name may be supplied to restrict the results.
@@ -717,14 +731,22 @@ class ClassificationManager(Client):
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
             self._async_get_elements_by_classification_with_property_value(classification_name, property_value,
-                property_names, open_metadata_type_name, effective_time, for_lineage, for_duplicate_processing,
-                start_from, page_size, server_name, time_out))
+                                                                           property_names, open_metadata_type_name,
+                                                                           effective_time, for_lineage,
+                                                                           for_duplicate_processing, start_from,
+                                                                           page_size, server_name, time_out))
         return response
 
     async def _async_find_elements_by_classification_with_property_value(self, classification_name: str,
-            property_value: str, property_names: [str], open_metadata_type_name: str = None, effective_time: str = None,
-            for_lineage: bool = None, for_duplicate_processing: bool = None, start_from: int = 0,
-            page_size: int = max_paging_size, server_name: str = None, time_out: int = default_time_out) -> list | str:
+                                                                         property_value: str, property_names: [str],
+                                                                         open_metadata_type_name: str = None,
+                                                                         effective_time: str = None,
+                                                                         for_lineage: bool = None,
+                                                                         for_duplicate_processing: bool = None,
+                                                                         start_from: int = 0,
+                                                                         page_size: int = max_paging_size,
+                                                                         server_name: str = None,
+                                                                         time_out: int = default_time_out) -> list | str:
         """
         Retrieve elements with the requested classification name and with the requested value found in
         one of the classification's properties specified.  The value must only be contained in the
@@ -777,10 +799,10 @@ class ClassificationManager(Client):
 
         possible_query_params = query_string(
             [("startFrom", start_from), ("pageSize", page_size), ("forLineage", for_lineage),
-                ("forDuplicateProcessing", for_duplicate_processing)])
+             ("forDuplicateProcessing", for_duplicate_processing)])
 
         body = {"class": "FindPropertyNamesProperties", "openMetadataTypeName": open_metadata_type_name,
-            "propertyValue": property_value, "propertyNames": property_names, "effectiveTime": effective_time, }
+                "propertyValue": property_value, "propertyNames": property_names, "effectiveTime": effective_time, }
 
         url = (f"{base_path(self, server_name)}/elements/by-classification/{classification_name}/"
                f"with-property-value-search{possible_query_params}")
@@ -792,9 +814,11 @@ class ClassificationManager(Client):
         return elements
 
     def find_elements_by_classification_with_property_value(self, classification_name: str, property_value: str,
-            property_names: [str], open_metadata_type_name: str = None, effective_time: str = None,
-            for_lineage: bool = None, for_duplicate_processing: bool = None, start_from: int = 0,
-            page_size: int = max_paging_size, server_name: str = None, time_out: int = default_time_out) -> list | str:
+                                                            property_names: [str], open_metadata_type_name: str = None,
+                                                            effective_time: str = None, for_lineage: bool = None,
+                                                            for_duplicate_processing: bool = None, start_from: int = 0,
+                                                            page_size: int = max_paging_size, server_name: str = None,
+                                                            time_out: int = default_time_out) -> list | str:
         """
         Retrieve elements with the requested classification name and with the requested a value found in
         one of the classification's properties specified.  The value must only be contained in the
@@ -846,17 +870,20 @@ class ClassificationManager(Client):
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
             self._async_find_elements_by_classification_with_property_value(classification_name, property_value,
-                property_names, open_metadata_type_name, effective_time, for_lineage, for_duplicate_processing,
-                start_from, page_size, server_name, time_out))
+                                                                            property_names, open_metadata_type_name,
+                                                                            effective_time, for_lineage,
+                                                                            for_duplicate_processing, start_from,
+                                                                            page_size, server_name, time_out))
         return response
 
     #
     #   related elements
     #
     async def _async_get_all_related_elements(self, element_guid: str, open_metadata_type_name: str = None,
-            start_at_end: int = 1, effective_time: str = None, for_lineage: bool = None,
-            for_duplicate_processing: bool = None, start_from: int = 0, page_size: int = max_paging_size,
-            server_name: str = None, time_out: int = default_time_out) -> list | str:
+                                              start_at_end: int = 1, effective_time: str = None,
+                                              for_lineage: bool = None, for_duplicate_processing: bool = None,
+                                              start_from: int = 0, page_size: int = max_paging_size,
+                                              server_name: str = None, time_out: int = default_time_out) -> list | str:
         """
         Retrieve elements linked any relationship type name. It is also possible to limit the results by
         specifying a type name for the elements that should be returned. If no type name is specified then any type of
@@ -906,10 +933,10 @@ class ClassificationManager(Client):
 
         possible_query_params = query_string(
             [("startFrom", start_from), ("pageSize", page_size), ("forLineage", for_lineage),
-                ("forDuplicateProcessing", for_duplicate_processing), ("startAtEnd", start_at_end)])
+             ("forDuplicateProcessing", for_duplicate_processing), ("startAtEnd", start_at_end)])
 
         body = {"class": "FindProperties", "openMetadataTypeName": open_metadata_type_name,
-            "effectiveTime": effective_time, }
+                "effectiveTime": effective_time, }
 
         url = (f"{base_path(self, server_name)}/elements/{element_guid}/by-relationship"
                f"{possible_query_params}")
@@ -921,9 +948,10 @@ class ClassificationManager(Client):
         return elements
 
     def get_all_related_elements(self, element_guid: str, open_metadata_type_name: str = None, start_at_end: int = 1,
-            effective_time: str = None, for_lineage: bool = None, for_duplicate_processing: bool = None,
-            start_from: int = 0, page_size: int = max_paging_size, server_name: str = None,
-            time_out: int = default_time_out) -> list | str:
+                                 effective_time: str = None, for_lineage: bool = None,
+                                 for_duplicate_processing: bool = None, start_from: int = 0,
+                                 page_size: int = max_paging_size, server_name: str = None,
+                                 time_out: int = default_time_out) -> list | str:
         """
         Retrieve elements linked via any relationship type name. It is also possible to limit the results by
         specifying a type name for the elements that should be returned. If no type name is specified then any type of
@@ -972,13 +1000,16 @@ class ClassificationManager(Client):
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
             self._async_get_all_related_elements(element_guid, open_metadata_type_name, start_at_end, effective_time,
-                for_lineage, for_duplicate_processing, start_from, page_size, server_name, time_out))
+                                                 for_lineage, for_duplicate_processing, start_from, page_size,
+                                                 server_name, time_out))
         return response
 
     async def _async_get_related_elements(self, element_guid: str, relationship_type: str,
-            open_metadata_type_name: str = None, start_at_end: int = 1, effective_time: str = None,
-            for_lineage: bool = None, for_duplicate_processing: bool = None, start_from: int = 0,
-            page_size: int = max_paging_size, server_name: str = None, time_out: int = default_time_out) -> list | str:
+                                          open_metadata_type_name: str = None, start_at_end: int = 1,
+                                          effective_time: str = None, for_lineage: bool = None,
+                                          for_duplicate_processing: bool = None, start_from: int = 0,
+                                          page_size: int = max_paging_size, server_name: str = None,
+                                          time_out: int = default_time_out) -> list | str:
         """
         Retrieve elements linked any relationship type name. It is also possible to limit the results by
         specifying a type name for the elements that should be returned. If no type name is specified then any type of
@@ -1030,10 +1061,10 @@ class ClassificationManager(Client):
 
         possible_query_params = query_string(
             [("startFrom", start_from), ("pageSize", page_size), ("forLineage", for_lineage),
-                ("forDuplicateProcessing", for_duplicate_processing), ("startAtEnd", start_at_end)])
+             ("forDuplicateProcessing", for_duplicate_processing), ("startAtEnd", start_at_end)])
 
         body = {"class": "FindProperties", "openMetadataTypeName": open_metadata_type_name,
-            "effectiveTime": effective_time, }
+                "effectiveTime": effective_time, }
 
         url = (f"{base_path(self, server_name)}/elements/{element_guid}/by-relationship/"
                f"{relationship_type}{possible_query_params}")
@@ -1045,9 +1076,10 @@ class ClassificationManager(Client):
         return elements
 
     def get_related_elements(self, element_guid: str, relationship_type: str, open_metadata_type_name: str = None,
-            start_at_end: int = 1, effective_time: str = None, for_lineage: bool = None,
-            for_duplicate_processing: bool = None, start_from: int = 0, page_size: int = max_paging_size,
-            server_name: str = None, time_out: int = default_time_out) -> list | str:
+                             start_at_end: int = 1, effective_time: str = None, for_lineage: bool = None,
+                             for_duplicate_processing: bool = None, start_from: int = 0,
+                             page_size: int = max_paging_size, server_name: str = None,
+                             time_out: int = default_time_out) -> list | str:
         """
         Retrieve elements linked via any relationship type name. It is also possible to limit the results by
         specifying a type name for the elements that should be returned. If no type name is specified then any type of
@@ -1098,14 +1130,19 @@ class ClassificationManager(Client):
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
             self._async_get_related_elements(element_guid, relationship_type, open_metadata_type_name, start_at_end,
-                effective_time, for_lineage, for_duplicate_processing, start_from, page_size, server_name, time_out))
+                                             effective_time, for_lineage, for_duplicate_processing, start_from,
+                                             page_size, server_name, time_out))
         return response
 
     async def _async_get_related_elements_with_property_value(self, element_guid: str, relationship_type: str,
-            property_value: str, property_names: [str], open_metadata_type_name: str = None, start_at_end: int = 1,
-            effective_time: str = None, for_lineage: bool = None, for_duplicate_processing: bool = None,
-            start_from: int = 0, page_size: int = max_paging_size, server_name: str = None,
-            time_out: int = default_time_out) -> list | str:
+                                                              property_value: str, property_names: [str],
+                                                              open_metadata_type_name: str = None,
+                                                              start_at_end: int = 1, effective_time: str = None,
+                                                              for_lineage: bool = None,
+                                                              for_duplicate_processing: bool = None,
+                                                              start_from: int = 0, page_size: int = max_paging_size,
+                                                              server_name: str = None,
+                                                              time_out: int = default_time_out) -> list | str:
         """
         Retrieve elements linked via the requested relationship type name and with the requested a value found in one of
         the classification's properties specified.  The value must match exactly. An open metadata type name may be
@@ -1162,10 +1199,10 @@ class ClassificationManager(Client):
 
         possible_query_params = query_string(
             [("startFrom", start_from), ("pageSize", page_size), ("forLineage", for_lineage),
-                ("forDuplicateProcessing", for_duplicate_processing), ("startAtEnd", start_at_end)])
+             ("forDuplicateProcessing", for_duplicate_processing), ("startAtEnd", start_at_end)])
 
         body = {"class": "FindPropertyNamesProperties", "openMetadataTypeName": open_metadata_type_name,
-            "propertyValue": property_value, "propertyNames": property_names, "effectiveTime": effective_time, }
+                "propertyValue": property_value, "propertyNames": property_names, "effectiveTime": effective_time, }
 
         url = (f"{base_path(self, server_name)}/elements/{element_guid}/by-relationship/"
                f"{relationship_type}/with-exact-property-value{possible_query_params}")
@@ -1178,10 +1215,12 @@ class ClassificationManager(Client):
         return elements
 
     def get_related_elements_with_property_value(self, element_guid: str, relationship_type: str, property_value: str,
-            property_names: [str], open_metadata_type_name: str = None, start_at_end: int = 1,
-            effective_time: str = None, for_lineage: bool = None, for_duplicate_processing: bool = None,
-            start_from: int = 0, page_size: int = max_paging_size, server_name: str = None,
-            time_out: int = default_time_out) -> list | str:
+                                                 property_names: [str], open_metadata_type_name: str = None,
+                                                 start_at_end: int = 1, effective_time: str = None,
+                                                 for_lineage: bool = None, for_duplicate_processing: bool = None,
+                                                 start_from: int = 0, page_size: int = max_paging_size,
+                                                 server_name: str = None,
+                                                 time_out: int = default_time_out) -> list | str:
         """
         Retrieve elements linked via the requested relationship type name and with the requested a value found in one of
         the classification's properties specified.  The value must match exactly. An open metadata type name may be
@@ -1236,15 +1275,20 @@ class ClassificationManager(Client):
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
             self._async_get_related_elements_with_property_value(element_guid, relationship_type, property_value,
-                property_names, open_metadata_type_name, start_at_end, effective_time, for_lineage,
-                for_duplicate_processing, start_from, page_size, server_name, time_out))
+                                                                 property_names, open_metadata_type_name, start_at_end,
+                                                                 effective_time, for_lineage, for_duplicate_processing,
+                                                                 start_from, page_size, server_name, time_out))
         return response
 
     async def _async_find_related_elements_with_property_value(self, element_guid: str, relationship_type: str,
-            property_value: str, property_names: [str], open_metadata_type_name: str = None, start_at_end: int = 1,
-            effective_time: str = None, for_lineage: bool = None, for_duplicate_processing: bool = None,
-            start_from: int = 0, page_size: int = max_paging_size, server_name: str = None,
-            time_out: int = default_time_out) -> list | str:
+                                                               property_value: str, property_names: [str],
+                                                               open_metadata_type_name: str = None,
+                                                               start_at_end: int = 1, effective_time: str = None,
+                                                               for_lineage: bool = None,
+                                                               for_duplicate_processing: bool = None,
+                                                               start_from: int = 0, page_size: int = max_paging_size,
+                                                               server_name: str = None,
+                                                               time_out: int = default_time_out) -> list | str:
         """
         Retrieve elements linked via the requested relationship type name and with the requested a value found in one of
         the classification's properties specified.  The value must only be contained in the properties rather than
@@ -1302,10 +1346,10 @@ class ClassificationManager(Client):
 
         possible_query_params = query_string(
             [("startFrom", start_from), ("pageSize", page_size), ("forLineage", for_lineage),
-                ("forDuplicateProcessing", for_duplicate_processing), ("startAtEnd", start_at_end)])
+             ("forDuplicateProcessing", for_duplicate_processing), ("startAtEnd", start_at_end)])
 
         body = {"class": "FindPropertyNamesProperties", "openMetadataTypeName": open_metadata_type_name,
-            "propertyValue": property_value, "propertyNames": property_names, "effectiveTime": effective_time, }
+                "propertyValue": property_value, "propertyNames": property_names, "effectiveTime": effective_time, }
 
         url = (f"{base_path(self, server_name)}/elements/{element_guid}/by-relationship/"
                f"{relationship_type}/with-property-value-search{possible_query_params}")
@@ -1319,10 +1363,12 @@ class ClassificationManager(Client):
         return elements
 
     def find_related_elements_with_property_value(self, element_guid: str, relationship_type: str, property_value: str,
-            property_names: [str], open_metadata_type_name: str = None, start_at_end: int = 1,
-            effective_time: str = None, for_lineage: bool = None, for_duplicate_processing: bool = None,
-            start_from: int = 0, page_size: int = max_paging_size, server_name: str = None,
-            time_out: int = default_time_out) -> list | str:
+                                                  property_names: [str], open_metadata_type_name: str = None,
+                                                  start_at_end: int = 1, effective_time: str = None,
+                                                  for_lineage: bool = None, for_duplicate_processing: bool = None,
+                                                  start_from: int = 0, page_size: int = max_paging_size,
+                                                  server_name: str = None,
+                                                  time_out: int = default_time_out) -> list | str:
         """
         Retrieve elements linked via the requested relationship type name and with the requested a value found in one of
         the classification's properties specified.  The value must only be contained in the properties rather than
@@ -1378,16 +1424,18 @@ class ClassificationManager(Client):
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
             self._async_find_related_elements_with_property_value(element_guid, relationship_type, property_value,
-                property_names, open_metadata_type_name, start_at_end, effective_time, for_lineage,
-                for_duplicate_processing, start_from, page_size, server_name, time_out))
+                                                                  property_names, open_metadata_type_name, start_at_end,
+                                                                  effective_time, for_lineage, for_duplicate_processing,
+                                                                  start_from, page_size, server_name, time_out))
         return response
 
     #
     #   relationships
 
     async def _async_get_relationships(self, relationship_type: str, effective_time: str = None,
-            for_lineage: bool = None, for_duplicate_processing: bool = None, start_from: int = 0,
-            page_size: int = max_paging_size, server_name: str = None, time_out: int = default_time_out) -> list | str:
+                                       for_lineage: bool = None, for_duplicate_processing: bool = None,
+                                       start_from: int = 0, page_size: int = max_paging_size, server_name: str = None,
+                                       time_out: int = default_time_out) -> list | str:
         """
         Retrieve relationships of the requested relationship type name. Async version.
 
@@ -1429,7 +1477,7 @@ class ClassificationManager(Client):
 
         possible_query_params = query_string(
             [("startFrom", start_from), ("pageSize", page_size), ("forLineage", for_lineage),
-                ("forDuplicateProcessing", for_duplicate_processing)])
+             ("forDuplicateProcessing", for_duplicate_processing)])
 
         body = {"class": "FindProperties", "effectiveTime": effective_time}
 
@@ -1445,8 +1493,8 @@ class ClassificationManager(Client):
         return rels
 
     def get_relationships(self, relationship_type: str, effective_time: str = None, for_lineage: bool = None,
-            for_duplicate_processing: bool = None, start_from: int = 0, page_size: int = max_paging_size,
-            server_name: str = None, time_out: int = default_time_out) -> list | str:
+                          for_duplicate_processing: bool = None, start_from: int = 0, page_size: int = max_paging_size,
+                          server_name: str = None, time_out: int = default_time_out) -> list | str:
         """
         Retrieve relationships of the requested relationship type name.
 
@@ -1487,13 +1535,15 @@ class ClassificationManager(Client):
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
             self._async_get_relationships(relationship_type, effective_time, for_lineage, for_duplicate_processing,
-                start_from, page_size, server_name, time_out))
+                                          start_from, page_size, server_name, time_out))
         return response
 
     async def _async_get_relationships_with_property_value(self, relationship_type: str, property_value: str,
-            property_names: [str], effective_time: str = None, for_lineage: bool = None,
-            for_duplicate_processing: bool = None, start_from: int = 0, page_size: int = max_paging_size,
-            server_name: str = None, time_out: int = default_time_out) -> list | str:
+                                                           property_names: [str], effective_time: str = None,
+                                                           for_lineage: bool = None,
+                                                           for_duplicate_processing: bool = None, start_from: int = 0,
+                                                           page_size: int = max_paging_size, server_name: str = None,
+                                                           time_out: int = default_time_out) -> list | str:
         """
         Retrieve relationships of the requested relationship type name and with the requested a value found in
         one of the relationship's properties specified.  The value must match exactly. Async version.
@@ -1542,10 +1592,10 @@ class ClassificationManager(Client):
 
         possible_query_params = query_string(
             [("startFrom", start_from), ("pageSize", page_size), ("forLineage", for_lineage),
-                ("forDuplicateProcessing", for_duplicate_processing)])
+             ("forDuplicateProcessing", for_duplicate_processing)])
 
         body = {"class": "FindPropertyNamesProperties", "propertyValue": property_value,
-            "propertyNames": property_names, "effectiveTime": effective_time, }
+                "propertyNames": property_names, "effectiveTime": effective_time, }
 
         url = (f"{base_path(self, server_name)}/relationships/{relationship_type}/"
                f"with-exact-property-value{possible_query_params}")
@@ -1558,9 +1608,10 @@ class ClassificationManager(Client):
         return rels
 
     def get_relationships_with_property_value(self, relationship_type: str, property_value: str, property_names: [str],
-            effective_time: str = None, for_lineage: bool = None, for_duplicate_processing: bool = None,
-            start_from: int = 0, page_size: int = max_paging_size, server_name: str = None,
-            time_out: int = default_time_out) -> list | str:
+                                              effective_time: str = None, for_lineage: bool = None,
+                                              for_duplicate_processing: bool = None, start_from: int = 0,
+                                              page_size: int = max_paging_size, server_name: str = None,
+                                              time_out: int = default_time_out) -> list | str:
         """
         Retrieve relationships of the requested relationship type name and with the requested a value found in
         one of the relationship's properties specified.  The value must match exactly.
@@ -1606,13 +1657,16 @@ class ClassificationManager(Client):
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
             self._async_get_relationships_with_property_value(relationship_type, property_value, property_names,
-                effective_time, for_lineage, for_duplicate_processing, start_from, page_size, server_name, time_out))
+                                                              effective_time, for_lineage, for_duplicate_processing,
+                                                              start_from, page_size, server_name, time_out))
         return response
 
     async def _async_find_relationships_with_property_value(self, relationship_type: str, property_value: str,
-            property_names: [str], effective_time: str = None, for_lineage: bool = None,
-            for_duplicate_processing: bool = None, start_from: int = 0, page_size: int = max_paging_size,
-            server_name: str = None, time_out: int = default_time_out) -> list | str:
+                                                            property_names: [str], effective_time: str = None,
+                                                            for_lineage: bool = None,
+                                                            for_duplicate_processing: bool = None, start_from: int = 0,
+                                                            page_size: int = max_paging_size, server_name: str = None,
+                                                            time_out: int = default_time_out) -> list | str:
         """
         Retrieve relationships of the requested relationship type name and with the requested a value found in one of
         the relationship's properties specified.  The value must only be contained in the properties rather than
@@ -1660,10 +1714,10 @@ class ClassificationManager(Client):
 
         possible_query_params = query_string(
             [("startFrom", start_from), ("pageSize", page_size), ("forLineage", for_lineage),
-                ("forDuplicateProcessing", for_duplicate_processing)])
+             ("forDuplicateProcessing", for_duplicate_processing)])
 
         body = {"class": "FindPropertyNamesProperties", "propertyValue": property_value,
-            "propertyNames": property_names, "effectiveTime": effective_time, }
+                "propertyNames": property_names, "effectiveTime": effective_time, }
 
         url = (f"{base_path(self, server_name)}/relationships/"
                f"{relationship_type}/with-property-value-search{possible_query_params}")
@@ -1677,9 +1731,10 @@ class ClassificationManager(Client):
         return rels
 
     def find_relationships_with_property_value(self, relationship_type: str, property_value: str, property_names: [str],
-            effective_time: str = None, for_lineage: bool = None, for_duplicate_processing: bool = None,
-            start_from: int = 0, page_size: int = max_paging_size, server_name: str = None,
-            time_out: int = default_time_out) -> list | str:
+                                               effective_time: str = None, for_lineage: bool = None,
+                                               for_duplicate_processing: bool = None, start_from: int = 0,
+                                               page_size: int = max_paging_size, server_name: str = None,
+                                               time_out: int = default_time_out) -> list | str:
         """
         Retrieve relationships of the requested relationship type name and with the requested a value found in one of
         the relationship's properties specified.  The value must only be contained in the properties rather than
@@ -1728,7 +1783,8 @@ class ClassificationManager(Client):
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
             self._async_find_relationships_with_property_value(relationship_type, property_value, property_names,
-                effective_time, for_lineage, for_duplicate_processing, start_from, page_size, server_name, time_out))
+                                                               effective_time, for_lineage, for_duplicate_processing,
+                                                               start_from, page_size, server_name, time_out))
         return response
 
     #
@@ -1736,8 +1792,8 @@ class ClassificationManager(Client):
     #
 
     async def _async_retrieve_instance_for_guid(self, guid: str, effective_time: str = None, for_lineage: bool = None,
-            for_duplicate_processing: bool = None, server_name: str = None,
-            time_out: int = default_time_out) -> list | str:
+                                                for_duplicate_processing: bool = None, server_name: str = None,
+                                                time_out: int = default_time_out) -> list | str:
         """
          Retrieve the header for the instance identified by the supplied unique identifier.
          It may be an element (entity) or a relationship between elements. Async version.
@@ -1784,11 +1840,9 @@ class ClassificationManager(Client):
         element = response.json().get('element', 'No elements found')
         return element
 
-
-
     def retrieve_instance_for_guid(self, guid: str, effective_time: str = None, for_lineage: bool = None,
-            for_duplicate_processing: bool = None, server_name: str = None,
-            time_out: int = default_time_out) -> list | str:
+                                   for_duplicate_processing: bool = None, server_name: str = None,
+                                   time_out: int = default_time_out) -> list | str:
         """
          Retrieve the header for the instance identified by the supplied unique identifier.
          It may be an element (entity) or a relationship between elements.
@@ -1826,16 +1880,15 @@ class ClassificationManager(Client):
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
             self._async_retrieve_instance_for_guid(guid, effective_time, for_lineage, for_duplicate_processing,
-                server_name, time_out))
+                                                   server_name, time_out))
         return response
 
-
     #
     #   Classification CRUD
     #
 
-    async def _async_set_confidence_classification(self, element_guid: str, body: dict,
-            for_lineage: bool = None, for_duplicate_processing: bool = None, server_name: str = None,
+    async def _async_set_confidence_classification(self, element_guid: str, body: dict, for_lineage: bool = None,
+                                                   for_duplicate_processing: bool = None, server_name: str = None,
                                                    time_out: int = default_time_out) -> None:
         """
         Classify/reclassify the element (typically an asset) to indicate the level of confidence that the organization
@@ -1898,19 +1951,16 @@ class ClassificationManager(Client):
             server_name = self.server_name
 
         possible_query_params = query_string(
-            [ ("forLineage", for_lineage), ("forDuplicateProcessing", for_duplicate_processing)])
-
+            [("forLineage", for_lineage), ("forDuplicateProcessing", for_duplicate_processing)])
 
         url = (f"{base_path(self, server_name)}/elements/{element_guid}/confidence"
-               f"{possible_query_params}"
-              )
+               f"{possible_query_params}")
 
         await self._async_make_request("POST", url, body_slimmer(body), time_out=time_out)
 
-
     def set_confidence_classification(self, element_guid: str, body: dict, for_lineage: bool = None,
-            for_duplicate_processing: bool = None,
-            server_name: str = None, time_out: int = default_time_out) -> None:
+                                      for_duplicate_processing: bool = None, server_name: str = None,
+                                      time_out: int = default_time_out) -> None:
         """
         Classify/reclassify the element (typically an asset) to indicate the level of confidence that the organization
         has that the data is complete, accurate and up-to-date.  The level of confidence is expressed by the
@@ -1972,13 +2022,12 @@ class ClassificationManager(Client):
         loop = asyncio.get_event_loop()
         loop.run_until_complete(
             self._async_set_confidence_classification(element_guid, body, for_lineage, for_duplicate_processing,
-                 server_name, time_out))
-        
+                                                      server_name, time_out))
 
-    async def _async_clear_confidence_classification(self, element_guid: str, 
-                                                   for_lineage: bool = None, for_duplicate_processing: bool = None,
-                                                   server_name: str = None,
-                                                   time_out: int = default_time_out) -> None:
+    async def _async_clear_confidence_classification(self, element_guid: str, for_lineage: bool = None,
+                                                     for_duplicate_processing: bool = None, effective_time: str = None,
+                                                     server_name: str = None,
+                                                     time_out: int = default_time_out) -> None:
         """
         Remove the confidence classification from the element.  This normally occurs when the organization has lost 
         track of the level of confidence to assign to the element. Async Version.
@@ -1993,6 +2042,8 @@ class ClassificationManager(Client):
             - determines if elements classified as Memento should be returned - normally false
         for_duplicate_processing: bool, default is set by server
             - Normally false. Set true when the caller is part of a deduplication function
+        effective_time: str, default = None
+            - Time format is "YYYY-MM-DDTHH:MM:SS" (ISO 8601)
         server_name: str, default = None
             - name of the server instances for this request.
         time_out: int, default = default_time_out
@@ -2021,14 +2072,18 @@ class ClassificationManager(Client):
             [("forLineage", for_lineage), ("forDuplicateProcessing", for_duplicate_processing)])
 
         url = (f"{base_path(self, server_name)}/elements/{element_guid}/confidence/remove"
-               f"{possible_query_params}"
-               )
+               f"{possible_query_params}")
+        body = {
+            "class": "ClassificationRequestBody",
+            "effectiveTime": effective_time
+        }
 
-        await self._async_make_request("POST", url, time_out=time_out)
+        await self._async_make_request("POST", url, body_slimmer(body), time_out=time_out)
 
     def clear_confidence_classification(self, element_guid: str, for_lineage: bool = None,
-                                      for_duplicate_processing: bool = None,
-                                      server_name: str = None, time_out: int = default_time_out) -> None:
+                                        for_duplicate_processing: bool = None, effective_time: str = None,
+                                        server_name: str = None,
+                                        time_out: int = default_time_out) -> None:
         """
         Remove the confidence classification from the element.  This normally occurs when the organization has lost 
         track of the level of confidence to assign to the element. 
@@ -2043,6 +2098,8 @@ class ClassificationManager(Client):
             - determines if elements classified as Memento should be returned - normally false
         for_duplicate_processing: bool, default is set by server
             - Normally false. Set true when the caller is part of a deduplication function
+        effective_time: str, default = None
+            - Time format is "YYYY-MM-DDTHH:MM:SS" (ISO 8601)
         server_name: str, default = None
             - name of the server instances for this request.
         time_out: int, default = default_time_out
@@ -2068,12 +2125,11 @@ class ClassificationManager(Client):
         loop = asyncio.get_event_loop()
         loop.run_until_complete(
             self._async_clear_confidence_classification(element_guid, for_lineage, for_duplicate_processing,
-                                                      server_name, time_out))
+                                                        effective_time, server_name, time_out))
 
-    async def _async_set_confidentiality_classification(self, element_guid: str, body: dict,
-                                                   for_lineage: bool = None, for_duplicate_processing: bool = None,
-                                                   server_name: str = None,
-                                                   time_out: int = default_time_out) -> None:
+    async def _async_set_confidentiality_classification(self, element_guid: str, body: dict, for_lineage: bool = None,
+                                                        for_duplicate_processing: bool = None, server_name: str = None,
+                                                        time_out: int = default_time_out) -> None:
         """
         Classify/reclassify the element (typically a data field, schema attribute or glossary term) to indicate the
         level of confidentiality that any data associated with the element should be given.  If the classification is
@@ -2140,14 +2196,13 @@ class ClassificationManager(Client):
             [("forLineage", for_lineage), ("forDuplicateProcessing", for_duplicate_processing)])
 
         url = (f"{base_path(self, server_name)}/elements/{element_guid}/confidentiality"
-               f"{possible_query_params}"
-               )
+               f"{possible_query_params}")
 
         await self._async_make_request("POST", url, body_slimmer(body), time_out=time_out)
 
     def set_confidentiality_classification(self, element_guid: str, body: dict, for_lineage: bool = None,
-                                      for_duplicate_processing: bool = None,
-                                      server_name: str = None, time_out: int = default_time_out) -> None:
+                                           for_duplicate_processing: bool = None, server_name: str = None,
+                                           time_out: int = default_time_out) -> None:
         """
         Classify/reclassify the element (typically a data field, schema attribute or glossary term) to indicate the
         level of confidentiality that any data associated with the element should be given.  If the classification is
@@ -2211,13 +2266,13 @@ class ClassificationManager(Client):
         loop = asyncio.get_event_loop()
         loop.run_until_complete(
             self._async_set_confidentiality_classification(element_guid, body, for_lineage, for_duplicate_processing,
-                                                      server_name, time_out))
+                                                           server_name, time_out))
 
-    async def _async_clear_confidentiality_classification(self, element_guid: str,
-                                                     for_lineage: bool = None,
-                                                     for_duplicate_processing: bool = None,
-                                                     server_name: str = None,
-                                                     time_out: int = default_time_out) -> None:
+    async def _async_clear_confidentiality_classification(self, element_guid: str, for_lineage: bool = None,
+                                                          for_duplicate_processing: bool = None,
+                                                          effective_time: str = None,
+                                                          server_name: str = None,
+                                                          time_out: int = default_time_out) -> None:
         """
         Remove the confidentiality classification from the element.  This normally occurs when the organization has lost 
         track of the level of confidentiality to assign to the element. Async Version.
@@ -2232,6 +2287,8 @@ class ClassificationManager(Client):
             - determines if elements classified as Memento should be returned - normally false
         for_duplicate_processing: bool, default is set by server
             - Normally false. Set true when the caller is part of a deduplication function
+        effective_time: str, default = None
+            - Time format is "YYYY-MM-DDTHH:MM:SS" (ISO 8601)
         server_name: str, default = None
             - name of the server instances for this request.
         time_out: int, default = default_time_out
@@ -2260,14 +2317,19 @@ class ClassificationManager(Client):
             [("forLineage", for_lineage), ("forDuplicateProcessing", for_duplicate_processing)])
 
         url = (f"{base_path(self, server_name)}/elements/{element_guid}/confidentiality/remove"
-               f"{possible_query_params}"
-               )
+               f"{possible_query_params}")
 
-        await self._async_make_request("POST", url,  time_out=time_out)
+        body = {
+            "class": "ClassificationRequestBody",
+            "effectiveTime": effective_time
+        }
+
+        await self._async_make_request("POST", url, body_slimmer(body), time_out=time_out)
 
     def clear_confidentiality_classification(self, element_guid: str, for_lineage: bool = None,
-                                        for_duplicate_processing: bool = None,
-                                        server_name: str = None, time_out: int = default_time_out) -> list | str:
+                                             for_duplicate_processing: bool = None, effective_time: str = None,
+                                             server_name: str = None,
+                                             time_out: int = default_time_out) -> None:
         """
         Remove the confidentiality classification from the element.  This normally occurs when the organization has lost 
         track of the level of confidentiality to assign to the element. 
@@ -2282,6 +2344,8 @@ class ClassificationManager(Client):
             - determines if elements classified as Memento should be returned - normally false
         for_duplicate_processing: bool, default is set by server
             - Normally false. Set true when the caller is part of a deduplication function
+        effective_time: str, default = None
+            - Time format is "YYYY-MM-DDTHH:MM:SS" (ISO 8601)
         server_name: str, default = None
             - name of the server instances for this request.
         time_out: int, default = default_time_out
@@ -2307,13 +2371,11 @@ class ClassificationManager(Client):
         loop = asyncio.get_event_loop()
         loop.run_until_complete(
             self._async_clear_confidentiality_classification(element_guid, for_lineage, for_duplicate_processing,
-                                                        server_name, time_out))
-
+                                                             effective_time, server_name, time_out))
 
-    async def _async_set_criticality_classification(self, element_guid: str, body: dict,
-                                                   for_lineage: bool = None, for_duplicate_processing: bool = None,
-                                                   server_name: str = None,
-                                                   time_out: int = default_time_out) -> None:
+    async def _async_set_criticality_classification(self, element_guid: str, body: dict, for_lineage: bool = None,
+                                                    for_duplicate_processing: bool = None, server_name: str = None,
+                                                    time_out: int = default_time_out) -> None:
         """
         Classify/reclassify the element (typically an asset) to indicate how critical the element (or
         associated resource) is to the organization.  The level of criticality is expressed by the levelIdentifier
@@ -2378,14 +2440,13 @@ class ClassificationManager(Client):
             [("forLineage", for_lineage), ("forDuplicateProcessing", for_duplicate_processing)])
 
         url = (f"{base_path(self, server_name)}/elements/{element_guid}/criticality"
-               f"{possible_query_params}"
-               )
+               f"{possible_query_params}")
 
         await self._async_make_request("POST", url, body_slimmer(body), time_out=time_out)
 
     def set_criticality_classification(self, element_guid: str, body: dict, for_lineage: bool = None,
-                                      for_duplicate_processing: bool = None,
-                                      server_name: str = None, time_out: int = default_time_out) -> None:
+                                       for_duplicate_processing: bool = None, server_name: str = None,
+                                       time_out: int = default_time_out) -> None:
         """
         Classify/reclassify the element (typically an asset) to indicate how critical the element (or
         associated resource) is to the organization.  The level of criticality is expressed by the levelIdentifier
@@ -2447,13 +2508,12 @@ class ClassificationManager(Client):
         loop = asyncio.get_event_loop()
         loop.run_until_complete(
             self._async_set_criticality_classification(element_guid, body, for_lineage, for_duplicate_processing,
-                                                      server_name, time_out))
+                                                       server_name, time_out))
 
-    async def _async_clear_criticality_classification(self, element_guid: str,
-                                                     for_lineage: bool = None,
-                                                     for_duplicate_processing: bool = None,
-                                                     server_name: str = None,
-                                                     time_out: int = default_time_out) -> None:
+    async def _async_clear_criticality_classification(self, element_guid: str, for_lineage: bool = None,
+                                                      for_duplicate_processing: bool = None, effective_time: str = None,
+                                                      server_name: str = None,
+                                                      time_out: int = default_time_out) -> None:
         """
         Remove the criticality classification from the element.  This normally occurs when the organization has lost
         track of the level of criticality to assign to the element. Async Version.
@@ -2468,6 +2528,8 @@ class ClassificationManager(Client):
             - determines if elements classified as Memento should be returned - normally false
         for_duplicate_processing: bool, default is set by server
             - Normally false. Set true when the caller is part of a deduplication function
+        effective_time: str, default = None
+            - Time format is "YYYY-MM-DDTHH:MM:SS" (ISO 8601)
         server_name: str, default = None
             - name of the server instances for this request.
         time_out: int, default = default_time_out
@@ -2496,14 +2558,19 @@ class ClassificationManager(Client):
             [("forLineage", for_lineage), ("forDuplicateProcessing", for_duplicate_processing)])
 
         url = (f"{base_path(self, server_name)}/elements/{element_guid}/criticality/remove"
-               f"{possible_query_params}"
-               )
+               f"{possible_query_params}")
+
+        body = {
+            "class": "ClassificationRequestBody",
+            "effectiveTime": effective_time
+        }
 
-        await self._async_make_request("POST", url,  time_out=time_out)
+        await self._async_make_request("POST", url, body_slimmer(body), time_out=time_out)
 
     def clear_criticality_classification(self, element_guid: str, for_lineage: bool = None,
-                                        for_duplicate_processing: bool = None,
-                                        server_name: str = None, time_out: int = default_time_out) -> list | str:
+                                         for_duplicate_processing: bool = None, effective_time: str = None,
+                                         server_name: str = None,
+                                         time_out: int = default_time_out) -> None:
         """
         Remove the criticality classification from the element.  This normally occurs when the organization has lost
         track of the level of criticality to assign to the element.
@@ -2518,6 +2585,212 @@ class ClassificationManager(Client):
             - determines if elements classified as Memento should be returned - normally false
         for_duplicate_processing: bool, default is set by server
             - Normally false. Set true when the caller is part of a deduplication function
+        effective_time: str, default = None
+            - Time format is "YYYY-MM-DDTHH:MM:SS" (ISO 8601)
+        server_name: str, default = None
+            - name of the server instances for this request.
+        time_out: int, default = default_time_out
+            - http request timeout for this request
+
+        Returns
+        -------
+        [dict] | str
+            Returns a string if no elements found and a list of dict of elements with the results.
+
+        Raises
+        ------
+        InvalidParameterException
+            one of the parameters is null or invalid or
+        PropertyServerException
+            There is a problem adding the element properties to the metadata repository or
+        UserNotAuthorizedException
+            the requesting user is not authorized to issue this request.
+
+
+        """
+
+        loop = asyncio.get_event_loop()
+        loop.run_until_complete(
+            self._async_clear_criticality_classification(element_guid, for_lineage, for_duplicate_processing,
+                                                         effective_time, server_name, time_out))
+
+    async def _async_add_gov_definition_to_element(self, definition_guid: str, element_guid: str,
+                                                   effective_time: str = None, for_lineage: bool = None,
+                                                   for_duplicate_processing: bool = None, server_name: str = None,
+                                                   time_out: int = default_time_out) -> None:
+        """
+        Link a governance definition to an element using the GovernedBy relationship. Async version.
+
+        Governance Definitions: https://egeria-project.org/types/4/0401-Governance-Definitions/
+
+        Parameters
+        ----------
+        definition_guid: str
+            - identity of the governance definition to add
+        element_guid: str
+            - the identity of the element to update
+        effective_time: str, default is None
+            - None means ignore, otherwise the time that the element must be effective
+        for_lineage: bool, default is set by server
+            - determines if elements classified as Memento should be returned - normally false
+        for_duplicate_processing: bool, default is set by server
+            - Normally false. Set true when the caller is part of a deduplication function
+        server_name: str, default = None
+            - name of the server instances for this request.
+        time_out: int, default = default_time_out
+            - http request timeout for this request
+
+        Returns
+        -------
+        None
+
+        Raises
+        ------
+        InvalidParameterException
+            one of the parameters is null or invalid or
+        PropertyServerException
+            There is a problem adding the element properties to the metadata repository or
+        UserNotAuthorizedException
+            the requesting user is not authorized to issue this request.
+
+        """
+        if server_name is None:
+            server_name = self.server_name
+
+        possible_query_params = query_string(
+            [("forLineage", for_lineage), ("forDuplicateProcessing", for_duplicate_processing)])
+
+        url = (f"{base_path(self, server_name)}/elements/{element_guid}/governed-by/definition/{definition_guid}"
+               f"{possible_query_params}")
+
+        body = {"class": "RelationshipRequestBody", "effectiveTime": effective_time}
+
+        await self._async_make_request("POST", url, body_slimmer(body), time_out=time_out)
+
+    def add_gov_definition_to_element(self, definition_guid: str, element_guid: str, effective_time: str = None,
+                                      for_lineage: bool = None, for_duplicate_processing: bool = None,
+                                      server_name: str = None, time_out: int = default_time_out) -> None:
+        """
+        Link a governance definition to an element using the GovernedBy relationship.
+
+        Governance Definition: https://egeria-project.org/types/4/0401-Governance-Definitions/
+
+        Parameters
+        ----------
+        definition_guid: str
+            - identity of the governance definition to add
+        element_guid: str
+            - the identity of the element to update
+        effective_time: str, default is None
+            - None means ignore, otherwise the time that the element must be effective
+        for_lineage: bool, default is set by server
+            - determines if elements classified as Memento should be returned - normally false
+        for_duplicate_processing: bool, default is set by server
+            - Normally false. Set true when the caller is part of a deduplication function
+        server_name: str, default = None
+            - name of the server instances for this request.
+        time_out: int, default = default_time_out
+            - http request timeout for this request
+
+        Returns
+        -------
+        None
+
+        Raises
+        ------
+        InvalidParameterException
+            one of the parameters is null or invalid or
+        PropertyServerException
+            There is a problem adding the element properties to the metadata repository or
+        UserNotAuthorizedException
+            the requesting user is not authorized to issue this request.
+
+        """
+
+        loop = asyncio.get_event_loop()
+        loop.run_until_complete(
+            self._async_add_gov_definition_to_element(definition_guid, element_guid, effective_time, for_lineage,
+                                                      for_duplicate_processing, server_name, time_out))
+
+    async def _async_clear_gov_definition_from_element(self, definition_guid, element_guid: str,
+                                                       for_lineage: bool = None, for_duplicate_processing: bool = None,
+                                                       effective_time: str = None, server_name: str = None,
+                                                       time_out: int = default_time_out) -> None:
+        """
+        Remove the GovernedBy relationship between a governance definition and an element. Async Version.
+
+        Governance Action Classifications: https://egeria-project.org/types/4/0422-Governance-Action-Classifications/
+
+        Parameters
+        ----------
+        definition_guid: str
+            - identity of the governance definition to add
+        element_guid: str
+            - the identity of the element to update
+        for_lineage: bool, default is set by server
+            - determines if elements classified as Memento should be returned - normally false
+        for_duplicate_processing: bool, default is set by server
+            - Normally false. Set true when the caller is part of a deduplication function
+        effective_time: str, default = None
+            - Time format is "YYYY-MM-DDTHH:MM:SS" (ISO 8601)
+        server_name: str, default = None
+            - name of the server instances for this request.
+        time_out: int, default = default_time_out
+            - http request timeout for this request
+
+        Returns
+        -------
+        [dict] | str
+            Returns a string if no elements found and a list of dict of elements with the results.
+
+        Raises
+        ------
+        InvalidParameterException
+            one of the parameters is null or invalid or
+        PropertyServerException
+            There is a problem adding the element properties to the metadata repository or
+        UserNotAuthorizedException
+            the requesting user is not authorized to issue this request.
+
+
+        """
+        if server_name is None:
+            server_name = self.server_name
+
+        possible_query_params = query_string(
+            [("forLineage", for_lineage), ("forDuplicateProcessing", for_duplicate_processing)])
+
+        url = (f"{base_path(self, server_name)}/elements/{element_guid}/governed-by/definition/"
+               f"{definition_guid}/remove{possible_query_params}")
+
+        body = {
+            "class": "ClassificationRequestBody",
+            "effectiveTime": effective_time
+        }
+
+        await self._async_make_request("POST", url, body_slimmer(body), time_out=time_out)
+
+    def clear_gov_definition_from_element(self, definition_guid, element_guid: str, for_lineage: bool = None,
+                                          for_duplicate_processing: bool = None, effective_time: str = None,
+                                          server_name: str = None,
+                                          time_out: int = default_time_out) -> None:
+        """
+        Remove the GovernedBy relationship between a governance definition and an element. Async Version.
+
+        Governance Action Classifications: https://egeria-project.org/types/4/0422-Governance-Action-Classifications/
+
+        Parameters
+        ----------
+        definition_guid: str
+            - identity of the governance definition to add
+        element_guid: str
+            - the identity of the element to update
+        for_lineage: bool, default is set by server
+            - determines if elements classified as Memento should be returned - normally false
+        for_duplicate_processing: bool, default is set by server
+            - Normally false. Set true when the caller is part of a deduplication function
+        effective_time: str, default = None
+            - Time format is "YYYY-MM-DDTHH:MM:SS" (ISO 8601)
         server_name: str, default = None
             - name of the server instances for this request.
         time_out: int, default = default_time_out
@@ -2543,5 +2816,1171 @@ class ClassificationManager(Client):
         loop = asyncio.get_event_loop()
         loop.run_until_complete(
             self._async_clear_criticality_classification(element_guid, for_lineage, for_duplicate_processing,
-                                                        server_name, time_out))
-## Add governance stuff
+                                                         effective_time, server_name, time_out))
+
+    async def _async_add_ownership_to_element(self, element_guid: str, body: dict, for_lineage: bool = None,
+                                              for_duplicate_processing: bool = None, server_name: str = None,
+                                              time_out: int = default_time_out) -> None:
+        """
+        Add or replace the ownership classification for an element. Async version.
+
+        Ownership: https://egeria-project.org/types/4/0445-Governance-Roles/
+
+        Parameters
+        ----------
+        element_guid: str
+            - the identity of the element to update
+        body: dict
+            - structure containing ownership information - see Notes
+        for_lineage: bool, default is set by server
+            - determines if elements classified as Memento should be returned - normally false
+        for_duplicate_processing: bool, default is set by server
+            - Normally false. Set true when the caller is part of a deduplication function
+        server_name: str, default = None
+            - name of the server instances for this request.
+        time_out: int, default = default_time_out
+            - http request timeout for this request
+
+        Returns
+        -------
+        None
+
+        Raises
+        ------
+        InvalidParameterException
+            one of the parameters is null or invalid or
+        PropertyServerException
+            There is a problem adding the element properties to the metadata repository or
+        UserNotAuthorizedException
+            the requesting user is not authorized to issue this request.
+
+        Notes
+        -----
+
+        {
+           "class" : "ClassificationRequestBody",
+           "effectiveTime" : "an isoTimestamp",
+           "properties" : {
+               "class" : "OwnerProperties",
+               "owner" : "Add value here",
+               "ownerTypeName" : "Add value here",
+               "ownerPropertyName" : "Add value here"
+           }
+        }
+
+        """
+        if server_name is None:
+            server_name = self.server_name
+
+        possible_query_params = query_string(
+            [("forLineage", for_lineage), ("forDuplicateProcessing", for_duplicate_processing)])
+
+        url = (f"{base_path(self, server_name)}/elements/{element_guid}/ownership"
+               f"{possible_query_params}")
+
+        await self._async_make_request("POST", url, body_slimmer(body), time_out=time_out)
+
+    def add_ownership_to_element(self, element_guid: str, body: dict, for_lineage: bool = None,
+                                 for_duplicate_processing: bool = None, server_name: str = None,
+                                 time_out: int = default_time_out) -> None:
+        """
+        Add or replace the ownership classification for an element.
+
+        Ownership: https://egeria-project.org/types/4/0445-Governance-Roles/
+
+        Parameters
+        ----------
+        element_guid: str
+            - the identity of the element to update
+        body: dict
+            - structure containing ownership information - see Notes
+        for_lineage: bool, default is set by server
+            - determines if elements classified as Memento should be returned - normally false
+        for_duplicate_processing: bool, default is set by server
+            - Normally false. Set true when the caller is part of a deduplication function
+        server_name: str, default = None
+            - name of the server instances for this request.
+        time_out: int, default = default_time_out
+            - http request timeout for this request
+
+        Returns
+        -------
+        None
+
+        Raises
+        ------
+        InvalidParameterException
+            one of the parameters is null or invalid or
+        PropertyServerException
+            There is a problem adding the element properties to the metadata repository or
+        UserNotAuthorizedException
+            the requesting user is not authorized to issue this request.
+
+        Notes
+        -----
+
+        {
+           "class" : "ClassificationRequestBody",
+           "effectiveTime" : "an isoTimestamp",
+           "properties" : {
+               "class" : "OwnerProperties",
+               "owner" : "Add value here",
+               "ownerTypeName" : "Add value here",
+               "ownerPropertyName" : "Add value here"
+           }
+        }
+
+        """
+
+        loop = asyncio.get_event_loop()
+        loop.run_until_complete(
+            self._async_add_ownership_to_element(element_guid, body, for_lineage, for_duplicate_processing, server_name,
+                                                 time_out))
+
+    async def _async_clear_ownership_from_element(self, element_guid: str, for_lineage: bool = None,
+                                                  for_duplicate_processing: bool = None, effective_time: str = None,
+                                                  server_name: str = None,
+                                                  time_out: int = default_time_out) -> None:
+        """
+        Remove the ownership classification from an element. Async version.
+
+        Ownership: https://egeria-project.org/types/4/0445-Governance-Roles/
+
+        Parameters
+        ----------
+        element_guid: str
+            - the identity of the element to update
+        for_lineage: bool, default is set by server
+            - determines if elements classified as Memento should be returned - normally false
+        for_duplicate_processing: bool, default is set by server
+            - Normally false. Set true when the caller is part of a deduplication function
+        effective_time: str, default = None
+            - Time format is "YYYY-MM-DDTHH:MM:SS" (ISO 8601)
+        server_name: str, default = None
+            - name of the server instances for this request.
+        time_out: int, default = default_time_out
+            - http request timeout for this request
+
+        Returns
+        -------
+        None
+
+        Raises
+        ------
+        InvalidParameterException
+            one of the parameters is null or invalid or
+        PropertyServerException
+            There is a problem adding the element properties to the metadata repository or
+        UserNotAuthorizedException
+            the requesting user is not authorized to issue this request.
+
+
+        """
+        if server_name is None:
+            server_name = self.server_name
+
+        possible_query_params = query_string(
+            [("forLineage", for_lineage), ("forDuplicateProcessing", for_duplicate_processing)])
+
+        url = (f"{base_path(self, server_name)}/elements/{element_guid}/ownership/remove"
+               f"{possible_query_params}")
+
+        body = {
+            "class": "ClassificationRequestBody",
+            "effectiveTime": effective_time
+        }
+
+        await self._async_make_request("POST", url, body_slimmer(body), time_out=time_out)
+
+    def clear_ownership_from_element(self, element_guid: str, for_lineage: bool = None,
+                                     for_duplicate_processing: bool = None, effective_time: str = None,
+                                     server_name: str = None,
+                                     time_out: int = default_time_out) -> None:
+        """
+        Remove the ownership classification from an element.
+
+        Ownership: https://egeria-project.org/types/4/0445-Governance-Roles/
+
+        Parameters
+        ----------
+        element_guid: str
+            - the identity of the element to update
+        for_lineage: bool, default is set by server
+            - determines if elements classified as Memento should be returned - normally false
+        for_duplicate_processing: bool, default is set by server
+            - Normally false. Set true when the caller is part of a deduplication function
+        effective_time: str, default = None
+            - Time format is "YYYY-MM-DDTHH:MM:SS" (ISO 8601)
+        server_name: str, default = None
+            - name of the server instances for this request.
+        time_out: int, default = default_time_out
+            - http request timeout for this request
+
+        Returns
+        -------
+        None
+
+        Raises
+        ------
+        InvalidParameterException
+            one of the parameters is null or invalid or
+        PropertyServerException
+            There is a problem adding the element properties to the metadata repository or
+        UserNotAuthorizedException
+            the requesting user is not authorized to issue this request.
+
+
+        """
+
+        loop = asyncio.get_event_loop()
+        loop.run_until_complete(
+            self._async_clear_ownership_from_element(element_guid, for_lineage, for_duplicate_processing,
+                                                     effective_time, server_name,
+                                                     time_out))
+
+    async def _async_set_retention_classification(self, element_guid: str, body: dict, for_lineage: bool = None,
+                                                  for_duplicate_processing: bool = None, server_name: str = None,
+                                                  time_out: int = default_time_out) -> None:
+        """
+        Classify/reclassify the element (typically an asset) to indicate how long the element (or associated resource)
+        is to be retained by the organization.  The policy to apply to the element/resource is captured by the retentionBasis
+        property.  The dates after which the element/resource is archived and then deleted are specified in the archiveAfter and deleteAfter
+        properties respectively. Async version
+
+        Governance Action Classifications: https://egeria-project.org/types/4/0422-Governance-Action-Classifications/
+
+        Parameters
+        ----------
+        element_guid: str
+            - the identity of the element to update
+        body: dict
+            - a dictionary structure containing the properties to set - see note below
+        for_lineage: bool, default is set by server
+            - determines if elements classified as Memento should be returned - normally false
+        for_duplicate_processing: bool, default is set by server
+            - Normally false. Set true when the caller is part of a deduplication function
+        server_name: str, default = None
+            - name of the server instances for this request.
+        time_out: int, default = default_time_out
+            - http request timeout for this request
+
+        Returns
+        -------
+        [dict] | str
+            Returns a string if no elements found and a list of dict of elements with the results.
+
+        Raises
+        ------
+        InvalidParameterException
+            one of the parameters is null or invalid or
+        PropertyServerException
+            There is a problem adding the element properties to the metadata repository or
+        UserNotAuthorizedException
+            the requesting user is not authorized to issue this request.
+
+        Note:
+
+        A sample dict structure is:
+
+        {
+           "class" : "ClassificationRequestBody",
+           "effectiveTime" : "an isoTimestamp",
+           "properties" : {
+               "class" : "RetentionClassificationProperties",
+               "retentionBasis" : 0,
+               "status" : 0,
+               "confidence" : 0,
+               "associatedGUID" : "Add value here",
+               "archiveAfter" : "{{$isoTimestamp}}",
+               "deleteAfter" : "{{$isoTimestamp}}",
+               "steward" : "Add value here",
+               "stewardTypeName" : "Add value here",
+               "stewardPropertyName" : "Add value here",
+               "source" : "Add value here",
+               "notes" : "Add value here"
+           }
+        }
+
+        """
+        if server_name is None:
+            server_name = self.server_name
+
+        possible_query_params = query_string(
+            [("forLineage", for_lineage), ("forDuplicateProcessing", for_duplicate_processing)])
+
+        url = (f"{base_path(self, server_name)}/elements/{element_guid}/retention"
+               f"{possible_query_params}")
+
+        await self._async_make_request("POST", url, body_slimmer(body), time_out=time_out)
+
+    def set_retention_classification(self, element_guid: str, body: dict, for_lineage: bool = None,
+                                     for_duplicate_processing: bool = None, server_name: str = None,
+                                     time_out: int = default_time_out) -> None:
+        """
+        Classify/reclassify the element (typically an asset) to indicate how long the element (or associated resource)
+        is to be retained by the organization.  The policy to apply to the element/resource is captured by the retentionBasis
+        property.  The dates after which the element/resource is archived and then deleted are specified in the archiveAfter and deleteAfter
+        properties respectively. Async version
+
+        Governance Action Classifications: https://egeria-project.org/types/4/0422-Governance-Action-Classifications/
+
+        Parameters
+        ----------
+        element_guid: str
+            - the identity of the element to update
+        body: dict
+            - a dictionary structure containing the properties to set - see note below
+        for_lineage: bool, default is set by server
+            - determines if elements classified as Memento should be returned - normally false
+        for_duplicate_processing: bool, default is set by server
+            - Normally false. Set true when the caller is part of a deduplication function
+        server_name: str, default = None
+            - name of the server instances for this request.
+        time_out: int, default = default_time_out
+            - http request timeout for this request
+
+        Returns
+        -------
+        [dict] | str
+            Returns a string if no elements found and a list of dict of elements with the results.
+
+        Raises
+        ------
+        InvalidParameterException
+            one of the parameters is null or invalid or
+        PropertyServerException
+            There is a problem adding the element properties to the metadata repository or
+        UserNotAuthorizedException
+            the requesting user is not authorized to issue this request.
+
+        Note:
+
+        A sample dict structure is:
+
+        {
+           "class" : "ClassificationRequestBody",
+           "effectiveTime" : "an isoTimestamp",
+           "properties" : {
+               "class" : "RetentionClassificationProperties",
+               "retentionBasis" : 0,
+               "status" : 0,
+               "confidence" : 0,
+               "associatedGUID" : "Add value here",
+               "archiveAfter" : "{{$isoTimestamp}}",
+               "deleteAfter" : "{{$isoTimestamp}}",
+               "steward" : "Add value here",
+               "stewardTypeName" : "Add value here",
+               "stewardPropertyName" : "Add value here",
+               "source" : "Add value here",
+               "notes" : "Add value here"
+           }
+        }
+        """
+
+        loop = asyncio.get_event_loop()
+        loop.run_until_complete(
+            self._async_set_retention_classification(element_guid, body, for_lineage, for_duplicate_processing,
+                                                     server_name, time_out))
+
+    async def _async_clear_retention_classification(self, element_guid: str, for_lineage: bool = None,
+                                                    for_duplicate_processing: bool = None, effective_time: str = None,
+                                                    server_name: str = None,
+                                                    time_out: int = default_time_out) -> None:
+        """
+         Remove the retention classification from the element.  This normally occurs when the organization has lost
+         track of the level of retention to assign to the element. Async Version.
+
+         Governance Action Classifications: https://egeria-project.org/types/4/0422-Governance-Action-Classifications/
+
+         Parameters
+         ----------
+         element_guid: str
+             - the identity of the element to update
+         for_lineage: bool, default is set by server
+             - determines if elements classified as Memento should be returned - normally false
+         for_duplicate_processing: bool, default is set by server
+             - Normally false. Set true when the caller is part of a deduplication function
+         effective_time: str, default = None
+            - Time format is "YYYY-MM-DDTHH:MM:SS" (ISO 8601)
+         server_name: str, default = None
+             - name of the server instances for this request.
+         time_out: int, default = default_time_out
+             - http request timeout for this request
+
+         Returns
+         -------
+         [dict] | str
+             Returns a string if no elements found and a list of dict of elements with the results.
+
+         Raises
+         ------
+         InvalidParameterException
+             one of the parameters is null or invalid or
+         PropertyServerException
+             There is a problem adding the element properties to the metadata repository or
+         UserNotAuthorizedException
+             the requesting user is not authorized to issue this request.
+
+
+         """
+        if server_name is None:
+            server_name = self.server_name
+
+        possible_query_params = query_string(
+            [("forLineage", for_lineage), ("forDuplicateProcessing", for_duplicate_processing)])
+
+        url = (f"{base_path(self, server_name)}/elements/{element_guid}/retention/remove"
+               f"{possible_query_params}")
+
+        body = {
+            "class": "ClassificationRequestBody",
+            "effectiveTime": effective_time
+        }
+
+        await self._async_make_request("POST", url, body_slimmer(body), time_out=time_out)
+
+    def clear_retention_classification(self, element_guid: str, for_lineage: bool = None,
+                                       for_duplicate_processing: bool = None, effective_time: str = None,
+                                       server_name: str = None,
+                                       time_out: int = default_time_out) -> None:
+        """
+        Remove the retention classification from the element.  This normally occurs when the organization has lost
+        track of the level of retention to assign to the element.
+    
+        Governance Action Classifications: https://egeria-project.org/types/4/0422-Governance-Action-Classifications/
+    
+        Parameters
+        ----------
+        element_guid: str
+            - the identity of the element to update
+        for_lineage: bool, default is set by server
+            - determines if elements classified as Memento should be returned - normally false
+        for_duplicate_processing: bool, default is set by server
+            - Normally false. Set true when the caller is part of a deduplication function
+        effective_time: str, default = None
+            - Time format is "YYYY-MM-DDTHH:MM:SS" (ISO 8601)
+        server_name: str, default = None
+            - name of the server instances for this request.
+        time_out: int, default = default_time_out
+            - http request timeout for this request
+    
+        Returns
+        -------
+        [dict] | str
+            Returns a string if no elements found and a list of dict of elements with the results.
+    
+        Raises
+        ------
+        InvalidParameterException
+            one of the parameters is null or invalid or
+        PropertyServerException
+            There is a problem adding the element properties to the metadata repository or
+        UserNotAuthorizedException
+            the requesting user is not authorized to issue this request.
+    
+    
+        """
+
+        loop = asyncio.get_event_loop()
+        loop.run_until_complete(
+            self._async_clear_retention_classification(element_guid, for_lineage, for_duplicate_processing,
+                                                       effective_time, server_name,
+                                                       time_out))
+
+    async def _async_set_security_tags_classification(self, element_guid: str, body: dict, for_lineage: bool = None,
+                                                      for_duplicate_processing: bool = None, server_name: str = None,
+                                                      time_out: int = default_time_out) -> None:
+        """
+        Add or replace the security tags for an element. Async versuib,
+
+        Security Tags: https://egeria-project.org/types/4/0423-Security-Definitions/
+
+        Parameters
+        ----------
+        element_guid: str
+            - the identity of the element to update
+        body: dict
+            - a dictionary structure containing the properties to set - see note below
+        for_lineage: bool, default is set by server
+            - determines if elements classified as Memento should be returned - normally false
+        for_duplicate_processing: bool, default is set by server
+            - Normally false. Set true when the caller is part of a deduplication function
+        server_name: str, default = None
+            - name of the server instances for this request.
+        time_out: int, default = default_time_out
+            - http request timeout for this request
+
+        Returns
+        -------
+        [dict] | str
+            Returns a string if no elements found and a list of dict of elements with the results.
+
+        Raises
+        ------
+        InvalidParameterException
+            one of the parameters is null or invalid or
+        PropertyServerException
+            There is a problem adding the element properties to the metadata repository or
+        UserNotAuthorizedException
+            the requesting user is not authorized to issue this request.
+
+        Note:
+
+        A sample dict structure is:
+
+        {
+           "class" : "ClassificationRequestBody",
+           "effectiveTime" : "an isoTimestamp",
+           "properties" : {
+               "class" : "SecurityTagsProperties",
+               "securityLabels" : [ "Label1", "Label2" ],
+               "securityProperties" : {
+                   "propertyName1" : "add property value here",
+                   "propertyName2" : "add property value here"
+               },
+               "accessGroups" : {
+                   "groupName1" : [ "operation1", "operation2" ],
+                   "groupName2" : [ "operation1", "operation3" ]
+               }
+           }
+        }
+
+
+        """
+        if server_name is None:
+            server_name = self.server_name
+
+        possible_query_params = query_string(
+            [("forLineage", for_lineage), ("forDuplicateProcessing", for_duplicate_processing)])
+
+        url = (f"{base_path(self, server_name)}/elements/{element_guid}/security-tags"
+               f"{possible_query_params}")
+
+        await self._async_make_request("POST", url, body_slimmer(body), time_out=time_out)
+
+    def set_security_tags_classification(self, element_guid: str, body: dict, for_lineage: bool = None,
+                                         for_duplicate_processing: bool = None, server_name: str = None,
+                                         time_out: int = default_time_out) -> None:
+        """
+        Add or replace the security tags for an element. Async versuib,
+
+        Security Tags: https://egeria-project.org/types/4/0423-Security-Definitions/
+
+        Parameters
+        ----------
+        element_guid: str
+            - the identity of the element to update
+        body: dict
+            - a dictionary structure containing the properties to set - see note below
+        for_lineage: bool, default is set by server
+            - determines if elements classified as Memento should be returned - normally false
+        for_duplicate_processing: bool, default is set by server
+            - Normally false. Set true when the caller is part of a deduplication function
+        server_name: str, default = None
+            - name of the server instances for this request.
+        time_out: int, default = default_time_out
+            - http request timeout for this request
+
+        Returns
+        -------
+        [dict] | str
+            Returns a string if no elements found and a list of dict of elements with the results.
+
+        Raises
+        ------
+        InvalidParameterException
+            one of the parameters is null or invalid or
+        PropertyServerException
+            There is a problem adding the element properties to the metadata repository or
+        UserNotAuthorizedException
+            the requesting user is not authorized to issue this request.
+
+        Note:
+
+        A sample dict structure is:
+
+        {
+           "class" : "ClassificationRequestBody",
+           "effectiveTime" : "an isoTimestamp",
+           "properties" : {
+               "class" : "SecurityTagsProperties",
+               "securityLabels" : [ "Label1", "Label2" ],
+               "securityProperties" : {
+                   "propertyName1" : "add property value here",
+                   "propertyName2" : "add property value here"
+               },
+               "accessGroups" : {
+                   "groupName1" : [ "operation1", "operation2" ],
+                   "groupName2" : [ "operation1", "operation3" ]
+               }
+           }
+        }
+
+
+        """
+
+        loop = asyncio.get_event_loop()
+        loop.run_until_complete(
+            self._async_set_security_tags_classification(element_guid, body, for_lineage, for_duplicate_processing,
+                                                         server_name, time_out))
+
+    async def _async_clear_security_tags_classification(self, element_guid: str, for_lineage: bool = None,
+                                                        for_duplicate_processing: bool = None,
+                                                        effective_time: str = None, server_name: str = None,
+                                                        time_out: int = default_time_out) -> None:
+        """
+         Remove the security-tags classification from the element.
+
+         Security Tags: https://egeria-project.org/types/4/0423-Security-Definitions/
+
+         Parameters
+         ----------
+         element_guid: str
+             - the identity of the element to update
+         for_lineage: bool, default is set by server
+             - determines if elements classified as Memento should be returned - normally false
+         for_duplicate_processing: bool, default is set by server
+             - Normally false. Set true when the caller is part of a deduplication function
+         server_name: str, default = None
+             - name of the server instances for this request.
+         time_out: int, default = default_time_out
+             - http request timeout for this request
+
+         Returns
+         -------
+            None
+
+         Raises
+         ------
+         InvalidParameterException
+             one of the parameters is null or invalid or
+         PropertyServerException
+             There is a problem adding the element properties to the metadata repository or
+         UserNotAuthorizedException
+             the requesting user is not authorized to issue this request.
+
+
+         """
+        if server_name is None:
+            server_name = self.server_name
+
+        possible_query_params = query_string(
+            [("forLineage", for_lineage), ("forDuplicateProcessing", for_duplicate_processing)])
+
+        url = (f"{base_path(self, server_name)}/elements/{element_guid}/security-tags/remove"
+               f"{possible_query_params}")
+
+        body = {
+            "class": "ClassificationRequestBody",
+            "effectiveTime": effective_time
+        }
+
+        await self._async_make_request("POST", url, body_slimmer(body), time_out=time_out)
+
+    def clear_security_tags_classification(self, element_guid: str, for_lineage: bool = None,
+                                           for_duplicate_processing: bool = None, effective_time: str = None,
+                                           server_name: str = None,
+                                           time_out: int = default_time_out) -> None:
+        """
+         Remove the security-tags classification from the element.
+
+         Security Tags: https://egeria-project.org/types/4/0423-Security-Definitions/
+
+         Parameters
+         ----------
+         element_guid: str
+             - the identity of the element to update
+         for_lineage: bool, default is set by server
+             - determines if elements classified as Memento should be returned - normally false
+         for_duplicate_processing: bool, default is set by server
+             - Normally false. Set true when the caller is part of a deduplication function
+         effective_time: str, default = None
+            - Time format is "YYYY-MM-DDTHH:MM:SS" (ISO 8601)
+         server_name: str, default = None
+             - name of the server instances for this request.
+         time_out: int, default = default_time_out
+             - http request timeout for this request
+
+         Returns
+         -------
+            None
+
+         Raises
+         ------
+         InvalidParameterException
+             one of the parameters is null or invalid or
+         PropertyServerException
+             There is a problem adding the element properties to the metadata repository or
+         UserNotAuthorizedException
+             the requesting user is not authorized to issue this request.
+
+
+         """
+
+        loop = asyncio.get_event_loop()
+        loop.run_until_complete(
+            self._async_clear_security_tags_classification(element_guid, for_lineage, for_duplicate_processing,
+                                                           effective_time, server_name, time_out))
+
+    async def _async_setup_semantic_assignment(self, glossary_term_guid: str, element_guid: str, body: dict,
+                                               for_lineage: bool = None, for_duplicate_processing: bool = None,
+                                               server_name: str = None, time_out: int = default_time_out) -> None:
+        """
+        Create a semantic assignment relationship between a glossary term and an element (normally a schema attribute,
+        data field or asset). This relationship indicates that the data associated with the element meaning matches
+        the description in the glossary term. Async version
+
+        Semantic Assignments: https://egeria-project.org/types/3/0370-Semantic-Assignment/
+
+        Parameters
+        ----------
+        glossary_term_guid: str
+            - identity of glossary to assign
+        element_guid: str
+            - the identity of the element to update
+        body: dict
+            - a dictionary structure containing the properties to set - see note below
+        for_lineage: bool, default is set by server
+            - determines if elements classified as Memento should be returned - normally false
+        for_duplicate_processing: bool, default is set by server
+            - Normally false. Set true when the caller is part of a deduplication function
+        server_name: str, default = None
+            - name of the server instances for this request.
+        time_out: int, default = default_time_out
+            - http request timeout for this request
+
+        Returns
+        -------
+        None
+
+        Raises
+        ------
+        InvalidParameterException
+            one of the parameters is null or invalid or
+        PropertyServerException
+            There is a problem adding the element properties to the metadata repository or
+        UserNotAuthorizedException
+            the requesting user is not authorized to issue this request.
+
+        Note:
+
+        A sample dict structure is:
+
+        {
+          "class" : "RelationshipRequestBody",
+          "effectiveTime" : "an isoTimestamp",
+          "relationshipProperties" : {
+            "class": "SemanticAssignmentProperties",
+            "expression" : "add value here",
+            "description" : "add value here",
+            "status" : "VALIDATED",
+            "confidence" : 100,
+            "createdBy" : "add value here",
+            "steward" : "add value here",
+            "source" : "add value here"
+          }
+        }
+
+
+        """
+        if server_name is None:
+            server_name = self.server_name
+
+        possible_query_params = query_string(
+            [("forLineage", for_lineage), ("forDuplicateProcessing", for_duplicate_processing)])
+
+        url = (f"{base_path(self, server_name)}/elements/{element_guid}/semantic-assignment/terms"
+               f"/{glossary_term_guid}{possible_query_params}")
+
+        await self._async_make_request("POST", url, body_slimmer(body), time_out=time_out)
+
+    def setup_semantic_assignment(self, glossary_term_guid: str, element_guid: str, body: dict,
+                                  for_lineage: bool = None, for_duplicate_processing: bool = None,
+                                  server_name: str = None, time_out: int = default_time_out) -> None:
+        """
+        Create a semantic assignment relationship between a glossary term and an element (normally a schema attribute,
+        data field or asset). This relationship indicates that the data associated with the element meaning matches
+        the description in the glossary term.
+
+        Semantic Assignments: https://egeria-project.org/types/3/0370-Semantic-Assignment/
+
+        Parameters
+        ----------
+        glossary_term_guid: str
+            - identity of glossary to assign
+        element_guid: str
+            - the identity of the element to update
+        body: dict
+            - a dictionary structure containing the properties to set - see note below
+        for_lineage: bool, default is set by server
+            - determines if elements classified as Memento should be returned - normally false
+        for_duplicate_processing: bool, default is set by server
+            - Normally false. Set true when the caller is part of a deduplication function
+        server_name: str, default = None
+            - name of the server instances for this request.
+        time_out: int, default = default_time_out
+            - http request timeout for this request
+
+        Returns
+        -------
+        None
+
+        Raises
+        ------
+        InvalidParameterException
+            one of the parameters is null or invalid or
+        PropertyServerException
+            There is a problem adding the element properties to the metadata repository or
+        UserNotAuthorizedException
+            the requesting user is not authorized to issue this request.
+
+        Note:
+
+        A sample dict structure is:
+
+        {
+          "class" : "RelationshipRequestBody",
+          "effectiveTime" : "an isoTimestamp",
+          "relationshipProperties" : {
+            "class": "SemanticAssignmentProperties",
+            "expression" : "add value here",
+            "description" : "add value here",
+            "status" : "VALIDATED",
+            "confidence" : 100,
+            "createdBy" : "add value here",
+            "steward" : "add value here",
+            "source" : "add value here"
+          }
+        }
+
+        """
+
+        loop = asyncio.get_event_loop()
+        loop.run_until_complete(
+            self._async_setup_semantic_assignment(glossary_term_guid, element_guid, body, for_lineage,
+                                                  for_duplicate_processing, server_name, time_out))
+
+    async def _async_clear_semantic_assignment_classification(self, glossary_term_guid: str, element_guid: str,
+                                                              for_lineage: bool = None,
+                                                              for_duplicate_processing: bool = None,
+                                                              effective_time: str = None,
+                                                              server_name: str = None,
+                                                              time_out: int = default_time_out) -> None:
+        """
+         Remove the semantic_assignment classification from the element. Async version.
+
+         Security Tags: https://egeria-project.org/types/4/0423-Security-Definitions/
+
+         Parameters
+         ----------
+         glossary_term_guid: str
+            - identity of glossary to remove
+         element_guid: str
+             - the identity of the element to update
+         for_lineage: bool, default is set by server
+             - determines if elements classified as Memento should be returned - normally false
+         for_duplicate_processing: bool, default is set by server
+             - Normally false. Set true when the caller is part of a deduplication function
+         effective_time: str, default = None
+            - Time format is "YYYY-MM-DDTHH:MM:SS" (ISO 8601)
+         server_name: str, default = None
+             - name of the server instances for this request.
+         time_out: int, default = default_time_out
+             - http request timeout for this request
+
+         Returns
+         -------
+            None
+
+         Raises
+         ------
+         InvalidParameterException
+             one of the parameters is null or invalid or
+         PropertyServerException
+             There is a problem adding the element properties to the metadata repository or
+         UserNotAuthorizedException
+             the requesting user is not authorized to issue this request.
+
+         """
+        if server_name is None:
+            server_name = self.server_name
+
+        possible_query_params = query_string(
+            [("forLineage", for_lineage), ("forDuplicateProcessing", for_duplicate_processing)])
+
+        url = (f"{base_path(self, server_name)}/elements/{element_guid}/semantic-assignment/terms/"
+               f"{glossary_term_guid}/remove{possible_query_params}")
+
+        body = {
+            "class": "ClassificationRequestBody",
+            "effectiveTime": effective_time
+        }
+
+        await self._async_make_request("POST", url, body_slimmer(body), time_out=time_out)
+
+    def clear_semantic_assignment_classification(self, glossary_term_guid: str, element_guid: str,
+                                                 for_lineage: bool = None, for_duplicate_processing: bool = None,
+                                                 effective_time: str = None,
+                                                 server_name: str = None, time_out: int = default_time_out) -> None:
+        """
+         Remove the semantic_assignment classification from the element.
+
+         Security Tags: https://egeria-project.org/types/4/0423-Security-Definitions/
+
+         Parameters
+         ----------
+         glossary_term_guid: str
+            - identity of glossary to remove
+         element_guid: str
+             - the identity of the element to update
+         for_lineage: bool, default is set by server
+             - determines if elements classified as Memento should be returned - normally false
+         for_duplicate_processing: bool, default is set by server
+             - Normally false. Set true when the caller is part of a deduplication function
+         effective_time: str, default = None
+            - Time format is "YYYY-MM-DDTHH:MM:SS" (ISO 8601)
+         server_name: str, default = None
+             - name of the server instances for this request.
+         time_out: int, default = default_time_out
+             - http request timeout for this request
+
+         Returns
+         -------
+            None
+
+         Raises
+         ------
+         InvalidParameterException
+             one of the parameters is null or invalid or
+         PropertyServerException
+             There is a problem adding the element properties to the metadata repository or
+         UserNotAuthorizedException
+             the requesting user is not authorized to issue this request.
+
+
+         """
+
+        loop = asyncio.get_event_loop()
+        loop.run_until_complete(
+            self._async_clear_semantic_assignment_classification(glossary_term_guid, element_guid, for_lineage,
+                                                                 for_duplicate_processing, effective_time, server_name,
+                                                                 time_out))
+
+    async def _async_add_element_to_subject_area(self, element_guid: str, body: dict, for_lineage: bool = None,
+                                                 for_duplicate_processing: bool = None, server_name: str = None,
+                                                 time_out: int = default_time_out) -> None:
+        """
+        Classify the element to assert that the definitions it represents are part of a subject area definition. Async
+
+        Subject Areas: https://egeria-project.org/types/4/0425-Subject-Areas/
+
+        Parameters
+        ----------
+        element_guid: str
+            - the identity of the element to update
+        body: dict
+            - a dictionary structure containing the properties to set - see note below
+        for_lineage: bool, default is set by server
+            - determines if elements classified as Memento should be returned - normally false
+        for_duplicate_processing: bool, default is set by server
+            - Normally false. Set true when the caller is part of a deduplication function
+        server_name: str, default = None
+            - name of the server instances for this request.
+        time_out: int, default = default_time_out
+            - http request timeout for this request
+
+        Returns
+        -------
+        None
+
+        Raises
+        ------
+        InvalidParameterException
+            one of the parameters is null or invalid or
+        PropertyServerException
+            There is a problem adding the element properties to the metadata repository or
+        UserNotAuthorizedException
+            the requesting user is not authorized to issue this request.
+
+        Note:
+
+        A sample dict structure is:
+
+        {
+           "class" : "ClassificationRequestBody",
+           "effectiveTime" : "an isoTimestamp",
+           "properties" : {
+               "class" : "SubjectAreaMemberProperties",
+               "subjectAreaName" : "Add value here"
+           }
+        }
+
+
+        """
+        if server_name is None:
+            server_name = self.server_name
+
+        possible_query_params = query_string(
+            [("forLineage", for_lineage), ("forDuplicateProcessing", for_duplicate_processing)])
+
+        url = (f"{base_path(self, server_name)}/elements/{element_guid}/subject-area-member"
+               f"{possible_query_params}")
+
+        await self._async_make_request("POST", url, body_slimmer(body), time_out=time_out)
+
+    def add_element_to_subject_area(self, element_guid: str, body: dict, for_lineage: bool = None,
+                                    for_duplicate_processing: bool = None, server_name: str = None,
+                                    time_out: int = default_time_out) -> None:
+        """
+        Classify the element to assert that the definitions it represents are part of a subject area definition. Async
+
+        Subject Areas: https://egeria-project.org/types/4/0425-Subject-Areas/
+
+        Parameters
+        ----------
+        element_guid: str
+            - the identity of the element to update
+        body: dict
+            - a dictionary structure containing the properties to set - see note below
+        for_lineage: bool, default is set by server
+            - determines if elements classified as Memento should be returned - normally false
+        for_duplicate_processing: bool, default is set by server
+            - Normally false. Set true when the caller is part of a deduplication function
+        server_name: str, default = None
+            - name of the server instances for this request.
+        time_out: int, default = default_time_out
+            - http request timeout for this request
+
+        Returns
+        -------
+        None
+
+        Raises
+        ------
+        InvalidParameterException
+            one of the parameters is null or invalid or
+        PropertyServerException
+            There is a problem adding the element properties to the metadata repository or
+        UserNotAuthorizedException
+            the requesting user is not authorized to issue this request.
+
+        Note:
+
+        A sample dict structure is:
+
+        {
+           "class" : "ClassificationRequestBody",
+           "effectiveTime" : "an isoTimestamp",
+           "properties" : {
+               "class" : "SubjectAreaMemberProperties",
+               "subjectAreaName" : "Add value here"
+           }
+        }
+
+
+        """
+
+        loop = asyncio.get_event_loop()
+        loop.run_until_complete(
+            self._async_add_element_to_subject_area(element_guid, body, for_lineage, for_duplicate_processing,
+                                                    server_name, time_out))
+
+    async def _async_remove_element_from_subject_area(self, element_guid: str, for_lineage: bool = None,
+                                                      for_duplicate_processing: bool = None, effective_time: str = None,
+                                                      server_name: str = None,
+                                                      time_out: int = default_time_out) -> None:
+        """
+        Remove the subject area designation from the identified element. Async version.
+
+        Subject Areas: https://egeria-project.org/types/4/0425-Subject-Areas/
+
+         Parameters
+         ----------
+         element_guid: str
+             - the identity of the element to update
+         for_lineage: bool, default is set by server
+             - determines if elements classified as Memento should be returned - normally false
+         for_duplicate_processing: bool, default is set by server
+             - Normally false. Set true when the caller is part of a deduplication function
+         effective_time: str, default = None
+            - Time format is "YYYY-MM-DDTHH:MM:SS" (ISO 8601)
+         server_name: str, default = None
+             - name of the server instances for this request.
+         time_out: int, default = default_time_out
+             - http request timeout for this request
+
+         Returns
+         -------
+            None
+
+         Raises
+         ------
+         InvalidParameterException
+             one of the parameters is null or invalid or
+         PropertyServerException
+             There is a problem adding the element properties to the metadata repository or
+         UserNotAuthorizedException
+             the requesting user is not authorized to issue this request.
+
+
+         """
+        if server_name is None:
+            server_name = self.server_name
+
+        possible_query_params = query_string(
+            [("forLineage", for_lineage), ("forDuplicateProcessing", for_duplicate_processing)])
+
+        url = (f"{base_path(self, server_name)}/elements/{element_guid}/subject-area-member"
+               f"/remove{possible_query_params}")
+
+        body = {
+            "class": "ClassificationRequestBody",
+            "effectiveTime": effective_time
+        }
+
+        await self._async_make_request("POST", url, body_slimmer(body), time_out=time_out)
+
+    def remove_element_from_subject_area(self, element_guid: str, for_lineage: bool = None,
+                                         for_duplicate_processing: bool = None, effective_time: str = None,
+                                         server_name: str = None,
+                                         time_out: int = default_time_out) -> None:
+        """
+        Remove the subject area designation from the identified element.
+
+        Subject Areas: https://egeria-project.org/types/4/0425-Subject-Areas/
+
+         Parameters
+         ----------
+         element_guid: str
+             - the identity of the element to update
+         for_lineage: bool, default is set by server
+             - determines if elements classified as Memento should be returned - normally false
+         for_duplicate_processing: bool, default is set by server
+             - Normally false. Set true when the caller is part of a deduplication function
+         effective_time: str, default = None
+            - Time format is "YYYY-MM-DDTHH:MM:SS" (ISO 8601)
+         server_name: str, default = None
+             - name of the server instances for this request.
+         time_out: int, default = default_time_out
+             - http request timeout for this request
+
+         Returns
+         -------
+            None
+
+         Raises
+         ------
+         InvalidParameterException
+             one of the parameters is null or invalid or
+         PropertyServerException
+             There is a problem adding the element properties to the metadata repository or
+         UserNotAuthorizedException
+             the requesting user is not authorized to issue this request.
+
+
+         """
+
+        loop = asyncio.get_event_loop()
+        loop.run_until_complete(
+            self._async_remove_element_from_subject_area(element_guid, for_lineage, for_duplicate_processing,
+                                                         effective_time, server_name, time_out))