pyegeria 5.4.0.28__py3-none-any.whl → 5.5.3.3__py3-none-any.whl

pyegeria/{collection_manager.py → omvs/collection_manager.py}

@@ -1,5 +1,5 @@
 """
-PDX-License-Identifier: Apache-2.0
+SPDX-License-Identifier: Apache-2.0
 Copyright Contributors to the ODPi Egeria project.
 
     Maintain and explore the contents of nested collections.
@@ -7,27 +7,26 @@ Copyright Contributors to the ODPi Egeria project.
 """
 
 import asyncio
-import inspect
 from datetime import datetime
 from typing import Optional, Annotated, Literal, Union
 
 from loguru import logger
-from pydantic import ValidationError, Field, HttpUrl
+from pydantic import Field, HttpUrl
 
-from pyegeria._exceptions_new import PyegeriaInvalidParameterException
-from pyegeria._globals import NO_ELEMENTS_FOUND, NO_GUID_RETURNED, NO_MEMBERS_FOUND
-from pyegeria._output_formats import select_output_format_set, get_output_format_type_match
-from pyegeria.config import settings
+from pyegeria.core._exceptions import PyegeriaInvalidParameterException
+from pyegeria.core._globals import NO_ELEMENTS_FOUND, NO_GUID_RETURNED
+from pyegeria.view.base_report_formats import select_report_spec, get_report_spec_match
+from pyegeria.core.config import settings
 from pyegeria.models import (SearchStringRequestBody, FilterRequestBody, GetRequestBody, NewElementRequestBody,
                              ReferenceableProperties, InitialClassifications, TemplateRequestBody,
-                             UpdateElementRequestBody, UpdateStatusRequestBody, NewRelationshipRequestBody,
-                             DeleteRequestBody, UpdateRelationshipRequestBody, ResultsRequestBody,
+                             UpdateElementRequestBody, NewRelationshipRequestBody,
+                             DeleteElementRequestBody, DeleteRelationshipRequestBody, UpdateRelationshipRequestBody,
+                             ResultsRequestBody,
+                             DeploymentStatusSearchString, DeploymentStatusFilterRequestBody,
                              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
-
+from pyegeria.view.output_formatter import (generate_output,
+                                            populate_common_columns)
+from pyegeria.core.utils import body_slimmer, dynamic_catch
 
 app_settings = settings
 EGERIA_LOCAL_QUALIFIER = app_settings.User_Profile.egeria_local_qualifier
@@ -57,7 +56,7 @@ def query_string(params):
             result = f"{result}{query_seperator(result)}{params[i][0]}={params[i][1]}"
     return result
 
-from pyegeria._client_new import Client2
+from pyegeria.core._server_client import ServerClient
 
 class CollectionProperties(ReferenceableProperties):
     class_: Annotated[Literal["CollectionProperties"], Field(alias="class")]
@@ -93,12 +92,24 @@ class DigitalProductProperties(CollectionProperties):
     next_version_date: datetime | None = None
     withdrawal_date: datetime | None = None
 
+class DigitalProductFamilyProperties(CollectionProperties):
+    class_: Annotated[Literal["DigitalProductFamilyProperties"], 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
+    next_version_date: datetime | None = None
+    withdrawal_date: datetime | None = None
+
+
 class Collections(PyegeriaModel):
-    collection: Union[CollectionProperties, DigitalSubscriptionProperties, DigitalProductProperties, AgreementProperties,
+    collection: Union[CollectionProperties, DigitalSubscriptionProperties, DigitalProductProperties, DigitalProductFamilyProperties,AgreementProperties,
                       DataSpecProperties, DataDictionaryProperties] = Field(desciminator="class_")
 
 
-class CollectionManager(Client2):
+class CollectionManager(ServerClient):
     """
     Maintain and explore the contents of nested collections. These collections can be used to represent digital
     products, or collections of resources for a particular project or team. They can be used to organize assets and
@@ -121,16 +132,16 @@ class CollectionManager(Client2):
     """
 
 
-    def __init__(self, view_server: str, platform_url: str, user_id: str, user_pwd: str = None, token: str = None, ):
+    def __init__(self, view_server: str, platform_url: str, user_id: str, user_pwd: Optional[str] = None, token: Optional[str] = None, ):
         self.view_server = view_server
         self.platform_url = platform_url
         self.user_id = user_id
         self.user_pwd = user_pwd
 
 
-        Client2.__init__(self, view_server, platform_url, user_id, user_pwd, token)
-        result = self.get_platform_origin()
-        logger.info(f"CollectionManager initialized, platform origin is: {result}")
+        ServerClient.__init__(self, view_server, platform_url, user_id, user_pwd, token)
+        # result = self.get_platform_origin()
+        # logger.info(f"CollectionManager initialized, platform origin is: {result}")
         self.collection_command_root: str = (
             f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/collection-manager/collections")
         #
@@ -140,9 +151,9 @@ class CollectionManager(Client2):
 
     @dynamic_catch
     async def _async_get_attached_collections(self, parent_guid: str, start_from: int = 0, page_size: int = 0,
-                                              category: str = None, classification_names: list[str]= None,
-                                              body: dict | FilterRequestBody = None, output_format: str = "JSON",
-                                              output_format_set: str | dict = None) -> list | str:
+                                              category: Optional[str] = None, classification_names: list[str]= None,
+                                              body: Optional[dict | FilterRequestBody] = None, output_format: str = "JSON",
+                                              report_spec: str | dict = None) -> list | str:
         """Returns the list of collections that are linked off of the supplied element using the ResourceList
            relationship. Async version.
 
@@ -159,7 +170,7 @@ class CollectionManager(Client2):
             If supplied, adds addition request details - for instance, to filter the results on collectionType
         output_format: str, default = "JSON"
             - one of "MD", "LIST", "FORM", "REPORT", "DICT", "MERMAID" or "JSON"
-         output_format_set: str | dict = None), optional, default = None
+         report_spec: str | dict = None), optional, default = None
             The desired output columns/fields to include.
 
         Returns
@@ -171,9 +182,9 @@ class CollectionManager(Client2):
         Raises
         ------
 
-        InvalidParameterException
+        PyegeriaInvalidParameterException
           If the client passes incorrect parameters on the request - such as bad URLs or invalid values
-        PropertyServerException
+        PyegeriaAPIException
           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
@@ -197,7 +208,7 @@ class CollectionManager(Client2):
 
         url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/collection-manager/"
                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:
@@ -205,14 +216,14 @@ class CollectionManager(Client2):
             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}")
+            logger.info(f"Found elements, output format: {output_format}, report_spec: {report_spec}")
             return self._generate_collection_output(elements, None, None, output_format,
-                                                    output_format_set=output_format_set)
+                                                    report_spec=report_spec)
         return elements
 
 
     def get_attached_collections(self, parent_guid: str, start_from: int = 0, page_size: int = 0, body: dict = None,
-                                 output_format: str = "JSON", output_format_set: str | dict = None) -> list:
+                                 output_format: str = "JSON", report_spec: str | dict = None) -> list:
         """Returns the list of collections that are linked off of the supplied element using the ResourceList
            relationship. Async version.
 
@@ -229,7 +240,7 @@ class CollectionManager(Client2):
             If supplied, adds addition request details - for instance, to filter the results on collectionType
         output_format: str, default = "JSON"
             - one of "MD", "LIST", "FORM", "REPORT", "DICT", "MERMAID" or "JSON"
-         output_format_set: str | dict = None), optional, default = None
+         report_spec: str | dict = None), optional, default = None
                 The desired output columns/fields to include.
 
 
@@ -242,9 +253,9 @@ class CollectionManager(Client2):
         Raises
         ------
 
-        InvalidParameterException
+        PyegeriaInvalidParameterException
           If the client passes incorrect parameters on the request - such as bad URLs or invalid values
-        PropertyServerException
+        PyegeriaAPIException
           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
@@ -267,47 +278,87 @@ class CollectionManager(Client2):
         """
         return asyncio.get_event_loop().run_until_complete(
             self._async_get_attached_collections(parent_guid, start_from, page_size,
-                                                 body, output_format, output_format_set))
+                                                 body, output_format, report_spec))
 
 
     @dynamic_catch
-    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,
-                                      body: dict | SearchStringRequestBody = None) -> list | str:
-        """ Returns the list of collections matching the search string filtered by the optional classification.
-            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.
+    async def _async_find_collections(self, search_string: str = "*",
+                                      starts_with: bool = True, ends_with: bool = False,
+                                      ignore_case: bool = False,
+                                      anchor_domain: Optional[str] = None,
+                                      metadata_element_type: Optional[str] = None,
+                                      metadata_element_subtypes: Optional[list[str]] = None,
+                                      skip_relationships: Optional[list[str]] = None,
+                                      include_only_relationships: Optional[list[str]] = None,
+                                      skip_classified_elements: Optional[list[str]] = None,
+                                      include_only_classified_elements: Optional[list[str]] = None,
+                                      graph_query_depth: int = 3,
+                                      governance_zone_filter: Optional[list[str]] = None, as_of_time: Optional[str] = None,
+                                      effective_time: Optional[str] = None, relationship_page_size: int = 0,
+                                      limit_results_by_status: Optional[list[str]] = None, sequencing_order: Optional[str] = None,
+                                      sequencing_property: Optional[str] = None,
+                                      output_format: str = "JSON",
+                                      report_spec: str | dict = None,
+                                      start_from: int = 0, page_size: int = 100,
+                                      property_names: Optional[list[str]] = None,
+                                      body: Optional[dict | SearchStringRequestBody] = None,
+                                      _type: str = "Collection") -> list | str:
+        """ Retrieve the list of collection metadata elements that contain the search string. Async Version.
 
         Parameters
         ----------
         search_string: str
-            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,
-        starts_with : bool, [default=False], optional
+            Search string to match against - None or '*' indicate match against all collections.
+        starts_with : bool, [default=True], optional
             Starts with the supplied string.
         ends_with : bool, [default=False], optional
             Ends with the supplied string
         ignore_case : bool, [default=False], optional
             Ignore case when searching
-        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.
+        anchor_domain: str, optional
+            The anchor domain to search in.
+        metadata_element_type: str, optional
+            The type of metadata element to search for.
+        metadata_element_subtypes: list[str], optional
+            The subtypes of metadata element to search for.
+        skip_relationships: list[str], optional
+            The types of relationships to skip.
+        include_only_relationships: list[str], optional
+            The types of relationships to include.
+        skip_classified_elements: list[str], optional
+            The types of classified elements to skip.
+        include_only_classified_elements: list[str], optional
+            The types of classified elements to include.
+        graph_query_depth: int, [default=3], optional
+            The depth of the graph query.
+        governance_zone_filter: list[str], optional
+            The governance zones to search in.
+        as_of_time: str, optional
+            The time to search as of.
+        effective_time: str, optional
+            The effective time to search at.
+        relationship_page_size: int, [default=0], optional
+            The page size for relationships.
+        limit_results_by_status: list[str], optional
+            The statuses to limit results by.
+        sequencing_order: str, optional
+            The order to sequence results by.
+        sequencing_property: str, optional
+            The property to sequence results by.
         output_format: str, default = "JSON"
             - one of "MD", "LIST", "FORM", "REPORT", "DICT", "MERMAID" or "JSON"
-        output_format_set: str | dict , optional, default = None
+        report_spec: str | dict , optional, default = None
             - The desired output columns/fields to include.
+        start_from: int, [default=0], optional
+            When multiple pages of results are available, the page number to start from.
+        page_size: int, [default=100]
+            The number of items to return in a single page.
+        property_names: list[str], optional
+            The names of properties to search for.
         body: dict | SearchStringRequestBody, optional, default = None
             - if provided, the search parameters in the body will supercede other attributes, such as "search_string"
+        _type: str, [default="Collection"], optional
+            - The type of element to search for.
 
         Returns
         -------
@@ -327,56 +378,107 @@ class CollectionManager(Client2):
 
         """
         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)
+        response = await self._async_find_request(url, _type=_type, _gen_output=self._generate_collection_output,
+                                                  search_string=search_string, starts_with=starts_with,
+                                                  ends_with=ends_with, ignore_case=ignore_case,
+                                                  anchor_domain=anchor_domain,
+                                                  metadata_element_type=metadata_element_type,
+                                                  metadata_element_subtypes=metadata_element_subtypes,
+                                                  skip_relationships=skip_relationships,
+                                                  include_only_relationships=include_only_relationships,
+                                                  skip_classified_elements=skip_classified_elements,
+                                                  include_only_classified_elements=include_only_classified_elements,
+                                                  graph_query_depth=graph_query_depth,
+                                                  governance_zone_filter=governance_zone_filter,
+                                                  as_of_time=as_of_time, effective_time=effective_time,
+                                                  relationship_page_size=relationship_page_size,
+                                                  limit_results_by_status=limit_results_by_status,
+                                                  sequencing_order=sequencing_order,
+                                                  sequencing_property=sequencing_property,
+                                                  output_format=output_format, report_spec=report_spec,
+                                                  start_from=start_from, page_size=page_size,
+                                                  property_names=property_names, body=body)
 
         return response
 
     @dynamic_catch
-    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,
-                         body: dict | SearchStringRequestBody = None) -> list | str:
-        """ Returns the list of collections matching the search string filtered by the optional classification.
-            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.
+    def find_collections(self, search_string: str = "*",
+                         starts_with: bool = True, ends_with: bool = False,
+                         ignore_case: bool = False,
+                         anchor_domain: Optional[str] = None,
+                         metadata_element_type: Optional[str] = None,
+                         metadata_element_subtypes: Optional[list[str]] = None,
+                         skip_relationships: Optional[list[str]] = None,
+                         include_only_relationships: Optional[list[str]] = None,
+                         skip_classified_elements: Optional[list[str]] = None,
+                         include_only_classified_elements: Optional[list[str]] = None,
+                         graph_query_depth: int = 3,
+                         governance_zone_filter: Optional[list[str]] = None, as_of_time: Optional[str] = None,
+                         effective_time: Optional[str] = None, relationship_page_size: int = 0,
+                         limit_results_by_status: Optional[list[str]] = None, sequencing_order: Optional[str] = None,
+                         sequencing_property: Optional[str] = None,
+                         output_format: str = "JSON",
+                         report_spec: str | dict = None,
+                         start_from: int = 0, page_size: int = 100,
+                         property_names: Optional[list[str]] = None,
+                         body: Optional[dict | SearchStringRequestBody] = None,
+                         _type: str = "Collection") -> list | str:
+        """ Retrieve the list of collection metadata elements that contain the search string.
 
         Parameters
         ----------
         search_string: str
-            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
+            Search string to match against - None or '*' indicate match against all collections.
+        starts_with : bool, [default=True], optional
             Starts with the supplied string.
         ends_with : bool, [default=False], optional
             Ends with the supplied string
         ignore_case : bool, [default=False], optional
             Ignore case when searching
-        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.
+        anchor_domain: str, optional
+            The anchor domain to search in.
+        metadata_element_type: str, optional
+            The type of metadata element to search for.
+        metadata_element_subtypes: list[str], optional
+            The subtypes of metadata element to search for.
+        skip_relationships: list[str], optional
+            The types of relationships to skip.
+        include_only_relationships: list[str], optional
+            The types of relationships to include.
+        skip_classified_elements: list[str], optional
+            The types of classified elements to skip.
+        include_only_classified_elements: list[str], optional
+            The types of classified elements to include.
+        graph_query_depth: int, [default=3], optional
+            The depth of the graph query.
+        governance_zone_filter: list[str], optional
+            The governance zones to search in.
+        as_of_time: str, optional
+            The time to search as of.
+        effective_time: str, optional
+            The effective time to search at.
+        relationship_page_size: int, [default=0], optional
+            The page size for relationships.
+        limit_results_by_status: list[str], optional
+            The statuses to limit results by.
+        sequencing_order: str, optional
+            The order to sequence results by.
+        sequencing_property: str, optional
+            The property to sequence results by.
         output_format: str, default = "JSON"
             - one of "MD", "LIST", "FORM", "REPORT", "DICT", "MERMAID" or "JSON"
-        output_format_set: str | dict , optional, default = None
+        report_spec: str | dict , optional, default = None
             - The desired output columns/fields to include.
+        start_from: int, [default=0], optional
+            When multiple pages of results are available, the page number to start from.
+        page_size: int, [default=100]
+            The number of items to return in a single page.
+        property_names: list[str], optional
+            The names of properties to search for.
         body: dict | SearchStringRequestBody, optional, default = None
             - if provided, the search parameters in the body will supercede other attributes, such as "search_string"
+        _type: str, [default="Collection"], optional
+            - The type of element to search for.
 
         Returns
         -------
@@ -394,24 +496,278 @@ class CollectionManager(Client2):
         NotAuthorizedException
           The principle specified by the user_id does not have authorization for the requested action
 
-        Args:
-            classification_names ():
-            metadata_element_types ():
+        """
+        loop = asyncio.get_event_loop()
+        return loop.run_until_complete(self._async_find_collections(search_string=search_string,
+                                                                    starts_with=starts_with,
+                                                                    ends_with=ends_with,
+                                                                    ignore_case=ignore_case,
+                                                                    anchor_domain=anchor_domain,
+                                                                    metadata_element_type=metadata_element_type,
+                                                                    metadata_element_subtypes=metadata_element_subtypes,
+                                                                    skip_relationships=skip_relationships,
+                                                                    include_only_relationships=include_only_relationships,
+                                                                    skip_classified_elements=skip_classified_elements,
+                                                                    include_only_classified_elements=include_only_classified_elements,
+                                                                    graph_query_depth=graph_query_depth,
+                                                                    governance_zone_filter=governance_zone_filter,
+                                                                    as_of_time=as_of_time,
+                                                                    effective_time=effective_time,
+                                                                    relationship_page_size=relationship_page_size,
+                                                                    limit_results_by_status=limit_results_by_status,
+                                                                    sequencing_order=sequencing_order,
+                                                                    sequencing_property=sequencing_property,
+                                                                    output_format=output_format,
+                                                                    report_spec=report_spec,
+                                                                    start_from=start_from,
+                                                                    page_size=page_size,
+                                                                    property_names=property_names,
+                                                                    body=body,
+                                                                    _type=_type))
+
+
+    @dynamic_catch
+    async def _async_find_digital_products(
+        self,
+        search_string: str = "*",
+        deployment_status: Optional[str] = None,
+        starts_with: bool = True,
+        ends_with: bool = False,
+        ignore_case: bool = False,
+        start_from: int = 0,
+        page_size: int = 100,
+        output_format: str = "JSON",
+        report_spec: str | dict = None,
+        body: Optional[dict | DeploymentStatusSearchString] = None,
+    ) -> list | str:
+        """
+        Returns the list of digital products matching the search string and optional deployment status.
+
+        Parameters
+        ----------
+        search_string: str, default = "*"
+            - the search string to use to find matching digital products
+        deployment_status: str, optional
+            - optional deployment status to filter by (e.g., ACTIVE)
+        starts_with: bool, default = True
+            - if True, the search string must match the start of the property value
+        ends_with: bool, default = False
+            - if True, the search string must match the end of the property value
+        ignore_case: bool, default = False
+            - if True, the search is case-insensitive
+        start_from: int, default = 0
+            - the starting point in the results list
+        page_size: int, default = 100
+            - the maximum number of results to return
+        output_format: str, default = "JSON"
+            - the format of the output (JSON, DICT, etc.)
+        report_spec: str | dict, optional
+            - the report specification to use for the output
+        body: dict | DeploymentStatusSearchString, optional
+            - the request body to use for the request. If specified, this takes precedence over other parameters.
+
+        Returns
+        -------
+        list | str
+            - a list of digital products or a string message if no products are found
+
+        Note:
+        -----
+        Sample body:
+        {
+          "class": "DeploymentStatusSearchString",
+          "searchString" : "add search string here",
+          "deploymentStatus" : "ACTIVE",
+          "startsWith" : false,
+          "endsWith" : false,
+          "ignoreCase" : true,
+          "startFrom" : 0,
+          "pageSize": 0
+        }
+        """
+        url = (
+            f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/collection-manager"
+            f"/digital-products/by-search-string"
+        )
+
+        if isinstance(body, DeploymentStatusSearchString):
+            validated_body = body
+        elif isinstance(body, dict):
+            validated_body = self._deployment_status_search_request_adapter.validate_python(body)
+        else:
+            search_string = None if search_string == "*" else search_string
+            body_dict = {
+                "class": "DeploymentStatusSearchString",
+                "searchString": search_string,
+                "deploymentStatus": deployment_status,
+                "startsWith": starts_with,
+                "endsWith": ends_with,
+                "ignoreCase": ignore_case,
+                "startFrom": start_from,
+                "pageSize": page_size,
+            }
+            validated_body = DeploymentStatusSearchString.model_validate(body_dict)
+
+        json_body = validated_body.model_dump_json(indent=2, exclude_none=True)
+        response = await self._async_make_request("POST", url, json_body)
+        elements = response.json().get("elements", NO_ELEMENTS_FOUND)
+
+        if type(elements) is str or len(elements) == 0:
+            logger.info(NO_ELEMENTS_FOUND)
+            return NO_ELEMENTS_FOUND
+
+        if output_format.upper() != "JSON":
+            return self._generate_collection_output(
+                elements, search_string, "DigitalProduct", output_format, report_spec
+            )
+        return elements
+
+    def find_digital_products(
+        self,
+        search_string: str = "*",
+        deployment_status: Optional[str] = None,
+        starts_with: bool = True,
+        ends_with: bool = False,
+        ignore_case: bool = False,
+        start_from: int = 0,
+        page_size: int = 100,
+        output_format: str = "JSON",
+        report_spec: str | dict = None,
+        body: Optional[dict | DeploymentStatusSearchString] = None,
+    ) -> list | str:
+        """
+        Returns the list of digital products matching the search string and optional deployment status. Sync version.
 
+        See _async_find_digital_products for more details.
         """
         return asyncio.get_event_loop().run_until_complete(
-            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))
+            self._async_find_digital_products(
+                search_string,
+                deployment_status,
+                starts_with,
+                ends_with,
+                ignore_case,
+                start_from,
+                page_size,
+                output_format,
+                report_spec,
+                body,
+            )
+        )
+
+    @dynamic_catch
+    async def _async_get_digital_products_by_category(
+        self,
+        category: str,
+        deployment_status: Optional[str] = None,
+        start_from: int = 0,
+        page_size: int = 100,
+        output_format: str = "JSON",
+        report_spec: str | dict = None,
+        body: Optional[dict | DeploymentStatusFilterRequestBody] = None,
+    ) -> list | str:
+        """
+        Returns the list of digital products matching the category and optional deployment status.
+
+        Parameters
+        ----------
+        category: str
+            - the category to use to find matching digital products
+        deployment_status: str, optional
+            - optional deployment status to filter by (e.g., ACTIVE)
+        start_from: int, default = 0
+            - the starting point in the results list
+        page_size: int, default = 100
+            - the maximum number of results to return
+        output_format: str, default = "JSON"
+            - the format of the output (JSON, DICT, etc.)
+        report_spec: str | dict, optional
+            - the report specification to use for the output
+        body: dict | DeploymentStatusFilterRequestBody, optional
+            - the request body to use for the request. If specified, this takes precedence over other parameters.
+
+        Returns
+        -------
+        list | str
+            - a list of digital products or a string message if no products are found
+
+        Note:
+        -----
+        Sample body:
+        {
+          "class" : "DeploymentStatusFilterRequestBody",
+          "filter" : "xxx",
+          "deploymentStatus" : "ACTIVE",
+          "startFrom" : 0,
+          "pageSize": 0
+        }
+        """
+        url = (
+            f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/collection-manager"
+            f"/digital-products/by-category"
+        )
+
+        if isinstance(body, DeploymentStatusFilterRequestBody):
+            validated_body = body
+        elif isinstance(body, dict):
+            validated_body = self._deployment_status_filter_request_adapter.validate_python(body)
+        else:
+            body_dict = {
+                "class": "DeploymentStatusFilterRequestBody",
+                "filter": category,
+                "deploymentStatus": deployment_status,
+                "startFrom": start_from,
+                "pageSize": page_size,
+            }
+            validated_body = DeploymentStatusFilterRequestBody.model_validate(body_dict)
+
+        json_body = validated_body.model_dump_json(indent=2, exclude_none=True)
+        response = await self._async_make_request("POST", url, json_body)
+        elements = response.json().get("elements", NO_ELEMENTS_FOUND)
+
+        if type(elements) is str or len(elements) == 0:
+            logger.info(NO_ELEMENTS_FOUND)
+            return NO_ELEMENTS_FOUND
+
+        if output_format.upper() != "JSON":
+            return self._generate_collection_output(
+                elements, category, "DigitalProduct", output_format, report_spec
+            )
+        return elements
 
+    def get_digital_products_by_category(
+        self,
+        category: str,
+        deployment_status: Optional[str] = None,
+        start_from: int = 0,
+        page_size: int = 100,
+        output_format: str = "JSON",
+        report_spec: str | dict = None,
+        body: Optional[dict | DeploymentStatusFilterRequestBody] = None,
+    ) -> list | str:
+        """
+        Returns the list of digital products matching the category and optional deployment status. Sync version.
+
+        See _async_get_digital_products_by_category for more details.
+        """
+        return asyncio.get_event_loop().run_until_complete(
+            self._async_get_digital_products_by_category(
+                category,
+                deployment_status,
+                start_from,
+                page_size,
+                output_format,
+                report_spec,
+                body,
+            )
+        )
 
     @dynamic_catch
-    async def _async_get_collections_by_name(self, filter_string: str = None, classification_names: list[str] = None,
-                                             body: dict | FilterRequestBody = None,
+    async def _async_get_collections_by_name(self, filter_string: Optional[str] = None, classification_names: Optional[list[str]] = None,
+                                             body: Optional[dict | FilterRequestBody] = None,
                                              start_from: int = 0, page_size: int = 0,
                                              output_format: str = 'JSON',
-                                             output_format_set: str | dict = None) -> list | str:
+                                             report_spec: str | dict = None) -> list | str:
         """ Returns the list of collections with a particular name.
 
             Parameters
@@ -429,7 +785,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
+            report_spec: dict , optional, default = None
                 The desired output columns/fields to include.
 
             Returns
@@ -441,9 +797,9 @@ class CollectionManager(Client2):
             Raises
             ------
 
-            InvalidParameterException
+            PyegeriaInvalidParameterException
               If the client passes incorrect parameters on the request - such as bad URLs or invalid values
-            PropertyServerException
+            PyegeriaAPIException
               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
@@ -453,23 +809,23 @@ class CollectionManager(Client2):
                                                   _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,
+                                                  output_format=output_format, report_spec=report_spec,
                                                   body=body)
 
         return response
 
 
-    def get_collections_by_name(self, name: str = None, classification_names: list[str] = None,
-                                body: dict | FilterRequestBody = None,
+    def get_collections_by_name(self, filter_string: Optional[str] = None, classification_names: Optional[list[str]] = None,
+                                body: Optional[dict | FilterRequestBody] = None,
                                 start_from: int = 0, page_size: int = 0, output_format: str = 'JSON',
-                                output_format_set: str | dict = None) -> list | str:
+                                report_spec: 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.
             The request parameters, startsWith, endsWith and ignoreCase can be used to allow a fuzzy search.
 
         Parameters
         ----------
-        name: str,
+        filter_string: str,
             name to use to find matching collections.
         classification_names: list[str], optional, default = None
             type of collection to filter by - e.g., DataDict, Folder, Root
@@ -482,7 +838,7 @@ 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
+         report_spec: str | dict, optional, default = None
                 The desired output columns/fields to include.
 
         Returns
@@ -497,15 +853,15 @@ class CollectionManager(Client2):
 
         """
         return asyncio.get_event_loop().run_until_complete(
-            self._async_get_collections_by_name(name, classification_names, body, start_from, page_size,
-                                                output_format, output_format_set))
+            self._async_get_collections_by_name(filter_string, classification_names, body, start_from, page_size,
+                                                output_format, report_spec))
 
 
     @dynamic_catch
-    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,
+    async def _async_get_collections_by_category(self, category: str, classification_names: Optional[list[str]] = None,
+                                             body: Optional[dict | FilterRequestBody] = None, start_from: int = 0, page_size: int = 0,
                                              output_format: str = 'JSON',
-                                             output_format_set: str | dict = None) -> list | str:
+                                             report_spec: str | dict = None) -> list | str:
         """Returns the list of collections with a particular category. This is an optional text field in the
             collection element.
 
@@ -525,7 +881,7 @@ 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
+         report_spec: str | dict , optional, default = None
                 The desired output columns/fields to include.
 
         Returns
@@ -560,17 +916,17 @@ class CollectionManager(Client2):
                                                   _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,
+                                                  output_format=output_format, report_spec=report_spec,
                                                   body=body)
 
         return response
 
 
 
-    def get_collections_by_category(self, category: str, classification_names: list[str] = None,
-                                body: dict | FilterRequestBody = None,
+    def get_collections_by_category(self, category: str, classification_names: Optional[list[str]] = None,
+                                body: Optional[dict | FilterRequestBody] = None,
                                 start_from: int = 0, page_size: int = 0, output_format: str = 'JSON',
-                                output_format_set: str | dict = None) -> list | str:
+                                report_spec: str | dict = None) -> list | str:
         """Returns the list of collections with a particular collectionType. This is an optional text field in the
             collection element.
 
@@ -590,7 +946,7 @@ 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
+        report_spec: str | dict, optional, default = None
                 The desired output columns/fields to include.
 
         Returns
@@ -602,9 +958,9 @@ class CollectionManager(Client2):
         Raises
         ------
 
-        InvalidParameterException
+        PyegeriaInvalidParameterException
           If the client passes incorrect parameters on the request - such as bad URLs or invalid values
-        PropertyServerException
+        PyegeriaAPIException
           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
@@ -629,14 +985,14 @@ class CollectionManager(Client2):
 
         return asyncio.get_event_loop().run_until_complete(
             self._async_get_collections_by_category(category, classification_names, body, start_from, page_size,
-                                                output_format, output_format_set))
+                                                output_format, report_spec))
 
 
     @dynamic_catch
-    async def _async_get_collection_by_guid(self, collection_guid: str, element_type: str = None,
-                                            body: dict | GetRequestBody = None,
+    async def _async_get_collection_by_guid(self, collection_guid: str, element_type: Optional[str] = None,
+                                            body: Optional[dict | GetRequestBody] = None,
                                             output_format: str = 'JSON',
-                                            output_format_set: str | dict = None) -> dict | str:
+                                            report_spec: str | dict = None) -> dict | str:
         """Return the properties of a specific collection. Async version.
 
         Parameters
@@ -649,7 +1005,7 @@ class CollectionManager(Client2):
             full request body.
         output_format: str, default = "JSON"
             - one of "DICT", "MERMAID" or "JSON"
-         output_format_set: str | dict, optional, default = None
+         report_spec: str | dict, optional, default = None
                 The desired output columns/fields to include.
 
         Returns
@@ -661,9 +1017,9 @@ class CollectionManager(Client2):
         Raises
         ------
 
-        InvalidParameterException
+        PyegeriaInvalidParameterException
           If the client passes incorrect parameters on the request - such as bad URLs or invalid values
-        PropertyServerException
+        PyegeriaAPIException
           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
@@ -685,7 +1041,7 @@ class CollectionManager(Client2):
 
         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,
+                                                  output_format=output_format, report_spec=report_spec,
                                                   body=body)
 
         return response
@@ -693,8 +1049,8 @@ class CollectionManager(Client2):
 
 
 
-    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:
+    def get_collection_by_guid(self, collection_guid: str, element_type: Optional[str] = None, body: dict | GetRequestBody= None,
+                               output_format: str = 'JSON', report_spec: str | dict = None) -> dict | str:
         """ Return the properties of a specific collection. Async version.
 
             Parameters
@@ -707,7 +1063,7 @@ class CollectionManager(Client2):
                 full request body.
             output_format: str, default = "JSON"
                 - one of "DICT", "MERMAID" or "JSON"
-            output_format_set: dict , optional, default = None
+            report_spec: dict , optional, default = None
                 The desired output columns/fields to include.
 
 
@@ -720,9 +1076,9 @@ class CollectionManager(Client2):
             Raises
             ------
 
-            InvalidParameterException
+            PyegeriaInvalidParameterException
               If the client passes incorrect parameters on the request - such as bad URLs or invalid values
-            PropertyServerException
+            PyegeriaAPIException
               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
@@ -740,14 +1096,14 @@ class CollectionManager(Client2):
         """
         return asyncio.get_event_loop().run_until_complete(
             self._async_get_collection_by_guid(collection_guid, element_type, body,
-                                               output_format, output_format_set))
+                                               output_format, report_spec))
 
 
     @dynamic_catch
-    async def _async_get_collection_members(self, collection_guid: str = None, collection_name: str = None,
-                                            collection_qname: str = None, body: dict | ResultsRequestBody = None, start_from: int = 0,
+    async def _async_get_collection_members(self, collection_guid: Optional[str] = None, collection_name: Optional[str] = None,
+                                            collection_qname: Optional[str] = None, body: Optional[dict | ResultsRequestBody] = None, start_from: int = 0,
                                             page_size: int = 0, output_format: str = "JSON",
-                                            output_format_set: str | dict = None) -> list | str:
+                                            report_spec: str | dict = None) -> list | str:
         """Return a list of elements that are a member of a collection. Async version.
 
         Parameters
@@ -770,7 +1126,7 @@ 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
+         report_spec: str | dict , optional, default = None
                 The desired output columns/fields to include.
 
         Returns
@@ -782,9 +1138,9 @@ class CollectionManager(Client2):
         Raises
         ------
 
-        InvalidParameterException
+        PyegeriaInvalidParameterException
           If the client passes incorrect parameters on the request - such as bad URLs or invalid values
-        PropertyServerException
+        PyegeriaAPIException
           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
@@ -812,16 +1168,16 @@ class CollectionManager(Client2):
 
         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,
+                                                  output_format=output_format, report_spec=report_spec,
                                                   body=body)
 
         return response
 
 
-    def get_collection_members(self, collection_guid: str = None, collection_name: str = None,
-                               collection_qname: str = None, body: dict = None, start_from: int = 0,
+    def get_collection_members(self, collection_guid: Optional[str] = None, collection_name: Optional[str] = None,
+                               collection_qname: Optional[str] = None, body: dict = None, start_from: int = 0,
                                page_size: int = 0,
-                               output_format: str = "JSON", output_format_set: str | dict = None) -> list | str:
+                               output_format: str = "JSON", report_spec: str | dict = None) -> list | str:
         """Return a list of elements that are a member of a collection.
         Parameters
         ----------
@@ -843,7 +1199,7 @@ 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
+         report_spec: str | dict , optional, default = None
                 The desired output columns/fields to include.
 
         Returns
@@ -855,9 +1211,9 @@ class CollectionManager(Client2):
         Raises
         ------
 
-        InvalidParameterException
+        PyegeriaInvalidParameterException
           If the client passes incorrect parameters on the request - such as bad URLs or invalid values
-        PropertyServerException
+        PyegeriaAPIException
           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
@@ -878,15 +1234,15 @@ class CollectionManager(Client2):
         loop = asyncio.get_event_loop()
         resp = loop.run_until_complete(
             self._async_get_collection_members(collection_guid, collection_name, collection_qname, body, start_from,
-                                               page_size, output_format, output_format_set))
+                                               page_size, output_format, report_spec))
 
         return resp
 
 
     @dynamic_catch
-    async def _async_get_collection_hierarchy(self, collection_guid: str, body: dict | ResultsRequestBody = None, start_from: int = 0,
+    async def _async_get_collection_hierarchy(self, collection_guid: str, body: Optional[dict | ResultsRequestBody] = None, start_from: int = 0,
                                           page_size: int = 0, output_format: str = "JSON",
-                                          output_format_set: str | dict = None) -> list | str:
+                                          report_spec: str | dict = None) -> list | str:
         """ Return a hierarchy of nested collections. Request body is optional Async version.
 
             Parameters
@@ -903,7 +1259,7 @@ 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
+             report_spec: dict , optional, default = None
                 The desired output columns/fields to include.
 
             Returns
@@ -915,9 +1271,9 @@ class CollectionManager(Client2):
             Raises
             ------
 
-            InvalidParameterException
+            PyegeriaInvalidParameterException
               If the client passes incorrect parameters on the request - such as bad URLs or invalid values
-            PropertyServerException
+            PyegeriaAPIException
               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
@@ -942,14 +1298,14 @@ class CollectionManager(Client2):
                                                               _gen_output=self._generate_collection_output,
                                                               start_from=start_from, page_size=page_size,
                                                               output_format=output_format,
-                                                              output_format_set=output_format_set,
+                                                              report_spec=report_spec,
                                                               body=body)
 
         return response
 
-    def get_collection_hierarchy(self, collection_guid: str = None, body: dict| ResultsRequestBody = None, start_from: int = 0,
+    def get_collection_hierarchy(self, collection_guid: Optional[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:
+                             report_spec: 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.
@@ -968,7 +1324,7 @@ 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
+         report_spec: str | dict , optional, default = None
                 The desired output columns/fields to include.
 
         Returns
@@ -980,9 +1336,9 @@ class CollectionManager(Client2):
         Raises
         ------
 
-        InvalidParameterException
+        PyegeriaInvalidParameterException
           If the client passes incorrect parameters on the request - such as bad URLs or invalid values
-        PropertyServerException
+        PyegeriaAPIException
           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
@@ -1001,13 +1357,13 @@ class CollectionManager(Client2):
         """
         return asyncio.get_event_loop().run_until_complete(
             self._async_get_collection_hierarchy(collection_guid, body, start_from, page_size,
-                                             output_format, output_format_set))
+                                             output_format, report_spec))
 
 
     @dynamic_catch
-    async def _async_create_collection(self, display_name: str = None, description: str = None,
-                                       category: str = None, initial_classifications: list[str] = None,
-                                       body: dict | NewElementRequestBody = None) -> str:
+    async def _async_create_collection(self, display_name: Optional[str] = None, description: Optional[str] = None,
+                                       category: Optional[str] = None, initial_classifications: Optional[list[str]] = None, prop: list[str] = ["Collection"],
+                                       body: Optional[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
@@ -1025,7 +1381,8 @@ class CollectionManager(Client2):
         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.
-
+        prop: list[str], optional
+            The kind of collection property to use.
         body: dict | NewElementRequestBody, 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
@@ -1054,7 +1411,7 @@ class CollectionManager(Client2):
           "properties": {
             "class": "CollectionProperties",
             "qualifiedName": "Must provide a unique name here",
-            "name": "Add display name here",
+            "displayName": "Add display name here",
             "description": "Add description of the collection here",
             "category": "Add appropriate valid value for type"
           }
@@ -1072,7 +1429,7 @@ class CollectionManager(Client2):
           "properties": {
             "class": "CollectionProperties",
             "qualifiedName": "Must provide a unique name here",
-            "name": "Add display name here",
+            "displayName": "Add display name here",
             "description": "Add description of the collection here",
             "category": "Add appropriate valid value for type"
           },
@@ -1098,7 +1455,7 @@ class CollectionManager(Client2):
           "properties": {
             "class": "CollectionProperties",
             "qualifiedName": "Must provide a unique name here",
-            "name": "Add display name here",
+            "displayName": "Add display name here",
             "description": "Add description of the collection here",
             "category": "Add appropriate valid value for type"
           },
@@ -1113,7 +1470,11 @@ class CollectionManager(Client2):
         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"
+            if initial_classifications:
+                pre = initial_classifications[0]
+            else:
+                pre = prop[0]
+
             qualified_name = self.__create_qualified_name__(pre, display_name, EGERIA_LOCAL_QUALIFIER)
             if initial_classifications:
                 initial_classifications_dict = {}
@@ -1127,7 +1488,8 @@ class CollectionManager(Client2):
                                                              qualified_name = qualified_name,
                                                              display_name = display_name,
                                                              description = description,
-                                                             category = category
+                                                             category = category,
+                                                             typeName = prop[0]
                                                              )
             body = {
                 "class" :"NewElementRequestBody",
@@ -1140,16 +1502,23 @@ class CollectionManager(Client2):
             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)
-        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)
 
+        prop = validated_body.properties['class']
+        prop = prop.replace('Properties','')
+
+        # 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)
+        response = await self._async_create_element_body_request(url, [prop], validated_body)
+        return response
 
-    def create_collection(self, display_name: str = None, description: str = None,
-                                category: str = None, initial_classifications: list[str] = None,
-                                body: dict | NewElementRequestBody = None) -> str:
+
+    def create_collection(self, display_name: Optional[str] = None, description: Optional[str] = None,
+                                category: Optional[str] = None, initial_classifications: Optional[list[str]] = None, prop:list[str]=["Collection"],
+                                body: Optional[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
@@ -1166,7 +1535,8 @@ class CollectionManager(Client2):
         initial_classifications: str, optional
             An initial classification for the collection. This can be used to distinguish, for instance, Folders
             from Root Collections.
-
+        prop: str, optional
+            The types of the collection.
         body: dict | NewElementRequestBody, 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
@@ -1195,7 +1565,7 @@ class CollectionManager(Client2):
           "properties": {
             "class": "CollectionProperties",
             "qualifiedName": "Must provide a unique name here",
-            "name": "Add display name here",
+            "displayName": "Add display name here",
             "description": "Add description of the collection here",
             "category": "Add appropriate valid value for type"
           }
@@ -1213,7 +1583,7 @@ class CollectionManager(Client2):
           "properties": {
             "class": "CollectionProperties",
             "qualifiedName": "Must provide a unique name here",
-            "name": "Add display name here",
+            "displayName": "Add display name here",
             "description": "Add description of the collection here",
             "category": "Add appropriate valid value for type"
           },
@@ -1239,7 +1609,7 @@ class CollectionManager(Client2):
           "properties": {
             "class": "CollectionProperties",
             "qualifiedName": "Must provide a unique name here",
-            "name": "Add display name here",
+            "displayName": "Add display name here",
             "description": "Add description of the collection here",
             "category": "Add appropriate valid value for type"
           },
@@ -1255,12 +1625,12 @@ class CollectionManager(Client2):
 
         return asyncio.get_event_loop().run_until_complete(
             self._async_create_collection(display_name, description,category,
-                                                 initial_classifications,    body))
+                                                 initial_classifications,  prop,  body))
 
 
     @dynamic_catch
-    def create_root_collection(self, display_name: str = None, description: str = None,
-                                      category: str = None,  body: dict | NewElementRequestBody = None) -> str:
+    def create_root_collection(self, display_name: Optional[str] = None, description: Optional[str] = None,
+                                      category: Optional[str] = None,  body: Optional[dict | NewElementRequestBody] = None) -> str:
         """ Create a new collection with the RootCollection classification.  Used to identify the top of a
             collection hierarchy.
             Create Collections: https://egeria-project.org/concepts/collection
@@ -1291,15 +1661,15 @@ class CollectionManager(Client2):
               The principle specified by the user_id does not have authorization for the requested action
 
         """
+        prop = "RootCollection"
 
         return asyncio.get_event_loop().run_until_complete(
             self._async_create_collection(display_name=display_name, description=description, category=category,
-                                         initial_classifications = ["RootCollection"], body=body))
-
+                                         initial_classifications = [], prop = [prop], body=body))
 
     @dynamic_catch
-    def create_folder_collection(self, display_name: str = None, description: str = None,
-                                      category: str = None, body: dict | NewElementRequestBody = None) -> str:
+    def create_folder_collection(self, display_name: Optional[str] = None, description: Optional[str] = None,
+                                      category: Optional[str] = None, body: Optional[dict | NewElementRequestBody] = None) -> str:
         """ Create a new collection with the RootCollection classification.  Used to identify the top of a
             collection hierarchy.
             Create Collections: https://egeria-project.org/concepts/collection
@@ -1330,17 +1700,15 @@ class CollectionManager(Client2):
               The principle specified by the user_id does not have authorization for the requested action
 
         """
+        prop = "CollectionFolder"
 
         return asyncio.get_event_loop().run_until_complete(
-            self._async_create_collection(display_name, description, category,
-                                          ["Folder"], body))
-
-
+            self._async_create_collection(display_name=display_name, description=description, category=category,
+                                          initial_classifications=[], prop=[prop], body=body))
 
-        return resp
     @dynamic_catch
-    def create_reference_list_collection(self, display_name: str = None, description: str = None,
-                                      category: str = None, body: dict | NewElementRequestBody = None) -> str:
+    def create_reference_list_collection(self, display_name: Optional[str] = None, description: Optional[str] = None,
+                                      category: Optional[str] = None, body: Optional[dict | NewElementRequestBody] = None) -> str:
         """ Create a new collection with the RootCollection classification.  Used to identify the top of a
             collection hierarchy.
             Create Collections: https://egeria-project.org/concepts/collection
@@ -1377,8 +1745,8 @@ class CollectionManager(Client2):
                                           ["ReferenceList"], body))
 
     @dynamic_catch
-    def create_context_event_collection(self, display_name: str = None, description: str = None,
-                                      category: str = None, body: dict | NewElementRequestBody = None) -> str:
+    def create_context_event_collection(self, display_name: Optional[str] = None, description: Optional[str] = None,
+                                      category: Optional[str] = None, body: Optional[dict | NewElementRequestBody] = None) -> str:
         """ Create a new collection with the RootCollection classification.  Used to identify the top of a
             collection hierarchy.
             Create Collections: https://egeria-project.org/concepts/collection
@@ -1415,8 +1783,8 @@ class CollectionManager(Client2):
                                           ["ContextEvent"], body))
 
     # @dynamic_catch
-    # def create_glossary(self, display_name: str, description: str = None, language: str = "English", usage: str = None,
-    #                     category: str = None, body: dict | NewElementRequestBody = None) -> str:
+    # def create_glossary(self, display_name: str, description: Optional[str] = None, language: str = "English", usage: Optional[str] = None,
+    #                     category: Optional[str] = None, body: Optional[dict | NewElementRequestBody] = None) -> str:
     #     """Create a new glossary with optional classification. """
     #     if body is None:
     #
@@ -1438,9 +1806,9 @@ class CollectionManager(Client2):
     #     return response
 
     @dynamic_catch
-    async def _async_create_data_spec_collection(self, display_name: str = None, description: str = None,
-                                                category: str = None, classification_name: str = None,
-                                                 body: dict | NewElementRequestBody = None) -> str:
+    async def _async_create_data_spec_collection(self, display_name: Optional[str] = None, description: Optional[str] = None,
+                                                category: Optional[str] = None, classification_name: Optional[str] = None,
+                                                 body: Optional[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
@@ -1487,7 +1855,7 @@ class CollectionManager(Client2):
           "properties": {
             "class": "CollectionProperties",
             "qualifiedName": "Must provide a unique name here",
-            "name": "Add display name here",
+            "displayName": "Add display name here",
             "description": "Add description of the collection here",
             "category": "Add appropriate valid value for type"
           }
@@ -1505,7 +1873,7 @@ class CollectionManager(Client2):
           "properties": {
             "class": "CollectionProperties",
             "qualifiedName": "Must provide a unique name here",
-            "name": "Add display name here",
+            "displayName": "Add display name here",
             "description": "Add description of the collection here",
             "category": "Add appropriate valid value for type"
           },
@@ -1531,7 +1899,7 @@ class CollectionManager(Client2):
           "properties": {
             "class": "CollectionProperties",
             "qualifiedName": "Must provide a unique name here",
-            "name": "Add display name here",
+            "displayName": "Add display name here",
             "description": "Add description of the collection here",
             "category": "Add appropriate valid value for type"
           },
@@ -1583,9 +1951,9 @@ class CollectionManager(Client2):
         return resp.json().get("guid", NO_GUID_RETURNED)
 
     @dynamic_catch
-    def create_data_spec_collection(self, display_name: str = None, description: str = None,
-                                category: str = None, classification_name: str = None,
-                                body: dict | NewElementRequestBody = None) -> str:
+    def create_data_spec_collection(self, display_name: Optional[str] = None, description: Optional[str] = None,
+                                category: Optional[str] = None, classification_name: Optional[str] = None,
+                                body: Optional[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
@@ -1631,7 +1999,7 @@ class CollectionManager(Client2):
           "properties": {
             "class": "CollectionProperties",
             "qualifiedName": "Must provide a unique name here",
-            "name": "Add display name here",
+            "displayName": "Add display name here",
             "description": "Add description of the collection here",
             "category": "Add appropriate valid value for type"
           }
@@ -1649,7 +2017,7 @@ class CollectionManager(Client2):
           "properties": {
             "class": "CollectionProperties",
             "qualifiedName": "Must provide a unique name here",
-            "name": "Add display name here",
+            "displayName": "Add display name here",
             "description": "Add description of the collection here",
             "category": "Add appropriate valid value for type"
           },
@@ -1675,7 +2043,7 @@ class CollectionManager(Client2):
           "properties": {
             "class": "CollectionProperties",
             "qualifiedName": "Must provide a unique name here",
-            "name": "Add display name here",
+            "displayName": "Add display name here",
             "description": "Add description of the collection here",
             "category": "Add appropriate valid value for type"
           },
@@ -1695,9 +2063,9 @@ class CollectionManager(Client2):
 
 
     @dynamic_catch
-    async def _async_create_data_dictionary_collection(self, display_name: str = None, description: str = None,
-                                                category: str = None, classification_name: str = None,
-                                                 body: dict | NewElementRequestBody = None) -> str:
+    async def _async_create_data_dictionary_collection(self, display_name: Optional[str] = None, description: Optional[str] = None,
+                                                category: Optional[str] = None, classification_name: Optional[str] = None,
+                                                 body: Optional[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
@@ -1744,7 +2112,7 @@ class CollectionManager(Client2):
           "properties": {
             "class": "CollectionProperties",
             "qualifiedName": "Must provide a unique name here",
-            "name": "Add display name here",
+            "displayName": "Add display name here",
             "description": "Add description of the collection here",
             "category": "Add appropriate valid value for type"
           }
@@ -1762,7 +2130,7 @@ class CollectionManager(Client2):
           "properties": {
             "class": "CollectionProperties",
             "qualifiedName": "Must provide a unique name here",
-            "name": "Add display name here",
+            "displayName": "Add display name here",
             "description": "Add description of the collection here",
             "category": "Add appropriate valid value for type"
           },
@@ -1788,7 +2156,7 @@ class CollectionManager(Client2):
           "properties": {
             "class": "CollectionProperties",
             "qualifiedName": "Must provide a unique name here",
-            "name": "Add display name here",
+            "displayName": "Add display name here",
             "description": "Add description of the collection here",
             "category": "Add appropriate valid value for type"
           },
@@ -1838,9 +2206,9 @@ class CollectionManager(Client2):
         return resp.json().get("guid", NO_GUID_RETURNED)
 
     @dynamic_catch
-    def create_data_dictionary_collection(self, display_name: str = None, description: str = None,
-                                category: str = None, classification_name: str = None,
-                                body: dict | NewElementRequestBody = None) -> str:
+    def create_data_dictionary_collection(self, display_name: Optional[str] = None, description: Optional[str] = None,
+                                category: Optional[str] = None, classification_name: Optional[str] = None,
+                                body: Optional[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
@@ -1886,7 +2254,7 @@ class CollectionManager(Client2):
           "properties": {
             "class": "CollectionProperties",
             "qualifiedName": "Must provide a unique name here",
-            "name": "Add display name here",
+            "displayName": "Add display name here",
             "description": "Add description of the collection here",
             "category": "Add appropriate valid value for type"
           }
@@ -1904,7 +2272,7 @@ class CollectionManager(Client2):
           "properties": {
             "class": "CollectionProperties",
             "qualifiedName": "Must provide a unique name here",
-            "name": "Add display name here",
+            "displayName": "Add display name here",
             "description": "Add description of the collection here",
             "category": "Add appropriate valid value for type"
           },
@@ -1930,7 +2298,7 @@ class CollectionManager(Client2):
           "properties": {
             "class": "CollectionProperties",
             "qualifiedName": "Must provide a unique name here",
-            "name": "Add display name here",
+            "displayName": "Add display name here",
             "description": "Add description of the collection here",
             "category": "Add appropriate valid value for type"
           },
@@ -1957,7 +2325,7 @@ class CollectionManager(Client2):
 
 
     @dynamic_catch
-    async def _async_create_collection_from_template(self, body: TemplateRequestBody | dict) -> str:
+    async def _async_create_collection_from_template(self, body: Optional[dict | TemplateRequestBody] = None) -> str:
         """Create a new metadata element to represent a collection using an existing metadata element as a template.
         The template defines additional classifications and relationships that are added to the new collection.
         Async version.
@@ -1974,12 +2342,13 @@ class CollectionManager(Client2):
 
         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
+        PyegeriaException
+            One of the pyegeria exceptions will be raised if there are issues in communications, message format, or
+            Egeria errors.
+        ValidationError
+            Pydantic validation errors are raised if the body does not conform to the DeleteElementRequestBody.
+        PyegeriaNotAuthorizedException
+            The principle specified by the user_id does not have authorization for the requested action
 
         Notes
         -----
@@ -2030,7 +2399,7 @@ class CollectionManager(Client2):
         return resp.json().get("guid", NO_GUID_RETURNED)
 
 
-    def create_collection_from_template(self, body: dict) -> str:
+    def create_collection_from_template(self, body: Optional[dict | TemplateRequestBody] = None) -> str:
         """Create a new metadata element to represent a collection using an existing metadata element as a template.
         The template defines additional classifications and relationships that are added to the new collection.
 
@@ -2045,9 +2414,9 @@ class CollectionManager(Client2):
 
         Raises
         ------
-        InvalidParameterException
+        PyegeriaInvalidParameterException
           If the client passes incorrect parameters on the request - such as bad URLs or invalid values
-        PropertyServerException
+        PyegeriaAPIException
           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
@@ -2107,9 +2476,7 @@ class CollectionManager(Client2):
             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.
-        merge_update: bool, optional, default = True
-            If true then property changes will be overlaid on top of existing properties. If false, existing
-            properties will all be replaced by the set provided in the update request.
+
 
         Returns
         -------
@@ -2132,8 +2499,9 @@ class CollectionManager(Client2):
           "class" : "UpdateElementRequestBody",
           "properties": {
             "class" : "CollectionProperties",
+            "contentStatus": "Add appropriate valid value for type",
             "qualifiedName": "Must provide a unique name here",
-            "name" : "Add display name here",
+            "displayName" : "Add display name here",
             "description" : "Add description of the collection here",
             "category": "Add appropriate valid value for type"
           },
@@ -2151,10 +2519,6 @@ class CollectionManager(Client2):
         await self._async_update_element_body_request(url, COLLECTION_PROPERTIES_LIST,body)
 
 
-
-
-
-
     @dynamic_catch
     def update_collection(self, collection_guid: str,  body: dict | NewElementRequestBody) -> None:
         """ Update the properties of a collection. Use the correct properties object (CollectionProperties,
@@ -2170,9 +2534,7 @@ class CollectionManager(Client2):
             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.
-        merge_update: bool, optional, default = True
-            If true then property changes will be overlaid on top of existing properties. If false, existing
-            properties will all be replaced by the set provided in the update request.
+
 
         Returns
         -------
@@ -2196,8 +2558,9 @@ class CollectionManager(Client2):
           "properties": {
             "class" : "CollectionProperties",
             "qualifiedName": "Must provide a unique name here",
-            "name" : "Add display name here",
+            "displayName" : "Add display name here",
             "description" : "Add description of the collection here",
+            "contentStatus": "Add appropriate valid value for type",
             "category": "Add appropriate valid value for type"
           },
           "externalSourceGUID": "add guid here",
@@ -2251,7 +2614,7 @@ class CollectionManager(Client2):
           "properties": {
             "class" : "DigitalProductProperties",
             "qualifiedName": "DigitalProduct::Add product name here",
-            "name" : "Product contents",
+            "displayName" : "Product contents",
             "description" : "Add description of product and its expected usage here",
             "identifier" : "Add product identifier here",
             "productName" : "Add product name here",
@@ -2281,11 +2644,11 @@ class CollectionManager(Client2):
         default to ACTIVE.
         """
         url = f"{self.collection_command_root}"
-        return await self._async_create_element_body_request(url, "DigitalProductProperties", body)
+        return await self._async_create_element_body_request(url, ["DigitalProductProperties"], body)
 
 
     @dynamic_catch
-    def create_digital_product(self, body: dict | NewElementRequestBody = None) -> str:
+    def create_digital_product(self, body: Optional[dict | NewElementRequestBody] = None) -> str:
         """ Create a new collection that represents a digital product.
 
             Parameters
@@ -2322,7 +2685,7 @@ class CollectionManager(Client2):
               "properties": {
                 "class" : "DigitalProductProperties",
                 "qualifiedName": "DigitalProduct::Add product name here",
-                "name" : "Product contents",
+                "displayName" : "Product contents",
                 "description" : "Add description of product and its expected usage here",
                 "identifier" : "Add product identifier here",
                 "productName" : "Add product name here",
@@ -2343,10 +2706,9 @@ class CollectionManager(Client2):
               "effectiveTime" : "{{$isoTimestamp}}",
               "forLineage" : false,
               "forDuplicateProcessing" : false,
-              "initialStatus" : "ACTIVE"
             }
 
-            The valid values for initialStatus are: DRAFT, PREPARED, PROPOSED, APPROVED, REJECTED, APPROVED_CONCEPT,
+            The valid values for Status 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.
@@ -2356,6 +2718,108 @@ class CollectionManager(Client2):
             self._async_create_digital_product(body))
 
 
+    @dynamic_catch
+    async def _async_create_digital_product_catalog(self, body: dict | NewElementRequestBody) -> str:
+        """ Create a new collection that represents a digital product.
+            Async version.
+
+        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.
+
+        simple body version:
+        {
+          "class": "NewElementRequestBody",
+          "isOwnAnchor": true,
+          "properties": {
+            "class": "DigitalProductCatalogProperties",
+            "qualifiedName": "Must provide a unique name here",
+            "displayName": "Add display name here",
+            "description": "Add description of the collection here",
+            "category": "Add appropriate valid value for type"
+          }
+        }
+
+        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}"
+        return await self._async_create_element_body_request(url, "DigitalProductCatalogProperties", body)
+
+
+    @dynamic_catch
+    def create_digital_product_catalog(self, body: Optional[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.
+
+             simple body version:
+            {
+              "class": "NewElementRequestBody",
+              "isOwnAnchor": true,
+              "properties": {
+                "class": "DigitalProductCatalogProperties",
+                "qualifiedName": "Must provide a unique name here",
+                "displayName": "Add display name here",
+                "description": "Add description of the collection here",
+                "category": "Add appropriate valid value for type"
+              }
+            }
+
+            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_digital_product_catalog(body))
+
+
+
+
     @dynamic_catch
     async def _async_update_digital_product(self, collection_guid: str,  body: dict | UpdateElementRequestBody) -> None:
         """ Update the properties of a digital product.
@@ -2371,9 +2835,7 @@ class CollectionManager(Client2):
             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.
-        merge_update: bool, optional, default = True
-            If true then property changes will be overlaid on top of existing properties. If false, existing
-            properties will all be replaced by the set provided in the update request.
+
 
         Returns
         -------
@@ -2396,7 +2858,7 @@ class CollectionManager(Client2):
           "properties": {
             "class" : "DigitalProductProperties",
             "qualifiedName": "DigitalProduct::Add product name here",
-            "name" : "Product contents",
+            "displayName" : "Product contents",
             "description" : "Add description of product and its expected usage here",
             "userDefinedStatus" : "OBSOLETE",
             "identifier" : "Add product identifier here",
@@ -2439,9 +2901,7 @@ class CollectionManager(Client2):
             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.
-        merge_update: bool, optional, default = True
-            If true then property changes will be overlaid on top of existing properties. If false, existing
-            properties will all be replaced by the set provided in the update request.
+
 
         Returns
         -------
@@ -2464,7 +2924,7 @@ class CollectionManager(Client2):
           "properties": {
             "class" : "DigitalProductProperties",
             "qualifiedName": "DigitalProduct::Add product name here",
-            "name" : "Product contents",
+            "displayName" : "Product contents",
             "description" : "Add description of product and its expected usage here",
             "userDefinedStatus" : "OBSOLETE",
             "identifier" : "Add product identifier here",
@@ -2493,545 +2953,410 @@ class CollectionManager(Client2):
             self._async_update_digital_product(collection_guid, body))
 
 
-    @dynamic_catch
-    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.
-        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
-        -------
-        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
-
-        Notes
-        -----
-        JSON Structure looks like:
-         {
-          "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/metadata-elements/{collection_guid}/update-status"
-        await self._async_update_status_request(url, status, body)
-
-    @dynamic_catch
-    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.
-        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
-        -------
-        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
-
-        Notes
-        -----
-        JSON Structure looks like:
-         {
-          "class": "UpdateStatusRequestBody",
-          "status": "APPROVED",
-          "externalSourceGUID": "add guid here",
-          "externalSourceName": "add qualified name here",
-          "effectiveTime": "{{$isoTimestamp}}",
-          "forLineage": false,
-          "forDuplicateProcessing": false
-        }
-        """
-        loop = asyncio.get_event_loop()
-        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, status: str = None,
-                                      body: dict | UpdateStatusRequestBody = None):
-        """Update the status of a DigitalProduct collection.
-
-        Parameters
-        ----------
-        digital_product_guid: str
-            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
-        -------
-        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
-
-        Notes
-        -----
-        JSON Structure looks like:
-         {
-          "class": "UpdateStatusRequestBody",
-          "status": "APPROVED",
-          "externalSourceGUID": "add guid here",
-          "externalSourceName": "add qualified name here",
-          "effectiveTime": "{{$isoTimestamp}}",
-          "forLineage": false,
-          "forDuplicateProcessing": false
-        }
-        """
-        loop = asyncio.get_event_loop()
-        loop.run_until_complete(self._async_update_collection_status(digital_product_guid, status, body))
-
-
-    @dynamic_catch
-    async def _async_link_digital_product_dependency(self, upstream_digital_prod_guid: str,
-                                                     downstream_digital_prod_guid: str,
-                                                     body: dict | NewRelationshipRequestBody = None):
-        """ Link two dependent digital products.  The linked elements are of type DigitalProduct.
-            Request body is optional. Async version.
-
-        Parameters
-        ----------
-        upstream_digital_prod_guid: str
-            The guid of the first digital product
-        downstream_digital_prod_guid: str
-            The guid of the downstream digital product
-        body: dict | NewRelationshipRequestBody, optional, default = None
-            A dict representing the details of the relationship.
-
-        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
-
-        Notes
-        -----
-        JSON Structure looks like:
-        {
-          "class" : "NewRelationshipRequestBody",
-          "externalSourceGUID": "add guid here",
-          "externalSourceName": "add qualified name here",
-          "effectiveTime" : "{{$isoTimestamp}}",
-          "forLineage" : false,
-          "forDuplicateProcessing" : false,
-          "properties": {
-            "class": "InformationSupplyChainLinkProperties",
-            "label": "add label here",
-            "description": "add description here",
-            "effectiveFrom": "{{$isoTimestamp}}",
-            "effectiveTo": "{{$isoTimestamp}}"
-          }
-        }
-        """
-        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")
-        await self._async_new_relationship_request(url, "InformationSupplyChainLinkProperties", body)
-        logger.info(f"Linked {upstream_digital_prod_guid} -> {downstream_digital_prod_guid}")
-
-
-    def link_digital_product_dependency(self, upstream_digital_prod_guid: str, downstream_digital_prod_guid: str,
-                                        body: dict | NewRelationshipRequestBody= None):
-        """ Link two dependent digital products.  The linked elements are of type DigitalProduct.
-            Request body is optional.
-
-            Parameters
-            ----------
-            upstream_digital_prod_guid: str
-                The guid of the first digital product
-            downstream_digital_prod_guid: str
-                The guid of the downstream digital product
-            body: dict | NewRelationshipRequestBody, optional, default = None
-                A structure representing the details of the relationship.
-
-            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
-
-            Notes
-            -----
-            JSON Structure looks like:
-            JSON Structure looks like:
-            {
-              "class" : "NewRelationshipRequestBody",
-              "externalSourceGUID": "add guid here",
-              "externalSourceName": "add qualified name here",
-              "effectiveTime" : "{{$isoTimestamp}}",
-              "forLineage" : false,
-              "forDuplicateProcessing" : false,
-              "properties": {
-                "class": "InformationSupplyChainLinkProperties",
-                "label": "add label here",
-                "description": "add description here",
-                "effectiveFrom": "{{$isoTimestamp}}",
-                "effectiveTo": "{{$isoTimestamp}}"
-              }
-            }
-        """
-        loop = asyncio.get_event_loop()
-        loop.run_until_complete(
-            self._async_link_digital_product_dependency(upstream_digital_prod_guid, downstream_digital_prod_guid,
-                                                        body))
-
-
-    @dynamic_catch
-    async def _async_detach_digital_product_dependency(self, upstream_digital_prod_guid: str,
-                                                       downstream_digital_prod_guid: str,
-                                                       body: dict | DeleteRequestBody = None)-> None:
-        """ Unlink two dependent digital products.  The linked elements are of type DigitalProduct.
-            Request body is optional. Async version.
-
-        Parameters
-        ----------
-        upstream_digital_prod_guid: str
-            The guid of the first digital product
-        downstream_digital_prod_guid: str
-            The guid of the downstream digital product
-        body: dict | DeleteRequestBody, optional, default = None
-            A structure representing the details of the relationship.
-
-        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
-
-        Notes
-        -----
-        JSON Structure looks like:
-        {
-          "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/collections/digital-products/"
-            f"{upstream_digital_prod_guid}/product-dependencies/{downstream_digital_prod_guid}/detach")
-        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,
-                                        body: dict | DeleteRequestBody= None):
-        """ Unlink two dependent digital products.  The linked elements are of type DigitalProduct.
-            Request body is optional.
-
-        Parameters
-        ----------
-        upstream_digital_prod_guid: str
-            The guid of the first digital product
-        downstream_digital_prod_guid: str
-            The guid of the downstream digital product
-        body: dict | DeleteRequestBody, optional, default = None
-            A structure representing the details of the relationship.
-
-        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
-
-        Notes
-        -----
-        JSON Structure looks like:
-        {
-          "class": "DeleteRequestBody",
-          "externalSourceGUID": "add guid here",
-          "externalSourceName": "add qualified name here",
-          "effectiveTime": "{{$isoTimestamp}}",
-          "forLineage": false,
-          "forDuplicateProcessing": false
-        }
-        """
-        loop = asyncio.get_event_loop()
-        loop.run_until_complete(
-            self._async_detach_digital_product_dependency(upstream_digital_prod_guid, downstream_digital_prod_guid,
-                                                        body))
-
-
-
-
-
-    @dynamic_catch
-    async def _async_link_product_manager(self, digital_prod_guid: str, digital_prod_manager_guid: str,
-                                          body: dict | NewRelationshipRequestBody = None) -> None:
-        """ Attach a product manager to a digital product. Request body is optional.
-            Request body is optional. Async version.
-
-        Parameters
-        ----------
-        digital_prod_guid: str
-            The guid of the digital product
-        digital_prod_manager_guid: str
-            The guid of the digital_product_manager
-        body: dict | NewRelationshipRequestBody, optional, default = None
-            A structure representing the details of the relationship.
-
-        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
-
-        Notes
-        -----
-        JSON Structure looks like:
-        {
-          "class": "NewRelationshipRequestBody",
-          "properties": {
-              "assignmentType": "Add type here",
-              "description": "Add assignment description here"
-          },
-          "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/collections/digital"
-            f"-products/"
-            f"{digital_prod_guid}/product-managers/{digital_prod_manager_guid}/attach")
-        await self._async_new_relationship_request(url, "AssignmentScopeProperties",body)
-        logger.info(f"Attached digital product manager {digital_prod_guid} -> {digital_prod_manager_guid}")
-
-
-    def link_product_manager(self, digital_prod_guid: str, digital_prod_manager_guid: str, body: dict | NewRelationshipRequestBody = None):
-        """ Attach a product manager to a digital product. Request body is optional.
-                Request body is optional.
-
-            Parameters
-            ----------
-            digital_prod_guid: str
-                The guid of the digital product
-            digital_prod_manager_guid: str
-                The guid of the digital_product_manager
-            body: dict | NewRelationshipRequestBody, optional, default = None
-                A structure representing the details of the relationship.
-
-            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
-
-            Notes
-            -----
-            JSON Structure looks like:
-            {
-              "class": "NewRelationshipRequestBody",
-              "properties": {
-                  "assignmentType": "Add type here",
-                  "description": "Add assignment description here"
-              },
-              "externalSourceGUID": "add guid here",
-              "externalSourceName": "add qualified name here",
-              "effectiveTime": "{{$isoTimestamp}}",
-              "forLineage": false,
-              "forDuplicateProcessing": false
-            }
-
-            """
-        loop = asyncio.get_event_loop()
-        loop.run_until_complete(
-            self._async_link_product_manager(digital_prod_guid, digital_prod_manager_guid, body))
-
-
-    @dynamic_catch
-    async def _async_detach_product_manager(self, digital_prod_guid: str,
-                                             digital_prod_manager_guid: str,
-                                             body: dict | DeleteRequestBody = None)-> None:
-        """ Detach a digital product manager from a digital product.
-            Request body is optional. Async version.
-
-        Parameters
-        ----------
-        digital_prod_guid: str
-            The guid of the digital product.
-        prod_manager: str
-            The guid of the digital product manager.
-        body: dict | DeleteRequestBody, optional, default = None
-            A structure representing the details of the relationship.
-
-        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
-
-        Notes
-        -----
-        JSON Structure looks like:
-        {
-          "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/collections/digital-products/"
-            f"{digital_prod_guid}/product-dependencies/{digital_prod_manager_guid}/detach")
-        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,
-                                body: dict | DeleteRequestBody= None):
-        """ Detach a digital product manager from a digital product.
-            Request body is optional. Async version.
-
-        Parameters
-        ----------
-        digital_prod_guid: str
-            The guid of the digital product.
-        digital_prod_manager_guid: str
-            The guid of the digital product manager.
-        body: dict | DeleteRequestBody, optional, default = None
-            A structure representing the details of the relationship.
-
-        Returns
-        -------
-        Nothing
+    # @dynamic_catch
+    # async def _async_link_digital_product_dependency(self, upstream_digital_prod_guid: str,
+    #                                                  downstream_digital_prod_guid: str,
+    #                                                  body: Optional[dict | NewRelationshipRequestBody] = None):
+    #     """ Link two dependent digital products.  The linked elements are of type DigitalProduct.
+    #         Request body is optional. Async version.
+    #
+    #     Parameters
+    #     ----------
+    #     upstream_digital_prod_guid: str
+    #         The guid of the first digital product
+    #     downstream_digital_prod_guid: str
+    #         The guid of the downstream digital product
+    #     body: dict | NewRelationshipRequestBody, optional, default = None
+    #         A dict representing the details of the relationship.
+    #
+    #     Returns
+    #     -------
+    #     Nothing
+    #
+    #     Raises
+    #     ------
+    #     PyegeriaInvalidParameterException
+    #       If the client passes incorrect parameters on the request - such as bad URLs or invalid values
+    #     PyegeriaAPIException
+    #       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
+    #     -----
+    #     JSON Structure looks like:
+    #     {
+    #       "class" : "NewRelationshipRequestBody",
+    #       "externalSourceGUID": "add guid here",
+    #       "externalSourceName": "add qualified name here",
+    #       "effectiveTime" : "{{$isoTimestamp}}",
+    #       "forLineage" : false,
+    #       "forDuplicateProcessing" : false,
+    #       "properties": {
+    #         "class": "DigitalProductDependencyProperties",
+    #         "label": "add label here",
+    #         "description": "add description here",
+    #         "effectiveFrom": "{{$isoTimestamp}}",
+    #         "effectiveTo": "{{$isoTimestamp}}"
+    #       }
+    #     }
+    #     """
+    #     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")
+    #     await self._async_new_relationship_request(url, ["InformationSupplyChainLinkProperties"], body)
+    #     logger.info(f"Linked {upstream_digital_prod_guid} -> {downstream_digital_prod_guid}")
+    #
+    #
+    # def link_digital_product_dependency(self, upstream_digital_prod_guid: str, downstream_digital_prod_guid: str,
+    #                                     body: dict | NewRelationshipRequestBody= None):
+    #     """ Link two dependent digital products.  The linked elements are of type DigitalProduct.
+    #         Request body is optional.
+    #
+    #         Parameters
+    #         ----------
+    #         upstream_digital_prod_guid: str
+    #             The guid of the first digital product
+    #         downstream_digital_prod_guid: str
+    #             The guid of the downstream digital product
+    #         body: dict | NewRelationshipRequestBody, optional, default = None
+    #             A structure representing the details of the relationship.
+    #
+    #         Returns
+    #         -------
+    #         Nothing
+    #
+    #         Raises
+    #         ------
+    #         PyegeriaInvalidParameterException
+    #           If the client passes incorrect parameters on the request - such as bad URLs or invalid values
+    #         PyegeriaAPIException
+    #           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
+    #         -----
+    #         JSON Structure looks like:
+    #         JSON Structure looks like:
+    #         {
+    #           "class" : "NewRelationshipRequestBody",
+    #           "externalSourceGUID": "add guid here",
+    #           "externalSourceName": "add qualified name here",
+    #           "effectiveTime" : "{{$isoTimestamp}}",
+    #           "forLineage" : false,
+    #           "forDuplicateProcessing" : false,
+    #           "properties": {
+    #             "class": "InformationSupplyChainLinkProperties",
+    #             "label": "add label here",
+    #             "description": "add description here",
+    #             "effectiveFrom": "{{$isoTimestamp}}",
+    #             "effectiveTo": "{{$isoTimestamp}}"
+    #           }
+    #         }
+    #     """
+    #     loop = asyncio.get_event_loop()
+    #     loop.run_until_complete(
+    #         self._async_link_digital_product_dependency(upstream_digital_prod_guid, downstream_digital_prod_guid,
+    #                                                     body))
+    #
+    #
+    # @dynamic_catch
+    # async def _async_detach_digital_product_dependency(self, upstream_digital_prod_guid: str,
+    #                                                    downstream_digital_prod_guid: str,
+    #                                                    body: Optional[dict | DeleteRelationshipRequestBody] = None)-> None:
+    #     """ Unlink two dependent digital products.  The linked elements are of type DigitalProduct.
+    #         Request body is optional. Async version.
+    #
+    #     Parameters
+    #     ----------
+    #     upstream_digital_prod_guid: str
+    #         The guid of the first digital product
+    #     downstream_digital_prod_guid: str
+    #         The guid of the downstream digital product
+    #     body: dict | DeleteRelationshipRequestBody, optional, default = None
+    #         A structure representing the details of the relationship.
+    #
+    #     Returns
+    #     -------
+    #     Nothing
+    #
+    #     Raises
+    #     ------
+    #     PyegeriaInvalidParameterException
+    #       If the client passes incorrect parameters on the request - such as bad URLs or invalid values
+    #     PyegeriaAPIException
+    #       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
+    #     -----
+    #     JSON Structure looks like:
+    #     {
+    #       "class": "DeleteRelationshipRequestBody",
+    #       "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/collections/digital-products/"
+    #         f"{upstream_digital_prod_guid}/product-dependencies/{downstream_digital_prod_guid}/detach")
+    #     await self._async_delete_relationship_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,
+    #                                     body: dict | DeleteRelationshipRequestBody= None):
+    #     """ Unlink two dependent digital products.  The linked elements are of type DigitalProduct.
+    #         Request body is optional.
+    #
+    #     Parameters
+    #     ----------
+    #     upstream_digital_prod_guid: str
+    #         The guid of the first digital product
+    #     downstream_digital_prod_guid: str
+    #         The guid of the downstream digital product
+    #     body: dict | DeleteRelationshipRequestBody, optional, default = None
+    #         A structure representing the details of the relationship.
+    #
+    #     Returns
+    #     -------
+    #     Nothing
+    #
+    #     Raises
+    #     ------
+    #     PyegeriaInvalidParameterException
+    #       If the client passes incorrect parameters on the request - such as bad URLs or invalid values
+    #     PyegeriaAPIException
+    #       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
+    #     -----
+    #     JSON Structure looks like:
+    #     {
+    #       "class": "DeleteRelationshipRequestBody",
+    #       "externalSourceGUID": "add guid here",
+    #       "externalSourceName": "add qualified name here",
+    #       "effectiveTime": "{{$isoTimestamp}}",
+    #       "forLineage": false,
+    #       "forDuplicateProcessing": false
+    #     }
+    #     """
+    #     loop = asyncio.get_event_loop()
+    #     loop.run_until_complete(
+    #         self._async_detach_digital_product_dependency(upstream_digital_prod_guid, downstream_digital_prod_guid,
+    #                                                     body))
+    #
+    #
 
-        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
-        -----
-        JSON Structure looks like:
-        {
-          "class": "DeleteRequestBody",
-          "externalSourceGUID": "add guid here",
-          "externalSourceName": "add qualified name here",
-          "effectiveTime": "{{$isoTimestamp}}",
-          "forLineage": false,
-          "forDuplicateProcessing": false
-        }
 
-        """
-        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_link_product_manager(self, digital_prod_guid: str, digital_prod_manager_guid: str,
+    #                                       body: Optional[dict | NewRelationshipRequestBody] = None) -> None:
+    #     """ Attach a product manager to a digital product. Request body is optional.
+    #         Request body is optional. Async version.
+    #
+    #     Parameters
+    #     ----------
+    #     digital_prod_guid: str
+    #         The guid of the digital product
+    #     digital_prod_manager_guid: str
+    #         The guid of the digital_product_manager
+    #     body: dict | NewRelationshipRequestBody, optional, default = None
+    #         A structure representing the details of the relationship.
+    #
+    #     Returns
+    #     -------
+    #     Nothing
+    #
+    #     Raises
+    #     ------
+    #     PyegeriaInvalidParameterException
+    #       If the client passes incorrect parameters on the request - such as bad URLs or invalid values
+    #     PyegeriaAPIException
+    #       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
+    #     -----
+    #     JSON Structure looks like:
+    #     {
+    #       "class": "NewRelationshipRequestBody",
+    #       "properties": {
+    #           "assignmentType": "Add type here",
+    #           "description": "Add assignment description here"
+    #       },
+    #       "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/collections/digital"
+    #         f"-products/"
+    #         f"{digital_prod_guid}/product-managers/{digital_prod_manager_guid}/attach")
+    #     await self._async_new_relationship_request(url, "AssignmentScopeProperties",body)
+    #     logger.info(f"Attached digital product manager {digital_prod_guid} -> {digital_prod_manager_guid}")
+    #
+    #
+    # def link_product_manager(self, digital_prod_guid: str, digital_prod_manager_guid: str, body: Optional[dict | NewRelationshipRequestBody] = None):
+    #     """ Attach a product manager to a digital product. Request body is optional.
+    #             Request body is optional.
+    #
+    #         Parameters
+    #         ----------
+    #         digital_prod_guid: str
+    #             The guid of the digital product
+    #         digital_prod_manager_guid: str
+    #             The guid of the digital_product_manager
+    #         body: dict | NewRelationshipRequestBody, optional, default = None
+    #             A structure representing the details of the relationship.
+    #
+    #         Returns
+    #         -------
+    #         Nothing
+    #
+    #         Raises
+    #         ------
+    #         PyegeriaInvalidParameterException
+    #           If the client passes incorrect parameters on the request - such as bad URLs or invalid values
+    #         PyegeriaAPIException
+    #           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
+    #         -----
+    #         JSON Structure looks like:
+    #         {
+    #           "class": "NewRelationshipRequestBody",
+    #           "properties": {
+    #               "assignmentType": "Add type here",
+    #               "description": "Add assignment description here"
+    #           },
+    #           "externalSourceGUID": "add guid here",
+    #           "externalSourceName": "add qualified name here",
+    #           "effectiveTime": "{{$isoTimestamp}}",
+    #           "forLineage": false,
+    #           "forDuplicateProcessing": false
+    #         }
+    #
+    #         """
+    #     loop = asyncio.get_event_loop()
+    #     loop.run_until_complete(
+    #         self._async_link_product_manager(digital_prod_guid, digital_prod_manager_guid, body))
+    #
+    #
+    # @dynamic_catch
+    # async def _async_detach_product_manager(self, digital_prod_guid: str,
+    #                                          digital_prod_manager_guid: str,
+    #                                          body: Optional[dict | DeleteRelationshipRequestBody] = None)-> None:
+    #     """ Detach a digital product manager from a digital product.
+    #         Request body is optional. Async version.
+    #
+    #     Parameters
+    #     ----------
+    #     digital_prod_guid: str
+    #         The guid of the digital product.
+    #     prod_manager: str
+    #         The guid of the digital product manager.
+    #     body: dict | DeleteRelationshipRequestBody, optional, default = None
+    #         A structure representing the details of the relationship.
+    #
+    #     Returns
+    #     -------
+    #     Nothing
+    #
+    #     Raises
+    #     ------
+    #     PyegeriaInvalidParameterException
+    #       If the client passes incorrect parameters on the request - such as bad URLs or invalid values
+    #     PyegeriaAPIException
+    #       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
+    #     -----
+    #     JSON Structure looks like:
+    #     {
+    #       "class": "DeleteRelationshipRequestBody",
+    #       "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/collections/digital-products/"
+    #         f"{digital_prod_guid}/product-dependencies/{digital_prod_manager_guid}/detach")
+    #     await self._async_delete_relationship_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,
+    #                             body: dict | DeleteRelationshipRequestBody= None):
+    #     """ Detach a digital product manager from a digital product.
+    #         Request body is optional. Async version.
+    #
+    #     Parameters
+    #     ----------
+    #     digital_prod_guid: str
+    #         The guid of the digital product.
+    #     digital_prod_manager_guid: str
+    #         The guid of the digital product manager.
+    #     body: dict | DeleteRelationshipRequestBody, optional, default = None
+    #         A structure representing the details of the relationship.
+    #
+    #     Returns
+    #     -------
+    #     Nothing
+    #
+    #     Raises
+    #     ------
+    #     PyegeriaInvalidParameterException
+    #       If the client passes incorrect parameters on the request - such as bad URLs or invalid values
+    #     PyegeriaAPIException
+    #       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
+    #     -----
+    #     JSON Structure looks like:
+    #     {
+    #       "class": "DeleteRelationshipRequestBody",
+    #       "externalSourceGUID": "add guid here",
+    #       "externalSourceName": "add qualified name here",
+    #       "effectiveTime": "{{$isoTimestamp}}",
+    #       "forLineage": false,
+    #       "forDuplicateProcessing": false
+    #     }
+    #
+    #     """
+    #     loop = asyncio.get_event_loop()
+    #     loop.run_until_complete(
+    #         self._async_detach_product_manager(digital_prod_guid, digital_prod_manager_guid,
+    #                                                     body))
 
 
 #
@@ -3075,7 +3400,7 @@ class CollectionManager(Client2):
           "properties": {
             "class" : "AgreementProperties",
             "qualifiedName": "Agreement::Add agreement name here",
-            "name" : "display name",
+            "displayName" : "display name",
             "description" : "Add description of the agreement here",
             "identifier" : "Add agreement identifier here",
             "additionalProperties": {
@@ -3100,7 +3425,7 @@ class CollectionManager(Client2):
         return await self._async_create_element_body_request(url, "AgreementProperties", body)
 
     @dynamic_catch
-    def create_agreement(self, body: dict | NewElementRequestBody = None) -> str:
+    def create_agreement(self, body: Optional[dict | NewElementRequestBody] = None) -> str:
         """ Create a new collection that represents an agreement..
 
             Parameters
@@ -3137,7 +3462,7 @@ class CollectionManager(Client2):
               "properties": {
                 "class" : "AgreementProperties",
                 "qualifiedName": "Agreement::Add agreement name here",
-                "name" : "display name",
+                "displayName" : "display name",
                 "description" : "Add description of the agreement here",
                 "identifier" : "Add agreement identifier here",
                 "additionalProperties": {
@@ -3202,7 +3527,7 @@ class CollectionManager(Client2):
     #       "properties": {
     #         "class" : "AgreementProperties",
     #         "qualifiedName": "Agreement::Add agreement name here",
-    #         "name" : "display name",
+    #         "displayName" : "display name",
     #         "description" : "Add description of the agreement here",
     #         "userDefinedStatus" : "NEW",
     #         "identifier" : "Add agreement identifier here",
@@ -3229,7 +3554,7 @@ class CollectionManager(Client2):
     #     return await self._async_create_element_body_request(url, "AgreementProperties", body)
     #
     # @dynamic_catch
-    # def create_data_sharing_agreement(self, body: dict | NewElementRequestBody = None) -> str:
+    # def create_data_sharing_agreement(self, body: Optional[dict | NewElementRequestBody] = None) -> str:
     #     """ Create a new collection that represents a digital product.
     #
     #         Parameters
@@ -3266,7 +3591,7 @@ class CollectionManager(Client2):
     #           "properties": {
     #             "class" : "DigitalProductProperties",
     #             "qualifiedName": "DigitalProduct::Add product name here",
-    #             "name" : "Product contents",
+    #             "displayName" : "Product contents",
     #             "description" : "Add description of product and its expected usage here",
     #             "identifier" : "Add product identifier here",
     #             "productName" : "Add product name here",
@@ -3313,9 +3638,7 @@ class CollectionManager(Client2):
 
         body: dict | NewElementRequestBody, optional
             A dict or NewElementRequestBody representing the details of the agreement to create.
-        merge_update: bool, optional, default = True
-            If true then property changes will be overlaid on top of existing properties. If false, existing
-            properties will all be replaced by the set provided in the update request.
+
 
         Returns
         -------
@@ -3338,7 +3661,7 @@ class CollectionManager(Client2):
           "properties": {
             "class" : "AgreementProperties",
             "qualifiedName": "Agreement::Add agreement name here",
-            "name" : "display name",
+            "displayName" : "display name",
             "description" : "Add description of the agreement here",
             "userDefinedStatus" : "OBSOLETE",
             "identifier" : "Add agreement identifier here",
@@ -3369,9 +3692,7 @@ class CollectionManager(Client2):
 
             body: dict | NewElementRequestBody, optional
                 A dict or NewElementRequestBody representing the details of the agreement to create.
-            merge_update: bool, optional, default = True
-                If true then property changes will be overlaid on top of existing properties. If false, existing
-                properties will all be replaced by the set provided in the update request.
+
 
             Returns
             -------
@@ -3394,7 +3715,7 @@ class CollectionManager(Client2):
               "properties": {
                 "class" : "AgreementProperties",
                 "qualifiedName": "Agreement::Add agreement name here",
-                "name" : "display name",
+                "displayName" : "display name",
                 "description" : "Add description of the agreement here",
                 "userDefinedStatus" : "OBSOLETE",
                 "identifier" : "Add agreement identifier here",
@@ -3415,54 +3736,9 @@ class CollectionManager(Client2):
             self._async_update_agreement(agreement_guid, body))
 
 
-
-    @dynamic_catch
-    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.
-
-        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
-
-        Notes
-        -----
-        JSON Structure looks like:
-         {
-          "class": "UpdateStatusRequestBody",
-          "status": "APPROVED",
-          "externalSourceGUID": "add guid here",
-          "externalSourceName": "add qualified name here",
-          "effectiveTime": "{{$isoTimestamp}}",
-          "forLineage": false,
-          "forDuplicateProcessing": false
-        }
-        """
-        loop = asyncio.get_event_loop()
-        loop.run_until_complete(self._async_update_collection_status(agreement_guid, status,body))
-
-
-
     @dynamic_catch
     async def _async_link_agreement_actor(self, agreement_guid: str, actor_guid: str,
-                                          body: dict | NewRelationshipRequestBody = None) -> None:
+                                          body: Optional[dict | NewRelationshipRequestBody] = None) -> None:
         """ Attach an actor to an agreement.  The actor element may be an actor profile (person, team or IT profile);
             actor role (person role, team role or IT profile role); or user identity. Request body is optional.
             Request body is optional. Async version.
@@ -3482,9 +3758,9 @@ class CollectionManager(Client2):
 
         Raises
         ------
-        InvalidParameterException
+        PyegeriaInvalidParameterException
           If the client passes incorrect parameters on the request - such as bad URLs or invalid values
-        PropertyServerException
+        PyegeriaAPIException
           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
@@ -3517,7 +3793,7 @@ class CollectionManager(Client2):
         logger.info(f"Attached digital product manager {agreement_guid} -> {actor_guid}")
 
 
-    def link_agreement_actor(self, agreement_guid: str, actor_guid: str, body: dict | NewRelationshipRequestBody = None):
+    def link_agreement_actor(self, agreement_guid: str, actor_guid: str, body: Optional[dict | NewRelationshipRequestBody] = None):
         """ Attach an actor to an agreement.  The actor element may be an actor profile (person, team or IT profile);
             actor role (person role, team role or IT profile role); or user identity. Request body is optional.
             Async version.
@@ -3537,9 +3813,9 @@ class CollectionManager(Client2):
 
           Raises
           ------
-          InvalidParameterException
+          PyegeriaInvalidParameterException
             If the client passes incorrect parameters on the request - such as bad URLs or invalid values
-          PropertyServerException
+          PyegeriaAPIException
             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
@@ -3572,7 +3848,7 @@ class CollectionManager(Client2):
     @dynamic_catch
     async def _async_detach_agreement_actor(self, agreement_guid: str,
                                              actor_guid: str,
-                                             body: dict | DeleteRequestBody = None)-> None:
+                                             body: Optional[dict | DeleteRelationshipRequestBody] = None)-> None:
         """ Detach an actor from an agreement.
             Request body is optional. Async Version.
 
@@ -3582,7 +3858,7 @@ class CollectionManager(Client2):
             The guid of the agreement.
         actor_guid: str
             The guid of the actor.
-        body: dict | DeleteRequestBody, optional, default = None
+        body: dict | DeleteRelationshipRequestBody, optional, default = None
             A structure representing the details of the relationship.
 
         Returns
@@ -3591,9 +3867,9 @@ class CollectionManager(Client2):
 
         Raises
         ------
-        InvalidParameterException
+        PyegeriaInvalidParameterException
           If the client passes incorrect parameters on the request - such as bad URLs or invalid values
-        PropertyServerException
+        PyegeriaAPIException
           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
@@ -3602,7 +3878,7 @@ class CollectionManager(Client2):
         -----
         JSON Structure looks like:
         {
-          "class": "DeleteRequestBody",
+          "class": "DeleteRelationshipRequestBody",
           "externalSourceGUID": "add guid here",
           "externalSourceName": "add qualified name here",
           "effectiveTime": "{{$isoTimestamp}}",
@@ -3616,12 +3892,12 @@ class CollectionManager(Client2):
             f"{self.platform_url}/servers/"
             f"{self.view_server}/api/open-metadata/collection-manager/collections/agreements/"
             f"{agreement_guid}/agreement-actors/{actor_guid}/detach")
-        self._async_delete_request(url, body)
+        self._async_delete_relationship_request(url, body)
         logger.info(f"Detached digital product manager {agreement_guid} -> {actor_guid}")
 
 
     def detach_agreement_actor(self, agreement_guid: str, actor_guid: str,
-                                body: dict | DeleteRequestBody= None):
+                                body: dict | DeleteRelationshipRequestBody= None):
         """ Detach an actor from an agreement.
             Request body is optional.
 
@@ -3631,7 +3907,7 @@ class CollectionManager(Client2):
             The guid of the agreement.
         actor_guid: str
             The guid of the actor.
-        body: dict | DeleteRequestBody, optional, default = None
+        body: dict | DeleteRelationshipRequestBody, optional, default = None
             A structure representing the details of the relationship.
 
         Returns
@@ -3640,9 +3916,9 @@ class CollectionManager(Client2):
 
         Raises
         ------
-        InvalidParameterException
+        PyegeriaInvalidParameterException
           If the client passes incorrect parameters on the request - such as bad URLs or invalid values
-        PropertyServerException
+        PyegeriaAPIException
           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
@@ -3651,7 +3927,7 @@ class CollectionManager(Client2):
         -----
         JSON Structure looks like:
         {
-          "class": "DeleteRequestBody",
+          "class": "DeleteRelationshipRequestBody",
           "externalSourceGUID": "add guid here",
           "externalSourceName": "add qualified name here",
           "effectiveTime": "{{$isoTimestamp}}",
@@ -3690,9 +3966,9 @@ class CollectionManager(Client2):
 
         Raises
         ------
-        InvalidParameterException
+        PyegeriaInvalidParameterException
           If the client passes incorrect parameters on the request - such as bad URLs or invalid values
-        PropertyServerException
+        PyegeriaAPIException
           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
@@ -3759,9 +4035,9 @@ class CollectionManager(Client2):
 
                Raises
                ------
-               InvalidParameterException
+               PyegeriaInvalidParameterException
                  If the client passes incorrect parameters on the request - such as bad URLs or invalid values
-               PropertyServerException
+               PyegeriaAPIException
                  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
@@ -3805,7 +4081,7 @@ class CollectionManager(Client2):
 
     @dynamic_catch
     async def _async_detach_agreement_item(self, agreement_guid: str, agreement_item_guid: str,
-                                           body: dict | DeleteRequestBody = None) -> None:
+                                           body: Optional[dict | DeleteRelationshipRequestBody] = None) -> None:
         """Detach an agreement item from an agreement. Request body is optional. Async version.
 
         Parameters
@@ -3814,7 +4090,7 @@ class CollectionManager(Client2):
             The guid of the agreement to link.
         agreement_item_guid: str
             The guid of the element to attach.
-        body: dict | DeleteRequestBody, optional, default = None
+        body: dict | DeleteRelationshipRequestBody, optional, default = None
             A structure representing the details of the relationship.
 
         Returns
@@ -3823,9 +4099,9 @@ class CollectionManager(Client2):
 
         Raises
         ------
-        InvalidParameterException
+        PyegeriaInvalidParameterException
           If the client passes incorrect parameters on the request - such as bad URLs or invalid values
-        PropertyServerException
+        PyegeriaAPIException
           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
@@ -3833,7 +4109,7 @@ class CollectionManager(Client2):
         Notes
         _____
         {
-          "class": "DeleteRequestBody",
+          "class": "DeleteRelationshipRequestBody",
           "externalSourceGUID": "add guid here",
           "externalSourceName": "add qualified name here",
           "effectiveTime": "{{$isoTimestamp}}",
@@ -3846,7 +4122,7 @@ class CollectionManager(Client2):
             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")
-        await self._async_delete_request(url, body)
+        await self._async_delete_relationship_request(url, body)
         logger.info(f"Detached agreement item {agreement_item_guid} from {agreement_guid}")
 
 
@@ -3868,9 +4144,9 @@ class CollectionManager(Client2):
 
         Raises
         ------
-        InvalidParameterException
+        PyegeriaInvalidParameterException
           If the client passes incorrect parameters on the request - such as bad URLs or invalid values
-        PropertyServerException
+        PyegeriaAPIException
           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
@@ -3892,8 +4168,8 @@ class CollectionManager(Client2):
 
 
     @dynamic_catch
-    async def _async_link_contract(self, agreement_guid: str, external_ref_guid: str, 
-                                   body: dict | NewRelationshipRequestBody = None) -> None:
+    async def _async_link_contract(self, agreement_guid: str, external_ref_guid: str,
+                                   body: Optional[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.
@@ -3913,9 +4189,9 @@ class CollectionManager(Client2):
 
         Raises
         ------
-        InvalidParameterException
+        PyegeriaInvalidParameterException
           If the client passes incorrect parameters on the request - such as bad URLs or invalid values
-        PropertyServerException
+        PyegeriaAPIException
           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
@@ -3968,9 +4244,9 @@ class CollectionManager(Client2):
 
         Raises
         ------
-        InvalidParameterException
+        PyegeriaInvalidParameterException
           If the client passes incorrect parameters on the request - such as bad URLs or invalid values
-        PropertyServerException
+        PyegeriaAPIException
           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
@@ -4020,9 +4296,9 @@ class CollectionManager(Client2):
 
         Raises
         ------
-        InvalidParameterException
+        PyegeriaInvalidParameterException
           If the client passes incorrect parameters on the request - such as bad URLs or invalid values
-        PropertyServerException
+        PyegeriaAPIException
           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
@@ -4043,7 +4319,7 @@ 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}/detach")
-        await self._async_delete_request(url, body)
+        await self._async_delete_relationship_request(url, body)
         logger.info(f"Detached contract: {external_ref_guid} from {agreement_guid}")
 
     @dynamic_catch
@@ -4065,9 +4341,9 @@ class CollectionManager(Client2):
 
         Raises
         ------
-        InvalidParameterException
+        PyegeriaInvalidParameterException
           If the client passes incorrect parameters on the request - such as bad URLs or invalid values
-        PropertyServerException
+        PyegeriaAPIException
           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
@@ -4107,9 +4383,9 @@ class CollectionManager(Client2):
 
         Raises
         ------
-        InvalidParameterException
+        PyegeriaInvalidParameterException
           If the client passes incorrect parameters on the request - such as bad URLs or invalid values
-        PropertyServerException
+        PyegeriaAPIException
           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
@@ -4130,7 +4406,7 @@ class CollectionManager(Client2):
           "properties": {
             "class" : "DigitalSubscriptionProperties",
             "qualifiedName": "DigitalSubscription::Add subscription name here",
-            "name" : "display name",
+            "displayName" : "display name",
             "description" : "Add description of the subscription here",
             "userDefinedStatus" : "OBSOLETE",
             "identifier" : "Add subscription identifier here",
@@ -4169,7 +4445,7 @@ class CollectionManager(Client2):
           "properties": {
             "class" : "DigitalSubscriptionProperties",
             "qualifiedName": "DigitalSubscription::Add subscription name here",
-            "name" : "display name",
+            "displayName" : "display name",
             "description" : "Add description of the subscription here",
             "userDefinedStatus" : "OBSOLETE",
             "identifier" : "Add subscription identifier here",
@@ -4209,9 +4485,9 @@ class CollectionManager(Client2):
 
         Raises
         ------
-        InvalidParameterException
+        PyegeriaInvalidParameterException
           If the client passes incorrect parameters on the request - such as bad URLs or invalid values
-        PropertyServerException
+        PyegeriaAPIException
           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
@@ -4240,7 +4516,7 @@ class CollectionManager(Client2):
           "properties": {
             "class" : "DigitalSubscriptionProperties",
             "qualifiedName": "DigitalSubscription::Add subscription name here",
-            "name" : "display name",
+            "displayName" : "display name",
             "description" : "Add description of the subscription here",
             "userDefinedStatus" : "OBSOLETE",
             "identifier" : "Add subscription identifier here",
@@ -4285,9 +4561,9 @@ class CollectionManager(Client2):
 
         Raises
         ------
-        InvalidParameterException
+        PyegeriaInvalidParameterException
           If the client passes incorrect parameters on the request - such as bad URLs or invalid values
-        PropertyServerException
+        PyegeriaAPIException
           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
@@ -4300,7 +4576,7 @@ class CollectionManager(Client2):
           "properties": {
             "class" : "DigitalSubscriptionProperties",
             "qualifiedName": "DigitalSubscription::Add subscription name here",
-            "name" : "display name",
+            "displayName" : "display name",
             "description" : "Add description of the subscription here",
             "userDefinedStatus" : "OBSOLETE",
             "identifier" : "Add subscription identifier here",
@@ -4336,8 +4612,6 @@ class CollectionManager(Client2):
             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.
 
 
         Returns
@@ -4346,9 +4620,9 @@ class CollectionManager(Client2):
 
         Raises
         ------
-        InvalidParameterException
+        PyegeriaInvalidParameterException
           If the client passes incorrect parameters on the request - such as bad URLs or invalid values
-        PropertyServerException
+        PyegeriaAPIException
           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
@@ -4361,7 +4635,7 @@ class CollectionManager(Client2):
           "properties": {
             "class" : "AgreementProperties",
             "qualifiedName": "Agreement::Add digital_subscription name here",
-            "name" : "display name",
+            "displayName" : "display name",
             "description" : "Add description of the digital_subscription here",
             "userDefinedStatus" : "OBSOLETE",
             "identifier" : "Add digital_subscription identifier here",
@@ -4383,99 +4657,9 @@ class CollectionManager(Client2):
             self._async_update_digital_subscription(digital_subscription_guid, body))
 
 
-    @dynamic_catch
-    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.
-        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
-        -------
-        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
-
-        Notes
-        -----
-        JSON Structure looks like:
-         {
-          "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_update_status_request(url, status, body)
-        logger.info(f"Updated status for DigitalProduct {digital_subscription_guid}")
-
-    @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
-            ----------
-            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.
-
-            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
-
-            Notes
-            -----
-            JSON Structure looks like:
-               {
-                  "class": "AgreementStatusRequestBody",
-                  "status": "APPROVED",
-                  "externalSourceGUID": "add guid here",
-                  "externalSourceName": "add qualified name here",
-                  "effectiveTime": "{{$isoTimestamp}}",
-                  "forLineage": false,
-                  "forDuplicateProcessing": false
-                }
-
-        """
-        loop = asyncio.get_event_loop()
-        loop.run_until_complete(self._async_update_digital_subscription_status(digital_subscription_guid, body))
-
-
     @dynamic_catch
     async def _async_link_subscriber(self, subscriber_guid: str, subscription_guid: str,
-                                     body: dict | NewRelationshipRequestBody = None)-> None:
+                                     body: Optional[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.
@@ -4496,9 +4680,9 @@ class CollectionManager(Client2):
 
         Raises
         ------
-        InvalidParameterException
+        PyegeriaInvalidParameterException
           If the client passes incorrect parameters on the request - such as bad URLs or invalid values
-        PropertyServerException
+        PyegeriaAPIException
           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
@@ -4530,7 +4714,7 @@ class CollectionManager(Client2):
 
     @dynamic_catch
     def link_subscriber(self, subscriber_guid: str, subscription_guid: str,
-                        body: dict | NewRelationshipRequestBody = None):
+                        body: Optional[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.
@@ -4551,9 +4735,9 @@ class CollectionManager(Client2):
 
         Raises
         ------
-        InvalidParameterException
+        PyegeriaInvalidParameterException
           If the client passes incorrect parameters on the request - such as bad URLs or invalid values
-        PropertyServerException
+        PyegeriaAPIException
           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
@@ -4582,7 +4766,7 @@ class CollectionManager(Client2):
 
     @dynamic_catch
     async def _async_detach_subscriber(self, subscriber_guid: str, subscription_guid: str,
-                                       body: dict | DeleteRequestBody = None) -> None:
+                                       body: Optional[dict | DeleteRelationshipRequestBody] = None) -> None:
         """ Detach a subscriber from a subscription Request body is optional. Async version.
 
         Parameters
@@ -4591,7 +4775,7 @@ class CollectionManager(Client2):
             The unique identifier of the subscriber.
         subscription_guid: str
             The unique identifier of the subscription.
-        body: dict | DeleteRequestBody, optional, default = None
+        body: dict | DeleteRelationshipRequestBody, optional, default = None
             A structure representing the details of the relationship.
 
         Returns
@@ -4600,9 +4784,9 @@ class CollectionManager(Client2):
 
         Raises
         ------
-        InvalidParameterException
+        PyegeriaInvalidParameterException
           If the client passes incorrect parameters on the request - such as bad URLs or invalid values
-        PropertyServerException
+        PyegeriaAPIException
           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
@@ -4623,11 +4807,11 @@ class CollectionManager(Client2):
             f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/collection-manager/collections"
             f"/agreements/"
             f"{subscriber_guid}/agreement-actors/{subscription_guid}/detach")
-        await self._async_delete_request(url, body)
+        await self._async_delete_relationship_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 | DeleteRequestBody= None):
+    def detach_subscriber(self, subscriber_guid: str, subscription_guid: str, body: dict | DeleteRelationshipRequestBody= None):
         """ Detach a subscriber from a subscription. Request body is optional.
 
         Parameters
@@ -4645,9 +4829,9 @@ class CollectionManager(Client2):
 
         Raises
         ------
-        InvalidParameterException
+        PyegeriaInvalidParameterException
           If the client passes incorrect parameters on the request - such as bad URLs or invalid values
-        PropertyServerException
+        PyegeriaAPIException
           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
@@ -4693,9 +4877,9 @@ class CollectionManager(Client2):
 
         Raises
         ------
-        InvalidParameterException
+        PyegeriaInvalidParameterException
           If the client passes incorrect parameters on the request - such as bad URLs or invalid values
-        PropertyServerException
+        PyegeriaAPIException
           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
@@ -4734,7 +4918,7 @@ class CollectionManager(Client2):
 
     @dynamic_catch
     def attach_collection(self, parent_guid: str, collection_guid: str,
-                          body: dict | NewRelationshipRequestBody = None):
+                          body: Optional[dict | NewRelationshipRequestBody] = None):
         """ Connect an existing collection to an element using the ResourceList relationship (0019).
 
             Parameters
@@ -4754,9 +4938,9 @@ class CollectionManager(Client2):
 
             Raises
             ------
-            InvalidParameterException
+            PyegeriaInvalidParameterException
               If the client passes incorrect parameters on the request - such as bad URLs or invalid values
-            PropertyServerException
+            PyegeriaAPIException
               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
@@ -4790,7 +4974,7 @@ class CollectionManager(Client2):
 
     @dynamic_catch
     async def _async_detach_collection(self, parent_guid: str, collection_guid: str,
-                                       body: dict | DeleteRequestBody = None):
+                                       body: Optional[dict | DeleteRelationshipRequestBody] = None):
         """ Detach an existing collection from an element. If the collection is anchored to the element,
         it is delete.
             Async version.
@@ -4801,7 +4985,7 @@ class CollectionManager(Client2):
                 The unique identifier of the parent to detach from.
         collection_guid: str
                 The identifier of the collection being detached.
-        body: dict | DeleteRequestBody, optional, default = None
+        body: dict | DeleteRelationshipRequestBody, optional, default = None
             A structure representing the details of the relationship.
 
 
@@ -4811,9 +4995,9 @@ class CollectionManager(Client2):
 
         Raises
         ------
-        InvalidParameterException
+        PyegeriaInvalidParameterException
           If the client passes incorrect parameters on the request - such as bad URLs or invalid values
-        PropertyServerException
+        PyegeriaAPIException
           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
@@ -4822,7 +5006,7 @@ class CollectionManager(Client2):
         -----
         JSON Structure looks like:
         {
-          "class": "DeleteRequestBody",
+          "class": "DeleteRelationshipRequestBody",
           "externalSourceGUID": "add guid here",
           "externalSourceName": "add qualified name here",
           "effectiveTime": "{{$isoTimestamp}}",
@@ -4835,12 +5019,12 @@ class CollectionManager(Client2):
             f"{self.platform_url}/servers/"
             f"{self.view_server}/api/open-metadata/collection-manager/metadata-elements/"
             f"{parent_guid}/collections/{collection_guid}/detach")
-        await self._async_delete_request(url, body)
+        await self._async_delete_relationship_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 | DeleteRequestBody = None):
+                          body: Optional[dict | DeleteRelationshipRequestBody] = None):
         """ Detach an existing collection from an element. If the collection is anchored to the element,
         it is delete.
 
@@ -4859,9 +5043,9 @@ class CollectionManager(Client2):
 
           Raises
           ------
-          InvalidParameterException
+          PyegeriaInvalidParameterException
             If the client passes incorrect parameters on the request - such as bad URLs or invalid values
-          PropertyServerException
+          PyegeriaAPIException
             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
@@ -4883,7 +5067,7 @@ class CollectionManager(Client2):
 
 
     @dynamic_catch
-    async def _async_delete_collection(self, collection_guid: str, body: dict | DeleteRequestBody= None,
+    async def _async_delete_collection(self, collection_guid: str, body: dict | DeleteElementRequestBody= 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
@@ -4897,7 +5081,7 @@ class CollectionManager(Client2):
         cascade: bool, optional, defaults to True
             If true, a cascade delete is performed.
 
-        body: dict | DeleteRequestBody, optional, default = None
+        body: dict | DeleteElementRequestBody, optional, default = None
             A structure representing the details of the relationship.
 
         Returns
@@ -4906,9 +5090,9 @@ class CollectionManager(Client2):
 
         Raises
         ------
-        InvalidParameterException
+        PyegeriaInvalidParameterException
           If the client passes incorrect parameters on the request - such as bad URLs or invalid values
-        PropertyServerException
+        PyegeriaAPIException
           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
@@ -4917,7 +5101,7 @@ class CollectionManager(Client2):
         _____
         JSON Structure looks like:
         {
-          "class": "DeleteRequestBody",
+          "class": "DeleteElementRequestBody",
           "externalSourceGUID": "add guid here",
           "externalSourceName": "add qualified name here",
           "effectiveTime": "{{$isoTimestamp}}",
@@ -4927,12 +5111,14 @@ class CollectionManager(Client2):
 
 
         """
+        if body is None:
+            body = {"class": "DeleteElementRequestBody"}
         url = f"{self.collection_command_root}/{collection_guid}/delete"
-        await self._async_delete_request(url, body, cascade)
+        await self._async_delete_element_request(url, body, cascade)
         logger.info(f"Deleted collection {collection_guid} with cascade {cascade}")
 
 
-    def delete_collection(self, collection_guid: str, body: dict | DeleteRequestBody = None,
+    def delete_collection(self, collection_guid: str, body: Optional[dict | DeleteElementRequestBody] = 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.
@@ -4945,7 +5131,7 @@ class CollectionManager(Client2):
         cascade: bool, optional, defaults to True
             If true, a cascade delete is performed.
 
-        body: dict DeleteRequestBodyt, optional, default = None
+        body: dict | DeleteElementRequestBody, optional, default = None
             A dict representing the details of the relationship.
 
         Returns
@@ -4954,12 +5140,13 @@ class CollectionManager(Client2):
 
         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
+        PyegeriaException
+            One of the pyegeria exceptions will be raised if there are issues in communications, message format, or
+            Egeria errors.
+        ValidationError
+            Pydantic validation errors are raised if the body does not conform to the DeleteElementRequestBody.
+        PyegeriaNotAuthorizedException
+            The principle specified by the user_id does not have authorization for the requested action
 
         Notes
         _____
@@ -4974,7 +5161,7 @@ class CollectionManager(Client2):
 
     @dynamic_catch
     async def _async_add_to_collection(self, collection_guid: str, element_guid: str,
-                                       body: dict | NewRelationshipRequestBody = None, ) -> None:
+                                       body: Optional[dict | NewRelationshipRequestBody] = None, ) -> None:
         """Add an element to a collection.  The request body is optional. Async version.
 
         Parameters
@@ -4992,13 +5179,13 @@ class CollectionManager(Client2):
 
         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
+        PyegeriaException
+            One of the pyegeria exceptions will be raised if there are issues in communications, message format, or
+            Egeria errors.
+        ValidationError
+            Pydantic validation errors are raised if the body does not conform to the NewRelationshipRequestBody.
+        PyegeriaNotAuthorizedException
+            The principle specified by the user_id does not have authorization for the requested action
 
         Notes
         -----
@@ -5057,9 +5244,9 @@ class CollectionManager(Client2):
         Raises
         ------
 
-        InvalidParameterException
+        PyegeriaInvalidParameterException
           If the client passes incorrect parameters on the request - such as bad URLs or invalid values
-        PropertyServerException
+        PyegeriaAPIException
           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
@@ -5092,10 +5279,10 @@ class CollectionManager(Client2):
 
         """
         loop = asyncio.get_event_loop()
-        loop.run_until_complete(self._async_add_to_collection(collection_guid, element_guid, body))
+        loop.run_until_complete(self._async_add_to_collection(element_guid, collection_guid, body))
 
     def add_term_to_folder(self, folder_guid: str, term_guid: str,
-                             body: dict | NewRelationshipRequestBody = None) -> None:
+                             body: Optional[dict | NewRelationshipRequestBody] = None) -> None:
         """Add a term to a category.  The request body is optional."""
         loop = asyncio.get_event_loop()
         loop.run_until_complete(self._async_add_to_collection(folder_guid, term_guid, body))
@@ -5114,10 +5301,7 @@ class CollectionManager(Client2):
             Effective time of the query. If not specified will default to any time.
         body: dict, optional, defaults to None
             The body of the request to add to the collection. See notes.
-        replace_all_props: bool, optional, defaults to False
-            Replace all properties or just update ones specified in body.
 
-            The name of the server to use.
 
 
         Returns
@@ -5127,9 +5311,9 @@ class CollectionManager(Client2):
         Raises
         ------
 
-        InvalidParameterException
+        PyegeriaInvalidParameterException
           If the client passes incorrect parameters on the request - such as bad URLs or invalid values
-        PropertyServerException
+        PyegeriaAPIException
           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
@@ -5180,10 +5364,7 @@ class CollectionManager(Client2):
             Effective time of the query. If not specified will default to any time.
         body: dict, optional, defaults to None
             The body of the request to add to the collection. See notes.
-        replace_all_props: bool, optional, defaults to False
-            Replace all properties or just update ones specified in body.
 
-            The name of the server to use.
 
 
         Returns
@@ -5193,9 +5374,9 @@ class CollectionManager(Client2):
         Raises
         ------
 
-        InvalidParameterException
+        PyegeriaInvalidParameterException
           If the client passes incorrect parameters on the request - such as bad URLs or invalid values
-        PropertyServerException
+        PyegeriaAPIException
           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
@@ -5233,7 +5414,7 @@ class CollectionManager(Client2):
 
     @dynamic_catch
     async def _async_remove_from_collection(self, collection_guid: str, element_guid: str,
-                                            body: dict | DeleteRequestBody = None) -> None:
+                                            body: Optional[dict | DeleteRelationshipRequestBody] = None) -> None:
         """Remove an element from a collection. Async version.
 
         Parameters
@@ -5242,7 +5423,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 | DeleteRequestBody, optional, defaults to None
+        body: dict | DeleteRelationshipRequestBody, optional, defaults to None
             The body of the request to add to the collection. See notes.
 
         Returns
@@ -5251,18 +5432,11 @@ class CollectionManager(Client2):
 
         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
-
+        PyegeriaException
         Notes
         -----
         {
-          "class" : "DeleteRequestBody",
+          "class" : "DeleteRelationshipRequestBody",
           "externalSourceGUID": "add guid here",
           "externalSourceName": "add qualified name here",
           "effectiveTime" : "{{$isoTimestamp}}",
@@ -5272,14 +5446,13 @@ class CollectionManager(Client2):
 
         """
 
-        url = (f"{self.collection_command_root}/{collection_guid}/members/"
-               f"{element_guid}/detach")
-        await self._async_delete_collection(url, body)
+        url = f"{self.collection_command_root}/{collection_guid}/members/{element_guid}/detach"
+        await self._async_delete_relationship_request(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 | DeleteRequestBody= None) -> None:
+                               body: dict | DeleteRelationshipRequestBody= None) -> None:
         """Remove an element from a collection. Async version.
 
         Parameters
@@ -5298,9 +5471,9 @@ class CollectionManager(Client2):
         Raises
         ------
 
-        InvalidParameterException
+        PyegeriaInvalidParameterException
           If the client passes incorrect parameters on the request - such as bad URLs or invalid values
-        PropertyServerException
+        PyegeriaAPIException
           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
@@ -5326,7 +5499,7 @@ class CollectionManager(Client2):
 
 
     def remove_term_from_category(self, folder_guid: str, term_guid: str,
-                               body: dict | DeleteRequestBody= None) -> None:
+                               body: dict | DeleteRelationshipRequestBody= None) -> None:
         """Remove a term from a category.
 
         Parameters
@@ -5345,9 +5518,9 @@ class CollectionManager(Client2):
         Raises
         ------
 
-        InvalidParameterException
+        PyegeriaInvalidParameterException
           If the client passes incorrect parameters on the request - such as bad URLs or invalid values
-        PropertyServerException
+        PyegeriaAPIException
           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
@@ -5365,8 +5538,8 @@ class CollectionManager(Client2):
 
 
     @dynamic_catch
-    async def _async_get_member_list(self, collection_guid: str = None, collection_name: str = None,
-                                     collection_qname: str = None, ) -> list | str:
+    async def _async_get_member_list(self, collection_guid: Optional[str] = None, collection_name: Optional[str] = None,
+                                     collection_qname: Optional[str] = None, ) -> list | str:
         """Get the member list for the collection - async version.
         Parameters
         ----------
@@ -5387,7 +5560,7 @@ class CollectionManager(Client2):
 
         Raises
         ------
-        InvalidParameterException
+        PyegeriaInvalidParameterException
             If the root_collection_name does not have exactly one root collection.
 
         """
@@ -5403,10 +5576,11 @@ class CollectionManager(Client2):
         # finally, construct a list of  member information
         for member_rel in members:
             member_guid = member_rel["elementHeader"]["guid"]
-            member = await self._async_get_element_by_guid_(member_guid)
+            # member = await self._async_get_element_by_guid_(member_guid)
+            member = member_rel
             if isinstance(member, dict):
                 member_instance = {
-                    "name": member["properties"].get('displayName', ''),
+                    "displayName": member["properties"].get('displayName', ''),
                     "qualifiedName": member["properties"]["qualifiedName"], "guid": member["elementHeader"]["guid"],
                     "description": member["properties"].get("description", ''),
                     "type": member["elementHeader"]["type"]['typeName'],
@@ -5416,8 +5590,8 @@ class CollectionManager(Client2):
         return member_list if len(member_list) > 0 else "No members found"
 
 
-    def get_member_list(self, collection_guid: str = None, collection_name: str = None,
-                        collection_qname: str = None, ) -> list | bool:
+    def get_member_list(self, collection_guid: Optional[str] = None, collection_name: Optional[str] = None,
+                        collection_qname: Optional[str] = None, ) -> list | bool:
         """Get the member list for a collection - async version.
         Parameters
         ----------
@@ -5437,7 +5611,7 @@ class CollectionManager(Client2):
 
         Raises
         ------
-        InvalidParameterException
+        PyegeriaInvalidParameterException
             If the root_collection_name does not have exactly one root collection.
 
         """
@@ -5448,7 +5622,12 @@ class CollectionManager(Client2):
 
     def _extract_digital_product_properties(self, element: dict, guid: str, output_format: str) -> dict:
         props = element["properties"]
-        digital_prod = DigitalProductProperties.model_validate(props)
+        prop_class = props.get("class", "DigitalProductProperties")
+        if prop_class == "DigitalProductFamilyProperties":
+            digital_prod = DigitalProductFamilyProperties.model_validate(props)
+        else:
+            digital_prod = DigitalProductProperties.model_validate(props)
+
         added_props = get_defined_field_values(digital_prod)
 
         used_by_digital_products = element.get("usedByDigitalProducts", "")
@@ -5465,6 +5644,40 @@ class CollectionManager(Client2):
                 uses_digital_products_list += f"{prod["relatedElement"]["properties"]["qualifiedName"]}, "
             added_props["uses_digital_products"] = uses_digital_products_list[:-2]
 
+        resources = element.get("resourceList", "")
+        if isinstance(resources, (list | dict)):
+            resource_list = ""
+            for resource in resources:
+                resource_list += f"{resource.get('properties',{}).get('qualifiedName', None)}, "
+            added_props["resource_list"] = resource_list[:-2] if resource_list else ""
+
+        actors = element.get("assignedActors", "")
+        if isinstance(actors, (list | dict)):
+            actor_list = ""
+            for actor in actors:
+                actor_type = actor['relatedElement']['elementHeader']['type']['typeName']
+                actor_qname = actor['relatedElement']['properties']['qualifiedName']
+                actor_display_name = actor['relatedElement']['properties']['displayName']
+                actor_list += actor_display_name
+            added_props["actor_list"] = actor_list[:-2] if actor_list else ""
+
+        governed_by = element.get("governedBy", "")
+        if isinstance(governed_by, (list | dict)):
+            governed_by_list = ""
+            for gov in governed_by:
+                license_type = gov['relatedElement']['properties'].get('typeName',"")
+                license_type_qname = gov['relatedElement']['properties'].get('qualifiedName','')
+                governed_by_list += license_type_qname
+            added_props["governed_list"] = governed_by_list[:-2] if governed_by_list else ""
+
+        solution_designs = element.get("solutionDesigns", "")
+        if isinstance(solution_designs, (list | dict)):
+            solution_design_list = ""
+            for design in solution_designs:
+                solution_design_qname = design['relatedElement']['properties'].get('qualifiedName', "")
+                solution_design_list += solution_design_qname
+            added_props["solution_design_list"] = solution_design_list[:-2] if solution_design_list else ""
+
         return added_props
 
     def _extract_agreement_properties(self, element: dict, guid: str, output_format: str) -> dict:
@@ -5483,70 +5696,31 @@ class CollectionManager(Client2):
         return added_props
 
     def _extract_collection_properties(self, element: dict, columns_struct: dict) -> dict:
-        """
-        Extract common properties from a collection element and populate into the provided columns_struct.
+        """Populate collection columns for output.
 
-        Args:
-            element (dict): The collection element
-            columns_struct (dict): The columns structure to populate
+        Uses `populate_common_columns` to fill standard fields and derive requested relationships.
 
-        Returns:
-            dict: columns_struct with column 'value' fields populated
-        """
-        # 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.get('elementHeader', {}).get("collectionCategories", [])
-        for classification in classifications:
-            classification_names += f"{classification['classificationName']}, "
-        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)
-
-        # 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
-
-        # Mermaid graph
-        mermaid_val = element.get('mermaidGraph', "") or ""
-        for column in columns_list:
-            if column.get('key') == 'mermaid':
-                column['value'] = mermaid_val
-                break
+        Parameters
+        ----------
+        element : dict
+            Raw element from the OMVS.
+        columns_struct : dict
+            Format-set structure whose columns' `value` fields will be populated.
 
+        Returns
+        -------
+        dict
+            The same columns_struct with populated values.
+        """
+        # Use centralized common population
+        col_data = populate_common_columns(element, columns_struct)
         logger.trace(f"Extracted/Populated columns: {col_data}")
-
         return col_data
 
 
-    def _generate_collection_output(self, elements: dict|list[dict], filter: Optional[str],
+    def _generate_collection_output(self, elements: dict|list[dict], filter_string: Optional[str],
                                     element_type_name: Optional[str], output_format: str = "DICT",
-                                    output_format_set: dict | str = None) -> str| list[dict]:
+                                    report_spec: dict | str = None) -> str | list[dict]:
         """ Generate output for collections in the specified format.
 
             Args:
@@ -5554,7 +5728,7 @@ class CollectionManager(Client2):
                 filter (Optional[str]): The search string used to find the elements
                 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
+                report_spec (Optional[dict], optional): List of dictionaries containing column data. Defaults
                 to None.
 
             Returns:
@@ -5564,22 +5738,22 @@ class CollectionManager(Client2):
             entity_type = "Collections"
         else:
             entity_type = element_type_name
-        # First see if the user has specified an output_format_set - either a label or a dict
+        # First see if the user has specified an report_spec - 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)
-            elif isinstance(output_format_set, dict):
-                output_formats = get_output_format_type_match(output_format_set, output_format)
+        if report_spec:
+            if isinstance(report_spec, str):
+                output_formats = select_report_spec(report_spec, output_format)
+            elif isinstance(report_spec, dict):
+                output_formats = get_report_spec_match(report_spec, 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)
+            output_formats = select_report_spec(element_type_name, output_format)
         else:
             # fallback to collections or entity type
-            output_formats = select_output_format_set(entity_type,output_format)
+            output_formats = select_report_spec(entity_type,output_format)
         if output_formats is None:
-            output_formats = select_output_format_set("Default", output_format)
+            output_formats = select_report_spec("Default", output_format)
 
         if output_formats:
             get_additional_props_name = output_formats.get("get_additional_props", {}).get("function", None)