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

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

@@ -10,30 +10,28 @@ import asyncio
 import os
 import sys
 from typing import Annotated, Literal, Union
-from typing import Dict, List
+from typing import Dict, List, Optional
 
 from loguru import logger
 from pydantic import Field
 
-from pyegeria._client_new import Client2
-from pyegeria.output_formatter import (
+from pyegeria.core._server_client import ServerClient
+from pyegeria.view.base_report_formats import select_report_spec, get_report_spec_match
+from pyegeria.view.output_formatter import (
     extract_mermaid_only,
     generate_output,
-    _extract_referenceable_properties,
-    populate_columns_from_properties,
-    get_required_relationships,
+    populate_common_columns,
 )
-from pyegeria._output_formats import select_output_format_set, get_output_format_type_match
 
 sys.path.insert(0, os.path.abspath(os.path.dirname(__file__)))
-from pyegeria._exceptions_new import PyegeriaInvalidParameterException
-from pyegeria._globals import NO_GUID_RETURNED
-from pyegeria.config import settings as app_settings
-from pyegeria.models import (SearchStringRequestBody, FilterRequestBody, NewElementRequestBody,
+from pyegeria.core._exceptions import PyegeriaInvalidParameterException
+from pyegeria.core._globals import NO_GUID_RETURNED
+from pyegeria.core.config import settings as app_settings
+from pyegeria.models import (GetRequestBody, SearchStringRequestBody, FilterRequestBody, NewElementRequestBody,
                              ReferenceableProperties, TemplateRequestBody,
-                             UpdateElementRequestBody, UpdateStatusRequestBody, NewRelationshipRequestBody,
-                             DeleteRequestBody)
-from pyegeria.utils import dynamic_catch
+                             UpdateElementRequestBody, NewRelationshipRequestBody,
+                             DeleteElementRequestBody, DeleteRelationshipRequestBody)
+from pyegeria.core.utils import dynamic_catch
 
 GOV_DEF_PROPERTIES_LIST = ["GovernanceDefinitionProperties", "GovernanceStrategyProperties", "RegulationProperties",
                            "GovernanceControlProperties", "SecurityGroupProperties", "NamingStandardRuleProperties",
@@ -71,53 +69,62 @@ class GovernanceDefinitionProperties(ReferenceableProperties):
     userDefinedStatus: str | None = None
 
 
-class GovernanceOfficer(Client2):
-    """GovernanceOfficer is a class that extends the Client class. The Governance Officer OMVS provides APIs for
-      defining and managing governance definitions.
-
-    Attributes:
-
-        view_server: str
-            The name of the View Server to connect to.
-        platform_url : str
-            URL of the server platform to connect to
-        user_id : str
-            The identity of the user calling the method - this sets a
-            default optionally used by the methods when the user
-            doesn't pass the user_id on a method call.
-        user_pwd: str
-            The password associated with the user_id. Defaults to None
-
-
+class GovernanceOfficer(ServerClient):
+    """
+    Client for the Governance Officer View Service.
+
+    The Governance Officer View Service provides methods to manage governance
+    definitions, peer definitions, and governance results.
+
+    Attributes
+    ----------
+    view_server : str
+        The name of the View Server to use.
+    platform_url : str
+        URL of the server platform to connect to.
+    user_id : str
+        The identity of the user calling the method.
+    user_pwd : str
+        The password associated with the user_id. Defaults to None.
     """
 
-    def __init__(self, view_server: str, platform_url: str, user_id: str = None, user_pwd: str = None,
-                 token: str = None, ):
+    def __init__(self, view_server: str, platform_url: str, user_id: Optional[str] = None, user_pwd: Optional[str] = None,
+                 token: Optional[str] = None, ):
         self.view_server = view_server
         self.platform_url = platform_url
         self.user_id = user_id
         self.user_pwd = user_pwd
 
-        Client2.__init__(self, view_server, platform_url, user_id=user_id, user_pwd=user_pwd, token=token)
+        ServerClient.__init__(self, view_server, platform_url, user_id=user_id, user_pwd=user_pwd, token=token)
         self.url_marker = "governance-officer"
 
     #
     # Extract properties functions
     #
-    def _generate_governance_definition_output(self, elements: list | dict, search_string: str, element_type_name: str = None,
-                                               output_format: str = 'DICT', output_format_set: dict | str = None
+    def _generate_governance_definition_output(self, elements: list | dict, search_string: str, element_type_name: Optional[str] = None,
+                                               output_format: str = 'DICT', report_spec: dict | str = None
                                                ) -> str | list:
         """
-        Generate output for governance definitions in the specified format, using output format sets.
+        Render governance definitions using the shared output pipeline.
 
-        Args:
-            elements: Dictionary or list of dictionaries containing governance definition elements
-            search_string: The search string used to find the elements
-            output_format: The desired output format (MD, FORM, REPORT, LIST, DICT, MERMAID, HTML)
-            output_format_set: Optional format set name or structure to control columns
+        Parameters
+        ----------
+        elements : dict | list[dict]
+            Element(s) returned by the OMVS.
+        search_string : str
+            The search string used to retrieve these elements (shown in preamble for some formats).
+        element_type_name : str, optional
+            Friendly type label to display (defaults to "Governance Definition").
+        output_format : str
+            One of: MD, FORM, REPORT, LIST, DICT, MERMAID, HTML.
+        report_spec : dict | str, optional
+            Either a label for a format set or a concrete format-set dict. When omitted, a sensible
+            default for Governance Definitions is chosen, falling back to "Default".
 
-        Returns:
-            Formatted output as string or list of dictionaries
+        Returns
+        -------
+        str | list
+            Rendered output in the requested format.
         """
         # Ensure elements handled consistently for MERMAID
         if output_format == "MERMAID":
@@ -125,18 +132,18 @@ class GovernanceOfficer(Client2):
 
         entity_type = element_type_name if element_type_name else "Governance Definition"
         # Resolve columns_struct via output format sets
-        if output_format_set:
-            if isinstance(output_format_set, str):
-                output_formats = select_output_format_set(output_format_set, output_format)
-            elif isinstance(output_format_set, dict):
-                output_formats = get_output_format_type_match(output_format_set, output_format)
+        if report_spec:
+            if isinstance(report_spec, str):
+                output_formats = select_report_spec(report_spec, output_format)
+            elif isinstance(report_spec, dict):
+                output_formats = get_report_spec_match(report_spec, output_format)
             else:
                 output_formats = None
         else:
             # Default to the Governance Definitions format set
-            output_formats = select_output_format_set("Governance Definitions", output_format)
+            output_formats = select_report_spec("Governance Definitions", output_format)
         if output_formats is None:
-            output_formats = select_output_format_set("Default", output_format)
+            output_formats = select_report_spec("Default", output_format)
 
         logger.trace(f"Executing generate_governance_definition_output: {output_formats}")
         return generate_output(
@@ -167,27 +174,13 @@ class GovernanceOfficer(Client2):
         Returns:
             dict: columns_struct with populated 'value' fields
         """
-        col_data = populate_columns_from_properties(element, columns_struct)
-        columns_list = col_data.get('formats', {}).get('columns', [])
-
-        # Header-derived values (GUID, type_name, etc.)
-        header_props = _extract_referenceable_properties(element)
-        for column in columns_list:
-            key = column.get('key')
-            if key in header_props:
-                column['value'] = header_props.get(key)
-            elif isinstance(key, str) and key.lower() == 'guid':
-                column['value'] = header_props.get('GUID')
-
-        # Populate requested relationship-based columns generically
-        col_data = get_required_relationships(element, col_data)
-
-        # Mermaid graph if requested
-        for column in columns_list:
-            if column.get('key') == 'mermaid':
-                column['value'] = element.get('mermaidGraph', '') or ''
-                break
-
+        # Use the common population pipeline to reduce duplication
+        col_data = populate_common_columns(element, columns_struct,
+                                           include_header=True,
+                                           include_relationships=True,
+                                           include_subject_area=True,
+                                           mermaid_source_key='mermaidGraph',
+                                           mermaid_dest_key='mermaid')
         return col_data
 
     def _extract_gov_def_list(self, element: Union[Dict, List[Dict]]) -> List[Dict]:
@@ -322,11 +315,11 @@ class GovernanceOfficer(Client2):
 
         Raises
         ------
-        InvalidParameterException
+        PyegeriaInvalidParameterException
             one of the parameters is null or invalid or
-        PropertyServerException
+        PyegeriaAPIException
             There is a problem adding the element properties to the metadata repository or
-        UserNotAuthorizedException
+        PyegeriaUnauthorizedException
             the requesting user is not authorized to issue this request.
 
         Notes
@@ -452,11 +445,11 @@ class GovernanceOfficer(Client2):
 
         Raises
         ------
-        InvalidParameterException
+        PyegeriaInvalidParameterException
             one of the parameters is null or invalid or
-        PropertyServerException
+        PyegeriaAPIException
             There is a problem adding the element properties to the metadata repository or
-        UserNotAuthorizedException
+        PyegeriaUnauthorizedException
             the requesting user is not authorized to issue this request.
 
         Notes
@@ -577,11 +570,11 @@ class GovernanceOfficer(Client2):
 
         Raises
         ------
-        InvalidParameterException
+        PyegeriaInvalidParameterException
             one of the parameters is null or invalid or
-        PropertyServerException
+        PyegeriaAPIException
             There is a problem adding the element properties to the metadata repository or
-        UserNotAuthorizedException
+        PyegeriaUnauthorizedException
             the requesting user is not authorized to issue this request.
 
         Notes
@@ -666,11 +659,11 @@ class GovernanceOfficer(Client2):
 
         Raises
         ------
-        InvalidParameterException
+        PyegeriaInvalidParameterException
             one of the parameters is null or invalid or
-        PropertyServerException
+        PyegeriaAPIException
             There is a problem adding the element properties to the metadata repository or
-        UserNotAuthorizedException
+        PyegeriaUnauthorizedException
             the requesting user is not authorized to issue this request.
 
         Notes
@@ -744,11 +737,11 @@ class GovernanceOfficer(Client2):
 
         Raises
         ------
-        InvalidParameterException
+        PyegeriaInvalidParameterException
             one of the parameters is null or invalid or
-        PropertyServerException
+        PyegeriaAPIException
             There is a problem adding the element properties to the metadata repository or
-        UserNotAuthorizedException
+        PyegeriaUnauthorizedException
             the requesting user is not authorized to issue this request.
 
         Notes
@@ -790,11 +783,7 @@ class GovernanceOfficer(Client2):
             f"{guid}/update")
         await self._async_update_element_body_request(url, GOV_DEF_PROPERTIES_LIST, body)
 
-    @dynamic_catch
-    async def _async_update_governance_definition(self, guid: str, body: dict | UpdateElementRequestBody) -> None:
-        """ Update a governance definition. Async Version."""
-
-    def update_governance_definition(self, guid: str, body: dict | UpdateStatusRequestBody) -> None:
+    def update_governance_definition(self, guid: str, body: dict | UpdateElementRequestBody) -> None:
         """ Update the properties of a governance definition.
 
         Parameters
@@ -813,11 +802,11 @@ class GovernanceOfficer(Client2):
 
         Raises
         ------
-        InvalidParameterException
+        PyegeriaInvalidParameterException
             one of the parameters is null or invalid or
-        PropertyServerException
+        PyegeriaAPIException
             There is a problem adding the element properties to the metadata repository or
-        UserNotAuthorizedException
+        PyegeriaUnauthorizedException
             the requesting user is not authorized to issue this request.
 
         Notes
@@ -855,102 +844,9 @@ class GovernanceOfficer(Client2):
         loop = asyncio.get_event_loop()
         loop.run_until_complete(self._async_update_governance_definition(guid, body))
 
-    @dynamic_catch
-    async def _async_update_governance_definition_status(self, guid: str, status: str = None,
-                                                         body: dict | UpdateStatusRequestBody = None) -> None:
-        """ Update the status of a governance definition. Async Version.
-
-        Parameters
-        ----------
-        guid: str
-            guid of the governance definition to update.
-        status: str, optional, default is None
-            The status to update the governance definition to. Superseded by the body definition if present.
-        body: dict
-            A dictionary containing the updates to the governance definition.
-
-        Returns
-        -------
-
-        None
-
-        Raises
-        ------
-        InvalidParameterException
-            one of the parameters is null or invalid or
-        PropertyServerException
-            There is a problem adding the element properties to the metadata repository or
-        UserNotAuthorizedException
-            the requesting user is not authorized to issue this request.
-
-        Notes
-        ----
-
-        Body structure:
-        {
-          "class": "UpdateGovernanceDefinitionRequestBody",
-          "externalSourceGUID": "add guid here",
-          "externalSourceName": "add qualified name here",
-          "effectiveTime": "{{$isoTimestamp}}",
-          "forLineage": false,
-          "forDuplicateProcessing": false,
-          "status": "ACTIVE"
-        }
-        """
-
-        url = (
-            f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/{self.url_marker}/governance-defnitions/"
-            f"{guid}/update-status")
-
-        await self._async_update_status_request(url, status, body)
-
-    def update_governance_definition_status(self, guid: str, status: str = None,
-                                            body: dict | UpdateStatusRequestBody = None) -> None:
-        """ Update the status of a governance definition.
-
-            Parameters
-            ----------
-            guid: str
-                guid of the information governance definition to update.
-            status: str, optional, default is None
-                The status to update the governance definition to. Superseded by the body definition if present.
-            body: dict
-                A dictionary containing the updates to the governance definition.
-
-            Returns
-            -------
-
-            None
-
-            Raises
-            ------
-            InvalidParameterException
-                one of the parameters is null or invalid or
-            PropertyServerException
-                There is a problem adding the element properties to the metadata repository or
-            UserNotAuthorizedException
-                the requesting user is not authorized to issue this request.
-
-            Notes
-            ----
-
-            Body structure:
-            {
-              "class" : "UpdateGovernanceDefinitionRequestBody",
-              "externalSourceGUID": "add guid here",
-              "externalSourceName": "add qualified name here",
-              "effectiveTime" : "{{$isoTimestamp}}",
-              "forLineage" : false,
-              "forDuplicateProcessing" : false,
-              "status": "ACTIVE"
-            }
-            """
-        loop = asyncio.get_event_loop()
-        loop.run_until_complete(self._async_update_governance_definition_status(guid, status, body))
-
     @dynamic_catch
     async def _async_delete_governance_definition(self, definition_guid: str,
-                                                  body: dict | DeleteRequestBody = None,
+                                                  body: Optional[dict | DeleteElementRequestBody] = None,
                                                   cascade: bool = False) -> None:
         """ Delete a governance definition. Async Version.
 
@@ -962,7 +858,7 @@ class GovernanceOfficer(Client2):
         cascade: bool, optional, defaults to True
             If true, a cascade delete is performed.
 
-        body: dict DeleteRequestBodyt, optional, default = None
+        body: dict DeleteElementRequestBodyt, optional, default = None
             A dict representing the details of the relationship.
 
         Returns
@@ -991,13 +887,12 @@ class GovernanceOfficer(Client2):
         }
         """
         url = (
-            f"{self.platform_url}/s"
-            f"ervers/{self.view_server}/api/open-metadata/governance-officer/governance-definitions/"
+            f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/governance-officer/governance-definitions/"
             f"{definition_guid}/delete")
-        await self._async_delete_request(url, body, cascade)
+        await self._async_delete_element_request(url, body, cascade)
         logger.info(f"Deleted collection {definition_guid} with cascade {cascade}")
 
-    def delete_governance_definition(self, definition_guid: str, body: dict | DeleteRequestBody = None,
+    def delete_governance_definition(self, definition_guid: str, body: Optional[dict | DeleteElementRequestBody] = None,
                                      cascade: bool = False) -> None:
         """Delete a governance definition.
 
@@ -1009,7 +904,7 @@ class GovernanceOfficer(Client2):
         cascade: bool, optional, defaults to True
             If true, a cascade delete is performed.
 
-        body: dict DeleteRequestBodyt, optional, default = None
+        body: dict DeleteElementRequestBodyt, optional, default = None
             A dict representing the details of the relationship.
 
         Returns
@@ -1062,11 +957,11 @@ class GovernanceOfficer(Client2):
 
         Raises
         ------
-        InvalidParameterException
+        PyegeriaInvalidParameterException
             one of the parameters is null or invalid or
-        PropertyServerException
+        PyegeriaAPIException
             There is a problem adding the element properties to the metadata repository or
-        UserNotAuthorizedException
+        PyegeriaUnauthorizedException
             the requesting user is not authorized to issue this request.
 
         Notes
@@ -1105,7 +1000,7 @@ class GovernanceOfficer(Client2):
 
     @dynamic_catch
     def link_peer_definitions(self, definition_guid1: str, relationship_type: str, definition_guid2: str,
-                              body: dict | NewElementRequestBody = None) -> None:
+                              body: Optional[dict | NewElementRequestBody] = None) -> None:
         """ Attach two peer governance definitions. Async Version.
 
         Parameters
@@ -1125,11 +1020,11 @@ class GovernanceOfficer(Client2):
 
         Raises
         ------
-        InvalidParameterException
+        PyegeriaInvalidParameterException
             one of the parameters is null or invalid or
-        PropertyServerException
+        PyegeriaAPIException
             There is a problem adding the element properties to the metadata repository or
-        UserNotAuthorizedException
+        PyegeriaUnauthorizedException
             the requesting user is not authorized to issue this request.
 
         Notes
@@ -1164,7 +1059,7 @@ class GovernanceOfficer(Client2):
 
     @dynamic_catch
     async def _async_detach_peer_definitions(self, definition_guid1: str, relationship_type: str, definition_guid2: str,
-                                             body: dict | DeleteRequestBody = None) -> None:
+                                             body: Optional[dict | DeleteRelationshipRequestBody] = None) -> None:
         """ Detach two peer governance definitions. Request body is optional. Async Version.
 
         Parameters
@@ -1184,11 +1079,11 @@ class GovernanceOfficer(Client2):
 
         Raises
         ------
-        InvalidParameterException
+        PyegeriaInvalidParameterException
             one of the parameters is null or invalid or
-        PropertyServerException
+        PyegeriaAPIException
             There is a problem adding the element properties to the metadata repository or
-        UserNotAuthorizedException
+        PyegeriaUnauthorizedException
             the requesting user is not authorized to issue this request.
 
         Notes
@@ -1209,12 +1104,12 @@ class GovernanceOfficer(Client2):
             f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/"
             f"{self.url_marker}/governance-definitions/"
             f"{definition_guid1}/peer-definitions/{relationship_type}/{definition_guid2}/detach")
-        await self._async_delete_request(url, body)
+        await self._async_delete_relationship_request(url, body)
         logger.info(f"Detached peer definitions: {definition_guid1} -> {definition_guid2}")
 
     @dynamic_catch
     def detach_peer_definitions(self, definition_guid1: str, relationship_type: str, definition_guid2: str,
-                                body: dict = None | DeleteRequestBody) -> None:
+                                body: dict = None | DeleteRelationshipRequestBody) -> None:
         """ Detach two peer governance definitions. Request body is optional.
 
         Parameters
@@ -1234,11 +1129,11 @@ class GovernanceOfficer(Client2):
 
         Raises
         ------
-        InvalidParameterException
+        PyegeriaInvalidParameterException
             one of the parameters is null or invalid or
-        PropertyServerException
+        PyegeriaAPIException
             There is a problem adding the element properties to the metadata repository or
-        UserNotAuthorizedException
+        PyegeriaUnauthorizedException
             the requesting user is not authorized to issue this request.
 
         Notes
@@ -1262,7 +1157,7 @@ class GovernanceOfficer(Client2):
     @dynamic_catch
     async def _async_attach_supporting_definitions(self, definition_guid1: str, relationship_type: str,
                                                    definition_guid2: str,
-                                                   body: dict | NewRelationshipRequestBody = None) -> None:
+                                                   body: Optional[dict | NewRelationshipRequestBody] = None) -> None:
         """ Attach a supporting governance definition. Request body is optional.
             The relationshipTypeNme can be:
             * GovernanceResponse between governance drivers (GovernanceStrategy, BusinessImperative, Regulation,
@@ -1291,11 +1186,11 @@ class GovernanceOfficer(Client2):
 
         Raises
         ------
-        InvalidParameterException
+        PyegeriaInvalidParameterException
             one of the parameters is null or invalid or
-        PropertyServerException
+        PyegeriaAPIException
             There is a problem adding the element properties to the metadata repository or
-        UserNotAuthorizedException
+        PyegeriaUnauthorizedException
             the requesting user is not authorized to issue this request.
 
         Notes
@@ -1326,7 +1221,7 @@ class GovernanceOfficer(Client2):
 
     @dynamic_catch
     def attach_supporting_definitions(self, definition_guid1: str, relationship_type: str, definition_guid2: str,
-                                      body: dict | NewRelationshipRequestBody = None) -> None:
+                                      body: Optional[dict | NewRelationshipRequestBody] = None) -> None:
         """ Attach a supporting governance definition. Request body is optional.
             The relationshipTypeNme can be:
             * GovernanceResponse between governance drivers (GovernanceStrategy, BusinessImperative, Regulation,
@@ -1353,11 +1248,11 @@ class GovernanceOfficer(Client2):
 
         Raises
         ------
-        InvalidParameterException
+        PyegeriaInvalidParameterException
             one of the parameters is null or invalid or
-        PropertyServerException
+        PyegeriaAPIException
             There is a problem adding the element properties to the metadata repository or
-        UserNotAuthorizedException
+        PyegeriaUnauthorizedException
             the requesting user is not authorized to issue this request.
 
         Notes
@@ -1386,7 +1281,7 @@ class GovernanceOfficer(Client2):
     @dynamic_catch
     async def _async_detach_supporting_definitions(self, definition_guid1: str, relationship_type: str,
                                                    definition_guid2: str,
-                                                   body: dict | DeleteRequestBody = None) -> None:
+                                                   body: Optional[dict | DeleteRelationshipRequestBody] = None) -> None:
         """ Detach a governance definition from a supporting governance definition.
             Request body is optional. Async Version.
 
@@ -1407,11 +1302,11 @@ class GovernanceOfficer(Client2):
 
         Raises
         ------
-        InvalidParameterException
+        PyegeriaInvalidParameterException
             one of the parameters is null or invalid or
-        PropertyServerException
+        PyegeriaAPIException
             There is a problem adding the element properties to the metadata repository or
-        UserNotAuthorizedException
+        PyegeriaUnauthorizedException
             the requesting user is not authorized to issue this request.
 
         Notes
@@ -1432,12 +1327,12 @@ class GovernanceOfficer(Client2):
             f"{self.url_marker}/governance-definitions/"
             f"{definition_guid1}/supporting-definitions/{relationship_type}/{definition_guid2}/detach"
         )
-        await self._async_delete_request(url, body)
+        await self._async_delete_relationship_request(url, body)
         logger.info(f"Detached digital supporting definitions: {definition_guid1} -> {definition_guid2}")
 
     @dynamic_catch
     def detach_supporting_definitions(self, definition_guid1: str, relationship_type: str, definition_guid2: str,
-                                      body: dict | DeleteRequestBody = None) -> None:
+                                      body: Optional[dict | DeleteRelationshipRequestBody] = None) -> None:
         """ Detach a governance definition from a supporting governance definition.
             Request body is optional.
 
@@ -1458,11 +1353,11 @@ class GovernanceOfficer(Client2):
 
         Raises
         ------
-        InvalidParameterException
+        PyegeriaInvalidParameterException
             one of the parameters is null or invalid or
-        PropertyServerException
+        PyegeriaAPIException
             There is a problem adding the element properties to the metadata repository or
-        UserNotAuthorizedException
+        PyegeriaUnauthorizedException
             the requesting user is not authorized to issue this request.
 
         Notes
@@ -1482,147 +1377,569 @@ class GovernanceOfficer(Client2):
         loop.run_until_complete(
             self._async_detach_supporting_definitions(definition_guid1, relationship_type, definition_guid2, body))
 
+
+
+    async def _async_attach_governed_by_definition(self, element_guid: str, definition_guid: str,
+                                                   body: Optional[dict | NewRelationshipRequestBody] = None) -> None:
+        """ Link a governance definition to an element using the GovernedBy relationship. Request body is optional.
+
+        Async Version.
+
+        Parameters
+        ----------
+        element_guid: str
+            guid of the element to be governed.
+        definition_guid: str
+            the governance definition guid.
+        body: dict
+            The body describing the link between the two.
+
+        Returns
+        -------
+        None
+
+        Raises
+        ------
+        PyegeriaException
+        ValidationError
+
+        Notes
+        ----
+
+        Body structure:
+       {
+           "class" : "NewRelationshipRequestBody",
+           "properties" : {
+             "class" : "GovernedByProperties",
+             "label" : "add label here",
+             "description" : "add description here"
+           },
+           "externalSourceGUID": "Add guid here",
+           "externalSourceName": "Add qualified name here",
+           "forLineage": false,
+           "forDuplicateProcessing": false,
+           "effectiveTime" : "{{$isoTimestamp}}"
+        }
+        """
+        url = (
+            f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/"
+            f"{self.url_marker}/elements/{element_guid}/governed-by/definition/{definition_guid}/attach"
+        )
+        await self._async_new_relationship_request(url, "GovernedByProperties", body)
+        logger.info(f"Linked Governed-By {definition_guid} -> {element_guid}")
+
     @dynamic_catch
-    async def _async_delete_governance_definition(self, guid: str, body: dict | DeleteRequestBody = None) -> None:
-        """ Delete an information supply. Async version.
+    def attach_governed_by_definition(self, element_guid: str, definition_guid: str,
+                                      body: Optional[dict | NewRelationshipRequestBody] = None) -> None:
+        """ Link a governance definition to an element using the GovernedBy relationship. Request body is optional.
 
         Parameters
         ----------
-        guid: str
-            GUID of the governance definition to delete.
- 
-        body: dict, optional
-            A dictionary containing the definition of the governance definition to create.
+        element_guid: str
+            guid of the element to be governed.
+        definition_guid: str
+            the governance definition guid.
+        body: dict
+            The body describing the link between the two.
 
         Returns
         -------
+        None
 
-        str - guid of the governance definition created.
+        Raises
+        ------
+        PyegeriaException
+        ValidationError
+
+        Notes
+        ----
+
+        Body structure:
+       {
+           "class" : "NewRelationshipRequestBody",
+           "properties" : {
+             "class" : "GovernedByProperties",
+             "label" : "add label here",
+             "description" : "add description here"
+           },
+           "externalSourceGUID": "Add guid here",
+           "externalSourceName": "Add qualified name here",
+           "forLineage": false,
+           "forDuplicateProcessing": false,
+           "effectiveTime" : "{{$isoTimestamp}}"
+        }
+        """
+        loop = asyncio.get_event_loop()
+        loop.run_until_complete(
+            self._async_attach_governed_by_definition(element_guid, definition_guid, body))
+
+    @dynamic_catch
+    async def _async_detach_governed_by_definition(self, element_guid: str, definition_guid: str,
+                                                   body: Optional[dict | DeleteRelationshipRequestBody] = None) -> None:
+        """ Detach a governance definition from a supporting governance definition.
+            Request body is optional. Async Version.
+
+        Parameters
+        ----------
+        element_guid: str
+            guid of the element to be governed.
+        definition_guid: str
+            the governance definition guid.
+        body: dict
+            The body describing the link between the two.
+
+        Returns
+        -------
+        None
 
         Raises
         ------
-        InvalidParameterException
+        PyegeriaInvalidParameterException
             one of the parameters is null or invalid or
-        PropertyServerException
+        PyegeriaAPIException
             There is a problem adding the element properties to the metadata repository or
-        UserNotAuthorizedException
+        PyegeriaUnauthorizedException
             the requesting user is not authorized to issue this request.
 
         Notes
         ----
-        https://egeria-project.org/concepts/governance-definition
 
         Body structure:
         {
-          "class": "MetadataSourceRequestBody",
+          "class" : "DeleteRelationshipRequestBody",
           "externalSourceGUID": "add guid here",
           "externalSourceName": "add qualified name here",
-          "effectiveTime": "{{$isoTimestamp}}",
-          "forLineage": false,
-          "forDuplicateProcessing": false
+          "effectiveTime" : "{{$isoTimestamp}}",
+          "forLineage" : false,
+          "forDuplicateProcessing" : false
         }
-
-       """
-        url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/"
-               f"{self.url_marker}/governance-definitions/{guid}/delete")
-        await self._async_delete_request(url, body)
-        logger.info(f"Deleted governance definition: {guid} ")
+        """
+        url = (
+            f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/"
+            f"{self.url_marker}/elements/{element_guid}/governed-by/{definition_guid}/detach"
+        )
+        await self._async_delete_relationship_request(url, body)
+        logger.info(f"Detached governed-by relationshup between: {definition_guid} -> {element_guid}")
 
     @dynamic_catch
-    def delete_governance_definition(self, guid: str, body: dict | DeleteRequestBody = None) -> None:
-        """ Delete an information supply. Request body is optional. Async version.
+    def detach_governed_by_definitio(self, element_guid: str, definition_guid: str,
+                                      body: Optional[dict | DeleteRelationshipRequestBody] = None) -> None:
+        """ Detach a governance definition from a supporting governance definition.
+            Request body is optional.
 
         Parameters
         ----------
-        guid: str
-            GUID of the governance definition to delete.
- 
-        body: dict, optionl
-            A dictionary containing the definition of the governance definition to create.
+        element_guid: str
+            guid of the element to be governed.
+        definition_guid: str
+            the governance definition guid.
+        body: dict
+            The body describing the link between the two.
 
         Returns
         -------
-
-        str - guid of the governance definition created.
+        None
 
         Raises
         ------
-        InvalidParameterException
+        PyegeriaInvalidParameterException
             one of the parameters is null or invalid or
-        PropertyServerException
+        PyegeriaAPIException
             There is a problem adding the element properties to the metadata repository or
-        UserNotAuthorizedException
+        PyegeriaUnauthorizedException
             the requesting user is not authorized to issue this request.
 
         Notes
         ----
-        https://egeria-project.org/concepts/governance-definition
 
         Body structure:
         {
-          "class": "MetadataSourceRequestBody",
+          "class" : "DeleteRelationshipRequestBody",
           "externalSourceGUID": "add guid here",
           "externalSourceName": "add qualified name here",
-          "effectiveTime": "{{$isoTimestamp}}",
-          "forLineage": false,
-          "forDuplicateProcessing": false
+          "effectiveTime" : "{{$isoTimestamp}}",
+          "forLineage" : false,
+          "forDuplicateProcessing" : false
         }
+        """
+        loop = asyncio.get_event_loop()
+        loop.run_until_complete(
+            self._async_detach_governed_by_definition(element_guid, definition_guid, body))
 
-       """
 
-        loop = asyncio.get_event_loop()
-        loop.run_until_complete(self._async_delete_governance_definition(guid, body))
+
+    # @dynamic_catch
+    # async def _async_delete_governance_definition(self, guid: str, body: Optional[dict | DeleteElementRequestBody] = None) -> None:
+    #     """ Delete an information supply. Async version.
+
+    #     Parameters
+    #     ----------
+    #     guid: str
+    #         GUID of the governance definition to delete.
+
+    #     body: dict, optional
+    #         A dictionary containing the definition of the governance definition to create.
+
+    #     Returns
+    #     -------
+
+    #     str - guid of the governance definition created.
+
+    #     Raises
+    #     ------
+    #     PyegeriaInvalidParameterException
+    #         one of the parameters is null or invalid or
+    #     PyegeriaAPIException
+    #         There is a problem adding the element properties to the metadata repository or
+    #     PyegeriaUnauthorizedException
+    #         the requesting user is not authorized to issue this request.
+
+    #     Notes
+    #     ----
+    #     https://egeria-project.org/concepts/governance-definition
+
+    #     Body structure:
+    #     {
+    #       "class": "MetadataSourceRequestBody",
+    #       "externalSourceGUID": "add guid here",
+    #       "externalSourceName": "add qualified name here",
+    #       "effectiveTime": "{{$isoTimestamp}}",
+    #       "forLineage": false,
+    #       "forDuplicateProcessing": false
+    #     }
+
+    #    """
+    #     url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/"
+    #            f"{self.url_marker}/governance-definitions/{guid}/delete")
+    #     await self._async_delete_element_request(url, body)
+    #     logger.info(f"Deleted governance definition: {guid} ")
+
+
+    # @dynamic_catch
+    # def delete_governance_definition(self, guid: str, body: Optional[dict | DeleteElementRequestBody] = None) -> None:
+    #     """ Delete an information supply. Request body is optional. Async version.
+
+    #     Parameters
+    #     ----------
+    #     guid: str
+    #         GUID of the governance definition to delete.
+ 
+    #     body: dict, optionl
+    #         A dictionary containing the definition of the governance definition to create.
+
+    #     Returns
+    #     -------
+
+    #     str - guid of the governance definition created.
+
+    #     Raises
+    #     ------
+    #     PyegeriaInvalidParameterException
+    #         one of the parameters is null or invalid or
+    #     PyegeriaAPIException
+    #         There is a problem adding the element properties to the metadata repository or
+    #     PyegeriaUnauthorizedException
+    #         the requesting user is not authorized to issue this request.
+
+    #     Notes
+    #     ----
+    #     https://egeria-project.org/concepts/governance-definition
+
+    #     Body structure:
+    #     {
+    #       "class": "MetadataSourceRequestBody",
+    #       "externalSourceGUID": "add guid here",
+    #       "externalSourceName": "add qualified name here",
+    #       "effectiveTime": "{{$isoTimestamp}}",
+    #       "forLineage": false,
+    #       "forDuplicateProcessing": false
+    #     }
+
+    #    """
+
+    #     loop = asyncio.get_event_loop()
+    #     loop.run_until_complete(self._async_delete_governance_definition(guid, body))
+
+    @dynamic_catch
+    async def _async_find_governance_definitions(self, search_string: str = "*",
+                                                 starts_with: bool = True, ends_with: bool = False,
+                                                 ignore_case: bool = False,
+                                                 anchor_domain: Optional[str] = None,
+                                                 metadata_element_type: Optional[str] = None,
+                                                 metadata_element_subtypes: Optional[list[str]] = None,
+                                                 skip_relationships: Optional[list[str]] = None,
+                                                 include_only_relationships: Optional[list[str]] = None,
+                                                 skip_classified_elements: Optional[list[str]] = None,
+                                                 include_only_classified_elements: Optional[list[str]] = None,
+                                                 graph_query_depth: int = 3,
+                                                 governance_zone_filter: Optional[list[str]] = None, as_of_time: Optional[str] = None,
+                                                 effective_time: Optional[str] = None, relationship_page_size: int = 0,
+                                                 limit_results_by_status: Optional[list[str]] = None, sequencing_order: Optional[str] = None,
+                                                 sequencing_property: Optional[str] = None,
+                                                 output_format: str = "JSON",
+                                                 report_spec: str | dict = None,
+                                                 start_from: int = 0, page_size: int = 100,
+                                                 property_names: Optional[list[str]] = None,
+                                                 body: Optional[dict | SearchStringRequestBody] = None) -> list | str:
+        """ Retrieve the list of governance definition metadata elements that contain the search string. Async Version.
+
+        Parameters
+        ----------
+        search_string: str
+            Search string to match against - None or '*' indicate match against all governance definitions.
+        starts_with : bool, [default=True], optional
+            Starts with the supplied string.
+        ends_with : bool, [default=False], optional
+            Ends with the supplied string
+        ignore_case : bool, [default=False], optional
+            Ignore case when searching
+        anchor_domain: str, optional
+            The anchor domain to search in.
+        metadata_element_type: str, optional
+            The type of metadata element to search for.
+        metadata_element_subtypes: list[str], optional
+            The subtypes of metadata element to search for.
+        skip_relationships: list[str], optional
+            The types of relationships to skip.
+        include_only_relationships: list[str], optional
+            The types of relationships to include.
+        skip_classified_elements: list[str], optional
+            The types of classified elements to skip.
+        include_only_classified_elements: list[str], optional
+            The types of classified elements to include.
+        graph_query_depth: int, [default=3], optional
+            The depth of the graph query.
+        governance_zone_filter: list[str], optional
+            The governance zones to search in.
+        as_of_time: str, optional
+            The time to search as of.
+        effective_time: str, optional
+            The effective time to search at.
+        relationship_page_size: int, [default=0], optional
+            The page size for relationships.
+        limit_results_by_status: list[str], optional
+            The statuses to limit results by.
+        sequencing_order: str, optional
+            The order to sequence results by.
+        sequencing_property: str, optional
+            The property to sequence results by.
+        output_format: str, default = "JSON"
+            - one of "MD", "LIST", "FORM", "REPORT", "DICT", "MERMAID" or "JSON"
+        report_spec: str | dict , optional, default = None
+            - The desired output columns/fields to include.
+        start_from: int, [default=0], optional
+            When multiple pages of results are available, the page number to start from.
+        page_size: int, [default=100]
+            The number of items to return in a single page.
+        property_names: list[str], optional
+            The names of properties to search for.
+        body: dict | SearchStringRequestBody, optional, default = None
+            - if provided, the search parameters in the body will supercede other attributes, such as "search_string"
+
+        Returns
+-------
+        List | str
+
+        Output depends on the output format specified.
+
+        Raises
+-------
+
+        ValidationError
+          If the client passes incorrect parameters on the request that don't conform to the data model.
+        PyegeriaException
+          Issues raised in communicating or server side processing.
+        NotAuthorizedException
+          The principle specified by the user_id does not have authorization for the requested action
+
+        """
+        url = (
+            f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/"
+            f"{self.url_marker}/governance-definitions/"
+            f"by-search-string")
+        response = await self._async_find_request(url, _type="GovernanceDefinition", _gen_output=self._generate_governance_definition_output,
+                                                  search_string=search_string, starts_with=starts_with,
+                                                  ends_with=ends_with, ignore_case=ignore_case,
+                                                  anchor_domain=anchor_domain,
+                                                  metadata_element_type=metadata_element_type,
+                                                  metadata_element_subtypes=metadata_element_subtypes,
+                                                  skip_relationships=skip_relationships,
+                                                  include_only_relationships=include_only_relationships,
+                                                  skip_classified_elements=skip_classified_elements,
+                                                  include_only_classified_elements=include_only_classified_elements,
+                                                  graph_query_depth=graph_query_depth,
+                                                  governance_zone_filter=governance_zone_filter,
+                                                  as_of_time=as_of_time, effective_time=effective_time,
+                                                  relationship_page_size=relationship_page_size,
+                                                  limit_results_by_status=limit_results_by_status,
+                                                  sequencing_order=sequencing_order,
+                                                  sequencing_property=sequencing_property,
+                                                  output_format=output_format, report_spec=report_spec,
+                                                  start_from=start_from, page_size=page_size,
+                                                  property_names=property_names, body=body)
+
+        return response
 
     @dynamic_catch
-    async def _async_find_governance_definitions(self, search_string: str = "*", classification_names: list[str] = None,
-                                                 metadata_element_types: list[str] = None,
-                                                 starts_with: bool = True,
-                                                 ends_with: bool = False, ignore_case: bool = False,
-                                                 start_from: int = 0, page_size: int = 0,
-                                                 output_format: str = 'JSON', output_format_set: dict = None,
-                                                 body: dict | SearchStringRequestBody = None,
-                                                 ) -> list | str:
+    def find_governance_definitions(self, search_string: str = "*",
+                                    starts_with: bool = True, ends_with: bool = False,
+                                    ignore_case: bool = False,
+                                    anchor_domain: Optional[str] = None,
+                                    metadata_element_type: Optional[str] = None,
+                                    metadata_element_subtypes: Optional[list[str]] = None,
+                                    skip_relationships: Optional[list[str]] = None,
+                                    include_only_relationships: Optional[list[str]] = None,
+                                    skip_classified_elements: Optional[list[str]] = None,
+                                    include_only_classified_elements: Optional[list[str]] = None,
+                                    graph_query_depth: int = 3,
+                                    governance_zone_filter: Optional[list[str]] = None, as_of_time: Optional[str] = None,
+                                    effective_time: Optional[str] = None, relationship_page_size: int = 0,
+                                    limit_results_by_status: Optional[list[str]] = None, sequencing_order: Optional[str] = None,
+                                    sequencing_property: Optional[str] = None,
+                                    output_format: str = "JSON",
+                                    report_spec: str | dict = None,
+                                    start_from: int = 0, page_size: int = 100,
+                                    property_names: Optional[list[str]] = None,
+                                    body: Optional[dict | SearchStringRequestBody] = None) -> list | str:
         """ Retrieve the list of governance definition metadata elements that contain the search string.
-            Async version.
+
+        Parameters
+        ----------
+        search_string: str
+            Search string to match against - None or '*' indicate match against all governance definitions.
+        starts_with : bool, [default=True], optional
+            Starts with the supplied string.
+        ends_with : bool, [default=False], optional
+            Ends with the supplied string
+        ignore_case : bool, [default=False], optional
+            Ignore case when searching
+        anchor_domain: str, optional
+            The anchor domain to search in.
+        metadata_element_type: str, optional
+            The type of metadata element to search for.
+        metadata_element_subtypes: list[str], optional
+            The subtypes of metadata element to search for.
+        skip_relationships: list[str], optional
+            The types of relationships to skip.
+        include_only_relationships: list[str], optional
+            The types of relationships to include.
+        skip_classified_elements: list[str], optional
+            The types of classified elements to skip.
+        include_only_classified_elements: list[str], optional
+            The types of classified elements to include.
+        graph_query_depth: int, [default=3], optional
+            The depth of the graph query.
+        governance_zone_filter: list[str], optional
+            The governance zones to search in.
+        as_of_time: str, optional
+            The time to search as of.
+        effective_time: str, optional
+            The effective time to search at.
+        relationship_page_size: int, [default=0], optional
+            The page size for relationships.
+        limit_results_by_status: list[str], optional
+            The statuses to limit results by.
+        sequencing_order: str, optional
+            The order to sequence results by.
+        sequencing_property: str, optional
+            The property to sequence results by.
+        output_format: str, default = "JSON"
+            - one of "MD", "LIST", "FORM", "REPORT", "DICT", "MERMAID" or "JSON"
+        report_spec: str | dict , optional, default = None
+            - The desired output columns/fields to include.
+        start_from: int, [default=0], optional
+            When multiple pages of results are available, the page number to start from.
+        page_size: int, [default=100]
+            The number of items to return in a single page.
+        property_names: list[str], optional
+            The names of properties to search for.
+        body: dict | SearchStringRequestBody, optional, default = None
+            - if provided, the search parameters in the body will supercede other attributes, such as "search_string"
+
+        Returns
+-------
+        List | str
+
+        Output depends on the output format specified.
+
+        Raises
+-------
+
+        ValidationError
+          If the client passes incorrect parameters on the request that don't conform to the data model.
+        PyegeriaException
+          Issues raised in communicating or server side processing.
+        NotAuthorizedException
+          The principle specified by the user_id does not have authorization for the requested action
+
+        """
+        loop = asyncio.get_event_loop()
+        return loop.run_until_complete(self._async_find_governance_definitions(search_string=search_string,
+                                                                               starts_with=starts_with,
+                                                                               ends_with=ends_with,
+                                                                               ignore_case=ignore_case,
+                                                                               anchor_domain=anchor_domain,
+                                                                               metadata_element_type=metadata_element_type,
+                                                                               metadata_element_subtypes=metadata_element_subtypes,
+                                                                               skip_relationships=skip_relationships,
+                                                                               include_only_relationships=include_only_relationships,
+                                                                               skip_classified_elements=skip_classified_elements,
+                                                                               include_only_classified_elements=include_only_classified_elements,
+                                                                               graph_query_depth=graph_query_depth,
+                                                                               governance_zone_filter=governance_zone_filter,
+                                                                               as_of_time=as_of_time,
+                                                                               effective_time=effective_time,
+                                                                               relationship_page_size=relationship_page_size,
+                                                                               limit_results_by_status=limit_results_by_status,
+                                                                               sequencing_order=sequencing_order,
+                                                                               sequencing_property=sequencing_property,
+                                                                               output_format=output_format,
+                                                                               report_spec=report_spec,
+                                                                               start_from=start_from,
+                                                                               page_size=page_size,
+                                                                               property_names=property_names,
+                                                                               body=body))
+
+    @dynamic_catch
+    async def _async_get_governance_definitions_by_name(self, filter_string: str,
+                                                        classification_names: Optional[list[str]] = None,
+                                                        body: Optional[dict | FilterRequestBody] = None,
+                                                        start_from: int = 0, page_size: int = 0,
+                                                        output_format: str = "JSON",
+                                                        report_spec: dict = None) -> list | str:
+        """ Returns the list of governance definitions with a particular name. Async Version.
 
             Parameters
             ----------
-            search_string : str
-                - string to search for.
-            starts_with : bool, [default=False], optional
-                Starts with the supplied string.
-            ends_with : bool, [default=False], optional
-                Ends with the supplied string
-            ignore_case : bool, [default=False], optional
-                Ignore case when searching
-            body: dict, optional, default = None
-                - additional optional specifications for the search.
+            filter_string: str
+                name of the information governance definition to retrieve.
+            body: dict, optional
+                A dictionary containing parameters of the retrieval.
             output_format: str, default = 'JSON'
-                Type of output to produce:
-                    JSON - output standard json
-                    MD - output standard markdown with no preamble
-                    FORM - output markdown with a preamble for a form
-                    REPORT - output markdown with a preamble for a report
-                    Mermaid - output markdown with a mermaid graph
+                Type of output to produce include:
+                JSON - output standard json
+                MD - output standard markdown with no preamble
+                FORM - output markdown with a preamble for a form
+                REPORT - output markdown with a preamble for a report
+                MERMAID - output mermaid markdown
 
             Returns
             -------
-            list[dict] | str
-                A list of information governance definition structures or a string if there are no elements found.
+            [dict] | str
+                A list of information governance definitions matching the name.
 
             Raises
             ------
-            InvalidParameterException
+            PyegeriaInvalidParameterException
                 one of the parameters is null or invalid or
-            PropertyServerException
+            PyegeriaAPIException
                 There is a problem adding the element properties to the metadata repository or
-            UserNotAuthorizedException
+            PyegeriaUnauthorizedException
                 the requesting user is not authorized to issue this request.
 
             Notes
             -----
             If a body is provided it overrides the filter_string parameter.
-            
             Body structure:
             {
               "class": "FilterRequestBody",
@@ -1636,68 +1953,69 @@ class GovernanceOfficer(Client2):
               "filter": "Add name here",
               "templateFilter": "NO_TEMPLATES"
             }
-            """
+
+        """
 
         url = (
             f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/"
-            f"{self.url_marker}/governance-definitions/"
-            f"by-search-string")
-        return await self._async_find_request(url, _type="GovernanceDefinition",
-                                              _gen_output=self._generate_governance_definition_output,
-                                              search_string=search_string, classification_names=classification_names,
-                                              metadata_element_types=metadata_element_types,
-                                              starts_with=starts_with, ends_with=ends_with, ignore_case=ignore_case,
-                                              start_from=start_from, page_size=page_size,
-                                              output_format=output_format, output_format_set=output_format_set,
-                                              body=body)
+            f"{self.url_marker}/governance-definitions/by-name")
+        response = await self._async_get_name_request(url, _type="GovernanceDefinition",
+                                                      _gen_output=self._generate_governance_definition_output,
+                                                      filter_string=filter_string,
+                                                      classification_names=classification_names,
+                                                      start_from=start_from, page_size=page_size,
+                                                      output_format=output_format, report_spec=report_spec,
+                                                      body=body)
+
+        return response
 
     @dynamic_catch
-    def find_governance_definitions(self, search_string: str = "*", classification_names: list[str] = None,
-                                    metadata_element_types: list[str] = None,
-                                    starts_with: bool = True, ends_with: bool = False,
-                                    ignore_case: bool = False, start_from: int = 0, page_size: int = 0,
-                                    output_format: str = 'JSON', output_format_set: dict = None,
-                                    body: dict | SearchStringRequestBody = None, ) -> list | str:
-        """ Retrieve the list of governance definition metadata elements that contain the search string.
+    def get_governance_definitions_by_name(self, filter_string: str, classification_names: Optional[list[str]] = None,
+                                           body: Optional[dict | FilterRequestBody] = None,
+                                           start_from: int = 0, page_size: int = 0,
+                                           output_format: str = "JSON",
+                                           report_spec: dict = None) -> list | str:
+        """ Returns the list of governance definitions with a particular name."""
+
+        """ Returns the list of information governance definitions with a particular name. Async Version.
 
             Parameters
             ----------
-            search_string : str
-                - filter_string string to search for.
-            starts_with : bool, [default=False], optional
-                Starts with the supplied string.
-            ends_with : bool, [default=False], optional
-                Ends with the supplied string
-            ignore_case : bool, [default=False], optional
-                Ignore case when searching
-            body: dict, optional, default = None
-                - additional optional specifications for the search.
+            filter_string: str
+                name of the information governance definition to retrieve.
+            body: dict, optional
+                A dictionary containing parameters of the retrieval.
+            add_implementation: bool, optional
+                Whether to add the implementation details to the response.
+            start_from: int, [default=0], optional
+                When multiple pages of results are available, the page number to start from.
+            page_size: int, [default=0], optional
+                The number of items to return in a single page. If not specified, the default will be taken from
+                the class instance.
             output_format: str, default = 'JSON'
                 Type of output to produce:
-                    JSON - output standard json
-                    MD - output standard markdown with no preamble
-                    FORM - output markdown with a preamble for a form
-                    REPORT - output markdown with a preamble for a report
-                    Mermaid - output markdown with a mermaid graph
+                JSON - output standard json
+                MD - output standard markdown with no preamble
+                FORM - output markdown with a preamble for a form
+                REPORT - output markdown with a preamble for a report
+                MERMAID - output mermaid markdown
 
             Returns
             -------
-            list[dict] | str
-                A list of information governance definition structures or a string if there are no elements found.
+            [dict] | str
+                A list of information governance definitions matching the name.
 
             Raises
             ------
-            InvalidParameterException
+            PyegeriaInvalidParameterException
                 one of the parameters is null or invalid or
-            PropertyServerException
+            PyegeriaAPIException
                 There is a problem adding the element properties to the metadata repository or
-            UserNotAuthorizedException
+            PyegeriaUnauthorizedException
                 the requesting user is not authorized to issue this request.
 
             Notes
             -----
-            If a body is provided it overrides the filter_string parameter.
-
             Body structure:
             {
               "class": "FilterRequestBody",
@@ -1711,28 +2029,26 @@ class GovernanceOfficer(Client2):
               "filter": "Add name here",
               "templateFilter": "NO_TEMPLATES"
             }
-            """
 
+        """
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
-            self._async_find_governance_definitions(search_string, classification_names, metadata_element_types,
-                                                    starts_with, ends_with, ignore_case, start_from,
-                                                    page_size, output_format, output_format_set, body))
+            self._async_get_governance_definitions_by_name(filter_string, classification_names, body,
+                                                           start_from, page_size, output_format, report_spec))
         return response
+ 
 
-    @dynamic_catch
-    async def _async_get_governance_definitions_by_name(self, filter_string: str,
-                                                        classification_names: list[str] = None,
-                                                        body: dict | FilterRequestBody = None,
-                                                        start_from: int = 0, page_size: int = 0,
+    async def _async_get_governance_definition_by_guid(self, definition_guid: str, 
+                                                       element_type: Optional[str] = None,
+                                                        body: Optional[dict | GetRequestBody] = None,
                                                         output_format: str = "JSON",
-                                                        output_format_set: dict = None) -> list | str:
-        """ Returns the list of governance definitions with a particular name. Async Version.
+                                                        report_spec: dict = None) -> list | str:
+        """ Returns the  governance definitions with a particular GUID. Async Version.
 
             Parameters
             ----------
-            filter_string: str
-                name of the information governance definition to retrieve.
+            definition_guid: str
+                identity of the information governance definition to retrieve.
             body: dict, optional
                 A dictionary containing parameters of the retrieval.
             output_format: str, default = 'JSON'
@@ -1750,11 +2066,11 @@ class GovernanceOfficer(Client2):
 
             Raises
             ------
-            InvalidParameterException
+            PyegeriaInvalidParameterException
                 one of the parameters is null or invalid or
-            PropertyServerException
+            PyegeriaAPIException
                 There is a problem adding the element properties to the metadata repository or
-            UserNotAuthorizedException
+            PyegeriaUnauthorizedException
                 the requesting user is not authorized to issue this request.
 
             Notes
@@ -1762,56 +2078,51 @@ class GovernanceOfficer(Client2):
             If a body is provided it overrides the filter_string parameter.
             Body structure:
             {
-              "class": "FilterRequestBody",
-              "asOfTime": {{isotime}},
-              "effectiveTime": {{isotime}},
-              "forLineage": false,
-              "forDuplicateProcessing": false,
-              "limitResultsByStatus": ["ACTIVE"],
-              "sequencingOrder": "PROPERTY_ASCENDING",
-              "sequencingProperty": "qualifiedName",
-              "filter": "Add name here",
-              "templateFilter": "NO_TEMPLATES"
+            "class" : "GetRequestBody",
+            "metadataElementTypeName": "GovernancePolicy",
+            "metadataElementSubtypeNames": [],
+            "skipRelationships": [],
+            "includeOnlyRelationships": [],
+            "relationshipsPageSize": 100,
+            "skipClassifiedElements": [],
+            "includeOnlyClassifiedElements": [],
+            "asOfTime" : "{{$isoTimestamp}}",
+            "effectiveTime" : "{{$isoTimestamp}}",
+            "forLineage" : false,
+            "forDuplicateProcessing" : false
             }
 
         """
 
         url = (
             f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/"
-            f"{self.url_marker}/governance-definitions/by-name")
-        response = await self._async_get_name_request(url, _type="GovernanceDefinition",
+            f"{self.url_marker}/governance-definitions/{definition_guid}/retrieve")
+        
+        element_type = element_type if element_type else "GovernanceDefinition"
+        response = await self._async_get_guid_request(url, _type=element_type,
                                                       _gen_output=self._generate_governance_definition_output,
-                                                      filter_string=filter_string,
-                                                      classification_names=classification_names,
-                                                      start_from=start_from, page_size=page_size,
-                                                      output_format=output_format, output_format_set=output_format_set,
+                                                      output_format=output_format, report_spec=report_spec,
                                                       body=body)
 
         return response
 
     @dynamic_catch
-    def get_governance_definitions_by_name(self, filter_string: str, classification_names: list[str] = None,
-                                           body: dict | FilterRequestBody = None,
-                                           start_from: int = 0, page_size: int = 0,
+    def get_governance_definition_by_guid(self, definition_guid: str, 
+                                           element_type: Optional[str] = None,
+                                           body: Optional[dict | GetRequestBody] = None,
                                            output_format: str = "JSON",
-                                           output_format_set: dict = None) -> list | str:
-        """ Returns the list of governance definitions with a particular name."""
-
-        """ Returns the list of information governance definitions with a particular name. Async Version.
+                                           report_spec: dict = None) -> list | str:
+        """ Returns the a governance definitions with a particular GUID. 
 
             Parameters
             ----------
-            filter_string: str
-                name of the information governance definition to retrieve.
+            definition_guid: str
+                GUID of the information governance definition to retrieve.
+            element_type: str
+                Type of element to retrieve.
             body: dict, optional
                 A dictionary containing parameters of the retrieval.
-            add_implementation: bool, optional
-                Whether to add the implementation details to the response.
-            start_from: int, [default=0], optional
-                When multiple pages of results are available, the page number to start from.
-            page_size: int, [default=0], optional
-                The number of items to return in a single page. If not specified, the default will be taken from
-                the class instance.
+            
             output_format: str, default = 'JSON'
                 Type of output to produce:
                 JSON - output standard json
@@ -1827,50 +2138,53 @@ class GovernanceOfficer(Client2):
 
             Raises
             ------
-            InvalidParameterException
+            PyegeriaInvalidParameterException
                 one of the parameters is null or invalid or
-            PropertyServerException
+            PyegeriaAPIException
                 There is a problem adding the element properties to the metadata repository or
-            UserNotAuthorizedException
+            PyegeriaUnauthorizedException
                 the requesting user is not authorized to issue this request.
 
             Notes
             -----
             Body structure:
-            {
-              "class": "FilterRequestBody",
-              "asOfTime": {{isotime}},
-              "effectiveTime": {{isotime}},
-              "forLineage": false,
-              "forDuplicateProcessing": false,
-              "limitResultsByStatus": ["ACTIVE"],
-              "sequencingOrder": "PROPERTY_ASCENDING",
-              "sequencingProperty": "qualifiedName",
-              "filter": "Add name here",
-              "templateFilter": "NO_TEMPLATES"
+           {
+            "class" : "GetRequestBody",
+            "metadataElementTypeName": "GovernancePolicy",
+            "metadataElementSubtypeNames": [],
+            "skipRelationships": [],
+            "includeOnlyRelationships": [],
+            "relationshipsPageSize": 100,
+            "skipClassifiedElements": [],
+            "includeOnlyClassifiedElements": [],
+            "asOfTime" : "{{$isoTimestamp}}",
+            "effectiveTime" : "{{$isoTimestamp}}",
+            "forLineage" : false,
+            "forDuplicateProcessing" : false
             }
-
         """
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
-            self._async_get_governance_definitions_by_name(filter_string, classification_names, body,
-                                                           start_from, page_size, output_format, output_format_set))
+            self._async_get_governance_definition_by_guid(definition_guid, element_type, body,
+                                                            output_format, report_spec))
         return response
+ 
+
 
     @dynamic_catch
-    async def _async_get_governance_definition_by_guid(self, guid: str, element_type: str = None,
-                                                       body: dict | FilterRequestBody = None,
+    async def _async_get_governance_process_graph(self, guid: str, element_type: Optional[str] = None,
+                                                       body: Optional[dict | FilterRequestBody] = None,
                                                        output_format: str = "JSON",
-                                                       output_format_set: dict = None) -> dict | str:
+                                                       report_spec: dict = None) -> dict | str:
 
-        """ Get governance definition by guid.
-            Async version.
+        """ Retrieve the governance action process metadata element with the supplied unique identifier
+            along with the flow definition describing its implementation. Async version.
 
         Parameters
         ----------
         guid: str
             GUID of the governance definition to get.
- 
+
         body: dict, optional
             A dictionary containing the definition of the governance definition to create.
         output_format: str
@@ -1885,11 +2199,11 @@ class GovernanceOfficer(Client2):
 
         Raises
         ------
-        InvalidParameterException
+        PyegeriaInvalidParameterException
             one of the parameters is null or invalid or
-        PropertyServerException
+        PyegeriaAPIException
             There is a problem adding the element properties to the metadata repository or
-        UserNotAuthorizedException
+        PyegeriaUnauthorizedException
             the requesting user is not authorized to issue this request.
 
         Notes
@@ -1909,29 +2223,29 @@ class GovernanceOfficer(Client2):
 
         url = (
             f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/"
-            f"{self.url_marker}/governance-definitions/"
-            f"{guid}/retrieve")
+            f"{self.url_marker}/governance-action-processes/{guid}/graph")
         type = element_type if element_type else "GovernanceDefinition"
 
         response = await self._async_get_guid_request(url, _type=type,
                                                       _gen_output=self._generate_governance_definition_output,
-                                                      output_format=output_format, output_format_set=output_format_set,
+                                                      output_format=output_format, report_spec=report_spec,
                                                       body=body)
 
         return response
 
     @dynamic_catch
-    def get_governance_definition_by_guid(self, guid: str, element_type: str = None, body: dict = None,
+    def get_governance_process_graph(self, guid: str, element_type: Optional[str] = None, body: dict = None,
                                           output_format: str = "JSON",
-                                          output_format_set: dict = None) -> dict | str:
+                                          report_spec: dict = None) -> dict | str:
 
-        """ Get governance definition by guid.
+        """ Retrieve the governance action process metadata element with the supplied unique identifier
+            along with the flow definition describing its implementation.
 
         Parameters
         ----------
         guid: str
             GUID of the governance definition to get.
- 
+
         body: dict, optional
             A dictionary containing the definition of the governance definition to create.
         output_format: str, default = "JSON"
@@ -1946,11 +2260,11 @@ class GovernanceOfficer(Client2):
 
         Raises
         ------
-        InvalidParameterException
+        PyegeriaInvalidParameterException
             one of the parameters is null or invalid or
-        PropertyServerException
+        PyegeriaAPIException
             There is a problem adding the element properties to the metadata repository or
-        UserNotAuthorizedException
+        PyegeriaUnauthorizedException
             the requesting user is not authorized to issue this request.
 
         Notes
@@ -1968,14 +2282,14 @@ class GovernanceOfficer(Client2):
        """
 
         loop = asyncio.get_event_loop()
-        response = loop.run_until_complete(self._async_get_governance_definition_by_guid(guid, element_type, body,
+        response = loop.run_until_complete(self._async_get_governance_process_graph(guid, element_type, body,
                                                                                          output_format,
-                                                                                         output_format_set))
+                                                                                         report_spec))
         return response
 
     @dynamic_catch
     async def _async_link_design_to_implementation(self, design_desc_guid: str, implementation_guid: str,
-                                                   body: dict | NewRelationshipRequestBody = None) -> None:
+                                                   body: Optional[dict | NewRelationshipRequestBody] = None) -> None:
         """ Attach a design object such as a solution component or governance definition to its implementation via the
             ImplementedBy relationship. Request body is optional. Async Version.
             https://egeria-project.org/types/7/0737-Solution-Implementation/
@@ -1995,11 +2309,11 @@ class GovernanceOfficer(Client2):
 
         Raises
         ------
-        InvalidParameterException
+        PyegeriaInvalidParameterException
             one of the parameters is null or invalid or
-        PropertyServerException
+        PyegeriaAPIException
             There is a problem adding the element properties to the metadata repository or
-        UserNotAuthorizedException
+        PyegeriaUnauthorizedException
             the requesting user is not authorized to issue this request.
 
         Notes
@@ -2032,7 +2346,7 @@ class GovernanceOfficer(Client2):
 
     @dynamic_catch
     def link_design_to_implementation(self, design_desc_guid: str, implementation_guid: str,
-                                      body: dict | NewRelationshipRequestBody = None) -> None:
+                                      body: Optional[dict | NewRelationshipRequestBody] = None) -> None:
         """ Attach a design object such as a solution component or governance definition to its implementation via the
             ImplementedBy relationship. Request body is optional.
             https://egeria-project.org/types/7/0737-Solution-Implementation/
@@ -2052,11 +2366,11 @@ class GovernanceOfficer(Client2):
 
         Raises
         ------
-        InvalidParameterException
+        PyegeriaInvalidParameterException
             one of the parameters is null or invalid or
-        PropertyServerException
+        PyegeriaAPIException
             There is a problem adding the element properties to the metadata repository or
-        UserNotAuthorizedException
+        PyegeriaUnauthorizedException
             the requesting user is not authorized to issue this request.
 
         Notes
@@ -2087,7 +2401,7 @@ class GovernanceOfficer(Client2):
 
     @dynamic_catch
     async def _async_detach_design_from_implementation(self, design_desc_guid: str, implementation_guid: str,
-                                                       body: dict | DeleteRequestBody = None) -> None:
+                                                       body: Optional[dict | DeleteElementRequestBody] = None) -> None:
         """ Detach a governance definition from its implementation. Async Version.
 
         Parameters
@@ -2105,11 +2419,11 @@ class GovernanceOfficer(Client2):
 
         Raises
         ------
-        InvalidParameterException
+        PyegeriaInvalidParameterException
             one of the parameters is null or invalid or
-        PropertyServerException
+        PyegeriaAPIException
             There is a problem adding the element properties to the metadata repository or
-        UserNotAuthorizedException
+        PyegeriaUnauthorizedException
             the requesting user is not authorized to issue this request.
 
         Notes
@@ -2128,13 +2442,13 @@ class GovernanceOfficer(Client2):
 
         url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/{self.url_marker}/designs/"
                f"{design_desc_guid}/implementations/{implementation_guid}/detach")
-        await self._async_delete_request(url, body)
+        await self._async_delete_relationship_request(url, body)
         logger.info(
             f"Detached design from implementation: {design_desc_guid} -> {implementation_guid}")
 
     @dynamic_catch
     def detach_design_from_implementation(self, design_desc_guid: str, implementation_guid: str,
-                                          body: dict | DeleteRequestBody = None) -> None:
+                                          body: Optional[dict | DeleteElementRequestBody] = None) -> None:
         """ Detach a governance definition from its implementation. Request body is optional.
 
         Parameters
@@ -2152,11 +2466,11 @@ class GovernanceOfficer(Client2):
 
         Raises
         ------
-        InvalidParameterException
+        PyegeriaInvalidParameterException
             one of the parameters is null or invalid or
-        PropertyServerException
+        PyegeriaAPIException
             There is a problem adding the element properties to the metadata repository or
-        UserNotAuthorizedException
+        PyegeriaUnauthorizedException
             the requesting user is not authorized to issue this request.
 
         Notes
@@ -2177,7 +2491,7 @@ class GovernanceOfficer(Client2):
 
     @dynamic_catch
     async def _async_link_implementation_resource(self, design_desc_guid: str, implementation_guid: str,
-                                                  body: dict | NewRelationshipRequestBody = None) -> None:
+                                                  body: Optional[dict | NewRelationshipRequestBody] = None) -> None:
         """ Attach a design object such as a solution component or governance definition to one of its implementation
             resource via the ImplementationResource relationship. Request body is optional.
             https://egeria-project.org/types/7/0737-Solution-Implementation/
@@ -2197,11 +2511,11 @@ class GovernanceOfficer(Client2):
 
         Raises
         ------
-        InvalidParameterException
+        PyegeriaInvalidParameterException
             one of the parameters is null or invalid or
-        PropertyServerException
+        PyegeriaAPIException
             There is a problem adding the element properties to the metadata repository or
-        UserNotAuthorizedException
+        PyegeriaUnauthorizedException
             the requesting user is not authorized to issue this request.
 
         Notes
@@ -2235,7 +2549,7 @@ class GovernanceOfficer(Client2):
 
     @dynamic_catch
     def link_implementation_resource(self, design_desc_guid: str, implementation_guid: str,
-                                     body: dict | NewRelationshipRequestBody = None) -> None:
+                                     body: Optional[dict | NewRelationshipRequestBody] = None) -> None:
         """ Attach a design object such as a solution component or governance definition to its implementation via the
             ImplementedBy relationship. Request body is optional.
             https://egeria-project.org/types/7/0737-Solution-Implementation/
@@ -2255,11 +2569,11 @@ class GovernanceOfficer(Client2):
 
         Raises
         ------
-        InvalidParameterException
+        PyegeriaInvalidParameterException
             one of the parameters is null or invalid or
-        PropertyServerException
+        PyegeriaAPIException
             There is a problem adding the element properties to the metadata repository or
-        UserNotAuthorizedException
+        PyegeriaUnauthorizedException
             the requesting user is not authorized to issue this request.
 
         Notes
@@ -2290,7 +2604,7 @@ class GovernanceOfficer(Client2):
 
     @dynamic_catch
     async def _async_detach_implementation_resource(self, design_desc_guid: str, implementation_guid: str,
-                                                    body: dict | DeleteRequestBody = None) -> None:
+                                                    body: Optional[dict | DeleteRelationshipRequestBody] = None) -> None:
         """ Detach a design object such as a solution component or governance definition from one of its implementation
             resources. Request body is optional. Async version.
 
@@ -2309,11 +2623,11 @@ class GovernanceOfficer(Client2):
 
         Raises
         ------
-        InvalidParameterException
+        PyegeriaInvalidParameterException
             one of the parameters is null or invalid or
-        PropertyServerException
+        PyegeriaAPIException
             There is a problem adding the element properties to the metadata repository or
-        UserNotAuthorizedException
+        PyegeriaUnauthorizedException
             the requesting user is not authorized to issue this request.
 
         Notes
@@ -2332,12 +2646,12 @@ class GovernanceOfficer(Client2):
 
         url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/{self.url_marker}/designs/"
                f"{design_desc_guid}/implementation-resources/{implementation_guid}/detach")
-        await self._async_delete_request(url, body)
+        await self._async_delete_relationship_request(url, body)
         logger.info(
             f"Detached design from implementation resource: {design_desc_guid} -> {implementation_guid}")
 
     def detach_implementation_resource(self, design_desc_guid: str, implementation_guid: str,
-                                       body: dict | DeleteRequestBody = None) -> None:
+                                       body: Optional[dict | DeleteRelationshipRequestBody] = None) -> None:
         """ Detach a design object such as a solution component or governance definition from one of its implementation
             resources. Request body is optional.
 
@@ -2356,11 +2670,11 @@ class GovernanceOfficer(Client2):
 
         Raises
         ------
-        InvalidParameterException
+        PyegeriaInvalidParameterException
             one of the parameters is null or invalid or
-        PropertyServerException
+        PyegeriaAPIException
             There is a problem adding the element properties to the metadata repository or
-        UserNotAuthorizedException
+        PyegeriaUnauthorizedException
             the requesting user is not authorized to issue this request.
 
         Notes
@@ -2379,6 +2693,188 @@ class GovernanceOfficer(Client2):
         loop = asyncio.get_event_loop()
         loop.run_until_complete(self._async_detach_implementation_resource(design_desc_guid, implementation_guid, body))
 
+
+    @dynamic_catch
+    async def _async_link_governance_results(self, gov_metric_guid: str, data_asset_guid: str,
+                                                  body: Optional[dict | NewRelationshipRequestBody] = None) -> None:
+        """ Attach a governance metric to a data asset that describes where its measurements are kept.
+            Request body is optional. https://egeria-project.org/concepts/governance-definition/
+
+            Async Version.
+
+        Parameters
+        ----------
+        gov_metric_guid: str
+            guid of the governance metric to link.
+        data_asset_guid: str
+            guid of the data asset to link.
+        body: dict, optional
+            The body describing the link between the two elements.
+
+        Returns
+        -------
+        None
+
+        Raises
+        ------
+        PyegeriaException
+        ValidationError
+
+        Notes
+        ----
+
+        Body structure:
+        {
+          "class" : "NewRelationshipRequestBody",
+          "properties": {
+            "class": "GovernanceResultsProperties",
+            "description": "",
+            "effectiveFrom": "{{$isoTimestamp}}",
+            "effectiveTo": "{{$isoTimestamp}}"
+          },
+          "externalSourceGUID": "add guid here",
+          "externalSourceName": "add qualified name here",
+          "effectiveTime" : "{{$isoTimestamp}}",
+          "forLineage" : false,
+          "forDuplicateProcessing" : false
+        }
+        """
+
+        url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/{self.url_marker}/governance-metrics/"
+               f"{gov_metric_guid}/measurements/{data_asset_guid}/attach"
+               )
+        await self._async_new_relationship_request(url, "GovernanceResultsProperties", body)
+        logger.info(f"Linked governance metric to a data asset containing its measurements.: {gov_metric_guid} -> {data_asset_guid}")
+
+    @dynamic_catch
+    def link_governance_results(self, gov_metric_guid: str, data_asset_guid: str,
+                                                  body: Optional[dict | NewRelationshipRequestBody] = None) -> None:
+        """ Attach a governance metric to a data asset that describes where its measurements are kept.
+            Request body is optional. https://egeria-project.org/concepts/governance-definition/
+
+
+        Parameters
+        ----------
+        gov_metric_guid: str
+            guid of the governance metric to link.
+        data_asset_guid: str
+            guid of the data asset to link.
+        body: dict, optional
+            The body describing the link between the two elements.
+
+        Returns
+        -------
+        None
+
+        Raises
+        ------
+        PyegeriaException
+        ValidationError
+
+        Notes
+        ----
+
+        Body structure:
+        {
+          "class" : "NewRelationshipRequestBody",
+          "properties": {
+            "class": "GovernanceResultsProperties",
+            "description": "",
+            "effectiveFrom": "{{$isoTimestamp}}",
+            "effectiveTo": "{{$isoTimestamp}}"
+          },
+          "externalSourceGUID": "add guid here",
+          "externalSourceName": "add qualified name here",
+          "effectiveTime" : "{{$isoTimestamp}}",
+          "forLineage" : false,
+          "forDuplicateProcessing" : false
+        }
+        """
+        loop = asyncio.get_event_loop()
+        loop.run_until_complete(self._async_link_governance_results(gov_metric_guid, data_asset_guid, body))
+
+    @dynamic_catch
+    async def _async_detach_governance_results(self, gov_metric_guid: str, data_asset_guid: str, body: Optional[dict | DeleteRelationshipRequestBody] = None) -> None:
+        """ Detach an governance metric from its measurements data set. Request body is optional.
+            https://egeria-project.org/concepts/governance-definition/ Async version.
+
+        Parameters
+        ----------
+        gov_metric_guid: str
+            guid of the governance metric to link.
+        data_asset_guid: str
+            guid of the data asset to link.
+        body: dict, optional
+            The body describing the link between the two elements.
+
+        Returns
+        -------
+        None
+
+        Raises
+        ------
+        PyegeriaException
+        ValidationError
+
+        Notes
+        ----
+
+        Body structure:
+        {
+          "class": "MetadataSourceRequestBody",
+          "externalSourceGUID": "string",
+          "externalSourceName": "string",
+          "forLineage": true,
+          "forDuplicateProcessing": true,
+          "effectiveTime": "2025-06-13T15:13:31.339Z"
+        }
+        """
+
+        url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/{self.url_marker}/governance-metrics/"
+               f"{gov_metric_guid}/measurements/{data_asset_guid}/detach")
+        await self._async_delete_relationship_request(url, body)
+        logger.info(
+            f"Detached governance metric from the asset where measurements were stored: {gov_metric_guid} -> {data_asset_guid}")
+
+    def detach_governance_results(self, gov_metric_guid: str, data_asset_guid: str,
+                                  body: Optional[dict | DeleteRelationshipRequestBody] = None) -> None:
+        """ Detach an governance metric from its measurements data set. Request body is optional.
+             https://egeria-project.org/concepts/governance-definition/
+
+         Parameters
+         ----------
+         gov_metric_guid: str
+             guid of the governance metric to link.
+         data_asset_guid: str
+             guid of the data asset to link.
+         body: dict, optional
+             The body describing the link between the two elements.
+
+         Returns
+         -------
+         None
+
+         Raises
+         ------
+         PyegeriaException
+         ValidationError
+
+         Notes
+         ----
+
+         Body structure:
+         {
+           "class": "MetadataSourceRequestBody",
+           "externalSourceGUID": "string",
+           "externalSourceName": "string",
+           "forLineage": true,
+           "forDuplicateProcessing": true,
+           "effectiveTime": "2025-06-13T15:13:31.339Z"
+         }
+         """
+        loop = asyncio.get_event_loop()
+        loop.run_until_complete(self._async_detach_governance_results(gov_metric_guid, data_asset_guid, data_asset_guid, body))
+
     # async def _async_get_gov_def_in_context(self, guid: str, body: dict = None, output_format: str = "JSON",
     # start_from: int = 0,
     #                                         page_size: int = 0) -> list[dict] | str:
@@ -2408,11 +2904,11 @@ class GovernanceOfficer(Client2):
     #
     #         Raises
     #         ------
-    #         InvalidParameterException
+    #         PyegeriaInvalidParameterException
     #             one of the parameters is null or invalid or
-    #         PropertyServerException
+    #         PyegeriaAPIException
     #             There is a problem adding the element properties to the metadata repository or
-    #         UserNotAuthorizedException
+    #         PyegeriaUnauthorizedException
     #             the requesting user is not authorized to issue this request.
     #
     #         Notes
@@ -2477,11 +2973,11 @@ class GovernanceOfficer(Client2):
     #
     #         Raises
     #         ------
-    #         InvalidParameterException
+    #         PyegeriaInvalidParameterException
     #             one of the parameters is null or invalid or
-    #         PropertyServerException
+    #         PyegeriaAPIException
     #             There is a problem adding the element properties to the metadata repository or
-    #         UserNotAuthorizedException
+    #         PyegeriaUnauthorizedException
     #             the requesting user is not authorized to issue this request.
     #
     #         Notes