pyegeria 5.4.0.20__py3-none-any.whl → 5.4.0.23__py3-none-any.whl

pyegeria/collection_manager.py

@@ -9,34 +9,35 @@ Copyright Contributors to the ODPi Egeria project.
 import asyncio
 import inspect
 from datetime import datetime
-from typing import Dict, Union, List, Optional, Annotated, Literal
+from typing import Optional, Annotated, Literal, Union
 
-import pydantic_core
-# from jsonschema import ValidationError
 from loguru import logger
-from pydantic import BaseModel, ValidationError, TypeAdapter, Field
+from pydantic import ValidationError, Field, HttpUrl
 
-from pyegeria._exceptions_new import PyegeriaInvalidParameterException, PyegeriaException
-from pyegeria._output_formats import select_output_format_set, get_output_format_type_match
-from pyegeria._client import Client
+from pyegeria._exceptions_new import PyegeriaInvalidParameterException
 from pyegeria._globals import NO_ELEMENTS_FOUND, NO_GUID_RETURNED, NO_MEMBERS_FOUND
-from pyegeria._validators import validate_guid, validate_search_string
-from pyegeria.output_formatter import (generate_output,
-                                       _extract_referenceable_properties)
-from pyegeria.utils import body_slimmer, dynamic_catch
+from pyegeria._output_formats import select_output_format_set, get_output_format_type_match
+from pyegeria.load_config import get_app_config
 from pyegeria.models import (SearchStringRequestBody, FilterRequestBody, GetRequestBody, NewElementRequestBody,
                              ReferenceableProperties, InitialClassifications, TemplateRequestBody,
                              UpdateElementRequestBody, UpdateStatusRequestBody, NewRelationshipRequestBody,
-                             DeleteRequestBody)
-from pyegeria.load_config import get_app_config
+                             DeleteRequestBody, UpdateRelationshipRequestBody, ResultsRequestBody,
+                             get_defined_field_values, PyegeriaModel)
+from pyegeria.output_formatter import (generate_output,
+                                       _extract_referenceable_properties, populate_columns_from_properties,
+                                       get_required_relationships)
+from pyegeria.utils import body_slimmer, dynamic_catch
+
 
 app_settings = get_app_config()
 EGERIA_LOCAL_QUALIFIER = app_settings.User_Profile.egeria_local_qualifier
 
-COLLECTION_PROPERTIES_LIST = ["CollectionPropertie", "DataDictionaryProperties",
+COLLECTION_PROPERTIES_LIST = ["CollectionProperties", "DataDictionaryProperties",
                               "DataSpecProperties", "DigitalProductProperties",
                               "AgreementProperties"]
 
+AGREEMENT_PROPERTIES_LIST = ["AgreementProperties", "DigitalSubscriptionProperties",]
+
 
 def query_seperator(current_string):
     if current_string == "":
@@ -62,28 +63,39 @@ class CollectionProperties(ReferenceableProperties):
     class_: Annotated[Literal["CollectionProperties"], Field(alias="class")]
 
 
-class DataSpecProperties(ReferenceableProperties):
+class DataSpecProperties(CollectionProperties):
     class_: Annotated[Literal["DataSpecProperties"], Field(alias="class")]
 
 
-class DataDictionaryProperties(ReferenceableProperties):
+class DataDictionaryProperties(CollectionProperties):
     class_: Annotated[Literal["DataDictionaryProperties"], Field(alias="class")]
 
 
-class AgreementProperties(ReferenceableProperties):
+class AgreementProperties(CollectionProperties):
     class_: Annotated[Literal["AgreementProperties"], Field(alias="class")]
     identifier: str | None = None
     user_defined_status: str | None = None
 
+class DigitalSubscriptionProperties(AgreementProperties):
+    class_: Annotated[Literal["DigitalSubscriptionProperties"], Field(alias="class")]
+    support_level: str | None = None
+    service_levels: dict | None = None
 
-class DigitalProductProperties(ReferenceableProperties):
+
+class DigitalProductProperties(CollectionProperties):
+    class_: Annotated[Literal["DigitalProductProperties"], Field(alias="class")]
+    user_defined_status: str | None = None
     product_name: str | None = None
+    identifier: str | None = None
+    introduction_date: datetime | None = None
     maturity: str | None = None
     service_life: str | None = None
-    introduction_date: datetime | None = None
     next_version_date: datetime | None = None
     withdrawal_date: datetime | None = None
-    current_version: str | None = None
+
+class Collections(PyegeriaModel):
+    collection: Union[CollectionProperties, DigitalSubscriptionProperties, DigitalProductProperties, AgreementProperties,
+                      DataSpecProperties, DataDictionaryProperties] = Field(desciminator="class_")
 
 
 class CollectionManager(Client2):
@@ -128,7 +140,8 @@ class CollectionManager(Client2):
 
     @dynamic_catch
     async def _async_get_attached_collections(self, parent_guid: str, start_from: int = 0, page_size: int = 0,
-                                              body: dict = None, output_format: str = "JSON",
+                                              category: str = None, classification_names: list[str]= None,
+                                              body: dict | FilterRequestBody = None, output_format: str = "JSON",
                                               output_format_set: str | dict = None) -> list | str:
         """Returns the list of collections that are linked off of the supplied element using the ResourceList
            relationship. Async version.
@@ -181,12 +194,10 @@ class CollectionManager(Client2):
         }
 
         """
-        if body is None:
-            body = {}
 
         url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/collection-manager/"
-               f"metadata-elements/{parent_guid}/collections?startFrom={start_from}&pageSize={page_size}")
-
+               f"metadata-elements/{parent_guid}/collections")
+        return await self._async_get_name_request(url, body, output_format, output_format_set)
         response = await self._async_make_request("POST", url, body_slimmer(body))
         elements = response.json().get("elements", NO_ELEMENTS_FOUND)
         if type(elements) is str:
@@ -260,164 +271,26 @@ class CollectionManager(Client2):
 
 
     @dynamic_catch
-    async def _async_find_collections_w_body(self, body: dict | SearchStringRequestBody,
-                                             output_format: str = 'JSON',
-                                             output_format_set: str | dict = None) -> list | str:
-        """ Returns the list of collections matching the search string filtered by the optional classification.
-            The search string is located in the request body and is interpreted as a plain string. The full
-            body allows complete control including status, asOfTime and effectiveTime.
-            The request parameters, startsWith, endsWith and ignoreCase can be used to allow a fuzzy search.
-
-        Parameters
-        ----------
-        body: dict
-            Details of the search request - see the notes below for details.
-        output_format: str, default = "JSON"
-            - one of "MD", "LIST", "FORM", "REPORT", "DICT", "MERMAID" or "JSON"
-         output_format_set: str | dict , optional, default = None
-            - The desired output columns/field options.
-        Returns
-        -------
-        List | str
-
-        A list of collections match matching the search string. Returns a string if none found.
-
-        Raises
-        ------
-
-        InvalidParameterException
-          If the client passes incorrect parameters on the request - such as bad URLs or invalid values
-        PropertyServerException
-          Raised by the server when an issue arises in processing a valid request
-        NotAuthorizedException
-          The principle specified by the user_id does not have authorization for the requested action
-
-        Notes
-        -----
-
-        {
-          "class" : "SearchStringRequestBody",
-          "searchString" : "Data Product Development Journey",
-          "includeOnlyClassifiedElements" : ["RootCollection"],
-          "startsWith" : false,
-          "endsWith" : false,
-          "ignoreCase" : true,
-          "startFrom" : 0,
-          "pageSize": 0,
-          "asOfTime" : "{{$isoTimestamp}}",
-          "effectiveTime" : "{{$isoTimestamp}}",
-          "forLineage" : false,
-          "forDuplicateProcessing" : false,
-          "limitResultsByStatus" : ["ACTIVE"],
-          "sequencingOrder" : "PROPERTY_ASCENDING",
-          "sequencingProperty" : "qualifiedName"
-        }
-        """
-        if isinstance(body, SearchStringRequestBody):
-            validated_body = body
-        elif isinstance(body, dict):
-            try:
-                validated_body = self._search_string_request_adapter.validate_python(body)
-            except ValidationError as e:
-                context: dict = {
-                    'class name': __class__.__name__, 'caller method': inspect.currentframe().f_back.f_code.co_name
-                    }
-                raise PyegeriaInvalidParameterException(context =  context, Exception = e)
-        else:
-            raise TypeError("Invalid parameter type")
-
-        val_json = validated_body.model_dump_json()
-
-        url = f"{self.collection_command_root}/by-search-string"
-        classification_name = validated_body.include_only_classified_elements
-
-        response = await self._async_make_request("POST", url, val_json)
-        elements = response.json().get("elements", NO_ELEMENTS_FOUND)
-        if type(elements) is str:
-            logger.info(NO_ELEMENTS_FOUND)
-            return NO_ELEMENTS_FOUND
-
-        if output_format != 'JSON':  # return a simplified markdown representation
-            # logger.info(f"Found elements, output format: {output_format} and output_format_set: {output_format_set}")
-            return self._generate_collection_output(elements, None, classification_name,
-                                                    output_format, output_format_set)
-        return elements
-
-    @dynamic_catch
-    def find_collections_w_body(self, body: dict | SearchStringRequestBody, output_format: str = 'JSON',
-                                output_format_set: str | dict = None) -> list | str:
-        """ Returns the list of collections matching the search string filtered by the optional classification.
-             The search string is located in the request body and is interpreted as a plain string. The full
-             body allows complete control including status, asOfTime and effectiveTime.
-             The request parameters, startsWith, endsWith and ignoreCase can be used to allow a fuzzy search.
-
-         Parameters
-         ----------
-         body: dict
-             Details of the search request - see the notes below for details.
-         output_format: str, default = "JSON"
-             - one of "MD", "LIST", "FORM", "REPORT", "DICT", "MERMAID" or "JSON"
-         output_format_set: str | dict , optional, default = None
-             - The desired output columns/field options.
-         Returns
-         -------
-         List | str
-
-         A list of collections match matching the search string. Returns a string if none found.
-
-         Raises
-         ------
-
-         InvalidParameterException
-           If the client passes incorrect parameters on the request - such as bad URLs or invalid values
-         PropertyServerException
-           Raised by the server when an issue arises in processing a valid request
-         NotAuthorizedException
-           The principle specified by the user_id does not have authorization for the requested action
-
-         Notes
-         -----
-
-        {
-           "class" : "SearchStringRequestBody",
-           "searchString" : "Data Product Development Journey",
-           "includeOnlyClassifiedElements" : ["RootCollection"],
-           "startsWith" : false,
-           "endsWith" : false,
-           "ignoreCase" : true,
-           "startFrom" : 0,
-           "pageSize": 0,
-           "asOfTime" : "{{$isoTimestamp}}",
-           "effectiveTime" : "{{$isoTimestamp}}",
-           "forLineage" : false,
-           "forDuplicateProcessing" : false,
-           "limitResultsByStatus" : ["ACTIVE"],
-           "sequencingOrder" : "PROPERTY_ASCENDING",
-           "sequencingProperty" : "qualifiedName"
-        }
-         """
-        return asyncio.get_event_loop().run_until_complete(
-            self._async_find_collections_w_body(body, output_format, output_format_set))
-
-
-    @dynamic_catch
-    async def _async_find_collections(self, search_string: str = '*', classification_name: str = None,
+    async def _async_find_collections(self, search_string: str = "*", classification_names: list[str] = None,
+                                      metadata_element_types: list[str] = None,
                                       starts_with: bool = True, ends_with: bool = False, ignore_case: bool = False,
                                       start_from: int = 0, page_size: int = 0, output_format: str = 'JSON',
-                                      output_format_set: str | dict = None) -> list | str:
+                                      output_format_set: str | dict = None,
+                                      body: dict | SearchStringRequestBody = None) -> list | str:
         """ Returns the list of collections matching the search string filtered by the optional classification.
-            The search string is located in the request body and is interpreted as a plain string. The full
-            body allows complete control including status, asOfTime and effectiveTime.
-            The request parameters, startsWith, endsWith and ignoreCase can be used to allow a fuzzy search.
+            This method can either be used with a body, allowing full control, or with the individual parameters.
+            If the body is provided it will be used and the search_string will be ignored.
 
         Parameters
         ----------
         search_string: str
             Search string to match against - None or '*' indicate match against all collections (may be filtered by
             classification).
-        classification_name: str, optional, default=None
-            A classification name to filter on - for example, DataSpec for data specifications. If none,
+        classification_names: list[str], optional, default=None
+            A list of classification names to filter on - for example, ["DataSpec"], for data specifications. If none,
             then all classifications are returned.
+        metadata_element_types: list[str], optional, default=None
+            A list of metadata element types to filter on - for example, ["DataSpec"], for data specifications. If none,
         starts_with : bool, [default=False], optional
             Starts with the supplied string.
         ends_with : bool, [default=False], optional
@@ -431,58 +304,62 @@ class CollectionManager(Client2):
             the class instance.
         output_format: str, default = "JSON"
             - one of "MD", "LIST", "FORM", "REPORT", "DICT", "MERMAID" or "JSON"
-         output_format_set: str | dict , optional, default = None
+        output_format_set: str | dict , optional, default = None
             - The desired output columns/fields to include.
+        body: dict | SearchStringRequestBody, optional, default = None
+            - if provided, the search parameters in the body will supercede other attributes, such as "search_string"
+
         Returns
         -------
         List | str
 
-        A list of collections match matching the search string. Returns a string if none found.
+        Output depends on the output format specified.
 
         Raises
         ------
 
-        InvalidParameterException
-          If the client passes incorrect parameters on the request - such as bad URLs or invalid values
-        PropertyServerException
-          Raised by the server when an issue arises in processing a valid request
+        ValidationError
+          If the client passes incorrect parameters on the request that don't conform to the data model.
+        PyegeriaException
+          Issues raised in communicating or server side processing.
         NotAuthorizedException
           The principle specified by the user_id does not have authorization for the requested action
 
         """
-        search_string = search_string if search_string != "*" else None
-
-        body = SearchStringRequestBody(
-            class_="SearchStringRequestBody",
-            starts_with=starts_with,
-            ends_with=ends_with,
-            ignore_case=ignore_case,
-            include_only_classified_elements = [classification_name],
-            search_string=search_string,
-            start_from=start_from,
-            page_size=page_size
-            )
-
-        resp = await self._async_find_collections_w_body(body, output_format, output_format_set)
-        return resp
+        url = str(HttpUrl(f"{self.collection_command_root}/by-search-string"))
+        response = await self._async_find_request(url, _type="Collection",
+                                                  _gen_output=self._generate_collection_output,
+                                                  search_string = search_string, classification_names = classification_names,
+                                                  metadata_element_types = metadata_element_types,
+                                                  starts_with = starts_with, ends_with = ends_with, ignore_case = ignore_case,
+                                                  start_from = start_from, page_size = page_size,
+                                                  output_format=output_format, output_format_set=output_format_set,
+                                                  body=body)
+
+        return response
 
     @dynamic_catch
-    def find_collections(self, search_string: str = '*', classification_name: str = None, starts_with: bool = True,
+    def find_collections(self, search_string: str = '*', classification_names: str = None,
+                         metadata_element_types: list[str] = None, starts_with: bool = True,
                          ends_with: bool = False, ignore_case: bool = False,
                          start_from: int = 0, page_size: int = 0, output_format: str = 'JSON',
-                         output_format_set: str | dict = None) -> list | str:
+                         output_format_set: str | dict = None,
+                         body: dict | SearchStringRequestBody = None) -> list | str:
         """ Returns the list of collections matching the search string filtered by the optional classification.
-            The search string is located in the request body and is interpreted as a plain string. The full
-            body allows complete control including status, asOfTime and effectiveTime.
-            The request parameters, startsWith, endsWith and ignoreCase can be used to allow a fuzzy search.
+            This method can either be used with a body, allowing full control, or with the individual parameters.
+            If the body is provided it will be used and the search_string will be ignored.
 
         Parameters
         ----------
         search_string: str
-            String to match against - None or '*' indicate match against all collections (may be filtered
-        classification_name: str, optional, default=None
-            A classification name to filter on - for example, DataSpec for data specifications. If none,
+            Search string to match against - None or '*' indicate match against all collections (may be filtered by
+            classification).
+        classification_names: list[str], optional, default=None
+            A list of classification names to filter on - for example, ["DataSpec"], for data specifications. If none,
             then all classifications are returned.
+        metadata_element_types: list[str], optional, default=None
+            A list of metadata element types to filter on - for example, ["DataSpec"], for data specifications. If none,
+            then all metadata element types are returned.
         starts_with : bool, [default=False], optional
             Starts with the supplied string.
         ends_with : bool, [default=False], optional
@@ -496,32 +373,41 @@ class CollectionManager(Client2):
             the class instance.
         output_format: str, default = "JSON"
             - one of "MD", "LIST", "FORM", "REPORT", "DICT", "MERMAID" or "JSON"
-         output_format_set: str | dict , optional, default = None
+        output_format_set: str | dict , optional, default = None
             - The desired output columns/fields to include.
+        body: dict | SearchStringRequestBody, optional, default = None
+            - if provided, the search parameters in the body will supercede other attributes, such as "search_string"
+
         Returns
         -------
         List | str
 
-        A list of collections match matching the search string. Returns a string if none found.
+        Output depends on the output format specified.
 
         Raises
         ------
 
-        InvalidParameterException
-          If the client passes incorrect parameters on the request - such as bad URLs or invalid values
-        PropertyServerException
-          Raised by the server when an issue arises in processing a valid request
+        ValidationError
+          If the client passes incorrect parameters on the request that don't conform to the data model.
+        PyegeriaException
+          Issues raised in communicating or server side processing.
         NotAuthorizedException
           The principle specified by the user_id does not have authorization for the requested action
 
+        Args:
+            classification_names ():
+            metadata_element_types ():
+
         """
         return asyncio.get_event_loop().run_until_complete(
-            self._async_find_collections(search_string, classification_name, starts_with, ends_with, ignore_case,
-                                         start_from, page_size, output_format, output_format_set))
+            self._async_find_collections(search_string, classification_names, metadata_element_types,
+                                         starts_with, ends_with, ignore_case,
+                                         start_from, page_size, output_format,
+                                         output_format_set, body))
 
 
     @dynamic_catch
-    async def _async_get_collections_by_name(self, name: str = None, classification_name: str = None,
+    async def _async_get_collections_by_name(self, filter_string: str = None, classification_names: list[str] = None,
                                              body: dict | FilterRequestBody = None,
                                              start_from: int = 0, page_size: int = 0,
                                              output_format: str = 'JSON',
@@ -532,7 +418,7 @@ class CollectionManager(Client2):
             ----------
             name: str,
                 name to use to find matching collections.
-            classification_name: str, optional, default = None
+            classification_names: list[str], optional, default = None
                 type of collection to filter by - e.g., DataDict, Folder, Root
             body: dict, optional, default = None
                 Provides, a full request body. If specified, the body supercedes the name parameter.
@@ -543,7 +429,7 @@ class CollectionManager(Client2):
                 the class instance.
             output_format: str, default = "JSON"
                 - one of "DICT", "MERMAID" or "JSON"
-         output_format_set: dict , optional, default = None
+            output_format_set: dict , optional, default = None
                 The desired output columns/fields to include.
 
             Returns
@@ -562,47 +448,20 @@ class CollectionManager(Client2):
             NotAuthorizedException
               The principle specified by the user_id does not have authorization for the requested action
         """
+        url = str(HttpUrl(f"{self.collection_command_root}/by-name"))
+        response = await self._async_get_name_request(url, _type="Collection",
+                                                  _gen_output=self._generate_collection_output,
+                                                  filter_string = filter_string, classification_names = classification_names,
+                                                  start_from = start_from, page_size = page_size,
+                                                  output_format=output_format, output_format_set=output_format_set,
+                                                  body=body)
 
-        if body is None:
-            validated_body = FilterRequestBody(
-                class_ = "FilterRequestBody",
-                filter = name,
-                start_from = start_from,
-                page_size = page_size,
-                include_only_classified_elements= [classification_name] if classification_name else None
-                )
-        elif isinstance(body, FilterRequestBody):
-            validated_body = body
-        elif isinstance(body, dict):
-            try:
-                validated_body = self._filter_request_adapter.validate_python(body)
-            except ValidationError as e:
-                context: dict = {
-                    'class name': __class__.__name__, 'caller method': inspect.currentframe().f_back.f_code.co_name
-                    }
-                raise PyegeriaInvalidParameterException(context=context, Exception=e)
-        else:
-            raise TypeError("Invalid parameter type")
-
-        url = f"{self.collection_command_root}/by-name"
-        classification_name = validated_body.include_only_classified_elements
+        return response
 
-        response = await self._async_make_request("POST", url, validated_body.model_dump_json())
-        elements = response.json().get("elements", NO_ELEMENTS_FOUND)
-        if type(elements) is str:
-            logger.info(NO_ELEMENTS_FOUND)
-            return NO_ELEMENTS_FOUND
 
-        if output_format != 'JSON':  # return a simplified markdown representation
-            logger.info(f"Found elements, output format: {output_format}, output_format_set: {output_format_set}")
-            return self._generate_collection_output(elements, filter, classification_name,
-                                                    output_format, output_format_set)
-        return elements
-
-
-    def get_collections_by_name(self, name: str = None, classification_name: str = None,
+    def get_collections_by_name(self, name: str = None, classification_names: list[str] = None,
                                 body: dict | FilterRequestBody = None,
-                                start_from: int = 0, page_size: int = None, output_format: str = 'JSON',
+                                start_from: int = 0, page_size: int = 0, output_format: str = 'JSON',
                                 output_format_set: str | dict = None) -> list | str:
         """Returns the list of collections matching the search string. Async version.
             The search string is located in the request body and is interpreted as a plain string.
@@ -612,7 +471,7 @@ class CollectionManager(Client2):
         ----------
         name: str,
             name to use to find matching collections.
-        classification_name: str, optional, default = None
+        classification_names: list[str], optional, default = None
             type of collection to filter by - e.g., DataDict, Folder, Root
         body: dict, optional, default = None
             Provides, a full request body. If specified, the body supercedes the name parameter.
@@ -638,24 +497,24 @@ class CollectionManager(Client2):
 
         """
         return asyncio.get_event_loop().run_until_complete(
-            self._async_get_collections_by_name(name, classification_name, body, start_from, page_size,
+            self._async_get_collections_by_name(name, classification_names, body, start_from, page_size,
                                                 output_format, output_format_set))
 
 
     @dynamic_catch
-    async def _async_get_collections_by_type(self, collection_type: str, classification_name: str = None,
+    async def _async_get_collections_by_category(self, category: str, classification_names: list[str] = None,
                                              body: dict | FilterRequestBody = None, start_from: int = 0, page_size: int = 0,
                                              output_format: str = 'JSON',
                                              output_format_set: str | dict = None) -> list | str:
-        """Returns the list of collections with a particular collectionType. This is an optional text field in the
+        """Returns the list of collections with a particular category. This is an optional text field in the
             collection element.
 
         Parameters
         ----------
-        collection_type: str
-            collection_type to use to find matching collections.
-        classification_name: str, optional
-            An optional filter on the search,  e.g., DataSpec
+        category: str
+            category to use to find matching collections.
+        classification_names: str, optional
+            An optional filter on the search, e.g., DataSpec
         body: dict, optional, default = None
             Provides, a full request body. If specified, the body filter parameter supercedes the collection_type
             parameter.
@@ -692,49 +551,23 @@ class CollectionManager(Client2):
           "limitResultsByStatus": ["ACTIVE"],
           "sequencingOrder": "PROPERTY_ASCENDING",
           "sequencingProperty": "qualifiedName",
-          "filter": "Add collection type here"
+          "filter": "Add category here"
         }
 
         """
-        if body is None:
-            validated_body = FilterRequestBody(
-                class_ = "FilterRequestBody",
-                filter = collection_type,
-                start_from = start_from,
-                page_size = page_size,
-                include_only_classified_elements= [classification_name] if classification_name else None
-                )
-        elif isinstance(body, FilterRequestBody):
-            validated_body = body
-        elif isinstance(body, dict):
-            try:
-                validated_body = self._filter_request_adapter.validate_python(body)
-            except ValidationError as e:
-                context: dict = {
-                    'class name': __class__.__name__, 'caller method': inspect.currentframe().f_back.f_code.co_name
-                    }
-                raise PyegeriaInvalidParameterException(context=context, Exception=e)
-        else:
-            raise TypeError("Invalid parameter type")
-
-        classification_name = validated_body.include_only_classified_elements
+        url = str(HttpUrl(f"{self.collection_command_root}/by-collection-category"))
+        response = await self._async_get_name_request(url, _type="Collection",
+                                                  _gen_output=self._generate_collection_output,
+                                                  filter_string = category, classification_names = classification_names,
+                                                  start_from = start_from, page_size = page_size,
+                                                  output_format=output_format, output_format_set=output_format_set,
+                                                  body=body)
 
-        url = f"{self.collection_command_root}/by-collection-category"
+        return response
 
-        response = await self._async_make_request("POST", url, validated_body.model_dump_json())
-        elements = response.json().get("elements", NO_ELEMENTS_FOUND)
-        if type(elements) is str:
-            logger.info(NO_ELEMENTS_FOUND)
-            return NO_ELEMENTS_FOUND
-
-        if output_format != 'JSON':  # return a simplified markdown representation
-            logger.info(f"Found elements, output format: {output_format}, output_format_set: {output_format_set}")
-            return self._generate_collection_output(elements, filter, classification_name,
-                                                    output_format, output_format_set)
-        return elements
 
 
-    def get_collections_by_type(self, collection_type: str, classification_name: str = None,
+    def get_collections_by_category(self, category: str, classification_names: list[str] = None,
                                 body: dict | FilterRequestBody = None,
                                 start_from: int = 0, page_size: int = 0, output_format: str = 'JSON',
                                 output_format_set: str | dict = None) -> list | str:
@@ -743,9 +576,9 @@ class CollectionManager(Client2):
 
         Parameters
         ----------
-        collection_type: str
+        category: str
             category to use to find matching collections.
-        classification_name: str, optional
+        classification_names: list[str], optional
             An optional filter on the search, e.g., DataSpec
         body: dict, optional, default = None
             Provides, a full request body. If specified, the body filter parameter supersedes the category
@@ -757,14 +590,14 @@ class CollectionManager(Client2):
             the class instance.
         output_format: str, default = "JSON"
             - one of "DICT", "MERMAID" or "JSON"
-         output_format_set: str | dict , optional, default = None
+        output_format_set: str | dict, optional, default = None
                 The desired output columns/fields to include.
 
         Returns
         -------
         List | str
 
-        A list of collections of the specified collection type. Returns a string if none found.
+        A list of collections filtered by the specified category. Output based on specified output format.
 
         Raises
         ------
@@ -789,13 +622,13 @@ class CollectionManager(Client2):
           "limitResultsByStatus": ["ACTIVE"],
           "sequencingOrder": "PROPERTY_ASCENDING",
           "sequencingProperty": "qualifiedName",
-          "filter": "Add collection type here"
+          "filter": "Add category here"
         }
 
         """
 
         return asyncio.get_event_loop().run_until_complete(
-            self._async_get_collections_by_type(collection_type, classification_name, body, start_from, page_size,
+            self._async_get_collections_by_category(category, classification_names, body, start_from, page_size,
                                                 output_format, output_format_set))
 
 
@@ -810,13 +643,13 @@ class CollectionManager(Client2):
         ----------
         collection_guid: str,
             unique identifier of the collection.
-        collection_type: str, default = None, optional
-            type of collection - Data Dictionary, Data Spec, Data Product, etc.
-        body: dict, optional, default = None
+        element_type: str, default = None, optional
+            type of collection - Collection, DataSpec, Agreement, etc.
+        body: dict | GetRequestBody, optional, default = None
             full request body.
         output_format: str, default = "JSON"
             - one of "DICT", "MERMAID" or "JSON"
-         output_format_set: str | dict , optional, default = None
+         output_format_set: str | dict, optional, default = None
                 The desired output columns/fields to include.
 
         Returns
@@ -847,43 +680,20 @@ class CollectionManager(Client2):
         }
         """
 
-        if body is None:
-            validated_body = GetRequestBody(
-                class_ = "GetRequestBody",
-                metadata_element_type_name=element_type
-                )
-        elif isinstance(body, FilterRequestBody):
-            validated_body = body
-        elif isinstance(body, dict):
-            try:
-                validated_body = self._get_request_adapter.validate_python(body)
-            except ValidationError as e:
-                context: dict = {
-                    'class name': __class__.__name__, 'caller method': inspect.currentframe().f_back.f_code.co_name
-                    }
-                raise PyegeriaInvalidParameterException(context=context, Exception=e)
-        else:
-            raise TypeError("Invalid parameter type")
-
-        url = f"{self.collection_command_root}/{collection_guid}"
+        url = str(HttpUrl(f"{self.collection_command_root}/{collection_guid}"))
+        type = element_type if element_type else "Collection"
 
+        response = await self._async_get_guid_request(url, _type=type,
+                                                  _gen_output=self._generate_collection_output,
+                                                  output_format=output_format, output_format_set=output_format_set,
+                                                  body=body)
 
-        response = await self._async_make_request("POST", url,
-                                                  validated_body.model_dump_json())
+        return response
 
-        elements = response.json().get("element", NO_ELEMENTS_FOUND)
-        if type(elements) is str:
-            logger.info(NO_ELEMENTS_FOUND)
-            return NO_ELEMENTS_FOUND
 
-        if output_format != 'JSON':  # return a simplified markdown representation
-            logger.info(f"Found elements, output format: {output_format}, output_format_set: {output_format_set}")
-            return self._generate_collection_output(elements, None, element_type,
-                                                    output_format, output_format_set)
-        return elements
 
 
-    def get_collection_by_guid(self, collection_guid: str, element_type: str = None, body: dict = None,
+    def get_collection_by_guid(self, collection_guid: str, element_type: str = None, body: dict | GetRequestBody= None,
                                output_format: str = 'JSON', output_format_set: str | dict = None) -> dict | str:
         """ Return the properties of a specific collection. Async version.
 
@@ -891,13 +701,13 @@ class CollectionManager(Client2):
             ----------
             collection_guid: str,
                 unique identifier of the collection.
-            collection_type: str, default = None, optional
-                type of collection - Data Dictionary, Data Spec, Data Product, etc.
-            body: dict, optional, default = None
+            element_type: str, default = None, optional
+                type of element - Collection, DataSpec, Agreement, etc.
+            body: dict | GetRequestBody, optional, default = None
                 full request body.
             output_format: str, default = "JSON"
                 - one of "DICT", "MERMAID" or "JSON"
-         output_format_set: dict , optional, default = None
+            output_format_set: dict , optional, default = None
                 The desired output columns/fields to include.
 
 
@@ -935,7 +745,7 @@ class CollectionManager(Client2):
 
     @dynamic_catch
     async def _async_get_collection_members(self, collection_guid: str = None, collection_name: str = None,
-                                            collection_qname: str = None, body: dict = None, start_from: int = 0,
+                                            collection_qname: str = None, body: dict | ResultsRequestBody = None, start_from: int = 0,
                                             page_size: int = 0, output_format: str = "JSON",
                                             output_format_set: str | dict = None) -> list | str:
         """Return a list of elements that are a member of a collection. Async version.
@@ -994,27 +804,18 @@ class CollectionManager(Client2):
         """
 
         if collection_guid is None:
-            collection_guid = self.__get_guid__(collection_guid, collection_name, "name",
+            collection_guid = self.__get_guid__(collection_guid, collection_name, "displayName",
                                                 collection_qname, None, )
 
-        url = (f"{self.collection_command_root}/{collection_guid}/"
-               f"members?startFrom={start_from}&pageSize={page_size}")
+        url = str(HttpUrl(f"{self.collection_command_root}/{collection_guid}/members"))
 
-        if body:
-            response = await self._async_make_request("POST", url, body_slimmer(body))
-        else:
-            response = await self._async_make_request("POST", url)
 
-        elements = response.json().get("elements", NO_MEMBERS_FOUND)
-        if type(elements) is str:
-            logger.trace(f"No elements found for collection {collection_guid}")
-            return NO_MEMBERS_FOUND
+        response = await self._async_get_results_body_request(url, _type="Collection",
+                                                  _gen_output=self._generate_collection_output,
+                                                  output_format=output_format, output_format_set=output_format_set,
+                                                  body=body)
 
-        if output_format != 'JSON':  # return a simplified markdown representation
-            logger.debug(f"Found elements, output format: {output_format}, output_format_set: {output_format_set}")
-            return self._generate_collection_output(elements, None, None,
-                                                    output_format, output_format_set)
-        return elements
+        return response
 
 
     def get_collection_members(self, collection_guid: str = None, collection_name: str = None,
@@ -1083,19 +884,17 @@ class CollectionManager(Client2):
 
 
     @dynamic_catch
-    async def _async_get_collection_graph(self, collection_guid: str, body: dict = None, start_from: int = 0,
+    async def _async_get_collection_hierarchy(self, collection_guid: str, body: dict | ResultsRequestBody = None, start_from: int = 0,
                                           page_size: int = 0, output_format: str = "JSON",
                                           output_format_set: str | dict = None) -> list | str:
-        """ Return a graph of elements that are the nested members of a collection along
-                with elements immediately connected to the starting collection.  The result
-                includes a mermaid graph of the returned elements. Async version.
+        """ Return a hierarchy of nested collections. Request body is optional Async version.
 
             Parameters
             ----------
             collection_guid: str,
                 identity of the collection to return members for. If none, collection_name or
                 collection_qname are used.
-            body: dict, optional, default = None
+            body: dict | ResultsRequestBody, optional, default = None
                 Providing the body allows full control of the request and replaces filter parameters.
             start_from: int, [default=0], optional
                         When multiple pages of results are available, the page number to start from.
@@ -1104,14 +903,14 @@ class CollectionManager(Client2):
                 the class instance.
             output_format: str, default = "JSON"
                 - one of "MD", "LIST", "FORM", "REPORT", "DICT", "MERMAID" or "JSON"
-         output_format_set: dict , optional, default = None
+             output_format_set: dict , optional, default = None
                 The desired output columns/fields to include.
 
             Returns
             -------
             List | str
 
-            A graph anchored in the collection.
+           Results based on the output format.
 
             Raises
             ------
@@ -1126,37 +925,29 @@ class CollectionManager(Client2):
             Notes:
             -----
                 Body sample:
-                {
-                  "class": "ResultsRequestBody",
-                  "effectiveTime": "{{$isoTimestamp}}",
-                  "limitResultsByStatus": ["ACTIVE"],
-                  "asOfTime": "{{$isoTimestamp}}",
-                  "sequencingOrder": "CREATION_DATE_RECENT",
-                  "sequencingProperty": ""
-                }
+            {
+              "class": "ResultsRequestBody",
+              "startFrom": 0,
+              "pageSize": 0,
+              "effectiveTime": "{{$isoTimestamp}}",
+              "limitResultsByStatus": ["ACTIVE"],
+              "asOfTime": "{{$isoTimestamp}}",
+              "sequencingOrder": "CREATION_DATE_RECENT",
+              "sequencingProperty": ""
+            }
             """
 
-        url = (f"{self.collection_command_root}/{collection_guid}/"
-               f"graph?startFrom={start_from}&pageSize={page_size}")
-
-        if body:
-            response = await self._async_make_request("POST", url, body_slimmer(body))
-        else:
-            response = await self._async_make_request("POST", url)
-
-        elements = response.json().get("graph", NO_ELEMENTS_FOUND)
-        if type(elements) is str:
-            logger.info(NO_ELEMENTS_FOUND)
-            return NO_ELEMENTS_FOUND
-
-        if output_format != 'JSON':  # return a simplified markdown representation
-            logger.info(f"Found elements, output format: {output_format}, output_format_set: {output_format_set}")
-            return self._generate_collection_output(elements, None, None,
-                                                    output_format, output_format_set)
-        return elements
+        url = str(HttpUrl(f"{self.collection_command_root}/{collection_guid}/hierarchy"))
+        response = await self._async_get_results_body_request(url, _type="Collection",
+                                                              _gen_output=self._generate_collection_output,
+                                                              start_from=start_from, page_size=page_size,
+                                                              output_format=output_format,
+                                                              output_format_set=output_format_set,
+                                                              body=body)
 
+        return response
 
-    def get_collection_graph(self, collection_guid: str = None, body: dict = None, start_from: int = 0,
+    def get_collection_hierarchy(self, collection_guid: str = None, body: dict| ResultsRequestBody = None, start_from: int = 0,
                              page_size: int = 0, output_format: str = "JSON",
                              output_format_set: str | dict = None) -> list | str:
         """ Return a graph of elements that are the nested members of a collection along
@@ -1209,168 +1000,14 @@ class CollectionManager(Client2):
             }
         """
         return asyncio.get_event_loop().run_until_complete(
-            self._async_get_collection_graph(collection_guid, body, start_from, page_size,
+            self._async_get_collection_hierarchy(collection_guid, body, start_from, page_size,
                                              output_format, output_format_set))
 
 
-    @dynamic_catch
-    async def _async_get_collection_graph_w_body(self, collection_guid: str, body: dict = None, start_from: int = 0,
-                                                 page_size: int = None, output_format: str = "JSON",
-                                                 output_format_set: str | dict = None) -> list | str:
-        """ Return a graph of elements that are the nested members of a collection along
-            with elements immediately connected to the starting collection.  The result
-            includes a mermaid graph of the returned elements. Async version.
-
-            Parameters
-            ----------
-            collection_guid: str,
-                identity of the collection to return members for.
-            body: dict
-                A dictionary containing the body of the request. See Note.
-            start_from: int, [default=0], optional
-                        When multiple pages of results are available, the page number to start from.
-            page_size: int, [default=None]
-                The number of items to return in a single page. If not specified, the default will be taken from
-                the class instance.
-            output_format: str, default = "JSON"
-                - one of "MD", "LIST", "FORM", "REPORT", "DICT", "MERMAID" or "JSON"
-    output_format_set: dict , optional, default = None
-
-            Returns
-            -------
-            List | str
-
-            A list of collection members in the collection.
-
-            Raises
-            ------
-            InvalidParameterException
-              If the client passes incorrect parameters on the request - such as bad URLs or invalid values
-            PropertyServerException
-              Raised by the server when an issue arises in processing a valid request
-            NotAuthorizedException
-              The principle specified by the user_id does not have authorization for the requested action
-
-            Note
-            ____
-            {
-              "class": "ResultsRequestBody",
-              "effectiveTime": "{{$isoTimestamp}}",
-              "limitResultsByStatus": ["ACTIVE"],
-              "asOfTime": "{{$isoTimestamp}}",
-              "sequencingOrder": "CREATION_DATE_RECENT",
-              "sequencingProperty": ""
-            }
-
-        """
-
-        if page_size is None:
-            page_size = self.page_size
-
-        url = (f"{self.collection_command_root}/{collection_guid}/"
-               f"graph?startFrom={start_from}&pageSize={page_size}")
-
-        response = await self._async_make_request("GET", url, body_slimmer(body))
-        elements = response.json().get("elements", NO_ELEMENTS_FOUND)
-        if type(elements) is str:
-            logger.info(NO_ELEMENTS_FOUND)
-            return NO_ELEMENTS_FOUND
-
-        if output_format != 'JSON':  # return a simplified markdown representation
-            logger.info(f"Found elements, output format: {output_format}, output_format_set: {output_format_set}")
-            return self._generate_collection_output(elements, None, None,
-                                                    output_format, output_format_set)
-        return elements
-
-
-    def get_collection_graph_w_body(self, collection_guid: str, body: dict = None, start_from: int = 0,
-                                    page_size: int = None, output_format: str = "JSON",
-                                    output_format_set: str | dict = None) -> list | str:
-        """ Return a graph of elements that are the nested members of a collection along
-            with elements immediately connected to the starting collection.  The result
-            includes a mermaid graph of the returned elements.
-
-            Parameters
-            ----------
-            collection_guid: str,
-               identity of the collection to return members for.
-            body: dict
-               A dictionary containing the body of the request. See Note.
-            start_from: int, [default=0], optional
-                       When multiple pages of results are available, the page number to start from.
-            page_size: int, [default=None]
-               The number of items to return in a single page. If not specified, the default will be taken from
-               the class instance.
-            output_format: str, default = "JSON"
-               - one of "MD", "LIST", "FORM", "REPORT", "DICT", "MERMAID" or "JSON"
-             output_format_set: str | dict  , optional, default = None
-                The desired output columns/fields to include.
-
-            Returns
-            -------
-            List | str
-
-            A list of collection members in the collection.
-
-            Raises
-            ------
-            InvalidParameterException
-               If the client passes incorrect parameters on the request - such as bad URLs or invalid values
-            PropertyServerException
-               Raised by the server when an issue arises in processing a valid request
-            NotAuthorizedException
-              The principle specified by the user_id does not have authorization for the requested action
-
-            Note
-            ____
-            {
-              "class": "ResultsRequestBody",
-              "effectiveTime": "{{$isoTimestamp}}",
-              "limitResultsByStatus": ["ACTIVE"],
-              "asOfTime": "{{$isoTimestamp}}",
-              "sequencingOrder": "CREATION_DATE_RECENT",
-              "sequencingProperty": ""
-            }
-
-       """
-
-        return asyncio.get_event_loop().run_until_complete(
-            self._async_get_collection_graph_w_body(collection_guid, body, start_from,
-                                                    page_size, output_format, output_format_set))
-
-        #
-        #   Create collection methods
-        #
-
-        ###
-        # =====================================================================================================================
-        # Create Collections: https://egeria-project.org/concepts/collection
-        # These requests use the following parameters:
-        #
-        # anchorGUID - the unique identifier of the element that should be the anchor for the new element. Set to
-        # null if
-        # no anchor,
-        # or if this collection is to be its own anchor.
-        #
-        # isOwnAnchor -this element should be classified as its own anchor or not.  The default is false.
-        #
-        # parentGUID - the optional unique identifier for an element that should be connected to the newly
-        # created element.
-        # If this property is specified, parentRelationshipTypeName must also be specified
-        #
-        # parentRelationshipTypeName - the name of the relationship, if any, that should be established between
-        # the new
-        # element and the parent element.
-        # Examples could be "ResourceList" or "DigitalServiceProduct".
-        #
-        # parentAtEnd1 -identifies which end any parent entity sits on the relationship.
-        #
-
-
     @dynamic_catch
     async def _async_create_collection(self, display_name: str = None, description: str = None,
-                                              category: str = None, classification_name: str = None,
-                                              body: dict | NewElementRequestBody = None) -> str:
+                                       category: str = None, initial_classifications: list[str] = None,
+                                       body: dict | NewElementRequestBody = None) -> str:
         """ Create a new generic collection. If the body is not present, the display_name, description, category
             and classification will be used to create a simple, self-anchored collection.
             Collections: https://egeria-project.org/concepts/collection
@@ -1385,8 +1022,8 @@ class CollectionManager(Client2):
             The description of the collection.
         category: str, optional
             An optional user-assigned category for the collection.
-        classification: str, optional
-            An initial classification for the collection. This can be used to distinguish, for instance, Folders
+        initial_classifications: list[str], optional
+            An initial list of classifications for the collection. This can be used to distinguish, for instance, Folders
             from Root Collections.
 
         body: dict | NewElementRequestBody, optional
@@ -1473,30 +1110,19 @@ class CollectionManager(Client2):
         }
 
         """
-
-
-        if isinstance(body, NewElementRequestBody):
-            validated_body = body
-        elif isinstance(body, dict):
-            try:
-                validated_body = self._new_element_request_adapter.validate_python(body)
-            except ValidationError as e:
-                logger.error(f"Validation error: {e}")
-                raise ValidationError(e)
-        elif display_name is not None:
-            pre = classification_name if classification_name is not None else "Collection   "
+        if body:
+            validated_body = self.validate_new_element_request(body,"CollectionProperties")
+        elif (body is None) and (display_name is not None):
+            pre = initial_classifications[0] if initial_classifications is not None else "Collection"
             qualified_name = self.__create_qualified_name__(pre, display_name, EGERIA_LOCAL_QUALIFIER)
-            print(f"\n\tDisplayName was {display_name}, classification {classification_name}\n")
-            if classification_name:
-                initial_classifications_data = {"class": "ClassificationProperties"}
-                initial_classification_dict = {
-                    classification_name: InitialClassifications.model_validate(initial_classifications_data)
-                    }
+            if initial_classifications:
+                initial_classifications_dict = {}
+                for c in initial_classifications:
+                    initial_classifications_dict = initial_classifications_dict | {c : {"class": "ClassificationProperties"}}
+
             else:
-                initial_classification_dict = None
-            initial_classification_dict = {
-                classification_name: InitialClassifications.model_validate(initial_classifications_data)
-                }
+                initial_classifications_dict = None
+
             collection_properties = CollectionProperties( class_ = "CollectionProperties",
                                                              qualified_name = qualified_name,
                                                              display_name = display_name,
@@ -1506,12 +1132,12 @@ class CollectionManager(Client2):
             body = {
                 "class" :"NewElementRequestBody",
                 "isOwnAnchor": True,
-                "initialClassifications": initial_classification_dict,
+                "initialClassifications": initial_classifications_dict,
                 "properties": collection_properties.model_dump()
                 }
             validated_body = NewElementRequestBody.model_validate(body)
         else:
-            raise TypeError("Invalid parameter type")
+            raise PyegeriaInvalidParameterException(additional_info={"reason": "Invalid input parameters"})
 
         url = f"{self.collection_command_root}"
         json_body = validated_body.model_dump_json(indent=2, exclude_none=True)
@@ -1522,7 +1148,7 @@ class CollectionManager(Client2):
 
 
     def create_collection(self, display_name: str = None, description: str = None,
-                                category: str = None, classification_name: str = None,
+                                category: str = None, initial_classifications: list[str] = None,
                                 body: dict | NewElementRequestBody = None) -> str:
         """ Create a new generic collection. If the body is not present, the display_name, description, category
             and classification will be used to create a simple, self-anchored collection.
@@ -1537,7 +1163,7 @@ class CollectionManager(Client2):
             The description of the collection.
         category: str, optional
             An optional user-assigned category for the collection.
-        classification: str, optional
+        initial_classifications: str, optional
             An initial classification for the collection. This can be used to distinguish, for instance, Folders
             from Root Collections.
 
@@ -1629,7 +1255,7 @@ class CollectionManager(Client2):
 
         return asyncio.get_event_loop().run_until_complete(
             self._async_create_collection(display_name, description,category,
-                                                 classification_name,    body))
+                                                 initial_classifications,    body))
 
 
     @dynamic_catch
@@ -1668,11 +1294,9 @@ class CollectionManager(Client2):
 
         return asyncio.get_event_loop().run_until_complete(
             self._async_create_collection(display_name, description, category,
-                                          "RootCollection", body))
+                                          ["RootCollection"], body))
 
-#######
 
-        return resp
     @dynamic_catch
     def create_folder_collection(self, display_name: str = None, description: str = None,
                                       category: str = None, body: dict | NewElementRequestBody = None) -> str:
@@ -1709,7 +1333,7 @@ class CollectionManager(Client2):
 
         return asyncio.get_event_loop().run_until_complete(
             self._async_create_collection(display_name, description, category,
-                                          "Folder", body))
+                                          ["Folder"], body))
 
 
 
@@ -1750,14 +1374,10 @@ class CollectionManager(Client2):
 
         return asyncio.get_event_loop().run_until_complete(
             self._async_create_collection(display_name, description, category,
-                                          "ReferenceList", body))
-
-
-
+                                          ["ReferenceList"], body))
 
-        return resp
     @dynamic_catch
-    def create_reference_list_collection(self, display_name: str = None, description: str = None,
+    def create_context_event_collection(self, display_name: str = None, description: str = None,
                                       category: str = None, body: dict | NewElementRequestBody = None) -> str:
         """ Create a new collection with the RootCollection classification.  Used to identify the top of a
             collection hierarchy.
@@ -1792,7 +1412,7 @@ class CollectionManager(Client2):
 
         return asyncio.get_event_loop().run_until_complete(
             self._async_create_collection(display_name, description, category,
-                                          "ReferenceList", body))
+                                          ["ContextEvent"], body))
 
     @dynamic_catch
     async def _async_create_data_spec_collection(self, display_name: str = None, description: str = None,
@@ -1900,51 +1520,35 @@ class CollectionManager(Client2):
         }
 
         """
+        validated_body = self.validate_new_element_request(body,"DataSpecProperties")
 
-        try:
-            if isinstance(body, NewElementRequestBody):
-                if body.properties.class_ == "DataSpecProperties":
-                    validated_body = body
-                else:
-                    raise PyegeriaInvalidParameterException(additional_info =
-                                                           {"reason" : "unexpected property class name"})
-
-            elif isinstance(body, dict):
-                    if body.get("properties", {}).get("class", "") == "DataSpecProperties":
-                        validated_body = self._new_element_request_adapter.validate_python(body)
-                    else:
-                        raise PyegeriaInvalidParameterException(additional_info =
-                                                                {"reason" : "unexpected property class name"})
-
-            elif display_name is not None:
-                qualified_name = self.__create_qualified_name__("DataSpec", display_name, EGERIA_LOCAL_QUALIFIER)
-                print(f"\n\tDisplayName was {display_name}, classification {classification_name}\n")
-                initial_classifications_data = {"class" : "ClassificationProperties"}
-                if classification_name:
-                    initial_classification_dict = {
-                        classification_name: InitialClassifications.model_validate(initial_classifications_data)
-                    }
-                else:
-                    initial_classification_dict = None
-                collection_properties = DataSpecProperties( class_ = "DataSpecProperties",
-                                                                 qualified_name = qualified_name,
-                                                                 display_name = display_name,
-                                                                 description = description,
-                                                                 category = category
-                                                                 )
-                body = {
-                    "class" :"NewElementRequestBody",
-                    "isOwnAnchor": True,
-                    "initialClassifications": initial_classification_dict,
-                    "properties": collection_properties.model_dump()
-                    }
-                validated_body = NewElementRequestBody.model_validate(body)
+        if validated_body is None and display_name is not None:
+            qualified_name = self.__create_qualified_name__("DataSpec", display_name, EGERIA_LOCAL_QUALIFIER)
+            print(f"\n\tDisplayName was {display_name}, classification {classification_name}\n")
+            initial_classifications_data = {"class" : "ClassificationProperties"}
+            if classification_name:
+                initial_classification_dict = {
+                    classification_name: InitialClassifications.model_validate(initial_classifications_data)
+                }
             else:
-                raise TypeError("Invalid parameter type")
+                initial_classification_dict = None
+            collection_properties = DataSpecProperties( class_ = "DataSpecProperties",
+                                                             qualified_name = qualified_name,
+                                                             display_name = display_name,
+                                                             description = description,
+                                                             category = category
+                                                             )
+            body = {
+                "class" :"NewElementRequestBody",
+                "isOwnAnchor": True,
+                "initialClassifications": initial_classification_dict,
+                "properties": collection_properties.model_dump()
+                }
+            validated_body = NewElementRequestBody.model_validate(body)
+        else:
+            raise PyegeriaInvalidParameterException(additional_info={"reason": "Invalid input parameters"})
+
 
-        except ValidationError as e:
-            logger.error(f"Validation error: {e}")
-            raise ValidationError(e)
 
 
         url = f"{self.collection_command_root}"
@@ -1971,7 +1575,7 @@ class CollectionManager(Client2):
             The description of the collection.
         category: str, optional
             An optional user-assigned category for the collection.
-        classification: str, optional
+        classification_name: str, optional
             An initial classification for the collection. This can be used to distinguish, for instance, Folders
             from Root Collections.
 
@@ -2173,49 +1777,33 @@ class CollectionManager(Client2):
 
         """
 
-        try:
-            if isinstance(body, NewElementRequestBody):
-                if body.properties.class_ == "DataDictionaryProperties":
-                    validated_body = body
-                else:
-                    raise PyegeriaInvalidParameterException(additional_info =
-                                                           {"reason" : "unexpected property class name"})
-
-            elif isinstance(body, dict):
-                    if body.get("properties", {}).get("class", "") == "DataDictionaryProperties":
-                        validated_body = self._new_element_request_adapter.validate_python(body)
-                    else:
-                        raise PyegeriaInvalidParameterException(additional_info =
-                                                                {"reason" : "unexpected property class name"})
-
-            elif display_name is not None:
-                qualified_name = self.__create_qualified_name__("DataDictionary", display_name, EGERIA_LOCAL_QUALIFIER)
-                initial_classifications_data = {"class" : "ClassificationProperties"}
-                if classification_name:
-                    initial_classification_dict = {
-                        classification_name: InitialClassifications.model_validate(initial_classifications_data)
-                    }
-                else:
-                    initial_classification_dict = None
-                collection_properties = DataDictionaryProperties( class_ = "DataDictionaryProperties",
-                                                                 qualified_name = qualified_name,
-                                                                 display_name = display_name,
-                                                                 description = description,
-                                                                 category = category
-                                                                 )
-                body = {
-                    "class" :"NewElementRequestBody",
-                    "isOwnAnchor": True,
-                    "initialClassifications": initial_classification_dict,
-                    "properties": collection_properties.model_dump()
-                    }
-                validated_body = NewElementRequestBody.model_validate(body)
+        validated_body = self.validate_new_element_request(body,"DataDictionaryProperties")
+
+        if validated_body is None and display_name is not None:
+            qualified_name = self.__create_qualified_name__("DataDictionary", display_name, EGERIA_LOCAL_QUALIFIER)
+            initial_classifications_data = {"class" : "ClassificationProperties"}
+            if classification_name:
+                initial_classification_dict = {
+                    classification_name: InitialClassifications.model_validate(initial_classifications_data)
+                }
             else:
-                raise TypeError("Invalid parameter type")
+                initial_classification_dict = None
+            collection_properties = DataDictionaryProperties( class_ = "DataDictionaryProperties",
+                                                             qualified_name = qualified_name,
+                                                             display_name = display_name,
+                                                             description = description,
+                                                             category = category
+                                                             )
+            body = {
+                "class" :"NewElementRequestBody",
+                "isOwnAnchor": True,
+                "initialClassifications": initial_classification_dict,
+                "properties": collection_properties.model_dump()
+                }
+            validated_body = NewElementRequestBody.model_validate(body)
 
-        except ValidationError as e:
-            logger.error(f"Validation error: {e}")
-            raise ValidationError(e)
+        if validated_body is None:
+            raise PyegeriaInvalidParameterException(additional_info={"reason": "Invalid input parameters"})
 
 
         url = f"{self.collection_command_root}"
@@ -2480,8 +2068,7 @@ class CollectionManager(Client2):
 
 
     @dynamic_catch
-    async def _async_update_collection(self, collection_guid: str,  body: dict | NewElementRequestBody,
-                                       merge_update: bool = True) -> None:
+    async def _async_update_collection(self, collection_guid: str,  body: dict | UpdateElementRequestBody) -> None:
         """ Update the properties of a collection. Use the correct properties object (CollectionProperties,
             DigitalProductProperties, AgreementProperties, etc), that is appropriate for your element.
             Collections: https://egeria-project.org/concepts/collection
@@ -2492,7 +2079,7 @@ class CollectionManager(Client2):
         collection_guid: str
             The guid of the collection to update.
 
-        body: dict | NewElementRequestBody, optional
+        body: dict | UpdateElementRequestBody, optional
             A dict or NewElementRequestBody representing the details of the collection to create. If supplied, this
             information will be used to create the collection and the other attributes will be ignored. The body is
             validated before being used.
@@ -2534,44 +2121,18 @@ class CollectionManager(Client2):
         }
         """
 
-        try:
-            if isinstance(body, NewElementRequestBody):
-                if body.properties.class_ in COLLECTION_PROPERTIES_LIST:
-                    validated_body = body
-                else:
-                    raise PyegeriaInvalidParameterException(additional_info =
-                                                           {"reason" : "unexpected property class name"})
-
-            elif isinstance(body, dict):
-                if body.get("properties", {}).get("class", "") in COLLECTION_PROPERTIES_LIST:
-                    validated_body = self._new_element_request_adapter.validate_python(body)
-                else:
-                    raise PyegeriaInvalidParameterException(additional_info =
-                                                            {"reason" : "unexpected property class name"})
-            else:
-                raise TypeError("Invalid parameter type")
-
-        except ValidationError as e:
-            logger.error(f"Validation error: {e}")
-            raise ValidationError(e)
-
-        merge_update_s = str(merge_update).lower()
-
-        url = (f"{self.collection_command_root}/{collection_guid}/update?"
-               f"replaceAllProperties={merge_update_s}")
+        # try:
 
-        json_body = validated_body.model_dump_json(indent=2, exclude_none=True)
+        url = (f"{self.collection_command_root}/{collection_guid}/update")
+        await self._async_update_element_body_request(url, COLLECTION_PROPERTIES_LIST,body)
 
-        await self._async_make_request("POST", url, json_body)
 
-        logger.info(f"Successfully updated {collection_guid} with {json_body}")
 
 
 
 
     @dynamic_catch
-    def update_collection(self, collection_guid: str,  body: dict | NewElementRequestBody,
-                                       merge_update: bool = True) -> None:
+    def update_collection(self, collection_guid: str,  body: dict | NewElementRequestBody) -> None:
         """ Update the properties of a collection. Use the correct properties object (CollectionProperties,
             DigitalProductProperties, AgreementProperties, etc), that is appropriate for your element.
             Collections: https://egeria-project.org/concepts/collection
@@ -2624,7 +2185,7 @@ class CollectionManager(Client2):
         """
 
         return asyncio.get_event_loop().run_until_complete(
-            self._async_update_collection(collection_guid, body, merge_update))
+            self._async_update_collection(collection_guid, body))
 
 
     @dynamic_catch
@@ -2695,32 +2256,9 @@ class CollectionManager(Client2):
         OTHER.  If using OTHER, set the userDefinedStatus with the status value you want. If not specified, will
         default to ACTIVE.
         """
-
-        if isinstance(body, NewElementRequestBody):
-            if body.properties.class_ == "DigitalProductProperties":
-                validated_body = body
-            else:
-                raise PyegeriaInvalidParameterException(additional_info=
-                                                        {"reason": "unexpected property class name"})
-
-        elif isinstance(body, dict):
-            if body.get("properties", {}).get("class", "") == "DigitalProductProperties":
-                validated_body = self._new_element_request_adapter.validate_python(body)
-            else:
-                raise PyegeriaInvalidParameterException(additional_info=
-                                                        {"reason": "unexpected property class name"})
-
-        else:
-            raise TypeError("Invalid parameter type")
-
-
-
         url = f"{self.collection_command_root}"
-        json_body = validated_body.model_dump_json(indent=2, exclude_none=True)
-        logger.info(json_body)
-        resp = await self._async_make_request("POST", url, json_body, is_json=True)
-        logger.info(f"Create collection with GUID: {resp.json().get('guid')}")
-        return resp.json().get("guid", NO_GUID_RETURNED)
+        return await self._async_create_element_body_request(url, "DigitalProductProperties", body)
+
 
     @dynamic_catch
     def create_digital_product(self, body: dict | NewElementRequestBody = None) -> str:
@@ -2795,8 +2333,7 @@ class CollectionManager(Client2):
 
 
     @dynamic_catch
-    async def _async_update_digital_product(self, collection_guid: str,  body: dict | UpdateElementRequestBody,
-                                       merge_update: bool = True) -> None:
+    async def _async_update_digital_product(self, collection_guid: str,  body: dict | UpdateElementRequestBody) -> None:
         """ Update the properties of a digital product.
             Collections: https://egeria-project.org/concepts/collection
 
@@ -2860,37 +2397,8 @@ class CollectionManager(Client2):
         }
         """
 
-        try:
-            if isinstance(body, NewElementRequestBody):
-                if body.properties.class_ == "DigitalProductProperties":
-                    validated_body = body
-                else:
-                    raise PyegeriaInvalidParameterException(additional_info =
-                                                           {"reason" : "unexpected property class name"})
-
-            elif isinstance(body, dict):
-                if body.get("properties", {}).get("class", "") == "DigitalProductProperties":
-                    validated_body = self._update_element_request_adapter.validate_python(body)
-                else:
-                    raise PyegeriaInvalidParameterException(additional_info =
-                                                            {"reason" : "unexpected property class name"})
-            else:
-                raise TypeError("Invalid parameter type")
-
-        except ValidationError as e:
-            logger.error(f"Validation error: {e}")
-            raise ValidationError(e)
-
-        merge_update_s = str(merge_update).lower()
-
-        url = (f"{self.collection_command_root}/{collection_guid}/update?"
-               f"replaceAllProperties={merge_update_s}")
-
-        json_body = validated_body.model_dump_json(indent=2, exclude_none=True)
-
-        await self._async_make_request("POST", url, json_body)
-
-        logger.info(f"Successfully updated {collection_guid} with {json_body}")
+        url = (f"{self.collection_command_root}/{collection_guid}/update")
+        await self._async_update_element_request_body(url, "DigitalProductProperties", body )
 
 
     @dynamic_catch
@@ -2963,15 +2471,19 @@ class CollectionManager(Client2):
 
 
     @dynamic_catch
-    async def _async_update_collection_status(self, collection_guid: str, body: dict | UpdateStatusRequestBody):
+    async def _async_update_collection_status(self, collection_guid: str, status: str = None,
+                                              body: dict | UpdateStatusRequestBody = None):
         """Update the status of a collection. Async version.
 
         Parameters
         ----------
         collection_guid: str
             The guid of the collection to update.
-        body: dict | UpdateStatusRequestBody
-            A structure representing the details of the collection to create.
+        status: str, optional
+            The new lifecycle status for the collection. Ignored, if the body is provided.
+        body: dict | UpdateStatusRequestBody, optional
+            A structure representing the details of the collection to create. If supplied, these details
+            supersede the status parameter provided.
 
         Returns
         -------
@@ -2999,31 +2511,24 @@ class CollectionManager(Client2):
           "forDuplicateProcessing": false
         }
         """
-        try:
-            if isinstance(body, UpdateStatusRequestBody):
-               validated_body = body
-            elif isinstance(body, dict):
-                validated_body = self._update_status_request_adapter.validate_python(body)
-
-        except ValidationError as e:
-            logger.error(f"Validation error: {e}")
-            raise ValidationError(e)
 
         url = f"{self.collection_command_root}/{collection_guid}/update-status"
-        json_body = validated_body.model_dump_json(indent=2, exclude_none=True)
-        await self._async_make_request("POST", url, json_body)
-        logger.info(f"Successfully updated {collection_guid} with {json_body}")
+        await self._async_update_status_request(url, status, body)
 
     @dynamic_catch
-    def update_collection_status(self, collection_guid: str, body: dict | UpdateStatusRequestBody):
+    def update_collection_status(self, collection_guid: str, status: str = None,
+                                 body: dict | UpdateStatusRequestBody = None):
         """Update the status of a DigitalProduct collection.
 
         Parameters
         ----------
         collection_guid: str
             The guid of the collection to update.
-        body: dict | UpdateStatusRequestBody
-            A structure representing the details of the collection to create.
+        status: str, optional
+            The new lifecycle status for the digital product. Ignored, if the body is provided.
+        body: dict | UpdateStatusRequestBody, optional
+            A structure representing the details of the collection to create. If supplied, these details
+            supersede the status parameter provided.
 
         Returns
         -------
@@ -3052,19 +2557,23 @@ class CollectionManager(Client2):
         }
         """
         loop = asyncio.get_event_loop()
-        loop.run_until_complete(self._async_update_collection_status(collection_guid, body))
+        loop.run_until_complete(self._async_update_collection_status(collection_guid, status, body))
 
 
     @dynamic_catch
-    def update_digital_product_status(self, digital_product_guid: str, body: dict | UpdateStatusRequestBody):
+    def update_digital_product_status(self, digital_product_guid: str, status: str = None,
+                                      body: dict | UpdateStatusRequestBody = None):
         """Update the status of a DigitalProduct collection.
 
         Parameters
         ----------
         digital_product_guid: str
-            The guid of the digital product collection to update.
-        body: dict | UpdateStatusRequestBody
-            A structure representing the details of the collection to create.
+            The guid of the collection to update.
+        status: str, optional
+            The new lifecycle status for the digital product. Ignored, if the body is provided.
+        body: dict | UpdateStatusRequestBody, optional
+            A structure representing the details of the collection to create. If supplied, these details
+            supersede the status parameter provided.
 
         Returns
         -------
@@ -3093,7 +2602,7 @@ class CollectionManager(Client2):
         }
         """
         loop = asyncio.get_event_loop()
-        loop.run_until_complete(self._async_update_collection_status(digital_product_guid, body))
+        loop.run_until_complete(self._async_update_collection_status(digital_product_guid, status, body))
 
 
     @dynamic_catch
@@ -3144,28 +2653,11 @@ class CollectionManager(Client2):
           }
         }
         """
-        try:
-            if isinstance(body, NewRelationshipRequestBody):
-                validated_body = body
-            elif isinstance(body, dict):
-                validated_body = self._new_relationship_request_adapter.validate_python(body)
-            else:
-                validated_body = None
-
-        except ValidationError as e:
-            logger.error(f"Validation error: {e}")
-            raise ValidationError(e)
-
-
         url = (
             f"{self.platform_url}/servers/"
             f"{self.view_server}/api/open-metadata/collection-manager/collections/digital-products/"
             f"{upstream_digital_prod_guid}/product-dependencies/{downstream_digital_prod_guid}/attach")
-        if validated_body:
-            json_body = validated_body.model_dump_json(indent=2, exclude_none=True)
-            await self._async_make_request("POST", url, json_body)
-        else:
-            await self._async_make_request("POST", url)
+        await self._async_new_relationship_request(url, "InformationSupplyChainLinkProperties", body)
         logger.info(f"Linked {upstream_digital_prod_guid} -> {downstream_digital_prod_guid}")
 
 
@@ -3264,30 +2756,13 @@ class CollectionManager(Client2):
         }
 
         """
-        try:
-            if isinstance(body, DeleteRequestBody):
-                validated_body = body
-            elif isinstance(body, dict):
-                validated_body = self._delete_request_adapter.validate_python(body)
-            else:
-                validated_body = None
-
-        except ValidationError as e:
-            logger.error(f"Validation error: {e}")
-            raise ValidationError(e)
-
 
         url = (
             f"{self.platform_url}/servers/"
             f"{self.view_server}/api/open-metadata/collection-manager/collections/digital-products/"
             f"{upstream_digital_prod_guid}/product-dependencies/{downstream_digital_prod_guid}/detach")
-
-        if validated_body:
-            json_body = validated_body.model_dump_json(indent=2, exclude_none=True)
-            await self._async_make_request("POST", url, json_body)
-        else:
-            await self._async_make_request("POST", url)
-        logger.info(f"Detched digital product dependency {upstream_digital_prod_guid} -> {downstream_digital_prod_guid}")
+        await self._async_delete_request(url, body)
+        logger.info(f"Detached digital product dependency {upstream_digital_prod_guid} -> {downstream_digital_prod_guid}")
 
 
     def detach_digital_product_dependency(self, upstream_digital_prod_guid: str, downstream_digital_prod_guid: str,
@@ -3383,30 +2858,12 @@ class CollectionManager(Client2):
         }
 
         """
-        try:
-            if isinstance(body, NewRelationshipRequestBody):
-                validated_body = body
-            elif isinstance(body, dict):
-                validated_body = self._new_relationship_request_adapter.validate_python(body)
-            else:
-                validated_body = None
-                raise PyegeriaInvalidParameterException(additional_info=
-                                                        {"reason": "unexpected body type"})
-        except ValidationError as e:
-            logger.error(f"Validation error: {e}")
-            raise ValidationError(e)
-
         url = (
             f"{self.platform_url}/servers/"
             f"{self.view_server}/api/open-metadata/collection-manager/collections/digital"
             f"-products/"
             f"{digital_prod_guid}/product-managers/{digital_prod_manager_guid}/attach")
-
-        if validated_body:
-            json_body = validated_body.model_dump_json(indent=2, exclude_none=True)
-            await self._async_make_request("POST", url, json_body)
-        else:
-            await self._async_make_request("POST", url)
+        await self._async_new_relationship_request(url, "AssignmentScopeProperties",body)
         logger.info(f"Attached digital product manager {digital_prod_guid} -> {digital_prod_manager_guid}")
 
 
@@ -3500,31 +2957,12 @@ class CollectionManager(Client2):
         }
 
         """
-        try:
-            if isinstance(body, DeleteRequestBody):
-                validated_body = body
-            elif isinstance(body, dict):
-                validated_body = self._delete_request_adapter.validate_python(body)
-            else:
-                validated_body = None
-                raise PyegeriaInvalidParameterException(additional_info=
-                                                        {"reason": "unexpected body type"})
-        except ValidationError as e:
-            logger.error(f"Validation error: {e}")
-            raise ValidationError(e)
-
-
         url = (
             f"{self.platform_url}/servers/"
             f"{self.view_server}/api/open-metadata/collection-manager/collections/digital-products/"
             f"{digital_prod_guid}/product-dependencies/{digital_prod_manager_guid}/detach")
-
-        if validated_body:
-            json_body = validated_body.model_dump_json(indent=2, exclude_none=True)
-            await self._async_make_request("POST", url, json_body)
-        else:
-            await self._async_make_request("POST", url)
-        logger.info(f"Detched digital product manager {digital_prod_guid} -> {digital_prod_manager_guid}")
+        await self._async_delete_request(url, body)
+        logger.info(f"Detached digital product manager {digital_prod_guid} -> {digital_prod_manager_guid}")
 
     @dynamic_catch
     def detach_product_manager(self, digital_prod_guid: str, digital_prod_manager_guid: str,
@@ -3569,174 +3007,21 @@ class CollectionManager(Client2):
         """
         loop = asyncio.get_event_loop()
         loop.run_until_complete(
-            self._async_detach_product_manager(digital_prod_guid, digital_prod_manager_guid,
-                                                        body))
-
-
-#
-
-    @dynamic_catch
-    async def _async_create_agreement(self, body: dict | NewElementRequestBody) -> str:
-        """ Create a new collection that represents an agreement.
-            Async version.
-
-        Parameters
-        ----------
-        body: dict | NewElementRequestBody
-            A structure representing the details of the agreement to create.
-
-        Returns
-        -------
-        str - the guid of the created collection
-
-        Raises
-        ------
-        PyegeriaException
-          If the client passes incorrect parameters on the request - such as bad URLs or invalid values
-        ValidationError
-          Raised by the pydantic validator if the body does not conform to the NewElementRequestBody.
-        NotAuthorizedException
-          The principle specified by the user_id does not have authorization for the requested action
-
-        Notes
-        -----
-        Note: the three dates: introductionDate, nextVersionDate and withdrawDate must
-        be valid dates if specified, otherwise you will get a 400 error response.
-
-        JSON Structure looks like:
-        {
-          "class" : "NewElementRequestBody",
-          "isOwnAnchor" : true,
-          "anchorScopeGUID" : "optional GUID of search scope",
-          "parentGUID" : "xxx",
-          "parentRelationshipTypeName" : "CollectionMembership",
-          "parentAtEnd1": true,
-          "properties": {
-            "class" : "AgreementProperties",
-            "qualifiedName": "Agreement::Add agreement name here",
-            "name" : "display name",
-            "description" : "Add description of the agreement here",
-            "identifier" : "Add agreement identifier here",
-            "additionalProperties": {
-              "property1Name" : "property1Value",
-              "property2Name" : "property2Value"
-            }
-          },
-          "externalSourceGUID": "add guid here",
-          "externalSourceName": "add qualified name here",
-          "effectiveTime" : "{{$isoTimestamp}}",
-          "forLineage" : false,
-          "forDuplicateProcessing" : false,
-          "initialStatus" : "ACTIVE"
-        }
-
-        The valid values for initialStatus are: DRAFT, PREPARED, PROPOSED, APPROVED, REJECTED, APPROVED_CONCEPT,
-        UNDER_DEVELOPMENT, DEVELOPMENT_COMPLETE, APPROVED_FOR_DEPLOYMENT, ACTIVE, DISABLED, DEPRECATED,
-        OTHER.  If using OTHER, set the userDefinedStatus with the status value you want. If not specified, will
-        default to ACTIVE.
-        """
-        try:
-            if isinstance(body, NewElementRequestBody):
-                if body.properties.class_ == "AgreementProperties":
-                    validated_body = body
-                else:
-                    raise PyegeriaInvalidParameterException(additional_info=
-                                                            {"reason": "unexpected property class name"})
-
-            elif isinstance(body, dict):
-                if body.get("properties", {}).get("class", "") == "AgreementProperties":
-                    validated_body = self._new_element_request_adapter.validate_python(body)
-                else:
-                    raise PyegeriaInvalidParameterException(additional_info=
-                                                            {"reason": "unexpected property class name"})
-
-            else:
-                raise TypeError("Invalid parameter type")
-
-        except ValidationError as e:
-            logger.error(f"Validation error: {e}")
-            raise ValidationError(e)
-
-        url = f"{self.collection_command_root}"
-        json_body = validated_body.model_dump_json(indent=2, exclude_none=True)
-        logger.info(json_body)
-        resp = await self._async_make_request("POST", url, json_body, is_json=True)
-        logger.info(f"Create collection with GUID: {resp.json().get('guid')}")
-        return resp.json().get("guid", NO_GUID_RETURNED)
-
-    @dynamic_catch
-    def create_agreement(self, body: dict | NewElementRequestBody = None) -> str:
-        """ Create a new collection that represents an agreement..
-
-            Parameters
-            ----------
-            body: dict | NewElementRequestBody
-                A structure representing the details of the agreement to create.
-
-            Returns
-            -------
-            str - the guid of the created collection
-
-            Raises
-            ------
-            PyegeriaException
-              If the client passes incorrect parameters on the request - such as bad URLs or invalid values
-            ValidationError
-              Raised by the pydantic validator if the body does not conform to the NewElementRequestBody.
-            NotAuthorizedException
-              The principle specified by the user_id does not have authorization for the requested action
-
-            Notes
-            -----
-            Note: the three dates: introductionDate, nextVersionDate and withdrawDate must
-            be valid dates if specified, otherwise you will get a 400 error response.
-
-            JSON Structure looks like:
-            {
-              "class" : "NewElementRequestBody",
-              "isOwnAnchor" : true,
-              "anchorScopeGUID" : "optional GUID of search scope",
-              "parentGUID" : "xxx",
-              "parentRelationshipTypeName" : "CollectionMembership",
-              "parentAtEnd1": true,
-              "properties": {
-                "class" : "AgreementProperties",
-                "qualifiedName": "Agreement::Add agreement name here",
-                "name" : "display name",
-                "description" : "Add description of the agreement here",
-                "identifier" : "Add agreement identifier here",
-                "additionalProperties": {
-                  "property1Name" : "property1Value",
-                  "property2Name" : "property2Value"
-                }
-              },
-              "externalSourceGUID": "add guid here",
-              "externalSourceName": "add qualified name here",
-              "effectiveTime" : "{{$isoTimestamp}}",
-              "forLineage" : false,
-              "forDuplicateProcessing" : false,
-              "initialStatus" : "ACTIVE"
-            }
-
-            The valid values for initialStatus are: DRAFT, PREPARED, PROPOSED, APPROVED, REJECTED, APPROVED_CONCEPT,
-            UNDER_DEVELOPMENT, DEVELOPMENT_COMPLETE, APPROVED_FOR_DEPLOYMENT, ACTIVE, DISABLED, DEPRECATED,
-            OTHER.  If using OTHER, set the userDefinedStatus with the status value you want. If not specified, will
-            default to ACTIVE.
-            """
+            self._async_detach_product_manager(digital_prod_guid, digital_prod_manager_guid,
+                                                        body))
 
-        return asyncio.get_event_loop().run_until_complete(
-            self._async_create_agreement(body))
 
+#
 
     @dynamic_catch
-    async def _async_create_data_sharing_agreement(self, body: dict | NewElementRequestBody) -> str:
-        """ Create a new collection that represents a data sharing agreement.
+    async def _async_create_agreement(self, body: dict | NewElementRequestBody) -> str:
+        """ Create a new collection that represents an agreement.
             Async version.
 
         Parameters
         ----------
         body: dict | NewElementRequestBody
-            A structure representing the details of the data sharing agreement to create.
+            A structure representing the details of the agreement to create.
 
         Returns
         -------
@@ -3769,19 +3054,18 @@ class CollectionManager(Client2):
             "qualifiedName": "Agreement::Add agreement name here",
             "name" : "display name",
             "description" : "Add description of the agreement here",
-            "userDefinedStatus" : "NEW",
             "identifier" : "Add agreement identifier here",
             "additionalProperties": {
               "property1Name" : "property1Value",
               "property2Name" : "property2Value"
             }
           },
-          "initialStatus" : "ACTIVE",
           "externalSourceGUID": "add guid here",
           "externalSourceName": "add qualified name here",
           "effectiveTime" : "{{$isoTimestamp}}",
           "forLineage" : false,
-          "forDuplicateProcessing" : false
+          "forDuplicateProcessing" : false,
+          "initialStatus" : "ACTIVE"
         }
 
         The valid values for initialStatus are: DRAFT, PREPARED, PROPOSED, APPROVED, REJECTED, APPROVED_CONCEPT,
@@ -3789,43 +3073,17 @@ class CollectionManager(Client2):
         OTHER.  If using OTHER, set the userDefinedStatus with the status value you want. If not specified, will
         default to ACTIVE.
         """
-        try:
-            if isinstance(body, NewElementRequestBody):
-                if body.properties.class_ == "AgreementProperties":
-                    validated_body = body
-                else:
-                    raise PyegeriaInvalidParameterException(additional_info=
-                                                            {"reason": "unexpected property class name"})
-
-            elif isinstance(body, dict):
-                if body.get("properties", {}).get("class", "") == "AgreementProperties":
-                    validated_body = self._new_element_request_adapter.validate_python(body)
-                else:
-                    raise PyegeriaInvalidParameterException(additional_info=
-                                                            {"reason": "unexpected property class name"})
-
-            else:
-                raise TypeError("Invalid parameter type")
-
-        except ValidationError as e:
-            logger.error(f"Validation error: {e}")
-            raise ValidationError(e)
-
-        url = f"{self.collection_command_root}/data-sharing-agreement"
-        json_body = validated_body.model_dump_json(indent=2, exclude_none=True)
-        logger.info(json_body)
-        resp = await self._async_make_request("POST", url, json_body, is_json=True)
-        logger.info(f"Create collection with GUID: {resp.json().get('guid')}")
-        return resp.json().get("guid", NO_GUID_RETURNED)
+        url = f"{self.collection_command_root}"
+        return await self._async_create_element_body_request(url, "AgreementProperties", body)
 
     @dynamic_catch
-    def create_data_sharing_agreement(self, body: dict | NewElementRequestBody = None) -> str:
-        """ Create a new collection that represents a digital product.
+    def create_agreement(self, body: dict | NewElementRequestBody = None) -> str:
+        """ Create a new collection that represents an agreement..
 
             Parameters
             ----------
             body: dict | NewElementRequestBody
-                A structure representing the details of the digital product to create.
+                A structure representing the details of the agreement to create.
 
             Returns
             -------
@@ -3854,19 +3112,11 @@ class CollectionManager(Client2):
               "parentRelationshipTypeName" : "CollectionMembership",
               "parentAtEnd1": true,
               "properties": {
-                "class" : "DigitalProductProperties",
-                "qualifiedName": "DigitalProduct::Add product name here",
-                "name" : "Product contents",
-                "description" : "Add description of product and its expected usage here",
-                "identifier" : "Add product identifier here",
-                "productName" : "Add product name here",
-                "category" : "Periodic Delta",
-                "maturity" : "Add valid value here",
-                "serviceLife" : "Add the estimated lifetime of the product",
-                "introductionDate" : "date",
-                "nextVersionDate": "date",
-                "withdrawDate": "date",
-                "currentVersion": "V0.1",
+                "class" : "AgreementProperties",
+                "qualifiedName": "Agreement::Add agreement name here",
+                "name" : "display name",
+                "description" : "Add description of the agreement here",
+                "identifier" : "Add agreement identifier here",
                 "additionalProperties": {
                   "property1Name" : "property1Value",
                   "property2Name" : "property2Value"
@@ -3887,12 +3137,148 @@ class CollectionManager(Client2):
             """
 
         return asyncio.get_event_loop().run_until_complete(
-            self._async_create_data_sharing_agreement(body))
+            self._async_create_agreement(body))
 
+    #
+    # @dynamic_catch
+    # async def _async_create_data_sharing_agreement(self, body: dict | NewElementRequestBody) -> str:
+    #     """ Create a new collection that represents a data sharing agreement.
+    #         Async version.
+    #
+    #     Parameters
+    #     ----------
+    #     body: dict | NewElementRequestBody
+    #         A structure representing the details of the data sharing agreement to create.
+    #
+    #     Returns
+    #     -------
+    #     str - the guid of the created collection
+    #
+    #     Raises
+    #     ------
+    #     PyegeriaException
+    #       If the client passes incorrect parameters on the request - such as bad URLs or invalid values
+    #     ValidationError
+    #       Raised by the pydantic validator if the body does not conform to the NewElementRequestBody.
+    #     NotAuthorizedException
+    #       The principle specified by the user_id does not have authorization for the requested action
+    #
+    #     Notes
+    #     -----
+    #     Note: the three dates: introductionDate, nextVersionDate and withdrawDate must
+    #     be valid dates if specified, otherwise you will get a 400 error response.
+    #
+    #     JSON Structure looks like:
+    #     {
+    #       "class" : "NewElementRequestBody",
+    #       "isOwnAnchor" : true,
+    #       "anchorScopeGUID" : "optional GUID of search scope",
+    #       "parentGUID" : "xxx",
+    #       "parentRelationshipTypeName" : "CollectionMembership",
+    #       "parentAtEnd1": true,
+    #       "properties": {
+    #         "class" : "AgreementProperties",
+    #         "qualifiedName": "Agreement::Add agreement name here",
+    #         "name" : "display name",
+    #         "description" : "Add description of the agreement here",
+    #         "userDefinedStatus" : "NEW",
+    #         "identifier" : "Add agreement identifier here",
+    #         "additionalProperties": {
+    #           "property1Name" : "property1Value",
+    #           "property2Name" : "property2Value"
+    #         }
+    #       },
+    #       "initialStatus" : "ACTIVE",
+    #       "externalSourceGUID": "add guid here",
+    #       "externalSourceName": "add qualified name here",
+    #       "effectiveTime" : "{{$isoTimestamp}}",
+    #       "forLineage" : false,
+    #       "forDuplicateProcessing" : false
+    #     }
+    #
+    #     The valid values for initialStatus are: DRAFT, PREPARED, PROPOSED, APPROVED, REJECTED, APPROVED_CONCEPT,
+    #     UNDER_DEVELOPMENT, DEVELOPMENT_COMPLETE, APPROVED_FOR_DEPLOYMENT, ACTIVE, DISABLED, DEPRECATED,
+    #     OTHER.  If using OTHER, set the userDefinedStatus with the status value you want. If not specified, will
+    #     default to ACTIVE.
+    #     """
+    #
+    #     url = f"{self.collection_command_root}/data-sharing-agreement"
+    #     return await self._async_create_element_body_request(url, "AgreementProperties", body)
+    #
+    # @dynamic_catch
+    # def create_data_sharing_agreement(self, body: dict | NewElementRequestBody = None) -> str:
+    #     """ Create a new collection that represents a digital product.
+    #
+    #         Parameters
+    #         ----------
+    #         body: dict | NewElementRequestBody
+    #             A structure representing the details of the digital product to create.
+    #
+    #         Returns
+    #         -------
+    #         str - the guid of the created collection
+    #
+    #         Raises
+    #         ------
+    #         PyegeriaException
+    #           If the client passes incorrect parameters on the request - such as bad URLs or invalid values
+    #         ValidationError
+    #           Raised by the pydantic validator if the body does not conform to the NewElementRequestBody.
+    #         NotAuthorizedException
+    #           The principle specified by the user_id does not have authorization for the requested action
+    #
+    #         Notes
+    #         -----
+    #         Note: the three dates: introductionDate, nextVersionDate and withdrawDate must
+    #         be valid dates if specified, otherwise you will get a 400 error response.
+    #
+    #         JSON Structure looks like:
+    #         {
+    #           "class" : "NewElementRequestBody",
+    #           "isOwnAnchor" : true,
+    #           "anchorScopeGUID" : "optional GUID of search scope",
+    #           "parentGUID" : "xxx",
+    #           "parentRelationshipTypeName" : "CollectionMembership",
+    #           "parentAtEnd1": true,
+    #           "properties": {
+    #             "class" : "DigitalProductProperties",
+    #             "qualifiedName": "DigitalProduct::Add product name here",
+    #             "name" : "Product contents",
+    #             "description" : "Add description of product and its expected usage here",
+    #             "identifier" : "Add product identifier here",
+    #             "productName" : "Add product name here",
+    #             "category" : "Periodic Delta",
+    #             "maturity" : "Add valid value here",
+    #             "serviceLife" : "Add the estimated lifetime of the product",
+    #             "introductionDate" : "date",
+    #             "nextVersionDate": "date",
+    #             "withdrawDate": "date",
+    #             "currentVersion": "V0.1",
+    #             "additionalProperties": {
+    #               "property1Name" : "property1Value",
+    #               "property2Name" : "property2Value"
+    #             }
+    #           },
+    #           "externalSourceGUID": "add guid here",
+    #           "externalSourceName": "add qualified name here",
+    #           "effectiveTime" : "{{$isoTimestamp}}",
+    #           "forLineage" : false,
+    #           "forDuplicateProcessing" : false,
+    #           "initialStatus" : "ACTIVE"
+    #         }
+    #
+    #         The valid values for initialStatus are: DRAFT, PREPARED, PROPOSED, APPROVED, REJECTED, APPROVED_CONCEPT,
+    #         UNDER_DEVELOPMENT, DEVELOPMENT_COMPLETE, APPROVED_FOR_DEPLOYMENT, ACTIVE, DISABLED, DEPRECATED,
+    #         OTHER.  If using OTHER, set the userDefinedStatus with the status value you want. If not specified, will
+    #         default to ACTIVE.
+    #         """
+    #
+    #     return asyncio.get_event_loop().run_until_complete(
+    #         self._async_create_data_sharing_agreement(body))
+    #
 
     @dynamic_catch
-    async def _async_update_agreement(self, agreement_guid: str,  body: dict | UpdateElementRequestBody,
-                                       merge_update: bool = True) -> None:
+    async def _async_update_agreement(self, agreement_guid: str,  body: dict | UpdateElementRequestBody) -> None:
         """ Update the properties of an agreement.
             Collections: https://egeria-project.org/concepts/collection
 
@@ -3945,43 +3331,11 @@ class CollectionManager(Client2):
           "forDuplicateProcessing" : false
         }
         """
-
-        try:
-            if isinstance(body, NewElementRequestBody):
-                if body.properties.class_ == "AgreementProperties":
-                    validated_body = body
-                else:
-                    raise PyegeriaInvalidParameterException(additional_info =
-                                                           {"reason" : "unexpected property class name"})
-
-            elif isinstance(body, dict):
-                if body.get("properties", {}).get("class", "") == "AgreementProperties":
-                    validated_body = self._update_element_request_adapter.validate_python(body)
-                else:
-                    raise PyegeriaInvalidParameterException(additional_info =
-                                                            {"reason" : "unexpected property class name"})
-            else:
-                raise TypeError("Invalid parameter type")
-
-        except ValidationError as e:
-            logger.error(f"Validation error: {e}")
-            raise ValidationError(e)
-
-        merge_update_s = str(merge_update).lower()
-
-        url = (f"{self.collection_command_root}/{agreement_guid}/update?"
-               f"replaceAllProperties={merge_update_s}")
-
-        json_body = validated_body.model_dump_json(indent=2, exclude_none=True)
-
-        await self._async_make_request("POST", url, json_body)
-
-        logger.info(f"Successfully updated {agreement_guid} with {json_body}")
-
+        url = (f"{self.collection_command_root}/{agreement_guid}/update")
+        await self._async_update_element_body_request(url, AGREEMENT_PROPERTIES_LIST,body)
 
     @dynamic_catch
-    def update_agreement(self, agreement_guid: str,  body: dict | UpdateElementRequestBody,
-                                       merge_update: bool = True) -> None:
+    def update_agreement(self, agreement_guid: str,  body: dict | UpdateElementRequestBody) -> None:
         """ Update the properties of an agreement.
                 Collections: https://egeria-project.org/concepts/collection
 
@@ -4035,68 +3389,20 @@ class CollectionManager(Client2):
             """
 
         return asyncio.get_event_loop().run_until_complete(
-            self._async_update_agreement(agreement_guid, body, merge_update))
-
-
-    @dynamic_catch
-    async def _async_update_agreement_status(self, agreement_guid: str, body: dict | UpdateStatusRequestBody):
-        """Update the status of an agreement. Async version.
-
-        Parameters
-        ----------
-        agreement_guid: str
-            The guid of the collection to update.
-        body: dict | UpdateStatusRequestBody
-            A structure representing the details of the collection to create.
-
-        Returns
-        -------
-        Nothing
-
-        Raises
-        ------
-        InvalidParameterException
-          If the client passes incorrect parameters on the request - such as bad URLs or invalid values
-        PropertyServerException
-          Raised by the server when an issue arises in processing a valid request
-        NotAuthorizedException
-          The principle specified by the user_id does not have authorization for the requested action
+            self._async_update_agreement(agreement_guid, body))
 
-        Notes
-        -----
-        JSON Structure looks like:
-         {
-          "class": "UpdateStatusRequestBody",
-          "status": "APPROVED",
-          "externalSourceGUID": "add guid here",
-          "externalSourceName": "add qualified name here",
-          "effectiveTime": "{{$isoTimestamp}}",
-          "forLineage": false,
-          "forDuplicateProcessing": false
-        }
-        """
-        try:
-            if isinstance(body, UpdateStatusRequestBody):
-               validated_body = body
-            elif isinstance(body, dict):
-                validated_body = self._update_status_request_adapter.validate_python(body)
-
-        except ValidationError as e:
-            logger.error(f"Validation error: {e}")
-            raise ValidationError(e)
 
-        url = f"{self.collection_command_root}/{agreement_guid}/update-status"
-        json_body = validated_body.model_dump_json(indent=2, exclude_none=True)
-        await self._async_make_request("POST", url, json_body)
-        logger.info(f"Successfully updated {agreement_guid} with {json_body}")
 
     @dynamic_catch
-    def update_agreement_status(self, agreement_guid: str, body: dict | UpdateStatusRequestBody):
+    def update_agreement_status(self, agreement_guid: str, status: str = None,
+                                body: dict | UpdateStatusRequestBody = None):
         """Update the status of an agreement.
         Parameters
         ----------
         agreement_guid: str
             The guid of the collection to update.
+        status: str, optional
+            The new lifecycle status for the collection. Ignored, if the body is provided.
         body: dict | UpdateStatusRequestBody
             A structure representing the details of the collection to create.
 
@@ -4127,7 +3433,7 @@ class CollectionManager(Client2):
         }
         """
         loop = asyncio.get_event_loop()
-        loop.run_until_complete(self._async_update_collection_status(agreement_guid, body))
+        loop.run_until_complete(self._async_update_collection_status(agreement_guid, status,body))
 
 
 
@@ -4180,37 +3486,11 @@ class CollectionManager(Client2):
         }
 
         """
-        try:
-            if isinstance(body, NewRelationshipRequestBody):
-                if body.properties.class_ == "AgreementActorProperties":
-                    validated_body = body
-                else:
-                    raise PyegeriaInvalidParameterException(additional_info=
-                                                            {"reason": "unexpected property class name"})
-
-            elif isinstance(body, dict):
-                if body.get("properties", {}).get("class", "") == "AgreementActorProperties":
-                    validated_body = self._new_relationship_request_adapter.validate_python(body)
-                else:
-                    raise PyegeriaInvalidParameterException(additional_info=
-                                                            {"reason": "unexpected property class name"})
-            else:
-                validated_body = None
-
-        except ValidationError as e:
-            logger.error(f"Validation error: {e}")
-            raise ValidationError(e)
-
         url = (
             f"{self.platform_url}/servers/"
             f"{self.view_server}/api/open-metadata/collection-manager/collections/agreements/"
             f"{agreement_guid}/agreement-actors/{actor_guid}/attach")
-
-        if validated_body:
-            json_body = validated_body.model_dump_json(indent=2, exclude_none=True)
-            await self._async_make_request("POST", url, json_body)
-        else:
-            await self._async_make_request("POST", url)
+        await self._async_new_relationship_request(url, "AgreementActorProperties",body)
         logger.info(f"Attached digital product manager {agreement_guid} -> {actor_guid}")
 
 
@@ -4309,28 +3589,11 @@ class CollectionManager(Client2):
 
         """
 
-        try:
-            if isinstance(body, DeleteRequestBody):
-                validated_body = body
-            elif isinstance(body, dict):
-                validated_body = self._delete_request_adapter.validate_python(body)
-            else:
-                validated_body = None
-
-        except ValidationError as e:
-            logger.error(f"Validation error: {e}")
-            raise ValidationError(e)
-
         url = (
             f"{self.platform_url}/servers/"
             f"{self.view_server}/api/open-metadata/collection-manager/collections/agreements/"
             f"{agreement_guid}/agreement-actors/{actor_guid}/detach")
-
-        if validated_body:
-            json_body = validated_body.model_dump_json(indent=2, exclude_none=True)
-            await self._async_make_request("POST", url, json_body)
-        else:
-            await self._async_make_request("POST", url)
+        self._async_delete_request(url, body)
         logger.info(f"Detached digital product manager {agreement_guid} -> {actor_guid}")
 
 
@@ -4447,29 +3710,11 @@ class CollectionManager(Client2):
         }
 
             """
-        pass
-        # if isinstance(body,NewRelationshipRequestBody ):
-        #     validated_body = body
-        # elif isinstance(body, dict):
-        #     try:
-        #         validated_body = (**body)
-        #     except ValidationError as e:
-        #         logger.error(f"Validation error: {e}")
-        #         raise PyegeriaInvalidParameterException(f"Invalid body: {e}")
-        # elif body is None:
-        #     validated_body = (
-        #
-        #     )
-        # # else:
-        #     raise PyegeriaInvalidParameterException(f"Invalid body type: {type(body)}")
-        #     url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/collection-manager/collections/"
-        #            f"agreements/{agreement_guid}/agreement-items/{agreement_item_guid}/attach")
-        #
-        #     if body:
-        #         await self._async_make_request("POST", url, body)
-        #     else:
-        #         await self._async_make_request("POST", url)
-        #     logger.info(f"Attached agreement item {agreement_item_guid} to {agreement_guid}")
+        url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/collection-manager/collections/"
+               f"agreements/{agreement_guid}/agreement-items/{agreement_item_guid}/attach")
+
+        await self._async_new_relationship_request(url, "AgreementItemProperties", body)
+        logger.info(f"Attached agreement item {agreement_item_guid} to {agreement_guid}")
 
 
     def link_agreement_item(self, agreement_guid: str, agreement_item_guid: str, body: dict = None) -> None:
@@ -4537,7 +3782,7 @@ class CollectionManager(Client2):
 
     @dynamic_catch
     async def _async_detach_agreement_item(self, agreement_guid: str, agreement_item_guid: str,
-                                           body: dict = None) -> None:
+                                           body: dict | DeleteRequestBody = None) -> None:
         """Detach an agreement item from an agreement. Request body is optional. Async version.
 
         Parameters
@@ -4546,8 +3791,8 @@ class CollectionManager(Client2):
             The guid of the agreement to link.
         agreement_item_guid: str
             The guid of the element to attach.
-        body: dict, optional, default = None
-            A dict representing the details of the relationship.
+        body: dict | DeleteRequestBody, optional, default = None
+            A structure representing the details of the relationship.
 
         Returns
         -------
@@ -4565,25 +3810,20 @@ class CollectionManager(Client2):
         Notes
         _____
         {
-          "class" : "MetadataSourceRequestBody",
+          "class": "DeleteRequestBody",
           "externalSourceGUID": "add guid here",
           "externalSourceName": "add qualified name here",
-          "effectiveTime" : "{{$isoTimestamp}}",
-          "forLineage" : false,
-          "forDuplicateProcessing" : false
+          "effectiveTime": "{{$isoTimestamp}}",
+          "forLineage": false,
+          "forDuplicateProcessing": false
         }
 
         """
-
         url = (
             f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/collection-manager/collections"
             f"/agreements"
             f"{agreement_guid}/agreement-items/{agreement_item_guid}/detach")
-
-        if body:
-            await self._async_make_request("POST", url, body)
-        else:
-            await self._async_make_request("POST", url)
+        await self._async_delete_request(url, body)
         logger.info(f"Detached agreement item {agreement_item_guid} from {agreement_guid}")
 
 
@@ -4629,7 +3869,8 @@ class CollectionManager(Client2):
 
 
     @dynamic_catch
-    async def _async_link_contract(self, agreement_guid: str, external_ref_guid: str, body: dict = None) -> None:
+    async def _async_link_contract(self, agreement_guid: str, external_ref_guid: str, 
+                                   body: dict | NewRelationshipRequestBody = None) -> None:
         """ Attach an agreement to an external reference element that describes the location of the contract
         documents.
             Request body is optional. Async version.
@@ -4640,8 +3881,8 @@ class CollectionManager(Client2):
             The guid of the agreement to update.
         external_ref_guid: str
             The guid of the external reference to attach.
-        body: dict, optional, default = None
-            A dict representing the details of the relationship.
+        body: dict | NewRelationshipRequestBody, optional, default = None
+            A structure representing the details of the relationship.
 
         Returns
         -------
@@ -4678,17 +3919,12 @@ class CollectionManager(Client2):
         }
 
         """
-
         url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/collection-manager/collections/"
                f"agreements/{agreement_guid}/contract-links/{external_ref_guid}/attach")
+        await self._async_new_relationship_request(url, "ContractLinkProperties", body)
+        logger.info(f"Attached agreement {agreement_guid} to contract {external_ref_guid}")
 
-        if body:
-            await self._async_make_request("POST", url, body)
-        else:
-            await self._async_make_request("POST", url)
-        logger.info(f"Attached agreemenbt {agreement_guid} to contract {external_ref_guid}")
-
-
+    @dynamic_catch
     def link_contract(self, agreement_guid: str, external_ref_guid: str, body: dict = None) -> None:
         """ Attach an agreement to an external reference element that describes the location of the contract
         documents.
@@ -4783,16 +4019,11 @@ class CollectionManager(Client2):
 
         url = (
             f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/collection-manager/collections"
-            f"/agreements"
-            f"{agreement_guid}/contract-links/{external_ref_guid}/detach")
-
-        if body:
-            await self._async_make_request("POST", url, body)
-        else:
-            await self._async_make_request("POST", url)
+            f"/agreements/{agreement_guid}/contract-links/{external_ref_guid}/detach")
+        await self._async_delete_request(url, body)
         logger.info(f"Detached contract: {external_ref_guid} from {agreement_guid}")
 
-
+    @dynamic_catch
     def detach_contract(self, agreement_guid: str, external_ref_guid: str, body: dict = None) -> None:
         """Detach an external reference to a contract, from an agreement. Request body is optional.
 
@@ -4839,13 +4070,13 @@ class CollectionManager(Client2):
 
 
     @dynamic_catch
-    async def _async_create_digital_subscription(self, body: dict) -> str:
+    async def _async_create_digital_subscription(self, body: dict | NewElementRequestBody) -> str:
         """Create a new collection that represents a type of agreement called a digital_subscription. Async version.
 
         Parameters
         ----------
-        body: dict
-            A dict representing the details of the collection to create.
+        body | NewElementRequewstBody: dict
+            A structure representing the details of the collection to create.
 
         Returns
         -------
@@ -4937,13 +4168,8 @@ class CollectionManager(Client2):
            "forDuplicateProcessing" : false
         }
         """
-
         url = f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/collection-manager/collections"
-
-        resp = await self._async_make_request("POST", url, body_slimmer(body))
-        guid = resp.json().get('guid', NO_GUID_RETURNED)
-        logger.info(f"Create collection with GUID: {guid}")
-        return guid
+        return await self._async_create_element_body_request(url, "DigitalSubscriptionProperties", body)
 
 
     def create_digital_subscription(self, body: dict) -> str:
@@ -5019,19 +4245,16 @@ class CollectionManager(Client2):
 
 
     @dynamic_catch
-    async def _async_update_digital_subscription(self, digital_subscription_guid: str, body: dict,
-                                                 replace_all_props: bool = False, ):
+    async def _async_update_digital_subscription(self, digital_subscription_guid: str,
+                                                 body: dict | UpdateElementRequestBody) -> None:
         """Update the properties of the digital_subscription collection. Async version.
 
         Parameters
         ----------
         digital_subscription_guid: str
             The guid of the digital_subscription to update.
-        body: dict
-            A dict representing the details of the collection to create.
-        replace_all_props: bool, optional, defaults to False
-            Whether to replace all properties in the collection.
-
+        body: dict | UpdateElementRequestBody
+            A structure representing the details of the collection to create.
 
         Returns
         -------
@@ -5075,17 +4298,13 @@ class CollectionManager(Client2):
           "forDuplicateProcessing" : false
         }
         """
-
-        replace_all_props_s = str(replace_all_props).lower()
         url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/collection-manager/collections/"
-               f"{digital_subscription_guid}/update?replaceAllProperties={replace_all_props_s}")
-
-        await self._async_make_request("POST", url, body)
+               f"{digital_subscription_guid}/update")
+        await self._async_update_element_body_request(url,["DigitalSubscriptionProperties"], body )
         logger.info(f"Updated digital subscription {digital_subscription_guid}")
 
-
-    def update_digital_subscription(self, digital_subscription_guid: str, body: dict,
-                                    replace_all_props: bool = False, ):
+    @dynamic_catch
+    def update_digital_subscription(self, digital_subscription_guid: str, body: dict,):
         """Update the properties of the DigitalProduct classification attached to a collection.
 
         Parameters
@@ -5138,19 +4357,22 @@ class CollectionManager(Client2):
         """
         loop = asyncio.get_event_loop()
         loop.run_until_complete(
-            self._async_update_digital_subscription(digital_subscription_guid, body, replace_all_props))
+            self._async_update_digital_subscription(digital_subscription_guid, body))
 
 
     @dynamic_catch
-    async def _async_update_digital_subscription_status(self, digital_subscription_guid: str, body: dict):
-        """Update the status of an digital_subscription collection. Async version.
+    async def _async_update_digital_subscription_status(self, digital_subscription_guid: str, status: str = None,
+                                                        body: dict | UpdateStatusRequestBody = None)-> None:
+        """Update the status of a digital_subscription collection. Async version.
 
         Parameters
         ----------
         digital_subscription_guid: str
             The guid of the digital product collection to update.
-        body: dict
-            A dict representing the details of the collection to create.
+        status: str, optional
+            The new status of the digital_subscription collection. Will be used only if body is not provided.
+        body: dict | UpdateStatusRequestBody, optional, defaults to None
+            A structure representing the details of the collection to create.
 
         Returns
         -------
@@ -5168,27 +4390,26 @@ class CollectionManager(Client2):
         Notes
         -----
         JSON Structure looks like:
-           {
-              "class": "AgreementStatusRequestBody",
-              "status": "APPROVED",
-              "externalSourceGUID": "add guid here",
-              "externalSourceName": "add qualified name here",
-              "effectiveTime": "{{$isoTimestamp}}",
-              "forLineage": false,
-              "forDuplicateProcessing": false
-            }
+         {
+          "class": "UpdateStatusRequestBody",
+          "status": "APPROVED",
+          "externalSourceGUID": "add guid here",
+          "externalSourceName": "add qualified name here",
+          "effectiveTime": "{{$isoTimestamp}}",
+          "forLineage": false,
+          "forDuplicateProcessing": false
+        }
         """
-
         url = (
             f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/collection-manager/collections"
             f"/agreements/"
             f"{digital_subscription_guid}/update-status")
-
-        await self._async_make_request("POST", url, body)
+        await self._async_update_status_request(url, status, body)
         logger.info(f"Updated status for DigitalProduct {digital_subscription_guid}")
 
-
-    def update_digital_subscription_status(self, digital_subscription_guid: str, body: dict):
+    @dynamic_catch
+    def update_digital_subscription_status(self, digital_subscription_guid: str,
+                                           body: dict | UpdateStatusRequestBody = None,):
         """Update the status of an digital_subscription collection. Async version.
 
             Parameters
@@ -5230,7 +4451,8 @@ class CollectionManager(Client2):
 
 
     @dynamic_catch
-    async def _async_link_subscriber(self, subscriber_guid: str, subscription_guid: str, body: dict = None):
+    async def _async_link_subscriber(self, subscriber_guid: str, subscription_guid: str,
+                                     body: dict | NewRelationshipRequestBody = None)-> None:
         """ Attach a subscriber to a subscription.  The subscriber is of type 'Referenceable' to allow digital
             products, team or business capabilities to be the subscriber. The subscription is an element of type
             DigitalSubscription.
@@ -5242,8 +4464,8 @@ class CollectionManager(Client2):
             The unique identifier of the subscriber.
         subscription_guid: str
             The identifier of the subscription.
-        body: dict, optional, default = None
-            A dict representing the details of the relationship.
+        body: dict | NewRelationshipRequestBody, optional, default = None
+            A structure representing the details of the relationship.
 
         Returns
         -------
@@ -5262,7 +4484,7 @@ class CollectionManager(Client2):
         -----
         JSON Structure looks like:
         {
-          "class" : "RelationshipRequestBody",
+          "class" : "NewRelationshipRequestBody",
           "externalSourceGUID": "add guid here",
           "externalSourceName": "add qualified name here",
           "effectiveTime" : "{{$isoTimestamp}}",
@@ -5276,19 +4498,16 @@ class CollectionManager(Client2):
           }
         }
         """
-
         url = (
             f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/collection-manager/collections"
             f"/subscribers/"
             f"{subscriber_guid}/subscriptions/{subscription_guid}/attach")
-        if body:
-            await self._async_make_request("POST", url, body)
-        else:
-            await self._async_make_request("POST", url)
+        await self._async_new_relationship_request(url, "DigitalSubscriberProperties", body)
         logger.info(f"Linking subscriber {subscriber_guid} to subscription {subscription_guid}")
 
-
-    def link_subscriber(self, subscriber_guid: str, subscription_guid: str, body: dict = None):
+    @dynamic_catch
+    def link_subscriber(self, subscriber_guid: str, subscription_guid: str,
+                        body: dict | NewRelationshipRequestBody = None):
         """ Attach a subscriber to a subscription.  The subscriber is of type 'Referenceable' to allow digital
             products, team or business capabilities to be the subscriber. The subscription is an element of type
             DigitalSubscription.
@@ -5339,7 +4558,8 @@ class CollectionManager(Client2):
 
 
     @dynamic_catch
-    async def _async_detach_subscriber(self, subscriber_guid: str, subscription_guid: str, body: dict = None):
+    async def _async_detach_subscriber(self, subscriber_guid: str, subscription_guid: str,
+                                       body: dict | DeleteRequestBody = None) -> None:
         """ Detach a subscriber from a subscription Request body is optional. Async version.
 
         Parameters
@@ -5348,8 +4568,8 @@ class CollectionManager(Client2):
             The unique identifier of the subscriber.
         subscription_guid: str
             The unique identifier of the subscription.
-        body: dict, optional, default = None
-            A dict representing the details of the relationship.
+        body: dict | DeleteRequestBody, optional, default = None
+            A structure representing the details of the relationship.
 
         Returns
         -------
@@ -5376,19 +4596,15 @@ class CollectionManager(Client2):
           "forDuplicateProcessing": false
         }
         """
-
         url = (
             f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/collection-manager/collections"
             f"/agreements/"
             f"{subscriber_guid}/agreement-actors/{subscription_guid}/detach")
-        if body:
-            await self._async_make_request("POST", url, body)
-        else:
-            await self._async_make_request("POST", url)
+        await self._async_delete_request(url, body)
         logger.info(f"Detached subscriber {subscriber_guid} from subscription {subscription_guid}")
 
 
-    def detach_subscriber(self, subscriber_guid: str, subscription_guid: str, body: dict = None):
+    def detach_subscriber(self, subscriber_guid: str, subscription_guid: str, body: dict | DeleteRequestBody= None):
         """ Detach a subscriber from a subscription. Request body is optional.
 
         Parameters
@@ -5434,8 +4650,8 @@ class CollectionManager(Client2):
 
 
     @dynamic_catch
-    async def _async_attach_collection(self, parent_guid: str, collection_guid: str, body: dict = None,
-                                       make_anchor: bool = False):
+    async def _async_attach_collection(self, parent_guid: str, collection_guid: str,
+                                       body: dict | NewRelationshipRequestBody= None):
         """ Connect an existing collection to an element using the ResourceList relationship (0019).
             Async version.
 
@@ -5445,10 +4661,8 @@ class CollectionManager(Client2):
             The unique identifier of the parent to attach to.
         collection_guid: str
             The identifier of the collection being attached.
-        body: dict, optional, default = None
-            A dict representing the details of the relationship.
-        make_anchor: bool, optional, default = False
-            Indicates if the collection should be anchored to the element.
+        body: dict | NewRelationshipRequestBody, optional, default = None
+            A structure representing the details of the relationship.
 
         Returns
         -------
@@ -5468,7 +4682,7 @@ class CollectionManager(Client2):
         JSON Structure looks like:
 
         {
-          "class" : "RelationshipRequestBody",
+          "class" : "NewRelationshipRequestBody",
           "properties": {
             "class": "ResourceListProperties",
             "resourceUse": "Add valid value here",
@@ -5491,16 +4705,13 @@ class CollectionManager(Client2):
         url = (
             f"{self.platform_url}/servers/"
             f"{self.view_server}/api/open-metadata/collection-manager/metadata-elements/"
-            f"{parent_guid}/collections/{collection_guid}/attach?makeAchor={make_anchor}")
-        if body:
-            await self._async_make_request("POST", url, body)
-        else:
-            await self._async_make_request("POST", url)
+            f"{parent_guid}/collections/{collection_guid}/attach")
+        await self._async_new_relationship_request(url, "ResourceListProperties", body)
         logger.info(f"Attached {collection_guid} to {parent_guid}")
 
-
-    def attach_collection(self, parent_guid: str, collection_guid: str, body: dict = None,
-                          make_anchor: bool = False):
+    @dynamic_catch
+    def attach_collection(self, parent_guid: str, collection_guid: str,
+                          body: dict | NewRelationshipRequestBody = None):
         """ Connect an existing collection to an element using the ResourceList relationship (0019).
 
             Parameters
@@ -5551,11 +4762,12 @@ class CollectionManager(Client2):
             }
             """
         loop = asyncio.get_event_loop()
-        loop.run_until_complete(self._async_attach_collection(parent_guid, collection_guid, body, make_anchor))
+        loop.run_until_complete(self._async_attach_collection(parent_guid, collection_guid, body))
 
 
     @dynamic_catch
-    async def _async_detach_collection(self, parent_guid: str, collection_guid: str, body: dict = None):
+    async def _async_detach_collection(self, parent_guid: str, collection_guid: str,
+                                       body: dict | DeleteRequestBody = None):
         """ Detach an existing collection from an element. If the collection is anchored to the element,
         it is delete.
             Async version.
@@ -5566,8 +4778,8 @@ class CollectionManager(Client2):
                 The unique identifier of the parent to detach from.
         collection_guid: str
                 The identifier of the collection being detached.
-        body: dict, optional, default = None
-            A dict representing the details of the relationship.
+        body: dict | DeleteRequestBody, optional, default = None
+            A structure representing the details of the relationship.
 
 
         Returns
@@ -5587,27 +4799,25 @@ class CollectionManager(Client2):
         -----
         JSON Structure looks like:
         {
-          "class": "MetadataSourceRequestBody",
+          "class": "DeleteRequestBody",
           "externalSourceGUID": "add guid here",
           "externalSourceName": "add qualified name here",
           "effectiveTime": "{{$isoTimestamp}}",
           "forLineage": false,
           "forDuplicateProcessing": false
         }
-        """
 
+        """
         url = (
             f"{self.platform_url}/servers/"
             f"{self.view_server}/api/open-metadata/collection-manager/metadata-elements/"
             f"{parent_guid}/collections/{collection_guid}/detach")
-        if body:
-            await self._async_make_request("POST", url, body)
-        else:
-            await self._async_make_request("POST", url)
+        await self._async_delete_request(url, body)
         logger.info(f"Detached collection {collection_guid} from {parent_guid}")
 
 
-    def detach_collection(self, parent_guid: str, collection_guid: str, body: dict = None):
+    def detach_collection(self, parent_guid: str, collection_guid: str,
+                          body: dict | DeleteRequestBody = None):
         """ Detach an existing collection from an element. If the collection is anchored to the element,
         it is delete.
 
@@ -5650,7 +4860,7 @@ class CollectionManager(Client2):
 
 
     @dynamic_catch
-    async def _async_delete_collection(self, collection_guid: str, body: dict = None,
+    async def _async_delete_collection(self, collection_guid: str, body: dict | DeleteRequestBody= None,
                                        cascade: bool = False) -> None:
         """Delete a collection.  It is detected from all parent elements.  If members are anchored to the collection
         then they are also deleted. Async version
@@ -5659,13 +4869,13 @@ class CollectionManager(Client2):
         Parameters
         ----------
         collection_guid: str
-            The guid of the collection to update.
+            The guid of the collection to delete.
 
         cascade: bool, optional, defaults to True
             If true, a cascade delete is performed.
 
-        body: dict, optional, default = None
-            A dict representing the details of the relationship.
+        body: dict | DeleteRequestBody, optional, default = None
+            A structure representing the details of the relationship.
 
         Returns
         -------
@@ -5684,38 +4894,35 @@ class CollectionManager(Client2):
         _____
         JSON Structure looks like:
         {
-          "class" : "MetadataSourceRequestBody",
+          "class": "DeleteRequestBody",
           "externalSourceGUID": "add guid here",
           "externalSourceName": "add qualified name here",
-          "effectiveTime" : "{{$isoTimestamp}}",
-          "forLineage" : false,
-          "forDuplicateProcessing" : false
+          "effectiveTime": "{{$isoTimestamp}}",
+          "forLineage": false,
+          "forDuplicateProcessing": false
         }
 
 
         """
-        cascade_s = str(cascade).lower()
-        url = f"{self.collection_command_root}/{collection_guid}/delete?cascadedDelete={cascade_s}"
-        if body is None:
-            body = {"class": "NullRequestBody"}
-
-        await self._async_make_request("POST", url, body)
+        url = f"{self.collection_command_root}/{collection_guid}/delete"
+        await self._async_delete_request(url, body, cascade)
         logger.info(f"Deleted collection {collection_guid} with cascade {cascade}")
 
 
-    def delete_collection(self, collection_guid: str, body: dict = None, cascade: bool = False) -> None:
-        """Delete a collection.  It is detected from all parent elements.  If members are anchored to the collection
+    def delete_collection(self, collection_guid: str, body: dict | DeleteRequestBody = None,
+                          cascade: bool = False) -> None:
+        """Delete a collection.  It is deleted from all parent elements.  If members are anchored to the collection
         then they are also deleted.
 
         Parameters
         ----------
         collection_guid: str
-            The guid of the collection to update.
+            The guid of the collection to delete.
 
         cascade: bool, optional, defaults to True
             If true, a cascade delete is performed.
 
-        body: dict, optional, default = None
+        body: dict DeleteRequestBodyt, optional, default = None
             A dict representing the details of the relationship.
 
         Returns
@@ -5734,14 +4941,7 @@ class CollectionManager(Client2):
         Notes
         _____
         JSON Structure looks like:
-        {
-          "class" : "MetadataSourceRequestBody",
-          "externalSourceGUID": "add guid here",
-          "externalSourceName": "add qualified name here",
-          "effectiveTime" : "{{$isoTimestamp}}",
-          "forLineage" : false,
-          "forDuplicateProcessing" : false
-        }
+
 
 
         """
@@ -5750,7 +4950,8 @@ class CollectionManager(Client2):
 
 
     @dynamic_catch
-    async def _async_add_to_collection(self, collection_guid: str, element_guid: str, body: dict = None, ) -> None:
+    async def _async_add_to_collection(self, collection_guid: str, element_guid: str,
+                                       body: dict | NewRelationshipRequestBody = None, ) -> None:
         """Add an element to a collection.  The request body is optional. Async version.
 
         Parameters
@@ -5759,12 +4960,9 @@ class CollectionManager(Client2):
             identity of the collection to return members for.
         element_guid: str
             Effective time of the query. If not specified will default to any time.
-        body: dict, optional, defaults to None
+        body: dict NewRelationshipRequestBody, optional, defaults to None
             The body of the request to add to the collection. See notes.
 
-            The name of the server to use.
-
-
         Returns
         -------
         None
@@ -5782,7 +4980,7 @@ class CollectionManager(Client2):
         Notes
         -----
         Example body:
-        { "class": "RelationshipRequestBody",
+        { "class": "NewRelationshipRequestBody",
            "properties" : {
               "class" : "CollectionMembershipProperties",
               "membershipRationale": "xxx",
@@ -5809,12 +5007,12 @@ class CollectionManager(Client2):
 
         url = (f"{self.collection_command_root}/{collection_guid}/members/"
                f"{element_guid}/attach")
-        body_s = body_slimmer(body)
-        await self._async_make_request("POST", url, body_s)
+        await self._async_new_relationship_request(url, "CollectionMembershipProperties", body)
         logger.info(f"Added {element_guid} to {collection_guid}")
 
 
-    def add_to_collection(self, collection_guid: str, element_guid: str, body: dict = None, ) -> None:
+    def add_to_collection(self, collection_guid: str, element_guid: str,
+                          body: dict | NewRelationshipRequestBody= None, ) -> None:
         """Add an element to a collection.  The request body is optional.
 
         Parameters
@@ -5875,8 +5073,8 @@ class CollectionManager(Client2):
 
 
     @dynamic_catch
-    async def _async_update_collection_membership(self, collection_guid: str, element_guid: str, body: dict = None,
-                                                  replace_all_props: bool = False, ) -> None:
+    async def _async_update_collection_membership_prop(self, collection_guid: str, element_guid: str, body: dict = None,
+                                                   ) -> None:
         """Update an element's membership to a collection. Async version.
 
         Parameters
@@ -5934,16 +5132,15 @@ class CollectionManager(Client2):
         }
         """
 
-        replace_all_props_s = str(replace_all_props).lower()
         url = (f"{self.collection_command_root}/{collection_guid}/members/"
-               f"{element_guid}/update?replaceAllProperties={replace_all_props_s}")
-        body_s = body_slimmer(body)
-        await self._async_make_request("POST", url, body_s)
+               f"{element_guid}/update")
+        await self._async_update_relationship_request(url, "CollectionMembershipProperties", body )
         logger.info(f"Updated membership for collection {collection_guid}")
 
 
-    def update_collection_membership(self, collection_guid: str, element_guid: str, body: dict = None,
-                                     replace_all_props: bool = False, ) -> None:
+    def update_collection_membership_prop(self, collection_guid: str, element_guid: str,
+                                     body: dict | UpdateRelationshipRequestBody= None,
+                                      ) -> None:
         """Update an element's membership to a collection.
 
         Parameters
@@ -6002,12 +5199,12 @@ class CollectionManager(Client2):
         """
         loop = asyncio.get_event_loop()
         loop.run_until_complete(
-            self._async_update_collection_membership(collection_guid, element_guid, body, replace_all_props))
+            self._async_update_collection_membership(collection_guid, element_guid, body))
 
 
     @dynamic_catch
     async def _async_remove_from_collection(self, collection_guid: str, element_guid: str,
-                                            body: dict = None) -> None:
+                                            body: dict | DeleteRequestBody = None) -> None:
         """Remove an element from a collection. Async version.
 
         Parameters
@@ -6016,7 +5213,7 @@ class CollectionManager(Client2):
             identity of the collection to return members for.
         element_guid: str
             Effective time of the query. If not specified will default to any time.
-        body: dict, optional, defaults to None
+        body: dict | DeleteRequestBody, optional, defaults to None
             The body of the request to add to the collection. See notes.
 
         Returns
@@ -6036,7 +5233,7 @@ class CollectionManager(Client2):
         Notes
         -----
         {
-          "class" : "MetadataSourceRequestBody",
+          "class" : "DeleteRequestBody",
           "externalSourceGUID": "add guid here",
           "externalSourceName": "add qualified name here",
           "effectiveTime" : "{{$isoTimestamp}}",
@@ -6048,13 +5245,12 @@ class CollectionManager(Client2):
 
         url = (f"{self.collection_command_root}/{collection_guid}/members/"
                f"{element_guid}/detach")
-        if body is None:
-            body = {"class": "NullRequestBody"}
-        await self._async_make_request("POST", url, body)
+        await self._async_delete_collection(url, body)
         logger.info(f"Removed member {element_guid} from collection {collection_guid}")
 
 
-    def remove_from_collection(self, collection_guid: str, element_guid: str, body: dict = None) -> None:
+    def remove_from_collection(self, collection_guid: str, element_guid: str,
+                               body: dict | DeleteRequestBody= None) -> None:
         """Remove an element from a collection. Async version.
 
         Parameters
@@ -6182,46 +5378,113 @@ class CollectionManager(Client2):
             self._async_get_member_list(collection_guid, collection_name, collection_qname))
         return resp
 
-
-    def _extract_collection_properties(self, element: dict) -> dict:
+    def _extract_digital_product_properties(self, element: dict, guid: str, output_format: str) -> dict:
+        props = element["properties"]
+        digital_prod = DigitalProductProperties.model_validate(props)
+        added_props = get_defined_field_values(digital_prod)
+
+        used_by_digital_products = element.get("usedByDigitalProducts", "")
+        if isinstance(used_by_digital_products, (list | dict)):
+            used_by_digital_products_list = ""
+            for prod in used_by_digital_products:
+                used_by_digital_products_list += f"{prod["relatedElement"]["properties"]["qualifiedName"]}, "
+            added_props["used_by_digital_products"] = used_by_digital_products_list[:-2]
+
+        uses_digital_products = element.get("usesDigitalProducts", "")
+        if isinstance(uses_digital_products, (list | dict)):
+            uses_digital_products_list = ""
+            for prod in uses_digital_products:
+                uses_digital_products_list += f"{prod["relatedElement"]["properties"]["qualifiedName"]}, "
+            added_props["uses_digital_products"] = uses_digital_products_list[:-2]
+
+        return added_props
+
+    def _extract_agreement_properties(self, element: dict, guid: str, output_format: str) -> dict:
+        props = element["properties"]
+        # agreement = Collections.model_validate(props)
+        # added_props = get_defined_field_values(agreement)
+
+        added_props = {}
+        agreement_items = element.get("agreementItems", "")
+        if isinstance(agreement_items, (list | dict)):
+            agreement_items_list = ""
+            for item in agreement_items:
+                agreement_items_list += f"{item["relatedElement"]["properties"]["qualifiedName"]}, "
+            added_props["agreementItems"] = agreement_items_list[:-2]
+
+        return added_props
+
+    def _extract_collection_properties(self, element: dict, columns_struct: dict) -> dict:
         """
-        Extract common properties from a collection element.
+        Extract common properties from a collection element and populate into the provided columns_struct.
 
         Args:
             element (dict): The collection element
+            columns_struct (dict): The columns structure to populate
 
         Returns:
-            dict: Dictionary of extracted properties
+            dict: columns_struct with column 'value' fields populated
         """
-
-        props = _extract_referenceable_properties(element)
+        # First, populate from element.properties using the utility
+        col_data = populate_columns_from_properties(element, columns_struct)
+
+        columns_list = col_data.get("formats", {}).get("columns", [])
+
+        # Populate header-derived values
+        header_props = _extract_referenceable_properties(element)
+        for column in columns_list:
+            key = column.get('key')
+            if key in header_props:
+                column['value'] = header_props.get(key)
+            elif isinstance(key, str) and key.lower() == 'guid':
+                column['value'] = header_props.get('GUID')
+
+        # Derived/computed fields
+        # collectionCategories are classifications
         classification_names = ""
-        # classifications = element['elementHeader'].get("classifications", [])
-        for classification in props['classifications']:
+        classifications = element.get('elementHeader', {}).get("collectionCategories", [])
+        for classification in classifications:
             classification_names += f"{classification['classificationName']}, "
-        props["classifications"] = classification_names[:-2]  # why?
+        if classification_names:
+            for column in columns_list:
+                if column.get('key') == 'classifications':
+                    column['value'] = classification_names[:-2]
+                    break
+
+        # Populate requested relationship-based columns generically from top-level keys
+        col_data = get_required_relationships(element, col_data)
 
-        props['mermaid'] = element.get('mermaidGraph', "") or ""
+        # Subject area classification
+        subject_area = element.get('elementHeader', {}).get("subjectArea", "") or ""
+        subj_val = ""
+        if isinstance(subject_area, dict):
+            subj_val = subject_area.get("classificationProperties", {}).get("subjectAreaName", "")
+        for column in columns_list:
+            if column.get('key') == 'subject_area':
+                column['value'] = subj_val
+                break
 
-        member_names = ""
-        members = self.get_member_list(collection_guid=props["GUID"])
-        if isinstance(members, list):
-            for member in members:
-                member_names += f"{member['qualifiedName']}, "
-            props['members'] = member_names[:-2]
-        logger.trace(f"Extracted properties: {props}")
-        return props
+        # Mermaid graph
+        mermaid_val = element.get('mermaidGraph', "") or ""
+        for column in columns_list:
+            if column.get('key') == 'mermaid':
+                column['value'] = mermaid_val
+                break
+
+        logger.trace(f"Extracted/Populated columns: {col_data}")
+
+        return col_data
 
 
     def _generate_collection_output(self, elements: dict|list[dict], filter: Optional[str],
-                                    classification_name: Optional[str], output_format: str = "DICT",
+                                    element_type_name: Optional[str], output_format: str = "DICT",
                                     output_format_set: dict | str = None) -> str| list[dict]:
         """ Generate output for collections in the specified format.
 
             Args:
                 elements (Union[Dict, List[Dict]]): Dictionary or list of dictionaries containing data field elements
                 filter (Optional[str]): The search string used to find the elements
-                classification_name (Optional[str]): The type of collection
+                element_type_name (Optional[str]): The type of collection
                 output_format (str): The desired output format (MD, FORM, REPORT, LIST, DICT, MERMAID, HTML)
                 output_format_set (Optional[dict], optional): List of dictionaries containing column data. Defaults
                 to None.
@@ -6229,22 +5492,33 @@ class CollectionManager(Client2):
             Returns:
                 Union[str, List[Dict]]: Formatted output as a string or list of dictionaries
         """
-        if classification_name is None:
+        if element_type_name is None:
             entity_type = "Collections"
         else:
-            entity_type = classification_name
+            entity_type = element_type_name
         # First see if the user has specified an output_format_set - either a label or a dict
+        get_additional_props_func  = None
         if output_format_set:
             if isinstance(output_format_set, str):
                 output_formats = select_output_format_set(output_format_set, output_format)
-            if isinstance(output_format_set, dict):
+            elif isinstance(output_format_set, dict):
                 output_formats = get_output_format_type_match(output_format_set, output_format)
-        # If no output_format was set, then use the classification_name to lookup the output format
-        elif classification_name:
-            output_formats = select_output_format_set(classification_name, output_format)
+
+        # If no output_format was set, then use the element_type_name to lookup the output format
+        elif element_type_name:
+            output_formats = select_output_format_set(element_type_name, output_format)
         else:
             # fallback to collections or entity type
             output_formats = select_output_format_set(entity_type,output_format)
+        if output_formats is None:
+            output_formats = select_output_format_set("Default", output_format)
+
+        if output_formats:
+            get_additional_props_name = output_formats.get("get_additional_props", {}).get("function", None)
+            if isinstance(get_additional_props_name, str):
+                class_name, method_name = get_additional_props_name.split(".")
+                if hasattr(self, method_name):
+                    get_additional_props_func = getattr(self, method_name)
 
         logger.trace(f"Executing generate_collection_output for {entity_type}: {output_formats}")
         return generate_output(
@@ -6253,7 +5527,7 @@ class CollectionManager(Client2):
             entity_type,
             output_format,
             self._extract_collection_properties,
-            None,
+            get_additional_props_func,
             output_formats,
             )