pyegeria 5.4.0.dev10__py3-none-any.whl → 5.4.0.dev12__py3-none-any.whl

pyegeria/collection_manager_omvs.py

@@ -10,7 +10,7 @@ import asyncio
 from pyegeria._client import Client
 from pyegeria._globals import NO_ELEMENTS_FOUND
 from pyegeria._validators import validate_guid, validate_search_string
-from pyegeria.output_formatter import (extract_mermaid_only, extract_basic_dict, generate_output)
+from pyegeria.output_formatter import (extract_mermaid_only, extract_basic_dict, generate_output, markdown_to_html)
 from pyegeria.utils import body_slimmer
 
 
@@ -33,6 +33,8 @@ def query_string(params):
     return result
 
 
+
+
 class CollectionManager(Client):
     """
     Maintain and explore the contents of nested collections. These collections can be used to represent digital
@@ -150,6 +152,10 @@ class CollectionManager(Client):
             the class instance.
         body: dict, optional, default = None
             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"
+
+
         Returns
         -------
         List
@@ -186,7 +192,7 @@ class CollectionManager(Client):
             self._async_get_attached_collections(parent_guid, start_from, page_size, body, output_format))
 
     async def _async_find_collections_w_body(self, body: dict, classification_name: str = None,
-                                             starts_with: bool = False, ends_with: bool = False,
+                                             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_profile: str = "CORE") -> list | str:
         """ Returns the list of collections matching the search string filtered by the optional classification.
@@ -273,7 +279,7 @@ class CollectionManager(Client):
             return self.generate_collection_output(elements, None, None, output_format)
         return elements
 
-    def find_collections_w_body(self, body: dict, classification_name: str = None, starts_with: bool = False,
+    def find_collections_w_body(self, body: dict, classification_name: 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_profile: str = "CORE") -> list | str:
@@ -340,7 +346,7 @@ class CollectionManager(Client):
                                                 start_from, page_size, output_format, output_profile))
 
     async def _async_find_collections(self, search_string: str = '*', classification_name: str = None,
-                                      starts_with: bool = False, ends_with: bool = False, ignore_case: bool = False,
+                                      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_profile: str = "CORE") -> list | str:
         """ Returns the list of collections matching the search string filtered by the optional classification.
@@ -397,9 +403,9 @@ class CollectionManager(Client):
                                                          start_from, page_size, output_format, output_profile)
         return resp
 
-    def find_collections(self, search_string: str = '*', classification_name: str = None, starts_with: bool = False,
-                         ends_with: bool = False, ignore_case: bool = False, start_from: int = 0, page_size: int = 0,
-                         output_format: str = 'JSON', output_profile: str = "CORE") -> list | str:
+    def find_collections(self, search_string: str = '*', classification_name: 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_profile: str = "CORE") -> list | str:
         """ Returns the list of collections matching the search string filtered by the optional classification.
             The search string is located in the request body and is interpreted as a plain string. The full
             body allows complete control including status, asOfTime and effectiveTime.
@@ -795,8 +801,8 @@ class CollectionManager(Client):
             self._async_get_collection_by_guid(collection_guid, collection_type, body, output_format))
 
     async def _async_get_collection_members(self, collection_guid: str = None, collection_name: str = None,
-                                            collection_qname: str = None, body: dict= None, start_from: int = 0, page_size: int = 0,
-                                            output_format: str = "JSON") -> list | str:
+                                            collection_qname: str = None, body: dict = None, start_from: int = 0,
+                                            page_size: int = 0, output_format: str = "JSON") -> list | str:
         """Return a list of elements that are a member of a collection. Async version.
 
         Parameters
@@ -930,9 +936,8 @@ class CollectionManager(Client):
 
         return resp
 
-
-    async def _async_get_collection_graph(self, collection_guid: str, body: dict = None, start_from: int = 0, page_size: int = 0,
-                                          output_format: str = "JSON") -> list | str:
+    async def _async_get_collection_graph(self, collection_guid: str, body: dict = None, start_from: int = 0,
+                                          page_size: int = 0, output_format: str = "JSON") -> list | str:
         """ Return a graph of elements that are the nested members of a collection along
             with elements immediately connected to the starting collection.  The result
             includes a mermaid graph of the returned elements. Async version.
@@ -997,8 +1002,8 @@ class CollectionManager(Client):
             return self.generate_collection_output(elements, None, None, output_format)
         return elements
 
-    def get_collection_graph(self, collection_guid: str = None, body: dict = None, start_from: int = 0, page_size: int = 0,
-                             output_format: str = "JSON") -> list | str:
+    def get_collection_graph(self, collection_guid: str = None, body: dict = None, start_from: int = 0,
+                             page_size: int = 0, output_format: str = "JSON") -> 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.
@@ -1112,8 +1117,8 @@ class CollectionManager(Client):
             return self.generate_collection_output(elements, None, None, output_format)
         return elements
 
-    def get_collection_graph_w_body(self, collection_guid: str, body: dict = None, start_from: int = 0, page_size: int = None,
-                                    output_format: str = "JSON") -> list | str:
+    def get_collection_graph_w_body(self, collection_guid: str, body: dict = None, start_from: int = 0,
+                                    page_size: int = None, output_format: str = "JSON") -> 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
@@ -1315,14 +1320,14 @@ class CollectionManager(Client):
         }
         """
 
-        return asyncio.get_event_loop().run_until_complete(self._async_create_collection_w_body(body, classification_name))
+        return asyncio.get_event_loop().run_until_complete(
+            self._async_create_collection_w_body(body, classification_name))
 
     async def _async_create_collection(self, display_name: str, description: str, is_own_anchor: bool = True,
                                        classification_name: str = None, anchor_guid: str = None,
                                        parent_guid: str = None, parent_relationship_type_name: str = None,
                                        parent_at_end1: bool = True, collection_type: str = None,
-                                       anchor_scope_guid: str = None, collection_ordering: str = None,
-                                       order_property_name: str = None, additional_properties: dict = None,
+                                       anchor_scope_guid: str = None, additional_properties: dict = None,
                                        extended_properties: dict = None) -> str:
         """ Create a new generic collection.
             Create Collections: https://egeria-project.org/concepts/collection
@@ -1354,11 +1359,6 @@ class CollectionManager(Client):
             Adds an user supplied valid value for the collection type.
         anchor_scope_guid: str, optional, defaults to None
             optional GUID of search scope
-        collection_ordering: str, optional, defaults to "OTHER"
-            Specifies the sequencing to use in a collection. Examples include "NAME", "OWNER", "DATE_CREATED",
-             "OTHER"
-        order_property_name: str, optional, defaults to "Something"
-            Property to use for sequencing if collection_ordering is "OTHER"
         additional_properties: dict, optional, defaults to None
             User specified Additional properties to add to the collection definition.
         extended_properties: dict, optional, defaults to None
@@ -1397,9 +1397,8 @@ class CollectionManager(Client):
             "parentRelationshipTypeName": parent_relationship_type_name, "parentAtEnd1": parent_at_end1_s,
             "properties": {
                 "class": "CollectionProperties", "qualifiedName": qualified_name, "name": display_name,
-                "description": description, "collectionType": collection_type, "collectionOrder": collection_ordering,
-                "orderByPropertyName": order_property_name, "additionalProperties": additional_properties,
-                "extendedProperties": extended_properties
+                "description": description, "collectionType": collection_type,
+                "additionalProperties": additional_properties, "extendedProperties": extended_properties
                 },
             }
 
@@ -1409,9 +1408,8 @@ class CollectionManager(Client):
     def create_collection(self, display_name: str, description: str, is_own_anchor: bool = True,
                           classification_name: str = None, anchor_guid: str = None, parent_guid: str = None,
                           parent_relationship_type_name: str = None, parent_at_end1: bool = True,
-                          collection_type: str = None, anchor_scope_guid: str = None, collection_ordering: str = None,
-                          order_property_name: str = None, additional_properties: dict = None,
-                          extended_properties: dict = None) -> str:
+                          collection_type: str = None, anchor_scope_guid: str = None,
+                          additional_properties: dict = None, extended_properties: dict = None) -> str:
         """ Create a new generic collection.
             Create Collections: https://egeria-project.org/concepts/collection
 
@@ -1441,11 +1439,6 @@ class CollectionManager(Client):
             Adds an user supplied valid value for the collection type.
         anchor_scope_guid: str, optional, defaults to None
             optional GUID of search scope
-        collection_ordering: str, optional, defaults to "OTHER"
-            Specifies the sequencing to use in a collection. Examples include "NAME", "OWNER", "DATE_CREATED",
-             "OTHER"
-        order_property_name: str, optional, defaults to "Something"
-            Property to use for sequencing if collection_ordering is "OTHER"
         additional_properties: dict, optional, defaults to None
             User specified Additional properties to add to the collection definition.
         extended_properties: dict, optional, defaults to None
@@ -1469,17 +1462,14 @@ class CollectionManager(Client):
         return asyncio.get_event_loop().run_until_complete(
             self._async_create_collection(display_name, description, is_own_anchor, classification_name, anchor_guid,
                                           parent_guid, parent_relationship_type_name, parent_at_end1, collection_type,
-                                          anchor_scope_guid, collection_ordering, order_property_name,
-                                          additional_properties, extended_properties))
-
+                                          anchor_scope_guid, additional_properties, extended_properties))
 
-
-    async def _async_create_generic_collection(self, display_name: str, description: str, is_own_anchor: bool = True,
+    async def _async_create_generic_collection(self, display_name: str, description: str, qualified_name: str = None,
+                                               is_own_anchor: bool = True, url_item=None,
                                                classification_name: str = None, anchor_guid: str = None,
                                                parent_guid: str = None, parent_relationship_type_name: str = None,
                                                parent_at_end1: bool = True, collection_type: str = None,
-                                               anchor_scope_guid: str = None, collection_ordering: str = None,
-                                               order_property_name: str = None, additional_properties: dict = None,
+                                               anchor_scope_guid: str = None, additional_properties: dict = None,
                                                extended_properties: dict = None) -> str:
         """ Create a new generic collection.
             Create Collections: https://egeria-project.org/concepts/collection
@@ -1491,6 +1481,8 @@ class CollectionManager(Client):
             The display name of the element. Will also be used as the basis of the qualified_name.
         description: str
             A description of the collection.
+        qualified_name: str, optional, defaults to None
+            Allows user to specify a qualified name of the collection.
         is_own_anchor: bool, optional, defaults to True
             Indicates if the collection should be classified as its own anchor or not.
         classification_name: str
@@ -1511,11 +1503,6 @@ class CollectionManager(Client):
             Adds an user supplied valid value for the collection type.
         anchor_scope_guid: str, optional, defaults to None
             optional GUID of search scope
-        collection_ordering: str, optional, defaults to "OTHER"
-            Specifies the sequencing to use in a collection. Examples include "NAME", "OWNER", "DATE_CREATED",
-             "OTHER"
-        order_property_name: str, optional, defaults to "Something"
-            Property to use for sequencing if collection_ordering is "OTHER"
         additional_properties: dict, optional, defaults to None
             User specified Additional properties to add to the collection definition.
         extended_properties: dict, optional, defaults to None
@@ -1535,17 +1522,21 @@ class CollectionManager(Client):
         NotAuthorizedException
           The principle specified by the user_id does not have authorization for the requested action
 
+        Args:
+            url_item ():
+            qualified_name ():
+
         """
 
         is_own_anchor_s = str(is_own_anchor).lower()
         parent_at_end1_s = str(parent_at_end1).lower()
 
-
-        url = f"{self.collection_command_root}/{classification_name}"
-        if classification_name is not None:
-            qualified_name = self.__create_qualified_name__(classification_name, display_name)
-        else:
-            qualified_name = self.__create_qualified_name__("Collection", display_name)
+        url = f"{self.collection_command_root}/{url_item}"
+        if qualified_name is None:
+            if classification_name is not None:
+                qualified_name = self.__create_qualified_name__(classification_name, display_name)
+            else:
+                qualified_name = self.__create_qualified_name__("Collection", display_name)
 
         body = {
             "class": "NewElementRequestBody", "anchorGUID": anchor_guid, "anchorScopeGUID": anchor_scope_guid,
@@ -1553,20 +1544,20 @@ class CollectionManager(Client):
             "parentRelationshipTypeName": parent_relationship_type_name, "parentAtEnd1": parent_at_end1_s,
             "properties": {
                 "class": "CollectionProperties", "qualifiedName": qualified_name, "name": display_name,
-                "description": description, "collectionType": collection_type, "collectionOrder": collection_ordering,
-                "orderByPropertyName": order_property_name, "additionalProperties": additional_properties,
-                "extendedProperties": extended_properties
+                "description": description, "collectionType": collection_type,
+                "additionalProperties": additional_properties, "extendedProperties": extended_properties
                 },
             }
 
         resp = await self._async_make_request("POST", url, body_slimmer(body))
         return resp.json().get("guid", "No GUID returned")
 
-    async def _async_create_root_collection(self, display_name: str, description: str, is_own_anchor: bool = True,
-                                            anchor_guid: str = None, parent_guid: str = None,
-                                            parent_relationship_type_name: str = None, parent_at_end1: bool = True,
-                                            collection_type: str = None, anchor_scope_guid: str = None,
-                                            collection_ordering: str = None, order_property_name: str = None,
+    async def _async_create_root_collection(self, display_name: str, description: str, qualified_name: str = None,
+                                            is_own_anchor: bool = True, anchor_guid: str = None,
+                                            parent_guid: str = None, parent_relationship_type_name: str = None,
+                                            parent_at_end1: bool = True, collection_type: str = None,
+                                            anchor_scope_guid: str = None,
+
                                             additional_properties: dict = None,
                                             extended_properties: dict = None) -> str:
         """ Create a new collection with the RootCollection classification.  Used to identify the top of a collection
@@ -1580,6 +1571,8 @@ class CollectionManager(Client):
             The display name of the element. Will also be used as the basis of the qualified_name.
         description: str
             A description of the collection.
+        qualified_name: str, optional, defaults to None
+            Allows user to specify a qualified name of the collection.
         is_own_anchor: bool, optional, defaults to True
             Indicates if the collection should be classified as its own anchor or not.
         anchor_guid: str
@@ -1597,11 +1590,6 @@ class CollectionManager(Client):
             Adds an user supplied valid value for the collection type.
         anchor_scope_guid: str, optional, defaults to None
             optional GUID of search scope
-        collection_ordering: str, optional, defaults to "OTHER"
-            Specifies the sequencing to use in a collection. Examples include "NAME", "OWNER", "DATE_CREATED",
-             "OTHER"
-        order_property_name: str, optional, defaults to "Something"
-            Property to use for sequencing if collection_ordering is "OTHER"
         additional_properties: dict, optional, defaults to None
             User specified Additional properties to add to the collection definition.
         extended_properties: dict, optional, defaults to None
@@ -1623,19 +1611,24 @@ class CollectionManager(Client):
 
         """
 
-        resp = await self._async_create_generic_collection(display_name, description, is_own_anchor, "root-collection",
-                                                           anchor_guid, parent_guid, parent_relationship_type_name,
-                                                           parent_at_end1, collection_type, anchor_scope_guid,
-                                                           collection_ordering, order_property_name,
-                                                           additional_properties, extended_properties)
+        resp = await self._async_create_generic_collection(display_name, description, qualified_name,
+                                                           is_own_anchor=is_own_anchor, url_item="root-collection",
+                                                           classification_name="RootCollection",
+                                                           anchor_guid=anchor_guid, parent_guid=parent_guid,
+                                                           parent_relationship_type_name=parent_relationship_type_name,
+                                                           parent_at_end1=parent_at_end1,
+                                                           collection_type=collection_type,
+                                                           anchor_scope_guid=anchor_scope_guid,
+                                                           additional_properties=additional_properties,
+                                                           extended_properties=extended_properties)
 
         return resp
 
-    def create_root_collection(self, display_name: str, description: str, is_own_anchor: bool = True,
-                               anchor_guid: str = None, parent_guid: str = None,
+    def create_root_collection(self, display_name: str, description: str, qualified_name: str = None,
+                               is_own_anchor: bool = True, anchor_guid: str = None, parent_guid: str = None,
                                parent_relationship_type_name: str = None, parent_at_end1: bool = True,
                                collection_type: str = None, anchor_scope_guid: str = None,
-                               collection_ordering: str = None, order_property_name: str = None,
+
                                additional_properties: dict = None, extended_properties: dict = None) -> str:
         """ Create a new collection with the RootCollection classification.
             Used to identify the top of a collection hierarchy.
@@ -1647,6 +1640,8 @@ class CollectionManager(Client):
             The display name of the element. Will also be used as the basis of the qualified_name.
         description: str
             A description of the collection.
+        qualified_name: str, optional, defaults to None
+            Allows user to specify a qualified name of the collection.
         is_own_anchor: bool, optional, defaults to True
             Indicates if the collection should be classified as its own anchor or not.
         anchor_guid: str
@@ -1664,11 +1659,6 @@ class CollectionManager(Client):
             Adds an user supplied valid value for the collection type.
         anchor_scope_guid: str, optional, defaults to None
             optional GUID of search scope
-        collection_ordering: str, optional, defaults to "OTHER"
-            Specifies the sequencing to use in a collection. Examples include "NAME", "OWNER", "DATE_CREATED",
-             "OTHER"
-        order_property_name: str, optional, defaults to "Something"
-            Property to use for sequencing if collection_ordering is "OTHER"
         additional_properties: dict, optional, defaults to None
             User specified Additional properties to add to the collection definition.
         extended_properties: dict, optional, defaults to None
@@ -1691,18 +1681,17 @@ class CollectionManager(Client):
         """
         loop = asyncio.get_event_loop()
         resp = loop.run_until_complete(
-            self._async_create_root_collection(display_name, description, is_own_anchor, anchor_guid, parent_guid,
-                                               parent_relationship_type_name, parent_at_end1, collection_type,
-                                               anchor_scope_guid, collection_ordering, order_property_name,
-                                               additional_properties, extended_properties))
+            self._async_create_root_collection(display_name, description, qualified_name, is_own_anchor, anchor_guid,
+                                               parent_guid, parent_relationship_type_name, parent_at_end1,
+                                               collection_type, anchor_scope_guid, additional_properties,
+                                               extended_properties))
         return resp
 
-    async def _async_create_data_spec_collection(self, display_name: str, description: str, is_own_anchor: bool = True,
-                                                 anchor_guid: str = None, parent_guid: str = None,
-                                                 parent_relationship_type_name: str = None, parent_at_end1: bool = True,
-                                                 collection_type: str = None, anchor_scope_guid: str = None,
-                                                 collection_ordering: str = None, order_property_name: str = None,
-                                                 additional_properties: dict = None,
+    async def _async_create_data_spec_collection(self, display_name: str, description: str, qualified_name: str = None,
+                                                 is_own_anchor: bool = True, anchor_guid: str = None,
+                                                 parent_guid: str = None, parent_relationship_type_name: str = None,
+                                                 parent_at_end1: bool = True, collection_type: str = None,
+                                                 anchor_scope_guid: str = None, additional_properties: dict = None,
                                                  extended_properties: dict = None) -> str:
         """ Create a new collection with the DataSpec classification.  Used to identify a collection of data
         structures and
@@ -1715,6 +1704,8 @@ class CollectionManager(Client):
             The display name of the element. Will also be used as the basis of the qualified_name.
         description: str
             A description of the collection.
+        qualified_name: str, optional, defaults to None
+            Allows user to specify a qualified name of the collection.
         is_own_anchor: bool, optional, defaults to True
             Indicates if the collection should be classified as its own anchor or not.
         anchor_guid: str
@@ -1732,11 +1723,6 @@ class CollectionManager(Client):
             Adds an user supplied valid value for the collection type.
         anchor_scope_guid: str, optional, defaults to None
             optional GUID of search scope
-        collection_ordering: str, optional, defaults to "OTHER"
-            Specifies the sequencing to use in a collection. Examples include "NAME", "OWNER", "DATE_CREATED",
-             "OTHER"
-        order_property_name: str, optional, defaults to "Something"
-            Property to use for sequencing if collection_ordering is "OTHER"
         additional_properties: dict, optional, defaults to None
             User specified Additional properties to add to the collection definition.
         extended_properties: dict, optional, defaults to None
@@ -1758,20 +1744,24 @@ class CollectionManager(Client):
 
         """
 
-        resp = await self._async_create_generic_collection(display_name, description, is_own_anchor,
-                                                           "data-spec-collection", anchor_guid, parent_guid,
-                                                           parent_relationship_type_name, parent_at_end1,
-                                                           collection_type, anchor_scope_guid, collection_ordering,
-                                                           order_property_name, additional_properties,
-                                                           extended_properties)
+        resp = await self._async_create_generic_collection(display_name, description, qualified_name,
+                                                           is_own_anchor=is_own_anchor, url_item="data-spec-collection",
+                                                           classification_name="DataSpec", anchor_guid=anchor_guid,
+                                                           parent_guid=parent_guid,
+                                                           parent_relationship_type_name=parent_relationship_type_name,
+                                                           parent_at_end1=parent_at_end1,
+                                                           collection_type=collection_type,
+                                                           anchor_scope_guid=anchor_scope_guid,
+                                                           additional_properties=additional_properties,
+                                                           extended_properties=extended_properties)
 
         return resp
 
-    def create_data_spec_collection(self, display_name: str, description: str, is_own_anchor: bool = True,
-                                    anchor_guid: str = None, parent_guid: str = None,
+    def create_data_spec_collection(self, display_name: str, description: str, qualified_name: str = None,
+                                    is_own_anchor: bool = True, anchor_guid: str = None, parent_guid: str = None,
                                     parent_relationship_type_name: str = None, parent_at_end1: bool = True,
                                     collection_type: str = None, anchor_scope_guid: str = None,
-                                    collection_ordering: str = None, order_property_name: str = None,
+
                                     additional_properties: dict = None, extended_properties: dict = None) -> str:
         """ Create a new collection with the DataSpec classification.  Used to identify a collection of data
         structures and
@@ -1783,6 +1773,8 @@ class CollectionManager(Client):
             The display name of the element. Will also be used as the basis of the qualified_name.
         description: str
             A description of the collection.
+        qualified_name: str, optional, defaults to None
+            Allows user to specify a qualified name of the collection.
         is_own_anchor: bool, optional, defaults to True
             Indicates if the collection should be classified as its own anchor or not.
         anchor_guid: str
@@ -1800,11 +1792,6 @@ class CollectionManager(Client):
             Adds an user supplied valid value for the collection type.
         anchor_scope_guid: str, optional, defaults to None
             optional GUID of search scope
-        collection_ordering: str, optional, defaults to "OTHER"
-            Specifies the sequencing to use in a collection. Examples include "NAME", "OWNER", "DATE_CREATED",
-             "OTHER"
-        order_property_name: str, optional, defaults to "Something"
-            Property to use for sequencing if collection_ordering is "OTHER"
         additional_properties: dict, optional, defaults to None
             User specified Additional properties to add to the collection definition.
         extended_properties: dict, optional, defaults to None
@@ -1827,19 +1814,18 @@ class CollectionManager(Client):
         """
         loop = asyncio.get_event_loop()
         resp = loop.run_until_complete(
-            self._async_create_data_spec_collection(display_name, description, is_own_anchor, anchor_guid, parent_guid,
-                                                    parent_relationship_type_name, parent_at_end1, collection_type,
-                                                    anchor_scope_guid, collection_ordering, order_property_name,
+            self._async_create_data_spec_collection(display_name, description, qualified_name, is_own_anchor,
+                                                    anchor_guid, parent_guid, parent_relationship_type_name,
+                                                    parent_at_end1, collection_type, anchor_scope_guid,
                                                     additional_properties, extended_properties))
         return resp
 
     async def _async_create_data_dictionary_collection(self, display_name: str, description: str,
-                                                       is_own_anchor: bool = True, anchor_guid: str = None,
-                                                       parent_guid: str = None,
+                                                       qualified_name: str = None, is_own_anchor: bool = True,
+                                                       anchor_guid: str = None, parent_guid: str = None,
                                                        parent_relationship_type_name: str = None,
                                                        parent_at_end1: bool = True, collection_type: str = None,
-                                                       anchor_scope_guid: str = None, collection_ordering: str = None,
-                                                       order_property_name: str = None,
+                                                       anchor_scope_guid: str = None,
                                                        additional_properties: dict = None,
                                                        extended_properties: dict = None) -> str:
         """ Create a new collection with the DataDictionary classification.  Used to identify a collection of data
@@ -1853,6 +1839,8 @@ class CollectionManager(Client):
             The display name of the element. Will also be used as the basis of the qualified_name.
         description: str
             A description of the collection.
+        qualified_name: str, optional, defaults to None
+            Allows user to specify a qualified name of the collection.
         is_own_anchor: bool, optional, defaults to True
             Indicates if the collection should be classified as its own anchor or not.
         anchor_guid: str
@@ -1870,11 +1858,6 @@ class CollectionManager(Client):
             Adds an user supplied valid value for the collection type.
         anchor_scope_guid: str, optional, defaults to None
             optional GUID of search scope
-        collection_ordering: str, optional, defaults to "OTHER"
-            Specifies the sequencing to use in a collection. Examples include "NAME", "OWNER", "DATE_CREATED",
-             "OTHER"
-        order_property_name: str, optional, defaults to "Something"
-            Property to use for sequencing if collection_ordering is "OTHER"
         additional_properties: dict, optional, defaults to None
             User specified Additional properties to add to the collection definition.
         extended_properties: dict, optional, defaults to None
@@ -1896,20 +1879,25 @@ class CollectionManager(Client):
 
         """
 
-        resp = await self._async_create_generic_collection(display_name, description, is_own_anchor,
-                                                           "data-dictionary-collection", anchor_guid, parent_guid,
-                                                           parent_relationship_type_name, parent_at_end1,
-                                                           collection_type, anchor_scope_guid, collection_ordering,
-                                                           order_property_name, additional_properties,
-                                                           extended_properties)
+        resp = await self._async_create_generic_collection(display_name, description, qualified_name,
+                                                           is_own_anchor=is_own_anchor,
+                                                           url_item="data-dictionary-collection",
+                                                           classification_name="DataDictionary",
+                                                           anchor_guid=anchor_guid, parent_guid=parent_guid,
+                                                           parent_relationship_type_name=parent_relationship_type_name,
+                                                           parent_at_end1=parent_at_end1,
+                                                           collection_type=collection_type,
+                                                           anchor_scope_guid=anchor_scope_guid,
+                                                           additional_properties=additional_properties,
+                                                           extended_properties=extended_properties)
 
         return resp
 
-    def create_data_dictionary_collection(self, display_name: str, description: str, is_own_anchor: bool = True,
-                                          anchor_guid: str = None, parent_guid: str = None,
+    def create_data_dictionary_collection(self, display_name: str, description: str, qualified_name: str = None,
+                                          is_own_anchor: bool = True, anchor_guid: str = None, parent_guid: str = None,
                                           parent_relationship_type_name: str = None, parent_at_end1: bool = True,
                                           collection_type: str = None, anchor_scope_guid: str = None,
-                                          collection_ordering: str = None, order_property_name: str = None,
+
                                           additional_properties: dict = None, extended_properties: dict = None) -> str:
         """ Create a new collection with the DataSpec classification.  Used to identify a collection of data
         structures and
@@ -1921,6 +1909,8 @@ class CollectionManager(Client):
             The display name of the element. Will also be used as the basis of the qualified_name.
         description: str
             A description of the collection.
+        qualified_name: str, optional, defaults to None
+            Allows user to specify a qualified name of the collection.
         is_own_anchor: bool, optional, defaults to True
             Indicates if the collection should be classified as its own anchor or not.
         anchor_guid: str
@@ -1938,11 +1928,6 @@ class CollectionManager(Client):
             Adds an user supplied valid value for the collection type.
         anchor_scope_guid: str, optional, defaults to None
             optional GUID of search scope
-        collection_ordering: str, optional, defaults to "OTHER"
-            Specifies the sequencing to use in a collection. Examples include "NAME", "OWNER", "DATE_CREATED",
-             "OTHER"
-        order_property_name: str, optional, defaults to "Something"
-            Property to use for sequencing if collection_ordering is "OTHER"
         additional_properties: dict, optional, defaults to None
             User specified Additional properties to add to the collection definition.
         extended_properties: dict, optional, defaults to None
@@ -1965,18 +1950,18 @@ class CollectionManager(Client):
         """
         loop = asyncio.get_event_loop()
         resp = loop.run_until_complete(
-            self._async_create_data_dictionary_collection(display_name, description, is_own_anchor, anchor_guid,
-                                                          parent_guid, parent_relationship_type_name, parent_at_end1,
-                                                          collection_type, anchor_scope_guid, collection_ordering,
-                                                          order_property_name, additional_properties,
-                                                          extended_properties))
+            self._async_create_data_dictionary_collection(display_name, description, qualified_name, is_own_anchor,
+                                                          anchor_guid, parent_guid, parent_relationship_type_name,
+                                                          parent_at_end1, collection_type, anchor_scope_guid,
+                                                          additional_properties, extended_properties))
         return resp
 
-    async def _async_create_folder_collection(self, display_name: str, description: str, is_own_anchor: bool = True,
-                                              anchor_guid: str = None, parent_guid: str = None,
-                                              parent_relationship_type_name: str = None, parent_at_end1: bool = True,
-                                              collection_type: str = None, anchor_scope_guid: str = None,
-                                              collection_ordering: str = None, order_property_name: str = None,
+    async def _async_create_folder_collection(self, display_name: str, description: str, qualified_name: str = None,
+                                              is_own_anchor: bool = True, anchor_guid: str = None,
+                                              parent_guid: str = None, parent_relationship_type_name: str = None,
+                                              parent_at_end1: bool = True, collection_type: str = None,
+                                              anchor_scope_guid: str = None,
+
                                               additional_properties: dict = None,
                                               extended_properties: dict = None) -> str:
         """ Create a new collection with the Folder classification.  This is used to identify the organizing collections
@@ -1989,6 +1974,8 @@ class CollectionManager(Client):
             The display name of the element. Will also be used as the basis of the qualified_name.
         description: str
             A description of the collection.
+        qualified_name: str, optional, defaults to None
+            Allows user to specify a qualified name of the collection.
         is_own_anchor: bool, optional, defaults to True
             Indicates if the collection should be classified as its own anchor or not.
         anchor_guid: str
@@ -2006,11 +1993,6 @@ class CollectionManager(Client):
             Adds an user supplied valid value for the collection type.
         anchor_scope_guid: str, optional, defaults to None
             optional GUID of search scope
-        collection_ordering: str, optional, defaults to "OTHER"
-            Specifies the sequencing to use in a collection. Examples include "NAME", "OWNER", "DATE_CREATED",
-             "OTHER"
-        order_property_name: str, optional, defaults to "Something"
-            Property to use for sequencing if collection_ordering is "OTHER"
         additional_properties: dict, optional, defaults to None
             User specified Additional properties to add to the collection definition.
         extended_properties: dict, optional, defaults to None
@@ -2032,19 +2014,24 @@ class CollectionManager(Client):
 
         """
 
-        resp = await self._async_create_generic_collection(display_name, description, is_own_anchor, "folder",
-                                                           anchor_guid, parent_guid, parent_relationship_type_name,
-                                                           parent_at_end1, collection_type, anchor_scope_guid,
-                                                           collection_ordering, order_property_name,
-                                                           additional_properties, extended_properties)
+        resp = await self._async_create_generic_collection(display_name, description, qualified_name,
+                                                           is_own_anchor=is_own_anchor, url_item="folder",
+                                                           classification_name="Folder", anchor_guid=anchor_guid,
+                                                           parent_guid=parent_guid,
+                                                           parent_relationship_type_name=parent_relationship_type_name,
+                                                           parent_at_end1=parent_at_end1,
+                                                           collection_type=collection_type,
+                                                           anchor_scope_guid=anchor_scope_guid,
+                                                           additional_properties=additional_properties,
+                                                           extended_properties=extended_properties)
 
         return resp
 
-    def create_folder_collection(self, display_name: str, description: str, is_own_anchor: bool = True,
-                                 anchor_guid: str = None, parent_guid: str = None,
+    def create_folder_collection(self, display_name: str, description: str, qualified_name: str = None,
+                                 is_own_anchor: bool = True, anchor_guid: str = None, parent_guid: str = None,
                                  parent_relationship_type_name: str = None, parent_at_end1: bool = True,
                                  collection_type: str = None, anchor_scope_guid: str = None,
-                                 collection_ordering: str = None, order_property_name: str = None,
+
                                  additional_properties: dict = None, extended_properties: dict = None) -> str:
         """ Create a new collection with the Folder classification.  This is used to identify the organizing collections
             in a collection hierarchy.
@@ -2055,6 +2042,8 @@ class CollectionManager(Client):
             The display name of the element. Will also be used as the basis of the qualified_name.
         description: str
             A description of the collection.
+        qualified_name: str, optional, defaults to None
+            Allows user to specify a qualified name of the collection.
         is_own_anchor: bool, optional, defaults to True
             Indicates if the collection should be classified as its own anchor or not.
         anchor_guid: str
@@ -2072,11 +2061,6 @@ class CollectionManager(Client):
             Adds an user supplied valid value for the collection type.
         anchor_scope_guid: str, optional, defaults to None
             optional GUID of search scope
-        collection_ordering: str, optional, defaults to "OTHER"
-            Specifies the sequencing to use in a collection. Examples include "NAME", "OWNER", "DATE_CREATED",
-             "OTHER"
-        order_property_name: str, optional, defaults to "Something"
-            Property to use for sequencing if collection_ordering is "OTHER"
         additional_properties: dict, optional, defaults to None
             User specified Additional properties to add to the collection definition.
         extended_properties: dict, optional, defaults to None
@@ -2099,19 +2083,18 @@ class CollectionManager(Client):
         """
         loop = asyncio.get_event_loop()
         resp = loop.run_until_complete(
-            self._async_create_folder_collection(display_name, description, is_own_anchor, anchor_guid, parent_guid,
-                                                 parent_relationship_type_name, parent_at_end1, collection_type,
-                                                 anchor_scope_guid, collection_ordering, order_property_name,
-                                                 additional_properties, extended_properties))
+            self._async_create_folder_collection(display_name, description, qualified_name, is_own_anchor, anchor_guid,
+                                                 parent_guid, parent_relationship_type_name, parent_at_end1,
+                                                 collection_type, anchor_scope_guid, additional_properties,
+                                                 extended_properties))
         return resp
 
     async def _async_create_context_event_collection(self, display_name: str, description: str,
-                                                     is_own_anchor: bool = True, anchor_guid: str = None,
-                                                     parent_guid: str = None, parent_relationship_type_name: str = None,
+                                                     qualified_name: str = None, is_own_anchor: bool = True,
+                                                     anchor_guid: str = None, parent_guid: str = None,
+                                                     parent_relationship_type_name: str = None,
                                                      parent_at_end1: bool = True, collection_type: str = None,
-                                                     anchor_scope_guid: str = None, collection_ordering: str = None,
-                                                     order_property_name: str = None,
-                                                     additional_properties: dict = None,
+                                                     anchor_scope_guid: str = None, additional_properties: dict = None,
                                                      extended_properties: dict = None) -> str:
         """ Create a new collection with the ContextEventCollection classification.  This is used to group context
         events together.
@@ -2124,6 +2107,8 @@ class CollectionManager(Client):
             The display name of the element. Will also be used as the basis of the qualified_name.
         description: str
             A description of the collection.
+        qualified_name: str, optional, defaults to None
+            Allows user to specify a qualified name of the collection.
         is_own_anchor: bool, optional, defaults to True
             Indicates if the collection should be classified as its own anchor or not.
         anchor_guid: str
@@ -2141,11 +2126,6 @@ class CollectionManager(Client):
             Adds an user supplied valid value for the collection type.
         anchor_scope_guid: str, optional, defaults to None
             optional GUID of search scope
-        collection_ordering: str, optional, defaults to "OTHER"
-            Specifies the sequencing to use in a collection. Examples include "NAME", "OWNER", "DATE_CREATED",
-             "OTHER"
-        order_property_name: str, optional, defaults to "Something"
-            Property to use for sequencing if collection_ordering is "OTHER"
         additional_properties: dict, optional, defaults to None
             User specified Additional properties to add to the collection definition.
         extended_properties: dict, optional, defaults to None
@@ -2167,20 +2147,25 @@ class CollectionManager(Client):
 
         """
 
-        resp = await self._async_create_generic_collection(display_name, description, is_own_anchor,
-                                                           "context-event-collection", anchor_guid, parent_guid,
-                                                           parent_relationship_type_name, parent_at_end1,
-                                                           collection_type, anchor_scope_guid, collection_ordering,
-                                                           order_property_name, additional_properties,
-                                                           extended_properties)
+        resp = await self._async_create_generic_collection(display_name, description, qualified_name,
+                                                           is_own_anchor=is_own_anchor,
+                                                           url_item="context-event-collection",
+                                                           classification_name="CtxEventCollection",
+                                                           anchor_guid=anchor_guid, parent_guid=parent_guid,
+                                                           parent_relationship_type_name=parent_relationship_type_name,
+                                                           parent_at_end1=parent_at_end1,
+                                                           collection_type=collection_type,
+                                                           anchor_scope_guid=anchor_scope_guid,
+                                                           additional_properties=additional_properties,
+                                                           extended_properties=extended_properties)
 
         return resp
 
-    def create_context_event_collection(self, display_name: str, description: str, is_own_anchor: bool = True,
-                                        anchor_guid: str = None, parent_guid: str = None,
+    def create_context_event_collection(self, display_name: str, description: str, qualified_name: str = None,
+                                        is_own_anchor: bool = True, anchor_guid: str = None, parent_guid: str = None,
                                         parent_relationship_type_name: str = None, parent_at_end1: bool = True,
                                         collection_type: str = None, anchor_scope_guid: str = None,
-                                        collection_ordering: str = None, order_property_name: str = None,
+
                                         additional_properties: dict = None, extended_properties: dict = None) -> str:
         """ Create a new collection with the ContextEventCollection classification.  This is used to group context
         events together.
@@ -2192,6 +2177,8 @@ class CollectionManager(Client):
             The display name of the element. Will also be used as the basis of the qualified_name.
         description: str
             A description of the collection.
+        qualified_name: str, optional, defaults to None
+            Allows user to specify a qualified name of the collection.
         is_own_anchor: bool, optional, defaults to True
             Indicates if the collection should be classified as its own anchor or not.
         anchor_guid: str
@@ -2209,11 +2196,6 @@ class CollectionManager(Client):
             Adds an user supplied valid value for the collection type.
         anchor_scope_guid: str, optional, defaults to None
             optional GUID of search scope
-        collection_ordering: str, optional, defaults to "OTHER"
-            Specifies the sequencing to use in a collection. Examples include "NAME", "OWNER", "DATE_CREATED",
-             "OTHER"
-        order_property_name: str, optional, defaults to "Something"
-            Property to use for sequencing if collection_ordering is "OTHER"
         additional_properties: dict, optional, defaults to None
             User specified Additional properties to add to the collection definition.
         extended_properties: dict, optional, defaults to None
@@ -2236,18 +2218,17 @@ class CollectionManager(Client):
         """
         loop = asyncio.get_event_loop()
         resp = loop.run_until_complete(
-            self._async_create_context_event_collection(display_name, description, is_own_anchor, anchor_guid,
-                                                       parent_guid, parent_relationship_type_name, parent_at_end1,
-                                                       collection_type, anchor_scope_guid, collection_ordering,
-                                                       order_property_name, additional_properties, extended_properties))
+            self._async_create_context_event_collection(display_name, description, qualified_name, is_own_anchor,
+                                                        anchor_guid, parent_guid, parent_relationship_type_name,
+                                                        parent_at_end1, collection_type, anchor_scope_guid,
+                                                        additional_properties, extended_properties))
         return resp
 
-    async def _async_create_name_space_collection(self, display_name: str, description: str, is_own_anchor: bool = True,
-                                                  anchor_guid: str = None, parent_guid: str = None,
-                                                  parent_relationship_type_name: str = None,
+    async def _async_create_name_space_collection(self, display_name: str, description: str, qualified_name: str = None,
+                                                  is_own_anchor: bool = True, anchor_guid: str = None,
+                                                  parent_guid: str = None, parent_relationship_type_name: str = None,
                                                   parent_at_end1: bool = True, collection_type: str = None,
-                                                  anchor_scope_guid: str = None, collection_ordering: str = None,
-                                                  order_property_name: str = None, additional_properties: dict = None,
+                                                  anchor_scope_guid: str = None, additional_properties: dict = None,
                                                   extended_properties: dict = None) -> str:
         """ Create a new collection with the Namespace classification.  This is used to group elements that belong to
         the same namespace.
@@ -2261,6 +2242,8 @@ class CollectionManager(Client):
             The display name of the element. Will also be used as the basis of the qualified_name.
         description: str
             A description of the collection.
+        qualified_name: str, optional, defaults to None
+            Allows user to specify a qualified name of the collection.
         is_own_anchor: bool, optional, defaults to True
             Indicates if the collection should be classified as its own anchor or not.
         anchor_guid: str
@@ -2278,11 +2261,6 @@ class CollectionManager(Client):
             Adds an user supplied valid value for the collection type.
         anchor_scope_guid: str, optional, defaults to None
             optional GUID of search scope
-        collection_ordering: str, optional, defaults to "OTHER"
-            Specifies the sequencing to use in a collection. Examples include "NAME", "OWNER", "DATE_CREATED",
-             "OTHER"
-        order_property_name: str, optional, defaults to "Something"
-            Property to use for sequencing if collection_ordering is "OTHER"
         additional_properties: dict, optional, defaults to None
             User specified Additional properties to add to the collection definition.
         extended_properties: dict, optional, defaults to None
@@ -2304,20 +2282,24 @@ class CollectionManager(Client):
 
         """
 
-        resp = await self._async_create_generic_collection(display_name, description, is_own_anchor,
-                                                           "namespace-collection", anchor_guid, parent_guid,
-                                                           parent_relationship_type_name, parent_at_end1,
-                                                           collection_type, anchor_scope_guid, collection_ordering,
-                                                           order_property_name, additional_properties,
-                                                           extended_properties)
+        resp = await self._async_create_generic_collection(display_name, description, qualified_name,
+                                                           is_own_anchor=is_own_anchor, url_item="namespace-collection",
+                                                           classification_name="NamespaceCollection",
+                                                           anchor_guid=anchor_guid, parent_guid=parent_guid,
+                                                           parent_relationship_type_name=parent_relationship_type_name,
+                                                           parent_at_end1=parent_at_end1,
+                                                           collection_type=collection_type,
+                                                           anchor_scope_guid=anchor_scope_guid,
+                                                           additional_properties=additional_properties,
+                                                           extended_properties=extended_properties)
 
         return resp
 
-    def create_name_space_collection(self, display_name: str, description: str, is_own_anchor: bool = True,
-                                     anchor_guid: str = None, parent_guid: str = None,
+    def create_name_space_collection(self, display_name: str, description: str, qualified_name: str = None,
+                                     is_own_anchor: bool = True, anchor_guid: str = None, parent_guid: str = None,
                                      parent_relationship_type_name: str = None, parent_at_end1: bool = True,
                                      collection_type: str = None, anchor_scope_guid: str = None,
-                                     collection_ordering: str = None, order_property_name: str = None,
+
                                      additional_properties: dict = None, extended_properties: dict = None) -> str:
         """ Create a new collection with the Namespace classification.  This is used to group elements that belong to
         the same namespace.
@@ -2330,6 +2312,8 @@ class CollectionManager(Client):
             The display name of the element. Will also be used as the basis of the qualified_name.
         description: str
             A description of the collection.
+        qualified_name: str, optional, defaults to None
+            Allows user to specify a qualified name of the collection.
         is_own_anchor: bool, optional, defaults to True
             Indicates if the collection should be classified as its own anchor or not.
         anchor_guid: str
@@ -2347,11 +2331,6 @@ class CollectionManager(Client):
             Adds an user supplied valid value for the collection type.
         anchor_scope_guid: str, optional, defaults to None
             optional GUID of search scope
-        collection_ordering: str, optional, defaults to "OTHER"
-            Specifies the sequencing to use in a collection. Examples include "NAME", "OWNER", "DATE_CREATED",
-             "OTHER"
-        order_property_name: str, optional, defaults to "Something"
-            Property to use for sequencing if collection_ordering is "OTHER"
         additional_properties: dict, optional, defaults to None
             User specified Additional properties to add to the collection definition.
         extended_properties: dict, optional, defaults to None
@@ -2374,17 +2353,17 @@ class CollectionManager(Client):
         """
         loop = asyncio.get_event_loop()
         resp = loop.run_until_complete(
-            self._async_create_name_space_collection(display_name, description, is_own_anchor, anchor_guid, parent_guid,
-                                                     parent_relationship_type_name, parent_at_end1, collection_type,
-                                                     anchor_scope_guid, collection_ordering, order_property_name,
-                                                     additional_properties, extended_properties))
+            self._async_create_name_space_collection(display_name, description, qualified_name, is_own_anchor,
+                                                     anchor_guid, parent_guid, parent_relationship_type_name,
+                                                     parent_at_end1, collection_type, anchor_scope_guid))
         return resp
 
-    async def _async_create_event_set_collection(self, display_name: str, description: str, is_own_anchor: bool = True,
-                                                 anchor_guid: str = None, parent_guid: str = None,
-                                                 parent_relationship_type_name: str = None, parent_at_end1: bool = True,
-                                                 collection_type: str = None, anchor_scope_guid: str = None,
-                                                 collection_ordering: str = None, order_property_name: str = None,
+    async def _async_create_event_set_collection(self, display_name: str, description: str, qualified_name: str = None,
+                                                 is_own_anchor: bool = True, anchor_guid: str = None,
+                                                 parent_guid: str = None, parent_relationship_type_name: str = None,
+                                                 parent_at_end1: bool = True, collection_type: str = None,
+                                                 anchor_scope_guid: str = None,
+
                                                  additional_properties: dict = None,
                                                  extended_properties: dict = None) -> str:
         """ Create a new collection with the EventSet classification.  This is used to group event schemas together.
@@ -2398,6 +2377,8 @@ class CollectionManager(Client):
             The display name of the element. Will also be used as the basis of the qualified_name.
         description: str
             A description of the collection.
+        qualified_name: str, optional, defaults to None
+            Allows user to specify a qualified name of the collection.
         is_own_anchor: bool, optional, defaults to True
             Indicates if the collection should be classified as its own anchor or not.
         anchor_guid: str
@@ -2415,11 +2396,6 @@ class CollectionManager(Client):
             Adds an user supplied valid value for the collection type.
         anchor_scope_guid: str, optional, defaults to None
             optional GUID of search scope
-        collection_ordering: str, optional, defaults to "OTHER"
-            Specifies the sequencing to use in a collection. Examples include "NAME", "OWNER", "DATE_CREATED",
-             "OTHER"
-        order_property_name: str, optional, defaults to "Something"
-            Property to use for sequencing if collection_ordering is "OTHER"
         additional_properties: dict, optional, defaults to None
             User specified Additional properties to add to the collection definition.
         extended_properties: dict, optional, defaults to None
@@ -2441,20 +2417,24 @@ class CollectionManager(Client):
 
         """
 
-        resp = await self._async_create_generic_collection(display_name, description, is_own_anchor,
-                                                           "event-set-collection", anchor_guid, parent_guid,
-                                                           parent_relationship_type_name, parent_at_end1,
-                                                           collection_type, anchor_scope_guid, collection_ordering,
-                                                           order_property_name, additional_properties,
-                                                           extended_properties)
+        resp = await self._async_create_generic_collection(display_name, description, qualified_name,
+                                                           is_own_anchor=is_own_anchor, url_item="event-set-collection",
+                                                           classification_name="EventSetCollection",
+                                                           anchor_guid=anchor_guid, parent_guid=parent_guid,
+                                                           parent_relationship_type_name=parent_relationship_type_name,
+                                                           parent_at_end1=parent_at_end1,
+                                                           collection_type=collection_type,
+                                                           anchor_scope_guid=anchor_scope_guid,
+                                                           additional_properties=additional_properties,
+                                                           extended_properties=extended_properties)
 
         return resp
 
-    def create_event_set_collection(self, display_name: str, description: str, is_own_anchor: bool = True,
-                                    anchor_guid: str = None, parent_guid: str = None,
+    def create_event_set_collection(self, display_name: str, description: str, qualified_name: str = None,
+                                    is_own_anchor: bool = True, anchor_guid: str = None, parent_guid: str = None,
                                     parent_relationship_type_name: str = None, parent_at_end1: bool = True,
                                     collection_type: str = None, anchor_scope_guid: str = None,
-                                    collection_ordering: str = None, order_property_name: str = None,
+
                                     additional_properties: dict = None, extended_properties: dict = None) -> str:
         """ Create a new collection with the EventSet classification.  This is used to group event schemas together.
             For example, the collection may describe a set of events emitted by a specific system or to disseminate
@@ -2466,6 +2446,8 @@ class CollectionManager(Client):
             The display name of the element. Will also be used as the basis of the qualified_name.
         description: str
             A description of the collection.
+        qualified_name: str, optional, defaults to None
+            Allows user to specify a qualified name of the collection.
         is_own_anchor: bool, optional, defaults to True
             Indicates if the collection should be classified as its own anchor or not.
         anchor_guid: str
@@ -2483,11 +2465,6 @@ class CollectionManager(Client):
             Adds an user supplied valid value for the collection type.
         anchor_scope_guid: str, optional, defaults to None
             optional GUID of search scope
-        collection_ordering: str, optional, defaults to "OTHER"
-            Specifies the sequencing to use in a collection. Examples include "NAME", "OWNER", "DATE_CREATED",
-             "OTHER"
-        order_property_name: str, optional, defaults to "Something"
-            Property to use for sequencing if collection_ordering is "OTHER"
         additional_properties: dict, optional, defaults to None
             User specified Additional properties to add to the collection definition.
         extended_properties: dict, optional, defaults to None
@@ -2510,20 +2487,18 @@ class CollectionManager(Client):
         """
         loop = asyncio.get_event_loop()
         resp = loop.run_until_complete(
-            self._async_create_event_set_collection(display_name, description, is_own_anchor, anchor_guid, parent_guid,
-                                                    parent_relationship_type_name, parent_at_end1, collection_type,
-                                                    anchor_scope_guid, collection_ordering, order_property_name,
+            self._async_create_event_set_collection(display_name, description, qualified_name, is_own_anchor,
+                                                    anchor_guid, parent_guid, parent_relationship_type_name,
+                                                    parent_at_end1, collection_type, anchor_scope_guid,
                                                     additional_properties, extended_properties))
         return resp
 
     async def _async_create_naming_standard_ruleset_collection(self, display_name: str, description: str,
-                                                               is_own_anchor: bool = True, anchor_guid: str = None,
-                                                               parent_guid: str = None,
+                                                               qualified_name: str = None, is_own_anchor: bool = True,
+                                                               anchor_guid: str = None, parent_guid: str = None,
                                                                parent_relationship_type_name: str = None,
                                                                parent_at_end1: bool = True, collection_type: str = None,
                                                                anchor_scope_guid: str = None,
-                                                               collection_ordering: str = None,
-                                                               order_property_name: str = None,
                                                                additional_properties: dict = None,
                                                                extended_properties: dict = None) -> str:
         """ Create a new collection with the NamingStandardRuleSet classification.  This is used to group naming
@@ -2537,6 +2512,8 @@ class CollectionManager(Client):
             The display name of the element. Will also be used as the basis of the qualified_name.
         description: str
             A description of the collection.
+        qualified_name: str, optional, defaults to None
+            Allows user to specify a qualified name of the collection.
         is_own_anchor: bool, optional, defaults to True
             Indicates if the collection should be classified as its own anchor or not.
         anchor_guid: str
@@ -2554,11 +2531,6 @@ class CollectionManager(Client):
             Adds an user supplied valid value for the collection type.
         anchor_scope_guid: str, optional, defaults to None
             optional GUID of search scope
-        collection_ordering: str, optional, defaults to "OTHER"
-            Specifies the sequencing to use in a collection. Examples include "NAME", "OWNER", "DATE_CREATED",
-             "OTHER"
-        order_property_name: str, optional, defaults to "Something"
-            Property to use for sequencing if collection_ordering is "OTHER"
         additional_properties: dict, optional, defaults to None
             User specified Additional properties to add to the collection definition.
         extended_properties: dict, optional, defaults to None
@@ -2580,21 +2552,25 @@ class CollectionManager(Client):
 
         """
 
-        resp = await self._async_create_generic_collection(display_name, description, is_own_anchor,
-                                                           "naming-standard-rule-set-collection", anchor_guid,
-                                                           parent_guid, parent_relationship_type_name, parent_at_end1,
-                                                           collection_type, anchor_scope_guid, collection_ordering,
-                                                           order_property_name, additional_properties,
-                                                           extended_properties)
+        resp = await self._async_create_generic_collection(display_name, description, qualified_name,
+                                                           is_own_anchor=is_own_anchor,
+                                                           url_item="naming-standard-rule-set-collection",
+                                                           classification_name="NamingRulesCollection",
+                                                           anchor_guid=anchor_guid, parent_guid=parent_guid,
+                                                           parent_relationship_type_name=parent_relationship_type_name,
+                                                           parent_at_end1=parent_at_end1,
+                                                           collection_type=collection_type,
+                                                           anchor_scope_guid=anchor_scope_guid,
+                                                           additional_properties=additional_properties,
+                                                           extended_properties=extended_properties)
 
         return resp
 
-    def create_naming_standard_ruleset_collection(self, display_name: str, description: str, is_own_anchor: bool = True,
-                                                  anchor_guid: str = None, parent_guid: str = None,
-                                                  parent_relationship_type_name: str = None,
+    def create_naming_standard_ruleset_collection(self, display_name: str, description: str, qualified_name: str = None,
+                                                  is_own_anchor: bool = True, anchor_guid: str = None,
+                                                  parent_guid: str = None, parent_relationship_type_name: str = None,
                                                   parent_at_end1: bool = True, collection_type: str = None,
-                                                  anchor_scope_guid: str = None, collection_ordering: str = None,
-                                                  order_property_name: str = None, additional_properties: dict = None,
+                                                  anchor_scope_guid: str = None, additional_properties: dict = None,
                                                   extended_properties: dict = None) -> str:
         """ Create a new collection with the NamingStandardRuleSet classification.  This is used to group naming
         standard rule
@@ -2606,6 +2582,8 @@ class CollectionManager(Client):
             The display name of the element. Will also be used as the basis of the qualified_name.
         description: str
             A description of the collection.
+        qualified_name: str, optional, defaults to None
+            Allows user to specify a qualified name of the collection.
         is_own_anchor: bool, optional, defaults to True
             Indicates if the collection should be classified as its own anchor or not.
         anchor_guid: str
@@ -2623,11 +2601,6 @@ class CollectionManager(Client):
             Adds an user supplied valid value for the collection type.
         anchor_scope_guid: str, optional, defaults to None
             optional GUID of search scope
-        collection_ordering: str, optional, defaults to "OTHER"
-            Specifies the sequencing to use in a collection. Examples include "NAME", "OWNER", "DATE_CREATED",
-             "OTHER"
-        order_property_name: str, optional, defaults to "Something"
-            Property to use for sequencing if collection_ordering is "OTHER"
         additional_properties: dict, optional, defaults to None
             User specified Additional properties to add to the collection definition.
         extended_properties: dict, optional, defaults to None
@@ -2650,11 +2623,10 @@ class CollectionManager(Client):
         """
         loop = asyncio.get_event_loop()
         resp = loop.run_until_complete(
-            self._async_create_naming_standard_ruleset_collection(display_name, description, is_own_anchor, anchor_guid,
-                                                                  parent_guid, parent_relationship_type_name,
-                                                                  parent_at_end1, collection_type, anchor_scope_guid,
-                                                                  collection_ordering, order_property_name,
-                                                                  additional_properties, extended_properties))
+            self._async_create_naming_standard_ruleset_collection(display_name, description, qualified_name,
+                                                                  is_own_anchor, anchor_guid, parent_guid,
+                                                                  parent_relationship_type_name, parent_at_end1,
+                                                                  collection_type, anchor_scope_guid))
         return resp
 
     #
@@ -2780,9 +2752,9 @@ class CollectionManager(Client):
     #
     async def _async_update_collection(self, collection_guid: str, qualified_name: str = None, display_name: str = None,
                                        description: str = None, collection_type: str = None,
-                                       collection_ordering: str = None, order_property_name: str = None,
-                                       additional_properties: dict = None,
-                                       extended_properties: dict = None, replace_all_props: bool = False) -> None:
+
+                                       additional_properties: dict = None, extended_properties: dict = None,
+                                       replace_all_props: bool = False) -> None:
         """Update the properties of a collection.  Async version.
 
         Parameters
@@ -2797,11 +2769,6 @@ class CollectionManager(Client):
            A description of the collection.
         collection_type: str, optional, defaults to None
            Add appropriate valid value for the collection type.
-        collection_ordering: str, optional, defaults to None
-           Specifies the sequencing to use in a collection. Examples include "NAME", "OWNER",
-           "DATE_CREATED", "OTHER"
-        order_property_name: str, optional, defaults to None
-           Property to use for sequencing if collection_ordering is "OTHER"
         replace_all_props: bool, optional, defaults to False
             Whether to replace all properties in the collection.
         additional_properties: dict, optional, defaults to None
@@ -2831,17 +2798,16 @@ class CollectionManager(Client):
         body = {
             "class": "UpdateElementRequestBody", "properties": {
                 "class": "CollectionProperties", "qualifiedName": qualified_name, "name": display_name,
-                "description": description, "collectionType": collection_type, "collectionOrder": collection_ordering,
-                "orderByPropertyName": order_property_name, "additionalProperties": additional_properties,
-                "extendedProperties": extended_properties
+                "description": description, "collectionType": collection_type,
+                "additionalProperties": additional_properties, "extendedProperties": extended_properties
                 }
             }
         body_s = body_slimmer(body)
         await self._async_make_request("POST", url, body_s)
 
     def update_collection(self, collection_guid, qualified_name: str = None, display_name: str = None,
-                          description: str = None, collection_type: str = None, collection_ordering: str = None,
-                          order_property_name: str = None, additional_properties: dict = None, extended_properties: dict = None, replace_all_props: bool = False) -> None:
+                          description: str = None, collection_type: str = None, additional_properties: dict = None,
+                          extended_properties: dict = None, replace_all_props: bool = False) -> None:
         """Update the properties of a collection.
 
         Parameters
@@ -2856,11 +2822,6 @@ class CollectionManager(Client):
            A description of the collection.
         collection_type: str
            Add appropriate valid value for the collection type.
-        collection_ordering: str, optional, defaults to "OTHER"
-           Specifies the sequencing to use in a collection. Examples include "NAME", "OWNER",
-           "DATE_CREATED", "OTHER"
-        order_property_name: str, optional, defaults to "Something"
-           Property to use for sequencing if collection_ordering is "OTHER"
         replace_all_props: bool, optional, defaults to False
             Whether to replace all properties in the collection.
         additional_properties: dict, optional, defaults to None
@@ -2885,11 +2846,11 @@ class CollectionManager(Client):
         loop = asyncio.get_event_loop()
         loop.run_until_complete(
             self._async_update_collection(collection_guid, qualified_name, display_name, description, collection_type,
-                                          collection_ordering, order_property_name,
-                                          additional_properties, extended_properties, replace_all_props))
 
+                                          additional_properties, extended_properties, replace_all_props))
 
-    async def _async_update_collection_w_body(self, collection_guid: str, body: dict, replace_all_props: bool=False) -> None:
+    async def _async_update_collection_w_body(self, collection_guid: str, body: dict,
+                                              replace_all_props: bool = False) -> None:
         """Update the properties of a collection.  Async version.
 
         Parameters
@@ -2940,7 +2901,7 @@ class CollectionManager(Client):
         body_s = body_slimmer(body)
         await self._async_make_request("POST", url, body_s)
 
-    def update_collection_w_body(self, collection_guid: str, body:dict, replace_all_props: bool=False) -> None:
+    def update_collection_w_body(self, collection_guid: str, body: dict, replace_all_props: bool = False) -> None:
         """Update the properties of a collection.
 
         Parameters
@@ -2986,15 +2947,16 @@ class CollectionManager(Client):
 
         """
         loop = asyncio.get_event_loop()
-        loop.run_until_complete(
-            self._async_update_collection_w_body(collection_guid, body, replace_all_props))
-
+        loop.run_until_complete(self._async_update_collection_w_body(collection_guid, body, replace_all_props))
 
     #
     #   Digital Products
     #
     async def _async_create_digital_product(self, body: dict) -> str:
-        """Create a new collection that represents a digital product. Async version.
+        """ Create a new collection that represents a digital product. To set a lifecycle status
+            use a NewDigitalProductRequestBody which has a default status of DRAFT. Using a
+            NewElementRequestBody sets the status to ACTIVE.
+            Async version.
 
         Parameters
         ----------
@@ -3020,6 +2982,8 @@ class CollectionManager(Client):
         be valid dates if specified, otherwise you will get a 400 error response.
 
         JSON Structure looks like:
+
+        Without lifecycle status:
         {
           "class" : "NewElementRequestBody",
           "anchorGUID" : "anchor GUID, if set then isOwnAnchor=false",
@@ -3102,64 +3066,111 @@ class CollectionManager(Client):
         return resp.json().get("guid", "No GUID returned")
 
     def create_digital_product(self, body: dict) -> str:
-        """Create a new collection that represents a digital product. Async version.
-
-        Parameters
-        ----------
-        body: dict
-            A dict representing the details of the collection to create.
-
-        Returns
-        -------
-        str - the guid of the created collection
-
-        Raises
-        ------
-        InvalidParameterException
-          If the client passes incorrect parameters on the request - such as bad URLs or invalid values
-        PropertyServerException
-          Raised by the server when an issue arises in processing a valid request
-        NotAuthorizedException
-          The principle specified by the user_id does not have authorization for the requested action
+        """ Create a new collection that represents a digital product. To set a lifecycle status
+               use a NewDigitalProductRequestBody which has a default status of DRAFT. Using a
+               NewElementRequestBody sets the status to ACTIVE.
+
+           Parameters
+           ----------
+           body: dict
+               A dict representing the details of the collection to create.
+
+           Returns
+           -------
+           str - the guid of the created collection
+
+           Raises
+           ------
+           InvalidParameterException
+             If the client passes incorrect parameters on the request - such as bad URLs or invalid values
+           PropertyServerException
+             Raised by the server when an issue arises in processing a valid request
+           NotAuthorizedException
+             The principle specified by the user_id does not have authorization for the requested action
+
+           Notes
+           -----
+           Note: the three dates: introductionDate, nextVersionDate and withdrawDate must
+           be valid dates if specified, otherwise you will get a 400 error response.
+
+           JSON Structure looks like:
+
+           Without lifecycle status:
+           {
+             "class" : "NewElementRequestBody",
+             "anchorGUID" : "anchor GUID, if set then isOwnAnchor=false",
+             "isOwnAnchor" : false,
+             "parentGUID" : "parent GUID, if set, set all parameters beginning 'parent'",
+             "parentRelationshipTypeName" : "open metadata type name",
+             "parentAtEnd1": true,
+             "properties": {
+               "class" : "CollectionProperties",
+               "qualifiedName": "Must provide a unique name here",
+               "name" : "Add display name here",
+               "description" : "Add description of the collection here",
+               "collectionType": "Add appropriate valid value for type",
+               "collectionOrder" : "OTHER",
+               "orderByPropertyName" : "Add property name if 'collectionOrder' is OTHER"
+             },
+             "digitalProductProperties" : {
+               "class" : "DigitalProductProperties",
+               "productStatus" : "ACTIVE",
+               "productName" : "Add name here",
+               "productType" : "Add valid value here",
+               "description" : "Add description here",
+               "introductionDate" : "date",
+               "maturity" : "Add valid value here",
+               "serviceLife" : "Add the estimated lifetime of the product",
+               "currentVersion": "V1.0",
+               "nextVersion": "V1.1",
+               "withdrawDate": "date",
+               "additionalProperties": {
+                 "property1Name" : "property1Value",
+                 "property2Name" : "property2Value"
+               }
+             }
+           }
 
-        Notes
-        -----
-        JSON Structure looks like:
-        {
-          "class" : "NewElementRequestBody",
-          "anchorGUID" : "anchor GUID, if set then isOwnAnchor=false",
-          "isOwnAnchor" : false,
-          "parentGUID" : "parent GUID, if set, set all parameters beginning 'parent'",
-          "parentRelationshipTypeName" : "open metadata type name",
-          "parentAtEnd1": true,
-          "properties": {
-            "class" : "CollectionProperties",
-            "qualifiedName": "Must provide a unique name here",
-            "name" : "Add display name here",
-            "description" : "Add description of the collection here",
-            "collectionType": "Add appropriate valid value for type",
-            "collectionOrder" : "OTHER",
-            "orderByPropertyName" : "Add property name if 'collectionOrder' is OTHER"
-          },
-          "digitalProductProperties" : {
-            "class" : "DigitalProductProperties",
-            "productStatus" : "ACTIVE",
-            "productName" : "Add name here",
-            "productType" : "Add valid value here",
-            "description" : "Add description here",
-            "introductionDate" : "date",
-            "maturity" : "Add valid value here",
-            "serviceLife" : "Add the estimated lifetime of the product",
-            "currentVersion": "V1.0",
-            "nextVersion": "V1.1",
-            "withdrawDate": "date",
-            "additionalProperties": {
-              "property1Name" : "property1Value",
-              "property2Name" : "property2Value"
-            }
-          }
-        }
-        """
+           With a lifecycle, the body is:
+           {
+             "class" : "NewDigitalProductRequestBody",
+             "isOwnAnchor" : true,
+             "anchorScopeGUID" : "optional GUID of search scope",
+             "parentGUID" : "xxx",
+             "parentRelationshipTypeName" : "CollectionMembership",
+             "parentAtEnd1": true,
+             "properties": {
+               "class" : "DigitalProductProperties",
+               "qualifiedName": "DigitalProduct:Add product name here",
+               "userDefinedStatus" : "Optional value here - used when initial status is OTHER",
+               "name" : "Product display name",
+               "description" : "Add description of product and its expected usage here",
+               "identifier" : "Add product identifier here",
+               "productName" : "Add product name here",
+               "productType" : "Periodic Delta",
+               "maturity" : "Add valid value here",
+               "serviceLife" : "Add the estimated lifetime of the product",
+               "introductionDate" : "date",
+               "nextVersionDate": "date",
+               "withdrawDate": "date",
+               "currentVersion": "V0.1",
+               "additionalProperties": {
+                 "property1Name" : "property1Value",
+                 "property2Name" : "property2Value"
+               }
+             },
+             "initialStatus" : "DRAFT",
+             "externalSourceGUID": "add guid here",
+             "externalSourceName": "add qualified name here",
+             "effectiveTime" : "{{$isoTimestamp}}",
+             "forLineage" : false,
+             "forDuplicateProcessing" : false
+           }
+
+           The valid values for initialStatus are: DRAFT, PREPARED, PROPOSED, APPROVED, REJECTED, APPROVED_CONCEPT,
+           UNDER_DEVELOPMENT, DEVELOPMENT_COMPLETE, APPROVED_FOR_DEPLOYMENT, ACTIVE, DISABLED, DEPRECATED,
+           OTHER.  If using OTHER, set the userDefinedStatus with the status value you want.
+           """
         loop = asyncio.get_event_loop()
         resp = loop.run_until_complete(self._async_create_digital_product(body))
         return resp
@@ -3219,7 +3230,6 @@ class CollectionManager(Client):
 
         await self._async_make_request("POST", url, body)
 
-
     def update_digital_product(self, collection_guid: str, body: dict, replace_all_props: bool = False, ):
         """Update the properties of the DigitalProduct classification attached to a collection.
 
@@ -3270,7 +3280,6 @@ class CollectionManager(Client):
         loop = asyncio.get_event_loop()
         loop.run_until_complete(self._async_update_digital_product(collection_guid, body, replace_all_props))
 
-
     async def _async_update_digital_product_status(self, digital_prod_guid: str, body: dict):
         """Update the status of a DigitalProduct collection. Async version.
 
@@ -3308,12 +3317,13 @@ class CollectionManager(Client):
             }
         """
 
-        url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/collection-manager/collections/digital-products/"
-               f"{digital_prod_guid}/update=status")
+        url = (
+            f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/collection-manager/collections/digital"
+            f"-products/"
+            f"{digital_prod_guid}/update=status")
 
         await self._async_make_request("POST", url, body)
 
-
     def update_digital_product_status(self, digital_prod_guid: str, body: dict):
         """Update the status of a DigitalProduct collection. Async version.
 
@@ -3354,8 +3364,6 @@ class CollectionManager(Client):
         loop = asyncio.get_event_loop()
         loop.run_until_complete(self._async_update_digital_product_status(digital_prod_guid, body))
 
-
-
     async def _async_link_digital_product_dependency(self, upstream_digital_prod_guid: str,
                                                      downstream_digital_prod_guid: str, body: dict = None):
         """ Link two dependent digital products.  The linked elements are of type DigitalProduct.
@@ -3403,16 +3411,17 @@ class CollectionManager(Client):
         }
         """
 
-
-        url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/collection-manager/collections/digital-products/"
-               f"{upstream_digital_prod_guid}/product-dependencies/{downstream_digital_prod_guid}/attach")
+        url = (
+            f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/collection-manager/collections/digital"
+            f"-products/"
+            f"{upstream_digital_prod_guid}/product-dependencies/{downstream_digital_prod_guid}/attach")
         if body:
             await self._async_make_request("POST", url, body)
         else:
             await self._async_make_request("POST", url)
 
-
-    def link_digital_product_dependency(self, upstream_digital_prod_guid: str, downstream_digital_prod_guid: str, body: dict = None):
+    def link_digital_product_dependency(self, upstream_digital_prod_guid: str, downstream_digital_prod_guid: str,
+                                        body: dict = None):
         """ Link two dependent digital products.  The linked elements are of type DigitalProduct.
             Request body is optional.
 
@@ -3461,7 +3470,6 @@ class CollectionManager(Client):
         loop.run_until_complete(
             self._async_link_digital_product_dependency(upstream_digital_prod_guid, downstream_digital_prod_guid, body))
 
-
     async def _async_detach_digital_product_dependency(self, upstream_digital_prod_guid: str,
                                                        downstream_digital_prod_guid: str, body: dict = None):
         """ Unlink two dependent digital products.  The linked elements are of type DigitalProduct.
@@ -3502,14 +3510,15 @@ class CollectionManager(Client):
         }
         """
 
-        url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/collection-manager/collections/digital-products/"
-               f"{upstream_digital_prod_guid}/product-dependencies/{downstream_digital_prod_guid}/detach")
+        url = (
+            f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/collection-manager/collections/digital"
+            f"-products/"
+            f"{upstream_digital_prod_guid}/product-dependencies/{downstream_digital_prod_guid}/detach")
         if body:
             await self._async_make_request("POST", url, body)
         else:
             await self._async_make_request("POST", url)
 
-
     async def _async_link_product_manager(self, digital_prod_guid: str, digital_prod_manager_guid: str,
                                           body: dict = None) -> None:
         """ Attach a product manager to a digital product. Request body is optional.
@@ -3550,15 +3559,15 @@ class CollectionManager(Client):
         }
         """
 
-
-        url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/collection-manager/collections/digital-products/"
-               f"{digital_prod_guid}/product-managers/{digital_prod_manager_guid}/attach")
+        url = (
+            f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/collection-manager/collections/digital"
+            f"-products/"
+            f"{digital_prod_guid}/product-managers/{digital_prod_manager_guid}/attach")
         if body:
             await self._async_make_request("POST", url, body)
         else:
             await self._async_make_request("POST", url)
 
-
     def link_product_manager(self, digital_prod_guid: str, digital_prod_manager_guid: str, body: dict = None):
         """ Link a product manager to a digital product.
             Request body is optional.
@@ -3598,11 +3607,10 @@ class CollectionManager(Client):
             }
         """
         loop = asyncio.get_event_loop()
-        loop.run_until_complete(
-            self._async_link_product_manager(digital_prod_guid, digital_prod_manager_guid, body))
-
+        loop.run_until_complete(self._async_link_product_manager(digital_prod_guid, digital_prod_manager_guid, body))
 
-    async def _async_detach_product_manager(self, digital_prod_guid: str, digital_prod_manager_guid: str, body: dict = None):
+    async def _async_detach_product_manager(self, digital_prod_guid: str, digital_prod_manager_guid: str,
+                                            body: dict = None):
         """ Detach a product manager from a digital product. Request body is optional.
             Async version.
 
@@ -3641,14 +3649,15 @@ class CollectionManager(Client):
         }
         """
 
-        url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/collection-manager/collections/digital-products/"
-               f"{digital_prod_guid}/product-managers/{digital_prod_manager_guid}/detach")
+        url = (
+            f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/collection-manager/collections/digital"
+            f"-products/"
+            f"{digital_prod_guid}/product-managers/{digital_prod_manager_guid}/detach")
         if body:
             await self._async_make_request("POST", url, body)
         else:
             await self._async_make_request("POST", url)
 
-
     def detach_product_manager(self, digital_prod_guid: str, digital_prod_manager_guid: str, body: dict = None):
         """ Detach a product manager from a digital product. Request body is optional.
 
@@ -3687,9 +3696,7 @@ class CollectionManager(Client):
             }
         """
         loop = asyncio.get_event_loop()
-        loop.run_until_complete(
-            self._async_detach_product_manager(digital_prod_guid, digital_prod_manager_guid, body))
-
+        loop.run_until_complete(self._async_detach_product_manager(digital_prod_guid, digital_prod_manager_guid, body))
 
     #
     # Agreements
@@ -3775,7 +3782,8 @@ class CollectionManager(Client):
         }
 
 
-        The valid values for initialStatus are: DRAFT, PREPARED, PROPOSED, APPROVED, REJECTED, ACTIVE, DISABLED, DEPRECATED,
+        The valid values for initialStatus are: DRAFT, PREPARED, PROPOSED, APPROVED, REJECTED, ACTIVE, DISABLED,
+        DEPRECATED,
         OTHER.  If using OTHER, set the userDefinedStatus with the status value you want.
         """
 
@@ -3784,7 +3792,6 @@ class CollectionManager(Client):
         resp = await self._async_make_request("POST", url, body_slimmer(body))
         return resp.json().get("guid", "No GUID returned")
 
-
     def create_agreement(self, body: dict) -> str:
         """Create a new collection that represents am agreement. Async version.
 
@@ -3866,7 +3873,8 @@ class CollectionManager(Client):
         }
 
 
-        The valid values for initialStatus are: DRAFT, PREPARED, PROPOSED, APPROVED, REJECTED, ACTIVE, DISABLED, DEPRECATED,
+        The valid values for initialStatus are: DRAFT, PREPARED, PROPOSED, APPROVED, REJECTED, ACTIVE, DISABLED,
+        DEPRECATED,
         OTHER.  If using OTHER, set the userDefinedStatus with the status value you want.
         """
         loop = asyncio.get_event_loop()
@@ -3930,12 +3938,12 @@ class CollectionManager(Client):
         }
         """
 
-        url = f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/collection-manager/collections/data-sharing-agreement"
+        url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/collection-manager/collections/data"
+               f"-sharing-agreement")
 
         resp = await self._async_make_request("POST", url, body_slimmer(body))
         return resp.json().get("guid", "No GUID returned")
 
-
     def create_data_sharing_agreement(self, body: dict) -> str:
         """ Create a new collection with the DataSharingAgreement classification.  The collection is typically
             an agreement which may use the NewElementRequestBody, or the NewAgreementRequestBody if the
@@ -3996,7 +4004,6 @@ class CollectionManager(Client):
         resp = loop.run_until_complete(self._async_create_data_sharing_agreement(body))
         return resp
 
-
     async def _async_update_agreement(self, agreement_guid: str, body: dict, replace_all_props: bool = False, ):
         """Update the properties of the agreement collection. Async version.
 
@@ -4055,7 +4062,6 @@ class CollectionManager(Client):
 
         await self._async_make_request("POST", url, body)
 
-
     def update_agreement(self, agreement_guid: str, body: dict, replace_all_props: bool = False, ):
         """Update the properties of the DigitalProduct classification attached to a collection.
 
@@ -4110,7 +4116,6 @@ class CollectionManager(Client):
         loop = asyncio.get_event_loop()
         loop.run_until_complete(self._async_update_digital_product(agreement_guid, body, replace_all_props))
 
-
     async def _async_update_agreement_status(self, agreement_guid: str, body: dict):
         """Update the status of an agreement collection. Async version.
 
@@ -4148,12 +4153,13 @@ class CollectionManager(Client):
             }
         """
 
-        url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/collection-manager/collections/agreements/"
-               f"{agreement_guid}/update-status")
+        url = (
+            f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/collection-manager/collections"
+            f"/agreements/"
+            f"{agreement_guid}/update-status")
 
         await self._async_make_request("POST", url, body)
 
-
     def update_agreement_status(self, agreement_guid: str, body: dict):
         """Update the status of an agreement collection. Async version.
 
@@ -4194,10 +4200,7 @@ class CollectionManager(Client):
         loop = asyncio.get_event_loop()
         loop.run_until_complete(self._async_update_agreement_status(agreement_guid, body))
 
-
-
-    async def _async_link_agreement_actor(self, agreement_guid: str,
-                                                     actor_guid: str, body: dict = None):
+    async def _async_link_agreement_actor(self, agreement_guid: str, actor_guid: str, body: dict = 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.
@@ -4243,15 +4246,15 @@ class CollectionManager(Client):
         }
         """
 
-
-        url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/collection-manager/collections/agreements/"
-               f"{agreement_guid}/agreement-actors/{actor_guid}/attach")
+        url = (
+            f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/collection-manager/collections"
+            f"/agreements/"
+            f"{agreement_guid}/agreement-actors/{actor_guid}/attach")
         if body:
             await self._async_make_request("POST", url, body)
         else:
             await self._async_make_request("POST", url)
 
-
     def link_agreement_actor(self, agreement_guid: str, actor_guid: str, body: dict = 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.
@@ -4298,12 +4301,9 @@ class CollectionManager(Client):
         }
         """
         loop = asyncio.get_event_loop()
-        loop.run_until_complete(
-            self._async_link_agreement_actor(agreement_guid, actor_guid, body))
+        loop.run_until_complete(self._async_link_agreement_actor(agreement_guid, actor_guid, body))
 
-
-    async def _async_detach_agreement_actor(self, agreement_guid: str,
-                                                       actor_guid: str, body: dict = None):
+    async def _async_detach_agreement_actor(self, agreement_guid: str, actor_guid: str, body: dict = None):
         """ Unlink an actor from an agreement. Request body is optional. Async version.
 
         Parameters
@@ -4341,14 +4341,15 @@ class CollectionManager(Client):
         }
         """
 
-        url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/collection-manager/collections/agreements/"
-               f"{agreement_guid}/agreement-actors/{actor_guid}/detach")
+        url = (
+            f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/collection-manager/collections"
+            f"/agreements/"
+            f"{agreement_guid}/agreement-actors/{actor_guid}/detach")
         if body:
             await self._async_make_request("POST", url, body)
         else:
             await self._async_make_request("POST", url)
 
-
     def detach_agreement_actor(self, agreement_guid: str, actor_guid: str, body: dict = None):
         """ Unlink an actor from an agreement. Request body is optional.
 
@@ -4387,12 +4388,10 @@ class CollectionManager(Client):
         }
         """
         loop = asyncio.get_event_loop()
-        loop.run_until_complete(
-            self._async_detach_agreement_actor(agreement_guid, actor_guid, body))
-
-
+        loop.run_until_complete(self._async_detach_agreement_actor(agreement_guid, actor_guid, body))
 
-    async def _async_link_agreement_item(self, agreement_guid: str, agreement_item_guid: str, body: dict=None ) -> None:
+    async def _async_link_agreement_item(self, agreement_guid: str, agreement_item_guid: str,
+                                         body: dict = None) -> None:
         """ Attach an agreement to an element referenced in its definition. The agreement item element is of type
            'Referenceable' to allow the agreement to refer to many things. Request body is optional. Async version.
 
@@ -4460,9 +4459,7 @@ class CollectionManager(Client):
         else:
             await self._async_make_request("POST", url)
 
-
-
-    def link_agreement_item(self, agreement_guid: str, agreement_item_guid: str, body: dict = None ) -> None:
+    def link_agreement_item(self, agreement_guid: str, agreement_item_guid: str, body: dict = None) -> None:
         """ Attach an agreement to an element referenced in its definition. The agreement item element is of type
                   'Referenceable' to allow the agreement to refer to many things. Request body is optional.
 
@@ -4522,11 +4519,10 @@ class CollectionManager(Client):
 
                """
         loop = asyncio.get_event_loop()
-        loop.run_until_complete(
-            self._async_link_agreement_item(agreement_guid, agreement_item_guid, body ))
-
+        loop.run_until_complete(self._async_link_agreement_item(agreement_guid, agreement_item_guid, body))
 
-    async def _async_detach_agreement_item(self, agreement_guid: str, agreement_item_guid: str, body: dict = None) -> None:
+    async def _async_detach_agreement_item(self, agreement_guid: str, agreement_item_guid: str,
+                                           body: dict = None) -> None:
         """Detach an agreement item from an agreement. Request body is optional. Async version.
 
         Parameters
@@ -4564,16 +4560,16 @@ class CollectionManager(Client):
 
         """
 
-        url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/collection-manager/collections/agreements"
-               f"{agreement_guid}/agreement-items/{agreement_item_guid}/detach")
+        url = (
+            f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/collection-manager/collections"
+            f"/agreements"
+            f"{agreement_guid}/agreement-items/{agreement_item_guid}/detach")
 
         if body:
             await self._async_make_request("POST", url, body)
         else:
             await self._async_make_request("POST", url)
 
-
-
     def detach_agreement_item(self, agreement_guid: str, agreement_item_guid: str, body: dict = None) -> None:
         """Detach an agreement item from an agreement. Request body is optional. Async version.
 
@@ -4614,9 +4610,7 @@ class CollectionManager(Client):
         loop = asyncio.get_event_loop()
         loop.run_until_complete(self._async_detach_agreement_item(agreement_guid, agreement_item_guid, body))
 
-
-    async def _async_link_contract(self, agreement_guid: str, external_ref_guid: str,
-                                         body: dict = None) -> None:
+    async def _async_link_contract(self, agreement_guid: str, external_ref_guid: str, body: dict = None) -> None:
         """ Attach an agreement to an external reference element that describes the location of the contract documents.
             Request body is optional. Async version.
 
@@ -4673,8 +4667,6 @@ class CollectionManager(Client):
         else:
             await self._async_make_request("POST", url)
 
-
-
     def link_contract(self, agreement_guid: str, external_ref_guid: str, body: dict = None) -> None:
         """ Attach an agreement to an external reference element that describes the location of the contract documents.
             Request body is optional.
@@ -4724,12 +4716,9 @@ class CollectionManager(Client):
 
         """
         loop = asyncio.get_event_loop()
-        loop.run_until_complete(
-            self._async_link_contract(agreement_guid, external_ref_guid, body))
-
+        loop.run_until_complete(self._async_link_contract(agreement_guid, external_ref_guid, body))
 
-    async def _async_detach_contract(self, agreement_guid: str, external_ref_guid: str,
-                                           body: dict = None) -> None:
+    async def _async_detach_contract(self, agreement_guid: str, external_ref_guid: str, body: dict = None) -> None:
         """Detach an external reference to a contract, from an agreement. Request body is optional. Async version.
 
         Parameters
@@ -4768,7 +4757,8 @@ class CollectionManager(Client):
         """
 
         url = (
-            f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/collection-manager/collections/agreements"
+            f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/collection-manager/collections"
+            f"/agreements"
             f"{agreement_guid}/contract-links/{external_ref_guid}/detach")
 
         if body:
@@ -4776,8 +4766,6 @@ class CollectionManager(Client):
         else:
             await self._async_make_request("POST", url)
 
-
-
     def detach_contract(self, agreement_guid: str, external_ref_guid: str, body: dict = None) -> None:
         """Detach an external reference to a contract, from an agreement. Request body is optional.
 
@@ -4818,7 +4806,6 @@ class CollectionManager(Client):
         loop = asyncio.get_event_loop()
         loop.run_until_complete(self._async_detach_contract(agreement_guid, external_ref_guid, body))
 
-
     #
     # Digital Subscriptions
     #
@@ -4927,7 +4914,6 @@ class CollectionManager(Client):
         resp = await self._async_make_request("POST", url, body_slimmer(body))
         return resp.json().get("guid", "No GUID returned")
 
-
     def create_digital_subscription(self, body: dict) -> str:
         """Create a new collection that represents a type of agreement called a digital_subscription.
 
@@ -4999,8 +4985,8 @@ class CollectionManager(Client):
         resp = loop.run_until_complete(self._async_create_digital_subscription(body))
         return resp
 
-
-    async def _async_update_digital_subscription(self, digital_subscription_guid: str, body: dict, replace_all_props: bool = False, ):
+    async def _async_update_digital_subscription(self, digital_subscription_guid: str, body: dict,
+                                                 replace_all_props: bool = False, ):
         """Update the properties of the digital_subscription collection. Async version.
 
         Parameters
@@ -5062,8 +5048,8 @@ class CollectionManager(Client):
 
         await self._async_make_request("POST", url, body)
 
-
-    def update_digital_subscription(self, digital_subscription_guid: str, body: dict, replace_all_props: bool = False, ):
+    def update_digital_subscription(self, digital_subscription_guid: str, body: dict,
+                                    replace_all_props: bool = False, ):
         """Update the properties of the DigitalProduct classification attached to a collection.
 
         Parameters
@@ -5115,8 +5101,8 @@ class CollectionManager(Client):
 
         """
         loop = asyncio.get_event_loop()
-        loop.run_until_complete(self._async_update_digital_subscription(digital_subscription_guid, body, replace_all_props))
-
+        loop.run_until_complete(
+            self._async_update_digital_subscription(digital_subscription_guid, body, replace_all_props))
 
     async def _async_update_digital_subscription_status(self, digital_subscription_guid: str, body: dict):
         """Update the status of an digital_subscription collection. Async version.
@@ -5155,12 +5141,13 @@ class CollectionManager(Client):
             }
         """
 
-        url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/collection-manager/collections/agreements/"
-               f"{digital_subscription_guid}/update-status")
+        url = (
+            f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/collection-manager/collections"
+            f"/agreements/"
+            f"{digital_subscription_guid}/update-status")
 
         await self._async_make_request("POST", url, body)
 
-
     def update_digital_digital_subscription_status(self, digital_subscription_guid: str, body: dict):
         """Update the status of an digital_subscription collection. Async version.
 
@@ -5201,12 +5188,10 @@ class CollectionManager(Client):
         loop = asyncio.get_event_loop()
         loop.run_until_complete(self._async_update_digital_subscription_status(digital_subscription_guid, body))
 
-
-
-    async def _async_link_subscriber(self, subscriber_guid: str,
-                                                     subscription_guid: str, body: dict = None):
+    async def _async_link_subscriber(self, subscriber_guid: str, subscription_guid: str, body: dict = 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.
+            products, team or business capabilities to be the subscriber. The subscription is an element of type
+            DigitalSubscription.
             Async version.
 
         Parameters
@@ -5250,18 +5235,19 @@ class CollectionManager(Client):
         }
         """
 
-
-        url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/collection-manager/collections/subscribers/"
-               f"{subscriber_guid}/subscriptions/{subscription_guid}/attach")
+        url = (
+            f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/collection-manager/collections"
+            f"/subscribers/"
+            f"{subscriber_guid}/subscriptions/{subscription_guid}/attach")
         if body:
             await self._async_make_request("POST", url, body)
         else:
             await self._async_make_request("POST", url)
 
-
     def link_subscriber(self, subscriber_guid: str, subscription_guid: str, body: dict = 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.
+            products, team or business capabilities to be the subscriber. The subscription is an element of type
+            DigitalSubscription.
             Async version.
 
         Parameters
@@ -5305,12 +5291,9 @@ class CollectionManager(Client):
         }
         """
         loop = asyncio.get_event_loop()
-        loop.run_until_complete(
-            self._async_link_subscriber(subscriber_guid, subscription_guid, body))
-
+        loop.run_until_complete(self._async_link_subscriber(subscriber_guid, subscription_guid, body))
 
-    async def _async_detach_subscriber(self, subscriber_guid: str,
-                                                       subscription_guid: str, body: dict = None):
+    async def _async_detach_subscriber(self, subscriber_guid: str, subscription_guid: str, body: dict = None):
         """ Detach a subscriber from a subscription Request body is optional. Async version.
 
         Parameters
@@ -5348,14 +5331,15 @@ class CollectionManager(Client):
         }
         """
 
-        url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/collection-manager/collections/agreements/"
-               f"{subscriber_guid}/agreement-actors/{subscription_guid}/detach")
+        url = (
+            f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/collection-manager/collections"
+            f"/agreements/"
+            f"{subscriber_guid}/agreement-actors/{subscription_guid}/detach")
         if body:
             await self._async_make_request("POST", url, body)
         else:
             await self._async_make_request("POST", url)
 
-
     def detach_subscriber(self, subscriber_guid: str, subscription_guid: str, body: dict = None):
         """ Detach a subscriber from a subscription. Request body is optional.
 
@@ -5394,18 +5378,13 @@ class CollectionManager(Client):
         }
         """
         loop = asyncio.get_event_loop()
-        loop.run_until_complete(
-            self._async_detach_subscriber(subscriber_guid, subscription_guid, body))
-
-
-
+        loop.run_until_complete(self._async_detach_subscriber(subscriber_guid, subscription_guid, body))
 
     #
     #
     #
 
-    async def _async_attach_collection(self, parent_guid: str,
-                                                     collection_guid: str, body: dict = None):
+    async def _async_attach_collection(self, parent_guid: str, collection_guid: str, body: dict = None, make_anchor: bool = False):
         """ Connect an existing collection to an element using the ResourceList relationship (0019).
             Async version.
 
@@ -5417,6 +5396,8 @@ class CollectionManager(Client):
             The identifier of the collection being attached.
         body: dict, optional, default = None
             A dict representing the details of the relationship.
+        make_anchor: bool, optional, default = False
+            Indicates if the collection should be anchored to the element.
 
         Returns
         -------
@@ -5456,15 +5437,14 @@ class CollectionManager(Client):
 
         """
 
-
         url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/collection-manager/metadata-elements/"
-               f"{parent_guid}/collections/{collection_guid}/attach")
+               f"{parent_guid}/collections/{collection_guid}/attach?makeAchor={make_anchor}")
         if body:
             await self._async_make_request("POST", url, body)
         else:
             await self._async_make_request("POST", url)
 
-    def attach_collection(self, parent_guid: str, collection_guid: str, body: dict = None):
+    def attach_collection(self, parent_guid: str, collection_guid: str, body: dict = None, make_anchor: bool = False):
         """ Connect an existing collection to an element using the ResourceList relationship (0019).
 
             Parameters
@@ -5475,6 +5455,8 @@ class CollectionManager(Client):
                 The identifier of the collection being attached.
             body: dict, optional, default = None
                 A dict representing the details of the relationship.
+            make_anchor: bool, optional, default = False
+                Indicates if the collection should be anchored to the element.
 
             Returns
             -------
@@ -5513,11 +5495,9 @@ class CollectionManager(Client):
             }
             """
         loop = asyncio.get_event_loop()
-        loop.run_until_complete(
-            self._async_attach_collection(parent_guid, collection_guid, body))
+        loop.run_until_complete(self._async_attach_collection(parent_guid, collection_guid, body, make_anchor))
 
-    async def _async_detach_collection(self, parent_guid: str,
-                                                       collection_guid: str, body: dict = None):
+    async def _async_detach_collection(self, parent_guid: str, collection_guid: str, body: dict = None):
         """ Detach an existing collection from an element. If the collection is anchored to the element, it is delete.
             Async version.
 
@@ -5530,6 +5510,7 @@ class CollectionManager(Client):
         body: dict, optional, default = None
             A dict representing the details of the relationship.
 
+
         Returns
         -------
         Nothing
@@ -5601,8 +5582,7 @@ class CollectionManager(Client):
           }
           """
         loop = asyncio.get_event_loop()
-        loop.run_until_complete(
-            self._async_detach_collection(parent_guid, collection_guid, body))
+        loop.run_until_complete(self._async_detach_collection(parent_guid, collection_guid, body))
 
     async def _async_delete_collection(self, collection_guid: str, body: dict = None, cascade: bool = False) -> None:
         """Delete a collection.  It is detected from all parent elements.  If members are anchored to the collection
@@ -5699,7 +5679,6 @@ class CollectionManager(Client):
         loop = asyncio.get_event_loop()
         loop.run_until_complete(self._async_delete_collection(collection_guid, body, cascade))
 
-
     async def _async_add_to_collection(self, collection_guid: str, element_guid: str, body: dict = None, ) -> None:
         """Add an element to a collection.  The request body is optional. Async version.
 
@@ -5948,7 +5927,7 @@ class CollectionManager(Client):
         loop.run_until_complete(
             self._async_update_collection_membership(collection_guid, element_guid, body, replace_all_props))
 
-    async def _async_remove_from_collection(self, collection_guid: str, element_guid: str, body:dict = None) -> None:
+    async def _async_remove_from_collection(self, collection_guid: str, element_guid: str, body: dict = None) -> None:
         """Remove an element from a collection. Async version.
 
         Parameters
@@ -5993,7 +5972,6 @@ class CollectionManager(Client):
             body = {"class": "NullRequestBody"}
         await self._async_make_request("POST", url, body)
 
-
     def remove_from_collection(self, collection_guid: str, element_guid: str, body: dict = None) -> None:
         """Remove an element from a collection. Async version.
 
@@ -6035,7 +6013,6 @@ class CollectionManager(Client):
         loop = asyncio.get_event_loop()
         loop.run_until_complete(self._async_remove_from_collection(collection_guid, element_guid, body))
 
-
     #
     #
     #
@@ -6141,6 +6118,7 @@ class CollectionManager(Client):
         for classification in classifications:
             classification_names += f"{classification['classificationName']}, "
         classification_names = classification_names[:-2]
+        mermaid = element.get('mermaidGraph', "") or ""
 
         member_names = ""
         members = self.get_member_list(collection_guid=guid)
@@ -6151,8 +6129,9 @@ class CollectionManager(Client):
 
         return {
             'GUID': guid, 'display_name': display_name, 'qualified_name': qualified_name, 'description': description,
-            'classifications': classification_names, 'collection_type': collection_type, 'members': member_names, 'properties': properties,
-            'additional_properties': additional_properties, 'extended_properties': extended_properties,
+            'classifications': classification_names, 'collection_type': collection_type, 'members': member_names,
+            'properties': properties, 'additional_properties': additional_properties,
+            'extended_properties': extended_properties, 'mermaid': mermaid
             }
 
     def generate_basic_structured_output(self, elements, filter, output_format: str = 'DICT',
@@ -6163,7 +6142,7 @@ class CollectionManager(Client):
         Args:
             elements: Dictionary or list of dictionaries containing element data
             filter: The search string used to find the elements
-            output_format: The desired output format (MD, FORM, REPORT, LIST, DICT, MERMAID)
+            output_format: The desired output format (MD, FORM, REPORT, LIST, DICT, MERMAID, HTML)
 
         Returns:
             Formatted output as string or list of dictionaries
@@ -6173,6 +6152,19 @@ class CollectionManager(Client):
             return extract_mermaid_only(elements)
         elif output_format == "DICT":
             return extract_basic_dict(elements)
+        elif output_format == "HTML":
+            if collection_type is None:
+                entity_type = "Collection"
+            else:
+                entity_type = collection_type
+
+            return generate_output(
+                elements=elements, 
+                search_string=filter, 
+                entity_type=entity_type,
+                output_format="HTML",
+                extract_properties_func=self._extract_collection_properties
+            )
 
         # For other formats (MD, FORM, REPORT, LIST), use generate_output
         elif output_format in ["MD", "FORM", "REPORT", "LIST"]:
@@ -6192,7 +6184,6 @@ class CollectionManager(Client):
                                    extract_properties_func=self._extract_collection_properties,
                                    columns=columns if output_format == 'LIST' else None)
 
-
     def generate_collection_output(self, elements, filter, classification_name, output_format) -> str | list:
         """
         Generate output for collections in the specified format.
@@ -6202,7 +6193,7 @@ class CollectionManager(Client):
             classification_name: str
                 The type of collection.
             filter: The search string used to find the elements
-            output_format: The desired output format (MD, FORM, REPORT, LIST, DICT, MERMAID)
+            output_format: The desired output format (MD, FORM, REPORT, LIST, DICT, MERMAID, HTML)
 
         Returns:
             Formatted output as a string or list of dictionaries
@@ -6212,10 +6203,20 @@ class CollectionManager(Client):
         else:
             entity_type = classification_name
 
-        if output_format in ["MD", "FORM", "REPORT", "LIST", "DICT", "MERMAID"]:
+        if output_format == "HTML":
+            return generate_output(
+                elements=elements, 
+                search_string=filter, 
+                entity_type=entity_type,
+                output_format="HTML",
+                extract_properties_func=self._extract_collection_properties
+            )
+
+        elif output_format in ["MD", "FORM", "REPORT", "LIST", "DICT", "MERMAID"]:
             # Define columns for LIST format
             columns = [{'name': 'Name', 'key': 'display_name'},
                        {'name': 'Qualified Name', 'key': 'qualified_name', 'format': True},
+                       {'name': 'Collection Type', 'key': 'collection_type'},
                        {'name': 'Description', 'key': 'description', 'format': True},
                        {'name': "Classifications", 'key': 'classifications'},
                        {'name': 'Members', 'key': 'members', 'format': True}, ]
@@ -6227,49 +6228,6 @@ class CollectionManager(Client):
         else:
             return self.generate_basic_structured_output(elements, filter, output_format)
 
-    # def generate_collection_output(self, elements, filter, collection_type: str, output_format,
-    #  # output_profile: str = "CORE") -> str | list | dict:  #     """  #     Generate output in the specified
-    #  format  # for the given elements.  #  #     Args:  #         elements: Dictionary or list of dictionaries
-    #  containing  # element data  #         filter: The search string used to find the elements  #
-    #  output_format: The  # desired output format (MD, FORM, REPORT, LIST, DICT, MERMAID, JSON)  #
-    #  output_profile: str, optional,  # default = "CORE"  #             The desired output profile - BASIC, CORE,
-    #  FULL  #     Returns:  #  # Formatted output as string or list of dictionaries  #     """  #     if
-    #  collection_type is None:  #  # entity_type = "Collection"  #     else:  #         entity_type =
-    #  collection_type  #  #     # For LIST and DICT  # formats, get member information  #  #     if output_format in
-    #  ["LIST", "DICT"]:  #         # Get the collection  # GUID  #         collection_guid = None  #         if
-    #  isinstance(elements, dict):  #             collection_guid  # = elements.get('elementHeader', {}).get('guid')
-    #         elif isinstance(elements, list) and len(elements) >  # 0:  #             collection_guid = elements[
-    #         0].get('elementHeader', {}).get('guid')  #  #         # Get member  # list if we have a valid
-    #         collection GUID  #         members = []  #         if collection_guid:  #  # members =
-    #         self.get_member_list(collection_guid=collection_guid)  #             if isinstance(members,
-    # str):  # "No members found" case  #                 members = []  #  #         # For DICT format, include all
-    # member information in the result  #         if output_format == "DICT":  #             result =  #
-    # self.generate_basic_structured_output(elements, filter, output_format, collection_type)  #             if  #
-    # isinstance(result, list):  #                 for item in result:  #                     item['members'] =  #
-    # members  #                 return result  #             elif isinstance(result, dict):  #  # result['members']
-    # = members  #                 return result  #  #         # For LIST format, add a column with  # bulleted list
-    # of qualified names  #         elif output_format == "LIST":  #             # Define columns for  # LIST format,
-    # including the new Members column  #             columns = [{'name': 'Collection Name',
-    # 'key': 'display_name'},  #                 {'name': 'Qualified Name', 'key': 'qualified_name'},  #  # {'name':
-    # 'Collection Type', 'key': 'collection_type'},  #                 {'name': 'Description',
-    # 'key': 'description', 'format': True},  #                 {'name': 'Classifications',
-    # 'key': 'classifications'},  #                 {'name': 'Members', 'key': 'members', 'format': True}]  #  #  #
-    # Create a function to add member information to the properties  #             def get_additional_props(element,
-    # guid, output_format):  #                 if not members:  #                     return {'members': ''}  #  #  #
-    # Create a comma-separated list of qualified names (no newlines to avoid table formatting issues)  #  #
-    # member_list = ", ".join([member.get('qualifiedName', '') for member in members])  #                 return {  #
-    # 'members': member_list}  #  #             # Generate output with the additional properties  #  #  # return
-    # generate_output(elements=elements, search_string=filter, entity_type=entity_type,
-    #  # output_format=output_format, extract_properties_func=self._extract_collection_properties,
-    #  # get_additional_props_func=get_additional_props, columns=columns)  #  #     # For FORM, REPORT, JSON formats,
-    # keep behavior unchanged  #     return self.generate_basic_structured_output(elements, filter, output_format,
-    # collection_type)
-
-    # def generate_data_class_output(self, elements, filter, output_format) -> str | list:  #     return  #  #
-    # self.generate_basic_structured_output(elements, filter, output_format)  #  # def generate_data_field_output(  #
-    # self, elements, filter, output_format) -> str | list:  #     return self.generate_basic_structured_output(  #
-    # elements, filter, output_format)
-
 
 if __name__ == "__main__":
     print("Main-Collection Manager")