pyegeria 5.4.3.3__py3-none-any.whl → 5.4.4__py3-none-any.whl

pyegeria/{solution_architect_omvs.py → solution_architect.py}

@@ -12,13 +12,18 @@ import sys
 from typing import Any, Callable, Dict, List, Optional, Tuple, Union
 
 from httpx import Response
+from loguru import logger
+
+from pyegeria.models import NewElementRequestBody, TemplateRequestBody, UpdateElementRequestBody, \
+    NewRelationshipRequestBody, DeleteRequestBody, UpdateStatusRequestBody, SearchStringRequestBody
 from pyegeria.output_formatter import make_preamble, make_md_attribute, generate_output, extract_mermaid_only, \
-    extract_basic_dict, MD_SEPARATOR
+    extract_basic_dict, MD_SEPARATOR, populate_common_columns
+from pyegeria._output_formats import select_output_format_set, get_output_format_type_match
 from pyegeria import validate_guid
 from pyegeria.governance_officer import GovernanceOfficer
-from pyegeria._client import Client, max_paging_size
-from pyegeria._globals import NO_ELEMENTS_FOUND
-from pyegeria.utils import body_slimmer
+from pyegeria._client_new import Client2, max_paging_size
+from pyegeria._globals import NO_ELEMENTS_FOUND, NO_GUID_RETURNED
+from pyegeria.utils import body_slimmer, dynamic_catch
 from pyegeria._exceptions import (InvalidParameterException)
 
 sys.path.insert(0, os.path.abspath(os.path.dirname(__file__)))
@@ -53,7 +58,7 @@ def base_path(client, view_server: str):
     return f"{client.platform_url}/servers/{view_server}/api/open-metadata/metadata-explorer"
 
 
-class SolutionArchitect(Client):
+class SolutionArchitect(Client2):
     """SolutionArchitect is a class that extends the Client class. The Solution Architect OMVS provides APIs for
       searching for architectural elements such as information supply chains, solution blueprints, solution components,
       and component implementations.
@@ -82,7 +87,7 @@ class SolutionArchitect(Client):
         self.user_pwd = user_pwd
         self.solution_architect_command_root: str = (f"{self.platform_url}/servers/{self.view_server}"
                                                      f"/api/open-metadata/solution-architect")
-        Client.__init__(self, view_server, platform_url, user_id=user_id, user_pwd=user_pwd, token=token, )
+        Client2.__init__(self, view_server, platform_url, user_id=user_id, user_pwd=user_pwd, token=token, )
         self.url_marker = "solution-architect"
     #
     # Extract properties functions
@@ -220,7 +225,7 @@ class SolutionArchitect(Client):
         else:
             return []
 
-    def _extract_info_supply_chain_properties(self, element: dict) -> dict:
+    def _extract_info_supply_chain_properties(self, element: dict, columns_struct: dict) -> dict:
         """
         Extract properties from an information supply chain element.
 
@@ -230,63 +235,18 @@ class SolutionArchitect(Client):
         Returns:
             Dictionary with extracted properties
         """
-        guid = element['elementHeader'].get("guid", None)
-        properties = element['properties']
-        qualified_name = properties.get("qualifiedName", None)
-        display_name = properties.get("displayName", None)
-        description = properties.get("description", None)
-        scope = properties.get("scope", None)
-        purposes = properties.get("purposes", [])
-        purpose_md = ""
-        if purposes:
-            for purpose in purposes:
-                purpose_md += f"{purpose},\n"
-        extended_properties = properties.get("extendedProperties", {})
-        additional_properties = properties.get("additionalProperties", {})
-        mer = element.get('mermaidGraph', None)
-
-
-        parents = element.get("parents", [])
-        parents_list = []
-        if parents:
-            for sub in parents:
-                sub_rel_label = sub.get('relationshipProperties',{}).get("label", None)
-                sub_qn = sub['relatedElement']['properties']['qualifiedName']
-                sub_lab = f"--> <{sub_rel_label}> -->" if sub_rel_label else ""
-                sub_info = f"{sub_lab} {sub_qn}"
-                parents_list.append(sub_info)
-
-        peer_supply_chains = element.get("links", {})
-        peer_supply_chains_list = []
-        if peer_supply_chains:
-            for peer in peer_supply_chains:
-                peer_supply_chain_qnames = peer['relatedElement']['properties'].get("qualifiedName", "")
-                peer_supply_chain_label = peer['relationshipProperties'].get('label', None)
-                peer_lab = f"==> <{peer_supply_chain_label}> ==>" if peer_supply_chain_label else ""
-                peer_supply_chains_list.append(f"{peer_lab} {peer_supply_chain_qnames}")
-
-        implemented_by = element.get("implementedByList", {})
-        implemented_by_qnames = []
-        if implemented_by:
-            for peer in peer_supply_chains:
-                implemented_by_qnames.append(peer['relatedElement']['properties'].get("qualifiedName", ""))
-
-        return {
-            'GUID': guid,
-            'qualified_name': qualified_name,
-            'display_name': display_name,
-            'description': description,
-            'scope': scope,
-            'purposes': purpose_md,
-            'extended_properties': extended_properties,
-            'additional_properties': additional_properties,
-            'parents_list': parents_list,
-            'links': peer_supply_chains_list,
-            'implemented_by': implemented_by_qnames,
-            'mermaid': mer
-        }
-
-    def _extract_solution_blueprint_properties(self, element: dict) -> dict:
+        # Follow common extractor pattern using populate_common_columns
+        return populate_common_columns(
+            element,
+            columns_struct,
+            include_header=True,
+            include_relationships=True,
+            include_subject_area=True,
+            mermaid_source_key='mermaidGraph',
+            mermaid_dest_key='mermaid'
+        )
+
+    def _extract_solution_blueprint_properties(self, element: dict, columns_struct: dict) -> dict:
         """
         Extract properties from a solution blueprint element.
 
@@ -296,34 +256,17 @@ class SolutionArchitect(Client):
         Returns:
             Dictionary with extracted properties
         """
-        guid = element['elementHeader'].get("guid", None)
-        element_properties = element['properties']
-        display_name = element_properties.get("displayName", None)
-        description = element_properties.get("description", None)
-        version = element_properties.get("version", None)
-        qualified_name = element_properties.get("qualifiedName", None)
-
-        solution_components = element.get('solutionComponents', None)
-        solution_components_md = ""
-        if solution_components:
-            for solution_component in solution_components:
-                sol_comp_prop = solution_component['solutionComponent']['properties']
-                sol_comp_name = sol_comp_prop.get("displayName", None)
-                sol_comp_desc = sol_comp_prop.get("description", None)
-                solution_components_md += '{' + f" {sol_comp_name}:\t {sol_comp_desc}" + " },\n"
-        mer = f"```mermaid\n\n{element.get('mermaidGraph', None)}\n\n```"
-
-        return {
-            'GUID': guid,
-            'qualified_name': qualified_name,
-            'display_name': display_name,
-            'description': description,
-            'version': version,
-            'solution_components': solution_components_md,
-            'mermaid': mer
-        }
-
-    def _extract_solution_roles_properties(self, element: dict) -> dict:
+        return populate_common_columns(
+            element,
+            columns_struct,
+            include_header=True,
+            include_relationships=True,
+            include_subject_area=True,
+            mermaid_source_key='mermaidGraph',
+            mermaid_dest_key='mermaid'
+        )
+
+    def _extract_solution_roles_properties(self, element: dict, columns_struct: dict) -> dict:
         """
         Extract properties from a solution role element.
 
@@ -333,35 +276,15 @@ class SolutionArchitect(Client):
         Returns:
             Dictionary with extracted properties
         """
-        guid = element['elementHeader'].get("guid", None)
-        element_properties = element['properties']
-        display_name = element_properties.get("title", None)
-        role_id = element_properties.get("roleId", None)
-        scope = element_properties.get("scope", None)
-        description = element_properties.get("description", None)
-        domain_identifier = element_properties.get("domainIdentifier", None)
-        qualified_name = element_properties.get("qualifiedName", None)
-
-        solution_components = element.get('solutionComponents', None)
-        solution_components_md = ""
-        if solution_components:
-            for solution_component in solution_components:
-                sol_comp_prop = solution_component.get('relationshipProperties', None)
-                if sol_comp_prop:
-                    sol_comp_name = sol_comp_prop.get("role", None)
-                    sol_comp_desc = sol_comp_prop.get("description", None)
-                    solution_components_md += "{" + f" {sol_comp_name}:\t {sol_comp_desc}" + " },\n"
-
-        return {
-            'GUID': guid,
-            'qualified_name': qualified_name,
-            'display_name': display_name,
-            'description': description,
-            'role_id': role_id,
-            'scope': scope,
-            'domain_identifier': domain_identifier,
-            'solution_components': solution_components_md
-        }
+        return populate_common_columns(
+            element,
+            columns_struct,
+            include_header=True,
+            include_relationships=True,
+            include_subject_area=True,
+            mermaid_source_key='mermaidGraph',
+            mermaid_dest_key='mermaid'
+        )
 
 
 
@@ -548,7 +471,7 @@ class SolutionArchitect(Client):
         else:
             return []
 
-    def _extract_solution_components_properties(self, element: Union[Dict,List[Dict]]) -> dict:
+    def _extract_solution_components_properties(self, element: Union[Dict,List[Dict]], columns_struct: dict) -> dict:
         """
         Extract properties from a solution component element.
 
@@ -559,125 +482,51 @@ class SolutionArchitect(Client):
             Dictionary with extracted properties
         """
 
-        guid = element['elementHeader'].get("guid", None)
-        properties = element.get('glossaryCategoryProperties', element.get('properties', {}))
-        display_name = properties.get("displayName", None)
-        description = properties.get("description", None)
-        component_type = properties.get("solutionComponentType", properties.get("componentType", None))
-        version = properties.get("version", None)
-        qualified_name = properties.get("qualifiedName", None)
-
-        # Extract extended properties
-        extended_props = properties.get("extendedProperties", None)
-        extended_props_md = ""
-        if extended_props:
-            for key in extended_props.keys():
-                extended_props_md += "{" + f" {key}: {extended_props[key]}" + " }, "
-
-        # Extract additional properties
-        additional_props = properties.get("additionalProperties", None)
-        additional_props_md = ""
-        if additional_props:
-            for key in additional_props.keys():
-                additional_props_md += "{" + f" {key}: {additional_props[key]}" + " }, "
-
-        rel_elements = self._get_component_rel_elements_dict(element)
-
-        # actors
-        actors_md = ", ".join(rel_elements.get("actor.qnames", []) )
-
-        # Extract blueprints & supply chains
-        blueprints_md = ", ".join(rel_elements.get("blueprint_qnames",[]))
-        owning_supply_chains_md = ", ".join(rel_elements.get("owning_info_supply_chain_qnames",[]))
-
-        # Extract parent components
-        parent_comp_md = ", ".join(rel_elements.get("parent_qnames",[]))
-
-        # Extract sub-components
-        sub_comp_md = ", ".join(rel_elements.get("sub_component_qnames",[]))
-
-        # wired from and to
-        wired_from_md = ", ".join(rel_elements.get("wired_from_qnames",[]))
-        wired_to_md = ", ".join(rel_elements.get("wired_to_qnames",[]))
-
-
-        comp_graph = element.get('mermaidGraph', None)
-
-        return {
-            'GUID': guid,
-            'qualified_name': qualified_name,
-            'display_name': display_name,
-            'description': description,
-            'component_type': component_type,
-            'version': version,
-            'blueprints': blueprints_md,
-            'owning_supply_chains': owning_supply_chains_md,
-            'actors': actors_md,
-            'parent_components': parent_comp_md,
-            'sub_components': sub_comp_md,
-            'wired_from_components': wired_from_md,
-            'wired_to_components': wired_to_md,
-            'additional_properties': additional_props_md,
-            'extended_properties': extended_props_md,
-            'mermaid_graph': comp_graph
-        }
+        return populate_common_columns(
+            element,
+            columns_struct,
+            include_header=True,
+            include_relationships=True,
+            include_subject_area=True,
+            mermaid_source_key='mermaidGraph',
+            mermaid_dest_key='mermaid'
+        )
 
     #
     # Markdown output support
     #
-    def generate_info_supply_chain_output(self, elements: list | dict, search_string: str,
-                                          output_format: str = 'MD') -> str | list:
-        """
-        Generate output for information supply chains in the specified format.
-
-        Args:
-            elements: Dictionary or list of dictionaries containing information supply chain elements
-            search_string: The search string used to find the elements
-            output_format: The desired output format (MD, FORM, REPORT, LIST, DICT, MERMAID, HTML)
-
-        Returns:
-            Formatted output as string or list of dictionaries
+    def generate_info_supply_chain_output(self, elements: list | dict, search_string: str, element_type_name: str | None,
+                                          output_format: str = 'MD', output_format_set: dict | str = None) -> str | list:
+        """Render Information Supply Chains using the shared output pipeline.
         """
-        # Handle MERMAID and DICT formats
         if output_format == "MERMAID":
             return extract_mermaid_only(elements)
-        elif output_format == "DICT":
-            # return extract_basic_dict(elements)
-            return self._extract_supply_chain_list(elements)
-        elif output_format == "HTML":
-            return generate_output(
-                elements=elements, 
-                search_string=search_string, 
-                entity_type="Information Supply Chain",
-                output_format="HTML",
-                extract_properties_func=self._extract_info_supply_chain_properties
-            )
-        # For other formats (MD, FORM, REPORT, LIST), use generate_output
-        elif output_format in ["MD", "FORM", "REPORT", "LIST"]:
-            # Define columns for LIST format
-            columns = [
-                {'name': 'Name', 'key': 'display_name'}, 
-                {'name': 'Qualified Name', 'key': 'qualified_name'},
-                {'name': 'Scope', 'key': 'scope'},
-                {'name': 'Description', 'key': 'description', 'format': True},
-                {'name': 'Purposes', 'key': 'purposes', 'format': True},
-                {'name': 'Peer Links', 'key': 'links', 'format': True},
-            ]
-
-            return generate_output(
-                elements=elements, 
-                search_string=search_string, 
-                entity_type="Information Supply Chain",
-                output_format=output_format, 
-                extract_properties_func=self._extract_info_supply_chain_properties,
-                columns=columns if output_format == 'LIST' else None
-            )
-
-        # Default case
-        return None
-
-    def generate_solution_blueprint_output(self, elements: list | dict, search_string: str,
-                                           output_format: str = 'MD') -> str | list:
+
+        entity_type = "Information Supply Chain"
+        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)
+            else:
+                output_formats = None
+        else:
+            output_formats = select_output_format_set("Information Supply Chains", output_format)
+        if output_formats is None:
+            output_formats = select_output_format_set("Default", output_format)
+
+        return generate_output(
+            elements=elements,
+            search_string=search_string,
+            entity_type=entity_type,
+            output_format=output_format,
+            extract_properties_func=self._extract_info_supply_chain_properties,
+            get_additional_props_func=None,
+            columns_struct=output_formats,
+        )
+
+    def generate_solution_blueprint_output(self, elements: list | dict, search_string: str, element_type_name: str | None,
+                                           output_format: str = 'MD', output_format_set: dict | str = None) -> str | list:
         """
         Generate output for solution blueprints in the specified format.
 
@@ -689,43 +538,34 @@ class SolutionArchitect(Client):
         Returns:
             Formatted output as string or list of dictionaries
         """
-        # Handle MERMAID and DICT formats
         if output_format == "MERMAID":
             return extract_mermaid_only(elements)
-        elif output_format == "DICT":
-            return extract_basic_dict(elements)
-        elif output_format == "HTML":
-            return generate_output(
-                elements=elements, 
-                search_string=search_string, 
-                entity_type="Solution Blueprint",
-                output_format="HTML",
-                extract_properties_func=self._extract_solution_blueprint_properties
-            )
-
-        # For other formats (MD, FORM, REPORT, LIST), use generate_output
-        elif output_format in ["MD", "FORM", "REPORT", "LIST"]:
-            # Define columns for LIST format
-            columns = [
-                {'name': 'Blueprint Name', 'key': 'display_name'}, 
-                {'name': 'Qualified Name', 'key': 'qualified_name'},
-                {'name': 'Version', 'key': 'version'},
-                {'name': 'Description', 'key': 'description', 'format': True}
-            ]
-
-            return generate_output(
-                elements=elements, 
-                search_string=search_string, 
-                entity_type="Solution Blueprint",
-                output_format=output_format, 
-                extract_properties_func=self._extract_solution_blueprint_properties,
-                columns=columns if output_format == 'LIST' else None
-            )
-
-        # Default case
-        return None
-
-    def generate_solution_roles_output(self, elements: list | dict, search_string: str, output_format: str = 'MD') -> str | list:
+
+        entity_type = "Solution Blueprint"
+        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)
+            else:
+                output_formats = None
+        else:
+            output_formats = select_output_format_set("Solution Blueprints", output_format)
+        if output_formats is None:
+            output_formats = select_output_format_set("Default", output_format)
+
+        return generate_output(
+            elements=elements,
+            search_string=search_string,
+            entity_type=entity_type,
+            output_format=output_format,
+            extract_properties_func=self._extract_solution_blueprint_properties,
+            get_additional_props_func=None,
+            columns_struct=output_formats,
+        )
+
+    def generate_solution_roles_output(self, elements: list | dict, search_string: str, element_type_name: str | None,
+                                       output_format: str = 'MD', output_format_set: dict | str = None) -> str | list:
         """
         Generate output for solution roles in the specified format.
 
@@ -737,45 +577,34 @@ class SolutionArchitect(Client):
         Returns:
             Formatted output as string or list of dictionaries
         """
-        # Handle MERMAID and DICT formats
         if output_format == "MERMAID":
             return extract_mermaid_only(elements)
-        elif output_format == "DICT":
-            return extract_basic_dict(elements)
-        elif output_format == "HTML":
-            return generate_output(
-                elements=elements, 
-                search_string=search_string, 
-                entity_type="Solution Role",
-                output_format="HTML",
-                extract_properties_func=self._extract_solution_roles_properties
-            )
-
-        # For other formats (MD, FORM, REPORT, LIST), use generate_output
-        elif output_format in ["MD", "FORM", "REPORT", "LIST"]:
-            # Define columns for LIST format
-            columns = [
-                {'name': 'Role Name', 'key': 'display_name'}, 
-                {'name': 'Role ID', 'key': 'role_id'},
-                {'name': 'Scope', 'key': 'scope'},
-                {'name': 'Domain', 'key': 'domain_identifier'},
-                {'name': 'Description', 'key': 'description', 'format': True}
-            ]
-
-            return generate_output(
-                elements=elements, 
-                search_string=search_string, 
-                entity_type="Solution Role",
-                output_format=output_format, 
-                extract_properties_func=self._extract_solution_roles_properties,
-                columns=columns if output_format == 'LIST' else None
-            )
-
-        # Default case
-        return None
-
-    def generate_solution_components_output(self, elements: list | dict, search_string: str,
-                                            output_format: str = 'MD') -> str | list:
+
+        entity_type = "Solution Role"
+        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)
+            else:
+                output_formats = None
+        else:
+            output_formats = select_output_format_set("Solution Roles", output_format)
+        if output_formats is None:
+            output_formats = select_output_format_set("Default", output_format)
+
+        return generate_output(
+            elements=elements,
+            search_string=search_string,
+            entity_type=entity_type,
+            output_format=output_format,
+            extract_properties_func=self._extract_solution_roles_properties,
+            get_additional_props_func=None,
+            columns_struct=output_formats,
+        )
+
+    def generate_solution_components_output(self, elements: list | dict, search_string: str, element_type_name: str | None,
+                                            output_format: str = 'MD', output_format_set: dict | str = None) -> str | list:
         """
         Generate output for solution components in the specified format.
 
@@ -792,50 +621,39 @@ class SolutionArchitect(Client):
         Returns:
             Formatted output as string or list of dictionaries
         """
-        # Handle MERMAID and DICT formats
         if output_format == "MERMAID":
             return extract_mermaid_only(elements)
-        elif output_format == "DICT":
-            return self._extract_component_list(elements)
-            # return extract_basic_dict(elements)
-            # add more to the body
-        elif output_format == "HTML":
-            return generate_output(
-                elements=elements, 
-                search_string=search_string, 
-                entity_type="Solution Component",
-                output_format="HTML",
-                extract_properties_func=self._extract_solution_components_properties
-            )
-        # For other formats (MD, FORM, REPORT, LIST), use generate_output
-        elif output_format in ["MD", "FORM", "REPORT", "LIST"]:
-            # Define columns for LIST format
-            columns = [
-                {'name': 'Component Name', 'key': 'display_name'}, 
-                {'name': 'Component Type', 'key': 'component_type'},
-                {'name': 'Version', 'key': 'version'},
-                {'name': 'Qualified Name', 'key': 'qualified_name'},
-                {'name': 'Description', 'key': 'description', 'format': True}
-            ]
-
-            return generate_output(
-                elements=elements, 
-                search_string=search_string, 
-                entity_type="Solution Component",
-                output_format=output_format, 
-                extract_properties_func=self._extract_solution_components_properties,
-                columns=columns if output_format == 'LIST' else None
-            )
-
-        # Default case
-        return None
-
-    async def _async_create_info_supply_chain(self, body: dict) -> str:
+
+        entity_type = "Solution Component"
+        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)
+            else:
+                output_formats = None
+        else:
+            output_formats = select_output_format_set("Solution Components", output_format)
+        if output_formats is None:
+            output_formats = select_output_format_set("Default", output_format)
+
+        return generate_output(
+            elements=elements,
+            search_string=search_string,
+            entity_type=entity_type,
+            output_format=output_format,
+            extract_properties_func=self._extract_solution_components_properties,
+            get_additional_props_func=None,
+            columns_struct=output_formats,
+        )
+
+    @dynamic_catch
+    async def _async_create_info_supply_chain(self, body: dict | NewElementRequestBody) -> str:
         """Create an information supply. Async version.
 
         Parameters
         ----------
-        body: dict
+        body: dict | NewElementRequestBody
             A dictionary containing the definition of the supply chain to create.
 
         Returns
@@ -887,6 +705,7 @@ class SolutionArchitect(Client):
             "description": "add description here",
             "scope": "add scope of this information supply chain's applicability.",
             "purposes": ["purpose1", "purpose2"],
+            "estimatedVolumetrics": {},
             "additionalProperties": {
               "property1": "propertyValue1",
               "property2": "propertyValue2"
@@ -900,16 +719,15 @@ class SolutionArchitect(Client):
         url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/solution-architect/"
                f"information-supply-chains")
 
-        response = await self._async_make_request("POST", url, body_slimmer(body))
-
-        return response.json().get("guid", "Supply Chain not created")
+        return await self._async_create_element_body_request(url, ["InformationSupplyChainProperties"], body)
 
-    def create_info_supply_chain(self, body: dict) -> str:
+    @dynamic_catch
+    def create_info_supply_chain(self, body: dict | NewElementRequestBody) -> str:
         """Create an information supply.
 
         Parameters
         ----------
-        body: dict
+        body: dict | NewElementRequestBody
             A dictionary containing the definition of the supply chain to create.
 
         Returns
@@ -961,6 +779,7 @@ class SolutionArchitect(Client):
             "description": "add description here",
             "scope": "add scope of this information supply chain's applicability.",
             "purposes": ["purpose1", "purpose2"],
+             "estimatedVolumetrics": {},
             "additionalProperties": {
               "property1": "propertyValue1",
               "property2": "propertyValue2"
@@ -975,7 +794,8 @@ class SolutionArchitect(Client):
         response = loop.run_until_complete(self._async_create_info_supply_chain(body))
         return response
 
-    async def _async_create_info_supply_chain_from_template(self, body: dict) -> str:
+    @dynamic_catch
+    async def _async_create_info_supply_chain_from_template(self, body: dict | TemplateRequestBody) -> str:
         """ Create a new metadata element to represent an information supply chain using an existing metadata element
          as a template.  The template defines additional classifications and relationships that should be added to
           the new element. Async Version.
@@ -983,7 +803,7 @@ class SolutionArchitect(Client):
 
         Parameters
         ----------
-        body: dict
+        body: dict | NewElementRequestBody
             A dictionary containing the definition of the supply chain to create.
 
         Returns
@@ -1049,18 +869,27 @@ class SolutionArchitect(Client):
         url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/solution-architect/"
                f"information-supply-chains/from-template")
 
-        response = await self._async_make_request("POST", url, body_slimmer(body))
+        if isinstance(body, TemplateRequestBody):
+            validated_body = body
+
+        elif isinstance(body, dict):
+            validated_body = self._template_request_adapter.validate_python(body)
 
-        return response.json().get("guid", "Supply Chain not created")
+        json_body = validated_body.model_dump_json(indent=2, exclude_none=True)
+        logger.info(json_body)
+        resp = await self._async_make_request("POST", url, json_body, is_json=True)
+        logger.info(f"Create Supply Chain from template with GUID: {resp.json().get('guid')}")
+        return resp.json().get("guid", NO_GUID_RETURNED)
 
-    def create_info_supply_chain_from_template(self, body: dict) -> str:
+    @dynamic_catch
+    def create_info_supply_chain_from_template(self, body: dict| TemplateRequestBody) -> str:
         """ Create a new metadata element to represent an information supply chain using an existing metadata element
          as a template.  The template defines additional classifications and relationships that should be added to
           the new element.
 
         Parameters
         ----------
-        body: dict
+        body: dict | TemplateRequestBody
             A dictionary containing the definition of the supply chain to create.
 
         Returns
@@ -1128,18 +957,17 @@ class SolutionArchitect(Client):
         response = loop.run_until_complete(self._async_create_info_supply_chain_from_template(body))
         return response
 
-    async def _async_update_info_supply_chain(self, guid: str, body: dict,
-                                              replace_all_properties: bool = False) -> None:
+    @dynamic_catch
+    async def _async_update_info_supply_chain(self, guid: str, body: dict | UpdateElementRequestBody,) -> None:
         """ Update the properties of an information supply chain. Async Version.
 
         Parameters
         ----------
         guid: str
             guid of the information supply chain to update.
-        body: dict
+        body: dict | UpdateElementRequestBody
             A dictionary containing the updates to the supply chain.
-        replace_all_properties: bool, optional
-            Whether to replace all properties with those provided in the body or to merge with existing properties.
+
 
         Returns
         -------
@@ -1184,24 +1012,22 @@ class SolutionArchitect(Client):
           }
         }
         """
-        validate_guid(guid)
-        replace_all_properties_s = str(replace_all_properties).lower()
+
         url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/solution-architect/"
-               f"information-supply-chains/{guid}/update?replaceAllProperties={replace_all_properties_s}")
+               f"information-supply-chains/{guid}/update")
 
-        await self._async_make_request("POST", url, body_slimmer(body))
+        await self._async_update_element_body_request(url, ["InformationSupplyChainProperties"],body)
 
-    def update_info_supply_chain(self, guid: str, body: dict, replace_all_properties: bool = False) -> None:
+    @dynamic_catch
+    def update_info_supply_chain(self, guid: str, body: dict | UpdateElementRequestBody) -> None:
         """ Update the properties of an information supply chain. Async Version.
 
             Parameters
             ----------
             guid: str
                 guid of the information supply chain to update.
-            body: dict
+            body: dict | UpdateElementRequestBody
                 A dictionary containing the updates to the supply chain.
-            replace_all_properties: bool, optional
-                Whether to replace all properties with those provided in the body or to merge with existing properties.
 
             Returns
             -------
@@ -1247,10 +1073,10 @@ class SolutionArchitect(Client):
             }
             """
         loop = asyncio.get_event_loop()
-        loop.run_until_complete(self._async_update_info_supply_chain(guid, body, replace_all_properties))
+        loop.run_until_complete(self._async_update_info_supply_chain(guid, body))
 
-
-    async def _async_link_peer_info_supply_chain(self, peer1_guid: str, peer2_guid: str, body: dict = None) -> None:
+    @dynamic_catch
+    async def _async_link_peer_info_supply_chains(self, peer1_guid: str, peer2_guid: str, body: dict | NewRelationshipRequestBody = None) -> None:
         """ Connect two peer information supply chains.  The linked elements are of type 'Referenceable' to
         allow significant data stores to be included in the definition of the information supply chain.
         Request body is optional. Async Version.
@@ -1261,7 +1087,7 @@ class SolutionArchitect(Client):
             guid of the first information supply chain  to link.
         peer2_guid: str
             guid of the second information supply chain to link.
-        body: dict, optional
+        body: dict | NewRelationshipRequestBody, optional
             The body describing the link between the two chains.
 
         Returns
@@ -1282,7 +1108,7 @@ class SolutionArchitect(Client):
 
         Body structure:
         {
-          "class" : "RelationshipRequestBody",
+          "class" : "NewRelationshipRequestBody",
           "externalSourceGUID": "add guid here",
           "externalSourceName": "add qualified name here",
           "effectiveTime" : "{{$isoTimestamp}}",
@@ -1297,17 +1123,15 @@ class SolutionArchitect(Client):
           }
         }
         """
-        validate_guid(peer1_guid)
-        validate_guid(peer2_guid)
+
         url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/solution-architect/"
                f"information-supply-chains/{peer1_guid}/peer-links/{peer2_guid}/attach")
 
-        if body:
-            await self._async_make_request("POST", url, body_slimmer(body))
-        else:
-            await self._async_make_request("POST", url)
+        await self._async_new_relationship_request(url, ["InformationSupplyChainLinkProperties"], body)
+        logger.info(f"Linked Supply Chains {peer1_guid} -> {peer2_guid}")
 
-    def link_peer_info_supply_chain(self, peer1_guid: str, peer2_guid: str, body: dict) -> None:
+    @dynamic_catch
+    def link_peer_info_supply_chains(self, peer1_guid: str, peer2_guid: str, body: dict | NewRelationshipRequestBody) -> None:
         """ Connect two peer information supply chains.  The linked elements are of type 'Referenceable' to
         allow significant data stores to be included in the definition of the information supply chain.
         Request body is optional.
@@ -1318,7 +1142,7 @@ class SolutionArchitect(Client):
             guid of the first information supply chain  to link.
         peer2_guid: str
             guid of the second information supply chain to link.
-        body: dict
+        body: dict | NewRelationshipRequestBody, optional
             The body describing the link between the two chains.
 
         Returns
@@ -1355,10 +1179,11 @@ class SolutionArchitect(Client):
         }
         """
         loop = asyncio.get_event_loop()
-        loop.run_until_complete(self._async_link_peer_info_supply_chain(peer1_guid, peer2_guid, body))
+        loop.run_until_complete(self._async_link_peer_info_supply_chains(peer1_guid, peer2_guid, body))
 
+    @dynamic_catch
     async def _async_unlink_peer_info_supply_chains(self, peer1_guid: str, peer2_guid: str,
-                                                       body: dict = None) -> None:
+                                                       body: dict | DeleteRequestBody = None) -> None:
         """ Detach two peers in an information supply chain from one another.  The linked elements are of type
            'Referenceable' to allow significant data stores to be included in the definition of the information
            supply chain. Request body is optional. Async Version.
@@ -1369,7 +1194,7 @@ class SolutionArchitect(Client):
             guid of the first information supply chain to link.
         peer2_guid: str
             guid of the second information supply chain to link.
-        body: dict, optional
+        body: dict | DeleteRequestBody, optional
             The body describing the link between the two segments.
 
         Returns
@@ -1390,7 +1215,7 @@ class SolutionArchitect(Client):
 
         Body structure:
         {
-          "class": "MetadataSourceRequestBody",
+          "class": "DeleteRequestBody",
           "externalSourceGUID": "add guid here",
           "externalSourceName": "add qualified name here",
           "effectiveTime": {{isotime}},
@@ -1403,11 +1228,11 @@ class SolutionArchitect(Client):
         validate_guid(peer2_guid)
         url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/solution-architect/"
                f"information-supply-chains/{peer1_guid}/peer-links/{peer2_guid}/detach")
-        if body:
-            await self._async_make_request("POST", url, body_slimmer(body))
-        else:
-            await self._async_make_request("POST", url)
+        await self._async_delete_request(url, body)
+        logger.info(
+            f"Detached supply chains  {peer1_guid} -> {peer2_guid}")
 
+    @dynamic_catch
     def unlink_peer_info_supply_chains(self, peer1_guid: str, peer2_guid: str,
                                                        body: dict = None) -> None:
         """ Detach two peers in an information supply chain from one another.  The linked elements are of type
@@ -1452,7 +1277,9 @@ class SolutionArchitect(Client):
         loop = asyncio.get_event_loop()
         loop.run_until_complete(self._async_unlink_peer_info_supply_chains(peer1_guid,peer2_guid, body))
 
-    async def _async_compose_info_supply_chains(self, chain_guid: str, nested_chain_guid: str, body: dict = None) -> None:
+    @dynamic_catch
+    async def _async_compose_info_supply_chains(self, chain_guid: str, nested_chain_guid: str,
+                                                body: dict | NewRelationshipRequestBody = None) -> None:
         """ Connect a nested information supply chain to its parent. Request body is optional.
             Async Version.
 
@@ -1462,7 +1289,7 @@ class SolutionArchitect(Client):
             guid of the first information supply chain  to link.
         nested_chain_guid: str
             guid of the second information supply chain to link.
-        body: dict, optional
+        body: dict | NewRelationshipRequestBody, optional
             The body describing the link between the two chains.
 
         Returns
@@ -1483,7 +1310,7 @@ class SolutionArchitect(Client):
 
         Body structure:
         {
-          "class" : "RelationshipRequestBody",
+          "class" : "NewRelationshipRequestBody",
           "externalSourceGUID": "add guid here",
           "externalSourceName": "add qualified name here",
           "effectiveTime" : "{{$isoTimestamp}}",
@@ -1502,21 +1329,21 @@ class SolutionArchitect(Client):
         validate_guid(nested_chain_guid)
         url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/solution-architect/"
                f"information-supply-chains/{chain_guid}/compositions/{nested_chain_guid}/attach")
-        if body:
-            await self._async_make_request("POST", url, body_slimmer(body))
-        else:
-            await self._async_make_request("POST", url)
 
-    def compose_info_supply_chains(self, chain_guid: str, nested_chain_guid: str, body: dict = None) -> None:
+        await self._async_new_relationship_request(url, ["InformationSupplyChainCompositionProperties"], body)
+        logger.info(f"Linked {chain_guid} -> {nested_chain_guid}")
+
+    @dynamic_catch
+    def compose_info_supply_chains(self, chain_guid: str, nested_chain_guid: str, body: dict | NewRelationshipRequestBody = None) -> None:
         """ Connect a nested information supply chain to its parent. Request body is optional.
 
         Parameters
         ----------
         chain_guid: str
-            guid of the first information supply chain  to link.
+            guid of the first information supply chain to link.
         nested_chain_guid: str
             guid of the second information supply chain to link.
-        body: dict, optional
+        body: dict | NewRelationshipRequestBody, optional
             The body describing the link between the two chains.
 
         Returns
@@ -1537,7 +1364,7 @@ class SolutionArchitect(Client):
 
         Body structure:
         {
-          "class" : "RelationshipRequestBody",
+          "class" : "NewRelationshipRequestBody",
           "externalSourceGUID": "add guid here",
           "externalSourceName": "add qualified name here",
           "effectiveTime" : "{{$isoTimestamp}}",
@@ -1555,6 +1382,8 @@ class SolutionArchitect(Client):
         loop = asyncio.get_event_loop()
         loop.run_until_complete(self._async_compose_info_supply_chains(chain_guid, nested_chain_guid, body))
 
+
+    @dynamic_catch
     async def _async_decompose_info_supply_chains(self, chain_guid: str, nested_chain_guid: str,
                                                        body: dict = None) -> None:
         """ Detach two peers in an information supply chain from one another.  Request body is optional. Async Version.
@@ -1600,10 +1429,12 @@ class SolutionArchitect(Client):
         url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/solution-architect/"
                f"information-supply-chains/{chain_guid}/compositions/{nested_chain_guid}/detach")
 
-        await self._async_make_request("POST", url, body_slimmer(body))
+        await self._async_delete_request(url, body)
+        logger.info(f"Removed composition of {nested_chain_guid} -> {chain_guid}")
 
+    @dynamic_catch
     def decompose_info_supply_chains(self, chain_guid: str, nested_chain_guid: str,
-                                                       body: dict = None) -> None:
+                                                       body: dict | DeleteRequestBody = None) -> None:
         """ Detach two peers in an information supply chain from one another.  Request body is optional.
 
         Parameters
@@ -1612,7 +1443,7 @@ class SolutionArchitect(Client):
             guid of the first information supply chain to link.
         nested_chain_guid: str
             guid of the second information supply chain to link.
-        body: dict, optional
+        body: dict | DeleteRequestBody, optional
             The body describing the link between the two segments.
 
         Returns
@@ -1633,7 +1464,7 @@ class SolutionArchitect(Client):
 
         Body structure:
         {
-          "class": "MetadataSourceRequestBody",
+          "class": "DeleteRequestBody",
           "externalSourceGUID": "add guid here",
           "externalSourceName": "add qualified name here",
           "effectiveTime": {{isotime}},
@@ -1645,8 +1476,8 @@ class SolutionArchitect(Client):
         loop.run_until_complete(self._async_decompose_info_supply_chains(chain_guid,
                                                                          nested_chain_guid, body))
 
-
-    async def _async_delete_info_supply_chain(self, guid: str, body: dict = None, cascade_delete: bool = False) -> None:
+    @dynamic_catch
+    async def _async_delete_info_supply_chain(self, guid: str, body: dict | DeleteRequestBody = None, cascade_delete: bool = False) -> None:
         """Delete an information supply chain. Async Version.
 
            Parameters
@@ -1662,8 +1493,6 @@ class SolutionArchitect(Client):
            -------
            None
 
-           Raises
-           ------
            Raises
            ------
            InvalidParameterException
@@ -1678,7 +1507,7 @@ class SolutionArchitect(Client):
 
            Body structure:
             {
-              "class": "MetadataSourceRequestBody",
+              "class": "DeleteRequestBody",
               "externalSourceGUID": "add guid here",
               "externalSourceName": "add qualified name here",
               "effectiveTime": {{isotime}},
@@ -1686,25 +1515,23 @@ class SolutionArchitect(Client):
               "forDuplicateProcessing": false
             }
            """
-        validate_guid(guid)
-        cascaded_s = str(cascade_delete).lower()
+
 
         url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/solution-architect/"
-               f"information-supply-chains/{guid}/delete?cascadedDelete={cascaded_s}")
-        try:
-            await self._async_make_request("POST", url, body_slimmer(body))
-        except (InvalidParameterException) as e:
-            if e.exception_error_message_id == 'OMAG-REPOSITORY-HANDLER-404-007':
-                print("The GUID does not exist")
-
-    def delete_info_supply_chain(self, guid: str, body: dict = None, cascade_delete: bool = False) -> None:
+               f"information-supply-chains/{guid}/delete")
+
+        await self._async_delete_request(url, body, cascade_delete=cascade_delete)
+        logger.info(f"Deleted Info Supply Chain  {guid} with cascade {cascade_delete}")
+
+    @dynamic_catch
+    def delete_info_supply_chain(self, guid: str, body: dict | DeleteRequestBody= None, cascade_delete: bool = False) -> None:
         """ Delete an information supply chain.
 
             Parameters
             ----------
             guid: str
                 guid of the information supply chain to delete.
-            body: dict, optional
+            body: dict | DeleteRequestBody, optional
                 A dictionary containing parameters of the deletion.
            cascade_delete: bool, optional
                If true, the child objects will also be deleted.
@@ -1726,7 +1553,7 @@ class SolutionArchitect(Client):
 
             Body structure:
             {
-              "class": "MetadataSourceRequestBody",
+              "class": "DeleteRequestBody",
               "externalSourceGUID": "add guid here",
               "externalSourceName": "add qualified name here",
               "effectiveTime": {{isotime}},
@@ -1737,8 +1564,13 @@ class SolutionArchitect(Client):
         loop = asyncio.get_event_loop()
         loop.run_until_complete(self._async_delete_info_supply_chain(guid, body, cascade_delete))
 
-    def find_all_information_supply_chains(self, body: dict = None, start_from: int = 0, page_size: int = max_paging_size,
-                                           output_format: str = "JSON") -> (list[dict] | str):
+    def find_all_information_supply_chains(self, search_string: str = "*", classification_names: list[str] = None,
+                                                    metadata_element_types: list[str] = None,
+                                                    starts_with: bool = True, ends_with: bool = False,
+                                                    ignore_case: bool = False, start_from: int = 0,
+                                                    page_size: int = 0, output_format: str = 'JSON',
+                                                    output_format_set: str = None,
+                                                    body: dict| SearchStringRequestBody = None) -> (list[dict] | str):
         """ Retrieve a list of all information supply chains
              Parameters
                 ----------
@@ -1785,14 +1617,15 @@ class SolutionArchitect(Client):
                 }
         """
 
-        return self.find_information_supply_chains("*", body = body, start_from=start_from, page_size=page_size,
-                                                   output_format=output_format)
+        return self.find_information_supply_chains("*", classification_names, metadata_element_types, starts_with, ends_with, ignore_case, start_from, page_size, output_format, output_format_set, body)
 
-    async def _async_find_information_supply_chains(self, search_filter: str = "*", add_implementation: bool = True,
+    async def _async_find_information_supply_chains(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 = max_paging_size, body: dict = None,
-                                                    output_format: str = 'JSON') -> list[dict] | str:
+                                                    page_size: int = 0, output_format: str = 'JSON',
+                                                    output_format_set: str = None,
+                                                    body: dict| SearchStringRequestBody = None) -> list[dict] | str:
         """Retrieve the list of information supply chain metadata elements that contain the search string.
                https://egeria-project.org/concepts/information-supply-chain
                Async version.
@@ -1848,39 +1681,26 @@ class SolutionArchitect(Client):
             }
 
             """
-        starts_with_s = str(starts_with).lower()
-        ends_with_s = str(ends_with).lower()
-        ignore_case_s = str(ignore_case).lower()
-
-        possible_query_params = query_string(
-            [("addImplementation", add_implementation), ("startFrom", start_from), ("pageSize", page_size),
-             ("startsWith", starts_with_s), ("endsWith", ends_with_s), ("ignoreCase", ignore_case_s), ])
-
-        if search_filter is None or search_filter == "*":
-            search_filter = None
-
-        if body is None:
-            body = {
-                "filter": search_filter,
-                }
-        else:
-            body["filter"] = search_filter
-
-        url = (f"{self.solution_architect_command_root}/information-supply-chains/by-search-string"
-               f"{possible_query_params}")
-
-        response: Response = await self._async_make_request("POST", url, body_slimmer(body))
-        element = response.json().get("elements", NO_ELEMENTS_FOUND)
-        if element == NO_ELEMENTS_FOUND:
-            return NO_ELEMENTS_FOUND
-        if output_format != 'JSON':  # return a simplified markdown representation
-            return self.generate_info_supply_chain_output(element, search_filter, output_format)
-        return response.json().get("elements", NO_ELEMENTS_FOUND)
 
-    def find_information_supply_chains(self, filter: str = "*", add_implementation: bool = True,
-                                       starts_with: bool = True, ends_with: bool = False, ignore_case: bool = False,
-                                       start_from: int = 0, page_size: int = max_paging_size, body: dict = None,
-                                       output_format: str = 'JSON', ) -> list[dict] | str:
+        url = f"{self.solution_architect_command_root}/information-supply-chains/by-search-string"
+        return await self._async_find_request(url, _type="GovernanceDefinition",
+                                              _gen_output=self.generate_info_supply_chain_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)
+
+
+
+    def find_information_supply_chains(self, search_string: str = "*", classification_names: list[str] = None,
+                                    metadata_element_types: list[str] = None,
+                                    starts_with: bool = True, ends_with: bool = False,
+                                    ignore_case: bool = False, start_from: int = 0,
+                                    page_size: int = 0, output_format: str = 'JSON',
+                                    output_format_set: str = None,
+                                    body: dict| SearchStringRequestBody = None) -> list[dict] | str:
         """Retrieve the list of information supply chain metadata elements that contain the search string.
           https://egeria-project.org/concepts/information-supply-chain
 
@@ -1929,7 +1749,7 @@ class SolutionArchitect(Client):
         -----
 
             {
-              "class" : "FilterRequestBody",
+              "class" : "SearchStringRequestBody",
               "asOfTime" : "{{$isoTimestamp}}",
               "effectiveTime" : "{{$isoTimestamp}}",
               "forLineage" : false,
@@ -1943,8 +1763,10 @@ class SolutionArchitect(Client):
 
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
-            self._async_find_information_supply_chains(filter, add_implementation, starts_with, ends_with, ignore_case,
-                                                       start_from, page_size, body, output_format))
+            self._async_find_information_supply_chains(search_string, classification_names, metadata_element_types,
+                                                       starts_with, ends_with, ignore_case,
+                                                       start_from, page_size,  output_format,
+                                                       output_format_set, body))
         return response
 
     async def _async_get_info_supply_chain_by_name(self, search_filter: str, body: dict = None,
@@ -2195,7 +2017,8 @@ class SolutionArchitect(Client):
     #  Blueprints
     #
 
-    async def _async_create_solution_blueprint(self, body: dict) -> str:
+    @dynamic_catch
+    async def _async_create_solution_blueprint(self, body: dict | NewElementRequestBody) -> str:
         """ Create a solution blueprint. To set a lifecycle status
             use a NewSolutionElementRequestBody which has a default status of DRAFT. Using a
             NewElementRequestBody sets the status to ACTIVE.
@@ -2203,7 +2026,7 @@ class SolutionArchitect(Client):
 
             Parameters
             ----------
-            body: dict
+            body: dict | NewElementRequestBody
                 A dictionary containing the definition of the blueprint to create.
 
             Returns
@@ -2251,6 +2074,8 @@ class SolutionArchitect(Client):
                 "displayName": "add short name here",
                 "description": "add description here",
                 "versionIdentifier": "add version here",
+                "userDefinedStatus" : "add status here",
+                "lifecycleStatus": "DRAFT"
                 "additionalProperties": {
                   "property1": "propertyValue1",
                   "property2": "propertyValue2"
@@ -2308,18 +2133,17 @@ class SolutionArchitect(Client):
         url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/solution-architect/"
                f"solution-blueprints")
 
-        response = await self._async_make_request("POST", url, body_slimmer(body))
-
-        return response.json().get("guid", "Blueprint not created")
+        return await self._async_create_element_body_request(url, ["SolutionBlueprintProperties"], body)
 
-    def create_solution_blueprint(self, body: dict) -> str:
+    @dynamic_catch
+    def create_solution_blueprint(self, body: dict | NewElementRequestBody) -> str:
         """ Create a solution blueprint. To set a lifecycle status
             use a NewSolutionElementRequestBody which has a default status of DRAFT. Using a
             NewElementRequestBody sets the status to ACTIVE.
 
             Parameters
             ----------
-            body: dict
+            body: dict | NewElementRequestBody
                 A dictionary containing the definition of the blueprint to create.
 
             Returns
@@ -2420,13 +2244,14 @@ class SolutionArchitect(Client):
               "forDuplicateProcessing" : false
             }
 
-       """
+        """
 
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(self._async_create_solution_blueprint(body))
         return response
 
-    async def _async_create_solution_blueprint_from_template(self, body: dict) -> str:
+    @dynamic_catch
+    async def _async_create_solution_blueprint_from_template(self, body: dict | TemplateRequestBody) -> str:
         """ Create a new solution blueprint using an existing metadata element
          as a template.  The template defines additional classifications and relationships that should be added to
           the new element. Async Version.
@@ -2434,7 +2259,7 @@ class SolutionArchitect(Client):
 
         Parameters
         ----------
-        body: dict
+        body: dict | TemplateRequestBody
             A dictionary containing the definition of the solution blueprint to create.
 
         Returns
@@ -2499,19 +2324,28 @@ class SolutionArchitect(Client):
        """
         url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/solution-architect/"
                f"solution-blueprints/from-template")
+        if isinstance(body, TemplateRequestBody):
+            validated_body = body
+
+        elif isinstance(body, dict):
+            validated_body = self._template_request_adapter.validate_python(body)
 
-        response = await self._async_make_request("POST", url, body_slimmer(body))
+        json_body = validated_body.model_dump_json(indent=2, exclude_none=True)
+        logger.info(json_body)
+        resp = await self._async_make_request("POST", url, json_body, is_json=True)
+        logger.info(f"Create Blueprint from template with GUID: {resp.json().get('guid')}")
+        return resp.json().get("guid", NO_GUID_RETURNED)
 
-        return response.json().get("guid", "Blueprint not created")
 
-    def create_solution_blueprint_from_template(self, body: dict) -> str:
+    @dynamic_catch
+    def create_solution_blueprint_from_template(self, body: dict | TemplateRequestBody) -> str:
         """ Create a new solution blueprint using an existing metadata element
          as a template.  The template defines additional classifications and relationships that should be added to
           the new element.
 
         Parameters
         ----------
-        body: dict
+        body: dict | TemplateRequestBody
             A dictionary containing the definition of the solution blueprint to create.
 
         Returns
@@ -2519,8 +2353,6 @@ class SolutionArchitect(Client):
 
         str - guid of the supply chain created.
 
-        Raises
-        ------
         Raises
         ------
         InvalidParameterException
@@ -2578,26 +2410,21 @@ class SolutionArchitect(Client):
         response = loop.run_until_complete(self._async_create_solution_blueprint_from_template(body))
         return response
 
-    async def _async_update_solution_blueprint(self, guid: str, body: dict,
-                                               replace_all_properties: bool = False) -> None:
-        """ Update the properties of a solution blueprint. Async Version.
+    @dynamic_catch
+    async def _async_update_solution_blueprint(self, guid: str, body: dict | UpdateElementRequestBody) -> None:
+        """ Update a solution blueprint. Async Version.
 
         Parameters
         ----------
         guid: str
             guid of the information supply chain to update.
-        body: dict
+        body: dict | UpdateElementRequestBody
             A dictionary containing the updates to the supply chain.
-        replace_all_properties: bool, optional
-            Whether to replace all properties with those provided in the body or to merge with existing properties.
-
         Returns
         -------
 
         None
 
-        Raises
-        ------
         Raises
         ------
         InvalidParameterException
@@ -2633,24 +2460,22 @@ class SolutionArchitect(Client):
            }
         }
         """
-        validate_guid(guid)
-        replace_all_properties_s = str(replace_all_properties).lower()
+
         url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/solution-architect/"
-               f"solution-blueprints/{guid}/update?replaceAllProperties={replace_all_properties_s}")
+               f"solution-blueprints/{guid}/update")
 
-        await self._async_make_request("POST", url, body_slimmer(body))
+        await self._async_update_element_body_request(url, ["SolutionBlueprintProperties"],body)
 
-    def update_solution_blueprint(self, guid: str, body: dict, replace_all_properties: bool = False) -> None:
+    @dynamic_catch
+    def update_solution_blueprint(self, guid: str, body: dict | UpdateElementRequestBody) -> None:
         """ Update the properties of a solution blueprint. Async Version.
 
             Parameters
             ----------
             guid: str
                 guid of the information supply chain to update.
-            body: dict
-                A dictionary containing the updates to the supply chain.
-            replace_all_properties: bool, optional
-                Whether to replace all properties with those provided in the body or to merge with existing properties.
+            body: dict | UpdateElementRequestBody
+                A dictionary containing the updates to the blueprint.
 
             Returns
             -------
@@ -2696,18 +2521,110 @@ class SolutionArchitect(Client):
             }
             """
         loop = asyncio.get_event_loop()
-        loop.run_until_complete(self._async_update_solution_blueprint(guid, body, replace_all_properties))
+        loop.run_until_complete(self._async_update_solution_blueprint(guid, body))
+
+
+    @dynamic_catch
+    async def _async_delete_solution_blueprint(self, guid: str, body: dict | DeleteRequestBody, cascade: bool = False) -> None:
+        """ Delete a solution blueprint. Async Version.
+         Parameters
+           ----------
+           guid: str
+               guid of the information supply chain to delete.
+           body: dict, optional
+               A dictionary containing parameters of the deletion.
+           cascade: bool, optional
+               If true, the child objects will also be deleted.
+
+           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": "DeleteRequestBody",
+              "externalSourceGUID": "add guid here",
+              "externalSourceName": "add qualified name here",
+              "effectiveTime": {{isotime}},
+              "forLineage": false,
+              "forDuplicateProcessing": false
+            }
+           """
+
+        url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/solution-architect/"
+               f"information-supply-chains/{guid}/delete")
+
+        await self._async_delete_request(url, body, cascade_delete=cascade)
+        logger.info(f"Deleted Info Supply Chain  {guid} with cascade {cascade}")
+
+    @dynamic_catch
+    def delete_solution_blueprint(self, guid: str, body: dict | DeleteRequestBody = None,
+                                 cascade: bool = False) -> None:
+        """ Delete an Solution Blueprint.
+
+            Parameters
+            ----------
+            guid: str
+                guid of the information supply chain to delete.
+            body: dict | DeleteRequestBody, optional
+                A dictionary containing parameters of the deletion.
+           cascade: bool, optional
+               If true, the child objects will also be deleted.
+            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": "DeleteRequestBody",
+              "externalSourceGUID": "add guid here",
+              "externalSourceName": "add qualified name here",
+              "effectiveTime": {{isotime}},
+              "forLineage": false,
+              "forDuplicateProcessing": false
+            }
+            """
+        loop = asyncio.get_event_loop()
+        loop.run_until_complete(self._async_delete_info_supply_chain(guid, body, cascade))
+
 
-    async def _async_update_solution_element_status(self, guid: str, body: dict,
-                                               replace_all_properties: bool = False) -> None:
+    @dynamic_catch
+    async def _async_update_solution_element_status(self, guid: str, status: str= None, body: dict| UpdateStatusRequestBody = None,
+                                               ) -> None:
         """ Update the properties of a blueprint, solution component, or solution port. Async Version.
 
         Parameters
         ----------
         guid: str
             guid of the information supply chain to update.
-        body: dict
+        body: dict | UpdateStatusRequestBody, optional
             A dictionary containing the updates to the supply chain.
+        status: str, optional
+            The status to update the supply chain to.
 
         Returns
         -------
@@ -2728,7 +2645,7 @@ class SolutionArchitect(Client):
 
         Body structure:
              {
-              "class" : "SolutionElementStatusRequestBody",
+              "class" : "UpdateStatusRequestBody",
               "status" : "APPROVED",
               "externalSourceGUID": "add guid here",
               "externalSourceName": "add qualified name here",
@@ -2737,14 +2654,14 @@ class SolutionArchitect(Client):
               "forDuplicateProcessing" : false
             }
         """
-        validate_guid(guid)
-        replace_all_properties_s = str(replace_all_properties).lower()
+
         url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/solution-architect/"
-               f"solution-blueprints/{guid}/update?replaceAllProperties={replace_all_properties_s}")
+               f"solution-blueprints/{guid}/update")
 
-        await self._async_make_request("POST", url, body_slimmer(body))
+        await self._async_update_status_request(url, status, body)
 
-    def update_solution_element_status(self, guid: str, body: dict) -> None:
+    @dynamic_catch
+    def update_solution_element_status(self, guid: str, status: str = None, body: dict| UpdateStatusRequestBody = None) -> None:
         """ Update the status of a blueprint, solution component, or solution port.
 
             Parameters
@@ -2782,12 +2699,12 @@ class SolutionArchitect(Client):
             }
             """
         loop = asyncio.get_event_loop()
-        loop.run_until_complete(self._async_update_solution_element_status(guid, body))
-
+        loop.run_until_complete(self._async_update_solution_element_status(guid = guid, status= status, body=body))
 
 
+    @dynamic_catch
     async def _async_link_solution_component_to_blueprint(self, blueprint_guid: str, component_guid: str,
-                                                          body: dict) -> None:
+                                                          body: dict | NewRelationshipRequestBody) -> None:
         """ Connect a solution component to a blueprint. Async Version.
 
         Parameters
@@ -2796,7 +2713,7 @@ class SolutionArchitect(Client):
             guid of the blueprint to connect to.
         component_guid: str
             guid of the component to link.
-        body: dict
+        body: dict | NewRelationshipRequestBody
             The body describing the link.
 
         Returns
@@ -2817,7 +2734,7 @@ class SolutionArchitect(Client):
 
         Body structure:
         {
-          "class" : "RelationshipRequestBody",
+          "class" : "NewRelationshipRequestBody",
           "properties": {
             "class": "SolutionBlueprintCompositionProperties",
             "role": "Add role that the component plays in the solution blueprint here",
@@ -2833,14 +2750,15 @@ class SolutionArchitect(Client):
         }
 
         """
-        validate_guid(blueprint_guid)
-        validate_guid(component_guid)
+
         url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/solution-architect/"
                f"solution-blueprints/{blueprint_guid}/solution-components/{component_guid}/attach")
 
-        await self._async_make_request("POST", url, body_slimmer(body))
+        await self._async_new_relationship_request(url, ["SolutionComponentCompositionProperties"], body)
+        logger.info(f"Linked component to blueprint {component_guid} -> {blueprint_guid}")
 
-    def link_solution_component_to_blueprint(self, blueprint_guid: str, component_guid: str, body: dict) -> None:
+    @dynamic_catch
+    def link_solution_component_to_blueprint(self, blueprint_guid: str, component_guid: str, body: dict | NewRelationshipRequestBody) -> None:
         """ Connect a solution component to a blueprint.
 
         Parameters
@@ -2849,7 +2767,7 @@ class SolutionArchitect(Client):
             guid of the blueprint to connect to.
         component_guid: str
             guid of the component to link.
-        body: dict
+        body: dict | NewRelationshipRequestBody
             The body describing the link.
 
         Returns
@@ -2888,8 +2806,9 @@ class SolutionArchitect(Client):
         loop = asyncio.get_event_loop()
         loop.run_until_complete(self._async_link_solution_component_to_blueprint(blueprint_guid, component_guid, body))
 
+    @dynamic_catch
     async def _async_detach_solution_component_from_blueprint(self, blueprint_guid: str, component_guid: str,
-                                                              body: dict = None) -> None:
+                                                              body: dict | DeleteRequestBody = None) -> None:
         """ Detach a solution component from a solution blueprint.
             Async Version.
 
@@ -2929,15 +2848,17 @@ class SolutionArchitect(Client):
         }
 
         """
-        validate_guid(blueprint_guid)
-        validate_guid(component_guid)
+
         url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/solution-architect/"
                f"solution-blueprints/{blueprint_guid}/solution-components/{component_guid}/detach")
 
-        await self._async_make_request("POST", url, body_slimmer(body))
+        await self._async_delete_request(url, body)
+        logger.info(
+            f"Detached component from blueprint  {component_guid} -> {blueprint_guid}")
 
+    @dynamic_catch
     def detach_solution_component_from_blueprint(self, blueprint_guid: str, component_guid: str,
-                                                 body: dict = None) -> None:
+                                                 body: dict | DeleteRequestBody = None) -> None:
         """ Detach a solution component from a solution blueprint.
 
         Parameters
@@ -2980,8 +2901,10 @@ class SolutionArchitect(Client):
         loop.run_until_complete(
             self._async_detach_solution_component_from_blueprint(blueprint_guid, component_guid, body))
 
+
+    @dynamic_catch
     async def _async_delete_solution_blueprint(self, blueprint_guid: str, cascade_delete: bool = False,
-                                               body: dict = None) -> None:
+                                               body: dict | DeleteRequestBody = None) -> None:
         """Delete a solution blueprint. Async Version.
 
            Parameters
@@ -3022,15 +2945,14 @@ class SolutionArchitect(Client):
             }
            """
         validate_guid(blueprint_guid)
-        cascaded_s = str(cascade_delete).lower()
+
         url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/solution-architect/"
-               f"solution-blueprints/{blueprint_guid}/delete?cascadeDelete={cascaded_s}")
-        if body:
-            await self._async_make_request("POST", url, body_slimmer(body))
-        else:
-            await self._async_make_request("POST", url)
+               f"solution-blueprints/{blueprint_guid}/delete")
+        await self._async_delete_request(url, body, cascade_delete=cascade_delete)
+        logger.info(f"Deleted Blueprint  {blueprint_guid} with cascade {cascade_delete}")
 
-    def delete_solution_blueprint(self, blueprint_guid: str, cascade_delete: bool = False, body: dict = None) -> None:
+    @dynamic_catch
+    def delete_solution_blueprint(self, blueprint_guid: str, cascade_delete: bool = False, body: dict | DeleteRequestBody = None) -> None:
         """ Delete a solution blueprint.
             Parameters
             ----------
@@ -3071,10 +2993,15 @@ class SolutionArchitect(Client):
         loop.run_until_complete(self._async_delete_solution_blueprint(blueprint_guid, cascade_delete, body))
 
 
-    async def _async_find_solution_blueprints(self, search_filter: str = "*", starts_with: bool = True,
-                                              ends_with: bool = False, ignore_case: bool = False, start_from: int = 0,
-                                              page_size: int = max_paging_size, body: dict = None,
-                                              output_format: str = "JSON") -> list[dict] | str:
+
+
+    async def _async_find_solution_blueprints(self, search_string: str = "*", classification_names: list[str] = None,
+                                    metadata_element_types: list[str] = None,
+                                    starts_with: bool = True, ends_with: bool = False,
+                                    ignore_case: bool = False, start_from: int = 0,
+                                    page_size: int = 0, output_format: str = 'JSON',
+                                    output_format_set: str = None,
+                                    body: dict| SearchStringRequestBody = None) -> list[dict] | str:
         """Retrieve the solution blueprint elements that contain the search string.
            https://egeria-project.org/concepts/solution-blueprint
            Async version.
@@ -3127,37 +3054,28 @@ class SolutionArchitect(Client):
         }
 
         """
-        starts_with_s = str(starts_with).lower()
-        ends_with_s = str(ends_with).lower()
-        ignore_case_s = str(ignore_case).lower()
 
-        possible_query_params = query_string(
-            [("startFrom", start_from), ("pageSize", page_size),
-             ("startsWith", starts_with_s), ("endsWith", ends_with_s), ("ignoreCase", ignore_case_s), ])
 
-        if search_filter is None or search_filter == "*":
-            search_filter = None
 
-        if body is None:
-            body = {
-                "filter": search_filter,
-                }
-        else:
-            body["filter"] = search_filter
 
-        url = (f"{self.solution_architect_command_root}/solution-blueprints/by-search-string"
-               f"{possible_query_params}")
-        response: Response = await self._async_make_request("POST", url, body_slimmer(body))
-        element = response.json().get("elements", NO_ELEMENTS_FOUND)
-        if element == NO_ELEMENTS_FOUND:
-            return NO_ELEMENTS_FOUND
-        if output_format != 'JSON':  # return a simplified markdown representation
-            return self.generate_solution_blueprint_output(element, search_filter, output_format)
-        return response.json().get("elements", NO_ELEMENTS_FOUND)
+        url = f"{self.solution_architect_command_root}/solution-blueprints/by-search-string"
+        return await self._async_find_request(url, _type="GovernanceDefinition",
+                                              _gen_output=self.generate_info_supply_chain_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)
+
 
-    def find_solution_blueprints(self, filter: str = "*", starts_with: bool = True, ends_with: bool = False,
-                                 ignore_case: bool = False, start_from: int = 0, page_size: int = max_paging_size,
-                                 body: dict = None, output_format: str = 'JSON') -> list[dict] | str:
+    def find_solution_blueprints(self, search_string: str = "*", classification_names: list[str] = None,
+                                    metadata_element_types: list[str] = None,
+                                    starts_with: bool = True, ends_with: bool = False,
+                                    ignore_case: bool = False, start_from: int = 0,
+                                    page_size: int = 0, output_format: str = 'JSON',
+                                    output_format_set: str = None,
+                                    body: dict| SearchStringRequestBody = None) -> list[dict] | str:
         """Retrieve the list of solution blueprint elements that contain the search string.
            https://egeria-project.org/concepts/solution-blueprint
 
@@ -3217,17 +3135,24 @@ class SolutionArchitect(Client):
 
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
-            self._async_find_solution_blueprints(filter, starts_with, ends_with, ignore_case, start_from, page_size,
-                                                 body, output_format))
+            self._async_find_solution_blueprints(search_string, classification_names, metadata_element_types,
+                                                  starts_with, ends_with, ignore_case, start_from,
+                                                  page_size, output_format, output_format_set, body))
         return response
 
-    def find_all_solution_blueprints(self, start_from: int = 0, page_size: int = max_paging_size,
-                                     output_format: str = "JSON") -> list[dict] | str:
+    def find_all_solution_blueprints(self, classification_names: list[str] = None,
+                                    metadata_element_types: list[str] = None,
+                                    starts_with: bool = True, ends_with: bool = False,
+                                    ignore_case: bool = False, start_from: int = 0,
+                                    page_size: int = 0, output_format: str = 'JSON',
+                                    output_format_set: str = None,
+                                    body: dict| SearchStringRequestBody = None) -> list[dict] | str:
         """Retrieve a list of all solution blueprint elements
         https://egeria-project.org/concepts/solution-blueprint
         """
-        return self.find_solution_blueprints("*", start_from=start_from, page_size=page_size,
-                                             output_format=output_format)
+        return self.find_solution_blueprints("*", classification_names, metadata_element_types,
+                                              starts_with, ends_with, ignore_case, start_from,
+                                              page_size, output_format, output_format_set, body)
 
 
     async def _async_get_solution_blueprint_by_guid(self, guid: str, body: dict = None,
@@ -3467,7 +3392,8 @@ class SolutionArchitect(Client):
     #   Components
     #
 
-    async def _async_create_solution_component(self, body: dict) -> str:
+    @dynamic_catch
+    async def _async_create_solution_component(self, body: dict | NewElementRequestBody) -> str:
         """Create a solution component. To set a lifecycle status
             use a NewSolutionElementRequestBody which has a default status of DRAFT. Using a
             NewElementRequestBody sets the status to ACTIVE.
@@ -3475,7 +3401,8 @@ class SolutionArchitect(Client):
 
         Parameters
         ----------
-        body: dict
+        body: dict | NewElementRequestBody
+            A dictionary containing parameters of the creation.
             A dictionary containing the definition of the component to create.
 
         Returns
@@ -3500,7 +3427,7 @@ class SolutionArchitect(Client):
 
         Body structure:
         {
-          "class": "NewSolutionComponentRequestBody",
+          "class": "NewElementRequestBody",
           "externalSourceGUID": "add guid here",
           "externalSourceName": "add qualified name here",
           "effectiveTime": {{isotime}},
@@ -3545,61 +3472,22 @@ class SolutionArchitect(Client):
           "forDuplicateProcessing" : false
         }
 
-        Without lifecycle:
-        {
-          "class" : "NewElementRequestBody",
-          "anchorGUID" : "add guid here",
-          "isOwnAnchor": false,
-          "parentGUID": "add guid here",
-          "parentRelationshipTypeName": "add type name here",
-          "parentRelationshipProperties": {
-            "class": "ElementProperties",
-            "propertyValueMap" : {
-              "description" : {
-                "class": "PrimitiveTypePropertyValue",
-                "typeName": "string",
-                "primitiveValue" : "New description"
-              }
-            }
-          },
-          "parentAtEnd1": false,
-          "properties": {
-            "class" : "SolutionComponentProperties",
-            "qualifiedName": "add unique name here",
-            "displayName": "add short name here",
-            "description": "add description here",
-            "solutionComponentType": "add optional type for this component",
-            "versionIdentifier": "add version for this component",
-            "plannedDeployedImplementationType": "add details of the type of implementation for this component",
-            "additionalProperties": {
-              "property1" : "propertyValue1",
-              "property2" : "propertyValue2"
-            },
-            "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/solution-architect/"
                f"solution-components")
 
-        response = await self._async_make_request("POST", url, body_slimmer(body))
-
-        return response.json().get("guid", "Solution component not created")
+        return await self._async_create_element_body_request(url, ["SolutionComponentProperties"], body)
 
-    def create_solution_component(self, body: dict) -> str:
+    @dynamic_catch
+    def create_solution_component(self, body: dict | NewElementRequestBody) -> str:
         """Create a solution component. To set a lifecycle status
             use a NewSolutionElementRequestBody which has a default status of DRAFT. Using a
             NewElementRequestBody sets the status to ACTIVE.
 
         Parameters
         ----------
-        body: dict
+        body: dict | NewElementRequestBody
             A dictionary containing the definition of the component to create.
 
         Returns
@@ -3624,7 +3512,7 @@ class SolutionArchitect(Client):
 
         Body structure:
         {
-          "class": "NewSolutionComponentRequestBody",
+          "class": "NewElementRequestBody",
           "externalSourceGUID": "add guid here",
           "externalSourceName": "add qualified name here",
           "effectiveTime": {{isotime}},
@@ -3669,52 +3557,15 @@ class SolutionArchitect(Client):
           "forDuplicateProcessing" : false
         }
 
-        Without lifecycle:
-        {
-          "class" : "NewElementRequestBody",
-          "anchorGUID" : "add guid here",
-          "isOwnAnchor": false,
-          "parentGUID": "add guid here",
-          "parentRelationshipTypeName": "add type name here",
-          "parentRelationshipProperties": {
-            "class": "ElementProperties",
-            "propertyValueMap" : {
-              "description" : {
-                "class": "PrimitiveTypePropertyValue",
-                "typeName": "string",
-                "primitiveValue" : "New description"
-              }
-            }
-          },
-          "parentAtEnd1": false,
-          "properties": {
-            "class" : "SolutionComponentProperties",
-            "qualifiedName": "add unique name here",
-            "displayName": "add short name here",
-            "description": "add description here",
-            "solutionComponentType": "add optional type for this component",
-            "versionIdentifier": "add version for this component",
-            "plannedDeployedImplementationType": "add details of the type of implementation for this component",
-            "additionalProperties": {
-              "property1" : "propertyValue1",
-              "property2" : "propertyValue2"
-            },
-            "effectiveFrom": "{{$isoTimestamp}}",
-            "effectiveTo": "{{$isoTimestamp}}"
-          },
-          "externalSourceGUID": "add guid here",
-          "externalSourceName": "add qualified name here",
-          "effectiveTime" : "{{$isoTimestamp}}",
-          "forLineage" : false,
-          "forDuplicateProcessing" : false
-        }
+
        """
 
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(self._async_create_solution_component(body))
         return response
 
-    async def _async_create_solution_component_from_template(self, body: dict) -> str:
+    @dynamic_catch
+    async def _async_create_solution_component_from_template(self, body: dict| TemplateRequestBody) -> str:
         """ Create a new solution component using an existing metadata element
          as a template.  The template defines additional classifications and relationships that should be added to
           the new element. Async Version.
@@ -3722,7 +3573,7 @@ class SolutionArchitect(Client):
 
         Parameters
         ----------
-        body: dict
+        body: dict | TemplateRequestBody
             A dictionary containing the definition of the solution component to create.
 
         Returns
@@ -3786,11 +3637,20 @@ class SolutionArchitect(Client):
         url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/solution-architect/"
                f"solution-components/from-template")
 
-        response = await self._async_make_request("POST", url, body_slimmer(body))
+        if isinstance(body, TemplateRequestBody):
+            validated_body = body
 
-        return response.json().get("guid", "Component not created")
+        elif isinstance(body, dict):
+            validated_body = self._template_request_adapter.validate_python(body)
 
-    def create_solution_component_from_template(self, body: dict) -> str:
+        json_body = validated_body.model_dump_json(indent=2, exclude_none=True)
+        logger.info(json_body)
+        resp = await self._async_make_request("POST", url, json_body, is_json=True)
+        logger.info(f"Create Solution Component from template with GUID: {resp.json().get('guid')}")
+        return resp.json().get("guid", NO_GUID_RETURNED)
+
+    @dynamic_catch
+    def create_solution_component_from_template(self, body: dict| TemplateRequestBody) -> str:
         """ Create a new solution component using an existing metadata element
                  as a template.  The template defines additional classifications and relationships that should be
                  added to
@@ -3799,7 +3659,7 @@ class SolutionArchitect(Client):
 
                 Parameters
                 ----------
-                body: dict
+                body: dict| TemplateRequestBody
                     A dictionary containing the definition of the solution component to create.
 
                 Returns
@@ -3865,26 +3725,22 @@ class SolutionArchitect(Client):
         response = loop.run_until_complete(self._async_create_solution_component_from_template(body))
         return response
 
-    async def _async_update_solution_component(self, guid: str, body: dict,
-                                               replace_all_properties: bool = False) -> None:
+    @dynamic_catch
+    async def _async_update_solution_component(self, guid: str, body: dict | UpdateElementRequestBody,
+                                               ) -> None:
         """ Update the properties of a solution component. Async Version.
 
         Parameters
         ----------
         guid: str
             guid of the solution component to update.
-        body: dict
+        body: dict | UpdateElementRequestBody
             A dictionary containing the updates to the component.
-        replace_all_properties: bool, optional
-            Whether to replace all properties with those provided in the body or to merge with existing properties.
 
         Returns
         -------
-
         None
 
-        Raises
-        ------
         Raises
         ------
         InvalidParameterException
@@ -3923,32 +3779,26 @@ class SolutionArchitect(Client):
         }
 
         """
-        validate_guid(guid)
-        replace_all_properties_s = str(replace_all_properties).lower()
+
         url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/solution-architect/"
-               f"solution-components/{guid}/update?replaceAllProperties={replace_all_properties_s}")
+               f"solution-components/{guid}/update")
 
-        await self._async_make_request("POST", url, body_slimmer(body))
+        await self._async_update_element_body_request(url, ["SolutionComponentProperties"], body)
 
-    def update_solution_component(self, guid: str, body: dict, replace_all_properties: bool = False) -> None:
+    @dynamic_catch
+    def update_solution_component(self, guid: str, body: dict | UpdateElementRequestBody) -> None:
         """ Update the properties of a solution component. Async Version.
 
         Parameters
         ----------
         guid: str
             guid of the solution component to update.
-        body: dict
+        body: dict | UpdateElementRequestBody
             A dictionary containing the updates to the component.
-        replace_all_properties: bool, optional
-            Whether to replace all properties with those provided in the body or to merge with existing properties.
-
         Returns
         -------
-
         None
 
-        Raises
-        ------
         Raises
         ------
         InvalidParameterException
@@ -3988,9 +3838,10 @@ class SolutionArchitect(Client):
 
             """
         loop = asyncio.get_event_loop()
-        loop.run_until_complete(self._async_update_solution_component(guid, body, replace_all_properties))
+        loop.run_until_complete(self._async_update_solution_component(guid, body))
 
-    async def _async_link_subcomponent(self, component_guid: str, sub_component_guid: str, body: dict) -> None:
+    @dynamic_catch
+    async def _async_link_subcomponent(self, component_guid: str, sub_component_guid: str, body: dict | NewRelationshipRequestBody) -> None:
         """ Attach a solution component to a solution component. Async Version.
 
         Parameters
@@ -3999,7 +3850,7 @@ class SolutionArchitect(Client):
             guid of the blueprint to connect to.
         sub_component_guid: str
             guid of the component to link.
-        body: dict
+        body: dict | NewRelationshipRequestBody
             The body describing the link.
 
         Returns
@@ -4020,25 +3871,23 @@ class SolutionArchitect(Client):
 
         Body structure:
         {
-          "class" : "RelationshipRequestBody",
+          "class": "NewRelationshipRequestBody",
           "externalSourceGUID": "add guid here",
           "externalSourceName": "add qualified name here",
-          "effectiveTime" : "{{$isoTimestamp}}",
-          "forLineage" : false,
-          "forDuplicateProcessing" : false
+          "effectiveTime": "{{$isoTimestamp}}",
+          "forLineage": false,
+          "forDuplicateProcessing": false
         }
         """
-        validate_guid(component_guid)
-        validate_guid(sub_component_guid)
+
         url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/solution-architect/"
                f"solution-components/{component_guid}/subcomponents/{sub_component_guid}/attach")
-        if body:
-            await self._async_make_request("POST", url, body_slimmer(body))
-        else:
-            await self._async_make_request("POST", url)
 
+        await self._async_new_relationship_request(url, ["SolutionCompositionProperties"], body)
+        logger.info(f"Linked Subcomponent {component_guid} -> {sub_component_guid}")
 
-    def link_subcomponent(self, component_guid: str, sub_component_guid: str, body: dict) -> None:
+    @dynamic_catch
+    def link_subcomponent(self, component_guid: str, sub_component_guid: str, body: dict | NewRelationshipRequestBody) -> None:
         """ Attach a solution component to a solution component.
 
                 Parameters
@@ -4047,7 +3896,7 @@ class SolutionArchitect(Client):
                     guid of the blueprint to connect to.
                 sub_component_guid: str
                     guid of the component to link.
-                body: dict
+                body: dict | NewRelationshipRequestBody
                     The body describing the link.
 
                 Returns
@@ -4068,7 +3917,7 @@ class SolutionArchitect(Client):
 
                 Body structure:
                 {
-                  "class" : "RelationshipRequestBody",
+                  "class" : "NewRelationshipRequestBody",
                   "externalSourceGUID": "add guid here",
                   "externalSourceName": "add qualified name here",
                   "effectiveTime" : "{{$isoTimestamp}}",
@@ -4078,9 +3927,9 @@ class SolutionArchitect(Client):
                 """
         loop = asyncio.get_event_loop()
         loop.run_until_complete(self._async_link_subcomponent(component_guid, sub_component_guid, body))
-
+    @dynamic_catch
     async def _async_detach_sub_component(self, parent_component_guid: str, member_component_guid: str,
-                                          body: dict = None) -> None:
+                                          body: dict |DeleteRequestBody = None) -> None:
         """ Detach a solution component from a solution component.
             Async Version.
 
@@ -4111,7 +3960,7 @@ class SolutionArchitect(Client):
 
         Body structure:
         {
-          "class": "MetadataSourceRequestBody",
+          "class": "DeleteRequestBody",
           "externalSourceGUID": "add guid here",
           "externalSourceName": "add qualified name here",
           "effectiveTime": {{isotime}},
@@ -4120,14 +3969,16 @@ class SolutionArchitect(Client):
         }
 
         """
-        validate_guid(parent_component_guid)
-        validate_guid(member_component_guid)
+
         url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/solution-architect/"
                f"solution-components/{parent_component_guid}/subcomponents/{member_component_guid}/detach")
 
-        await self._async_make_request("POST", url, body_slimmer(body))
+        await self._async_delete_request(url, body)
+        logger.info(
+            f"Detached components  {parent_component_guid} -> {member_component_guid}")
 
-    def detach_sub_component(self, parent_component_guid: str, member_component_guid: str, body: dict = None) -> None:
+    @dynamic_catch
+    def detach_sub_component(self, parent_component_guid: str, member_component_guid: str, body: dict| DeleteRequestBody = None) -> None:
         """ Detach a solution component from a solution component.
             Async Version.
 
@@ -4137,7 +3988,7 @@ class SolutionArchitect(Client):
             guid of the parent component to disconnect from.
         member_component_guid: str
             guid of the member (child) component to disconnect.
-        body: dict
+        body: dict | DeleteRequestBody
             The body describing the request.
 
         Returns
@@ -4158,7 +4009,7 @@ class SolutionArchitect(Client):
 
         Body structure:
         {
-          "class": "MetadataSourceRequestBody",
+          "class": "DeleteRequestBody",
           "externalSourceGUID": "add guid here",
           "externalSourceName": "add qualified name here",
           "effectiveTime": {{isotime}},
@@ -4170,7 +4021,8 @@ class SolutionArchitect(Client):
         loop = asyncio.get_event_loop()
         loop.run_until_complete(self._async_detach_sub_component(parent_component_guid, member_component_guid, body))
 
-    async def _async_link_solution_linking_wire(self, component1_guid: str, component2_guid: str, body: dict) -> None:
+    @dynamic_catch
+    async def _async_link_solution_linking_wire(self, component1_guid: str, component2_guid: str, body: dict | NewRelationshipRequestBody) -> None:
         """ Attach a solution component to a solution component as a peer in a solution. Async Version.
 
         Parameters
@@ -4179,9 +4031,10 @@ class SolutionArchitect(Client):
             GUID of the first component to link.
         component2_guid: str
            GUID of the second component to link.
-        body: dict
+        body: dict | NewRelationshipRequestBody
             The body describing the link.
 
+
         Returns
         -------
         None
@@ -4200,7 +4053,7 @@ class SolutionArchitect(Client):
 
         Body structure:
         {
-          "class": "RelationshipRequestBody",
+          "class": "NewRelationshipRequestBody",
           "externalSourceGUID": "add guid here",
           "externalSourceName": "add qualified name here",
           "properties": {
@@ -4214,16 +4067,14 @@ class SolutionArchitect(Client):
           "forDuplicateProcessing": false
         }
         """
-        validate_guid(component1_guid)
-        validate_guid(component2_guid)
+
         url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/solution-architect/"
                f"solution-components/{component1_guid}/wired-to/{component2_guid}/attach")
-        if body:
-            await self._async_make_request("POST", url, body_slimmer(body))
-        else:
-            await self._async_make_request("POST", url)
+        await self._async_new_relationship_request(url, ["SolutionLinkingWireProperties"], body)
+        logger.info(f"Linked Solution Linking wires between {component1_guid} -> {component2_guid}")
 
-    def link_solution_linking_wire(self, component1_guid: str, component2_guid: str, body: dict) -> None:
+    @dynamic_catch
+    def link_solution_linking_wire(self, component1_guid: str, component2_guid: str, body: dict | NewRelationshipRequestBody) -> None:
         """ Attach a solution component to a solution component as a peer in a solution.
 
                 Parameters
@@ -4232,7 +4083,7 @@ class SolutionArchitect(Client):
                     GUID of the first component to link.
                 component2_guid: str
                    GUID of the second component to link.
-                body: dict
+                body: dict | NewRelationshipRequestBody
                     The body describing the link.
 
                 Returns
@@ -4253,7 +4104,7 @@ class SolutionArchitect(Client):
 
                 Body structure:
                 {
-                  "class": "RelationshipRequestBody",
+                  "class": "NewRelationshipRequestBody",
                   "externalSourceGUID": "add guid here",
                   "externalSourceName": "add qualified name here",
                   "properties": {
@@ -4270,8 +4121,9 @@ class SolutionArchitect(Client):
         loop = asyncio.get_event_loop()
         loop.run_until_complete(self._async_link_solution_linking_wire(component1_guid, component2_guid, body))
 
+    @dynamic_catch
     async def _async_detach_solution_linking_wire(self, component1_guid: str, component2_guid: str,
-                                                  body: dict = None) -> None:
+                                                  body: dict | DeleteRequestBody = None) -> None:
         """ Detach a solution component from a peer solution component.
             Async Version.
 
@@ -4281,7 +4133,7 @@ class SolutionArchitect(Client):
             GUID of the first component to unlink.
         component2_guid: str
             GUID of the second component to unlink.
-        body: dict
+        body: dict | DeleteRequestBody
             The body describing the request.
 
         Returns
@@ -4302,7 +4154,7 @@ class SolutionArchitect(Client):
 
         Body structure:
         {
-          "class" : "MetadataSourceRequestBody",
+          "class" : "DeleteRequestBody",
           "externalSourceGUID": "add guid here",
           "externalSourceName": "add qualified name here",
           "effectiveTime" : "{{$isoTimestamp}}",
@@ -4311,14 +4163,16 @@ class SolutionArchitect(Client):
         }
 
         """
-        validate_guid(component1_guid)
-        validate_guid(component2_guid)
+
         url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/solution-architect/"
                f"solution-components/{component1_guid}/wired-to/{component2_guid}/detach")
 
-        await self._async_make_request("POST", url, body_slimmer(body))
+        await self._async_delete_request(url, body)
+        logger.info(
+            f"Detached solution linking wire between  {component1_guid} -> {component2_guid}")
 
-    def detach_solution_linking_wire(self, component1_guid: str, component2_guid: str, body: dict = None) -> None:
+    @dynamic_catch
+    def detach_solution_linking_wire(self, component1_guid: str, component2_guid: str, body: dict | DeleteRequestBody = None) -> None:
         """ Detach a solution component from a peer solution component.
                     Async Version.
 
@@ -4328,7 +4182,8 @@ class SolutionArchitect(Client):
                     GUID of the first component to unlink.
                 component2_guid: str
                     GUID of the second component to unlink.
-                body: dict
+                body: dict | DeleteRequestBody
+                    The body describing the request.
                     The body describing the request.
 
                 Returns
@@ -4349,7 +4204,7 @@ class SolutionArchitect(Client):
 
                 Body structure:
                 {
-                  "class" : "MetadataSourceRequestBody",
+                  "class" : "DeleteRequestBody",
                   "externalSourceGUID": "add guid here",
                   "externalSourceName": "add qualified name here",
                   "effectiveTime" : "{{$isoTimestamp}}",
@@ -4361,9 +4216,9 @@ class SolutionArchitect(Client):
         loop = asyncio.get_event_loop()
         loop.run_until_complete(self._async_detach_solution_linking_wire(component1_guid, component2_guid, body))
 
-
+    @dynamic_catch
     async def _async_delete_solution_component(self, solution_component_guid: str, cascade_delete: bool = False,
-                                               body: dict = None) -> None:
+                                               body: dict  | DeleteRequestBody= None) -> None:
         """Delete a solution component. Async Version.
 
            Parameters
@@ -4372,7 +4227,7 @@ class SolutionArchitect(Client):
                guid of the component to delete.
            cascade_delete: bool, optional, default: False
                Cascade the delete to dependent objects?
-           body: dict, optional
+           body: dict | DeleteRequestBody, optional
                A dictionary containing parameters for the deletion.
 
            Returns
@@ -4393,7 +4248,7 @@ class SolutionArchitect(Client):
 
            Body structure:
             {
-              "class": "MetadataSourceRequestBody",
+              "class": "DeleteRequestBody",
               "externalSourceGUID": "add guid here",
               "externalSourceName": "add qualified name here",
               "effectiveTime": {{isotime}},
@@ -4401,18 +4256,16 @@ class SolutionArchitect(Client):
               "forDuplicateProcessing": false
             }
            """
-        validate_guid(solution_component_guid)
-        cascaded_s = str(cascade_delete).lower()
+
 
         url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/solution-architect/"
-               f"solution-components/{solution_component_guid}/delete?cascadeDelete={cascade_delete}")
-        if body:
-            await self._async_make_request("POST", url, body_slimmer(body))
-        else:
-            await self._async_make_request("POST", url)
+               f"solution-components/{solution_component_guid}/delete")
+        await self._async_delete_request(url, body, cascade_delete=cascade_delete)
+        logger.info(f"Deleted Solution Component  {solution_component_guid} with cascade {cascade_delete}")
 
+    @dynamic_catch
     def delete_solution_component(self, solution_component_guid: str, cascade_delete: bool = False,
-                                  body: dict = None) -> None:
+                                  body: dict | DeleteRequestBody = None) -> None:
         """Delete a solution component.
            Parameters
            ----------
@@ -4420,7 +4273,7 @@ class SolutionArchitect(Client):
                guid of the component to delete.
            cascade_delete: bool, optional, default: False
                Cascade the delete to dependent objects?
-           body: dict, optional
+           body: dict | DeleteRequestBody, optional
                A dictionary containing parameters for the deletion.
 
            Returns
@@ -4441,7 +4294,7 @@ class SolutionArchitect(Client):
 
            Body structure:
             {
-              "class": "MetadataSourceRequestBody",
+              "class": "DeleteRequestBody",
               "externalSourceGUID": "add guid here",
               "externalSourceName": "add qualified name here",
               "effectiveTime": {{isotime}},
@@ -4452,10 +4305,13 @@ class SolutionArchitect(Client):
         loop = asyncio.get_event_loop()
         loop.run_until_complete(self._async_delete_solution_component(solution_component_guid, cascade_delete, body))
 
-    async def _async_find_solution_components(self, search_filter: str = "*", starts_with: bool = True,
-                                              ends_with: bool = False, ignore_case: bool = False, start_from: int = 0,
-                                              page_size: int = 0, body: dict = None,
-                                              output_format: str = "JSON") -> list[dict] | str:
+    async def _async_find_solution_components(self, search_string: str = "*", classification_names: list[str] = None,
+                                    metadata_element_types: list[str] = None,
+                                    starts_with: bool = True, ends_with: bool = False,
+                                    ignore_case: bool = False, start_from: int = 0,
+                                    page_size: int = 0, output_format: str = 'JSON',
+                                    output_format_set: str = None,
+                                    body: dict| SearchStringRequestBody = None) -> list[dict] | str:
         """ Retrieve the solution component elements that contain the search string. The solutions components returned
             include information about consumers, actors, and other solution components that are associated with them.
             https://egeria-project.org/concepts/solution-components
@@ -4511,35 +4367,26 @@ class SolutionArchitect(Client):
         }
         """
 
-        starts_with_s = str(starts_with).lower()
-        ends_with_s = str(ends_with).lower()
-        ignore_case_s = str(ignore_case).lower()
 
-        possible_query_params = query_string(
-            [ ("startFrom", start_from), ("pageSize", page_size),
-             ("startsWith", starts_with_s), ("endsWith", ends_with_s), ("ignoreCase", ignore_case_s), ])
 
-        if search_filter is None or search_filter == "*":
-            search_filter = None
+        url = f"{self.solution_architect_command_root}/solution-components/by-search-string"
 
-        if body is None:
-            body = {
-                "filter": search_filter,
-                }
+        return await self._async_find_request(url, _type="GovernanceDefinition",
+                                              _gen_output=self.generate_info_supply_chain_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)
 
-        url = (f"{self.solution_architect_command_root}/solution-components/by-search-string"
-               f"{possible_query_params}")
-        response: Response = await self._async_make_request("POST", url, body_slimmer(body))
-        element = response.json().get("elements", NO_ELEMENTS_FOUND)
-        if element == NO_ELEMENTS_FOUND:
-            return NO_ELEMENTS_FOUND
-        if output_format != 'JSON':  # return a simplified markdown representation
-            return self.generate_solution_components_output(element, filter, output_format)
-        return response.json().get("elements", NO_ELEMENTS_FOUND)
-
-    def find_solution_components(self, search_filter: str = "*", starts_with: bool = True, ends_with: bool = False,
-                                 ignore_case: bool = False, start_from: int = 0, page_size: int = 0,
-                                 body: dict = None, output_format: str = "JSON") -> list[dict] | str:
+    def find_solution_components(self, search_string: str = "*", classification_names: list[str] = None,
+                                    metadata_element_types: list[str] = None,
+                                    starts_with: bool = True, ends_with: bool = False,
+                                    ignore_case: bool = False, start_from: int = 0,
+                                    page_size: int = 0, output_format: str = 'JSON',
+                                    output_format_set: str = None,
+                                    body: dict| SearchStringRequestBody = None) -> list[dict] | str:
         """ Retrieve the solution component elements that contain the search string. The solutions components returned
             include information about consumers, actors, and other solution components that are associated with them.
             https://egeria-project.org/concepts/solution-components
@@ -4597,17 +4444,20 @@ class SolutionArchitect(Client):
 
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
-            self._async_find_solution_components(search_filter, starts_with, ends_with, ignore_case, start_from,
-                                                 page_size, body, output_format))
+            self._async_find_solution_components(search_string, classification_names, metadata_element_types, starts_with, ends_with, ignore_case, start_from, page_size, output_format, output_format_set, body))
         return response
 
-    def find_all_solution_components(self, body: dict = None, start_from: int = 0, page_size: int = max_paging_size,
-                                     output_format: str = "JSON") -> list[dict] | str:
+    def find_all_solution_components(self, classification_names: list[str] = None,
+                                    metadata_element_types: list[str] = None,
+                                    starts_with: bool = True, ends_with: bool = False,
+                                    ignore_case: bool = False, start_from: int = 0,
+                                    page_size: int = 0, output_format: str = 'JSON',
+                                    output_format_set: str = None,
+                                    body: dict| SearchStringRequestBody = None) -> list[dict] | str:
         """Retrieve a list of all solution component elements
         https://egeria-project.org/concepts/solution-components
         """
-        return self.find_solution_components("*", body = body, start_from=start_from, page_size=page_size,
-                                             output_format=output_format)
+        return self.find_solution_components("*", classification_names, metadata_element_types, starts_with, ends_with, ignore_case, start_from, page_size, output_format, output_format_set, body)
 
     async def _async_get_solution_components_by_name(self, search_filter: str, body: dict = None, start_from: int = 0,
                                                      page_size: int = 0, output_format: str = "JSON") -> dict | str:
@@ -5018,22 +4868,20 @@ class SolutionArchitect(Client):
     #
     #   Roles
     #
-
-    async def _async_create_solution_role(self, body: dict) -> str:
+    @dynamic_catch
+    async def _async_create_solution_role(self, body: dict | NewElementRequestBody) -> str:
         """ Create a solution role. Async version.
 
         Parameters
         ----------
-        body: dict
-            A dictionary containing the definition of the role to create.
+        body: dict | NewElementRequestBody
+            A dictionary containing the properties of the solution role to create.
 
         Returns
         -------
 
         str - guid of the role created.
 
-        Raises
-        ------
         Raises
         ------
         InvalidParameterException
@@ -5087,17 +4935,16 @@ class SolutionArchitect(Client):
         url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/solution-architect/"
                f"solution-roles")
 
-        response = await self._async_make_request("POST", url, body_slimmer(body))
+        return await self._async_create_element_body_request(url, ["SolutionRoleProperties"], body)
 
-        return response.json().get("guid", "Solution role not created")
-
-    def create_solution_role(self, body: dict) -> str:
+    @dynamic_catch
+    def create_solution_role(self, body: dict| NewElementRequestBody) -> str:
         """Create a solution role. Async version.
 
         Parameters
         ----------
-        body: dict
-            A dictionary containing the definition of the role to create.
+        body: dict | NewElementRequestBody
+            A dictionary containing the properties of the solution role to create.
 
         Returns
         -------
@@ -5162,7 +5009,8 @@ class SolutionArchitect(Client):
         response = loop.run_until_complete(self._async_create_solution_role(body))
         return response
 
-    async def _async_create_solution_role_from_template(self, body: dict) -> str:
+    @dynamic_catch
+    async def _async_create_solution_role_from_template(self, body: dict | TemplateRequestBody) -> str:
         """ Create a new metadata element to represent a solution role using an existing metadata element as a template.
             The template defines additional classifications and relationships that should be added to the new element.
             Async Version.
@@ -5170,8 +5018,9 @@ class SolutionArchitect(Client):
 
         Parameters
         ----------
-        body: dict
-            A dictionary containing the definition of the solution component to create.
+        body: dict | TemplateRequestBody
+            A dictionary containing the properties of the solution role to create.
+
 
         Returns
         -------
@@ -5233,12 +5082,20 @@ class SolutionArchitect(Client):
        """
         url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/solution-architect/"
                f"solution-roles/from-template")
+        if isinstance(body, TemplateRequestBody):
+            validated_body = body
 
-        response = await self._async_make_request("POST", url, body_slimmer(body))
+        elif isinstance(body, dict):
+            validated_body = self._template_request_adapter.validate_python(body)
 
-        return response.json().get("guid", "Role not created")
+        json_body = validated_body.model_dump_json(indent=2, exclude_none=True)
+        logger.info(json_body)
+        resp = await self._async_make_request("POST", url, json_body, is_json=True)
+        logger.info(f"Create Solution Role from template with GUID: {resp.json().get('guid')}")
+        return resp.json().get("guid", NO_GUID_RETURNED)
 
-    def create_solution_role_from_template(self, body: dict) -> str:
+    @dynamic_catch
+    def create_solution_role_from_template(self, body: dict |TemplateRequestBody) -> str:
         """ Create a new solution component using an existing metadata element
                  as a template.  The template defines additional classifications and relationships that should be
                  added to
@@ -5247,8 +5104,8 @@ class SolutionArchitect(Client):
 
                 Parameters
                 ----------
-                body: dict
-                    A dictionary containing the definition of the solution component to create.
+                body: dict | TemplateRequestBody
+                    A dictionary containing the properties of the solution role to create.
 
                 Returns
                 -------
@@ -5313,7 +5170,8 @@ class SolutionArchitect(Client):
         response = loop.run_until_complete(self._async_create_solution_role_from_template(body))
         return response
 
-    async def _async_update_solution_role(self, guid: str, body: dict, replace_all_properties: bool = False) -> None:
+    @dynamic_catch
+    async def _async_update_solution_role(self, guid: str, body: dict |UpdateElementRequestBody) -> None:
         """ Update the properties of a solution role. Async Version.
 
         Parameters
@@ -5368,24 +5226,22 @@ class SolutionArchitect(Client):
         }
 
         """
-        validate_guid(guid)
-        replace_all_properties_s = str(replace_all_properties).lower()
+
         url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/solution-architect/"
-               f"solution-roles/{guid}/update?replaceAllProperties={replace_all_properties_s}")
+               f"solution-roles/{guid}/update")
 
-        await self._async_make_request("POST", url, body_slimmer(body))
+        await self._async_update_element_body_request(url, ["SolutionRoleProperties"], body)
 
-    def update_solution_role(self, guid: str, body: dict, replace_all_properties: bool = False) -> None:
+    @dynamic_catch
+    def update_solution_role(self, guid: str, body: dict | UpdateElementRequestBody) -> None:
         """ Update the properties of a solution role.
 
         Parameters
         ----------
         guid: str
             guid of the solution role to update.
-        body: dict
-            A dictionary containing the updates to the component.
-        replace_all_properties: bool, optional, default is False
-            Whether to replace all properties with those provided in the body or to merge with existing properties.
+        body: dict | UpdateElementRequestBody
+            A dictionary containing the updates to the role.
 
         Returns
         -------
@@ -5430,9 +5286,10 @@ class SolutionArchitect(Client):
         }
             """
         loop = asyncio.get_event_loop()
-        loop.run_until_complete(self._async_update_solution_role(guid, body, replace_all_properties))
+        loop.run_until_complete(self._async_update_solution_role(guid, body))
 
-    async def _async_link_component_to_actor(self, role_guid: str, component_guid: str, body: dict) -> None:
+    @dynamic_catch
+    async def _async_link_component_to_actor(self, role_guid: str, component_guid: str, body: dict | NewRelationshipRequestBody) -> None:
         """ Attach a solution component to a solution role. Async Version.
 
         Parameters
@@ -5441,8 +5298,8 @@ class SolutionArchitect(Client):
             guid of the role to link.
         component_guid: str
             guid of the component to link.
-        body: dict
-            The body describing the link.
+        body: dict | NewRelationshipRequestBody
+            A dictionary containing the properties of the relationship to create.
 
         Returns
         -------
@@ -5462,7 +5319,7 @@ class SolutionArchitect(Client):
 
         Body structure:
         {
-          "class" : "RelationshipRequestBody",
+          "class" : "NewRelationshipRequestBody",
           "properties": {
             "class": "SolutionComponentActorProperties",
             "role": "Add role here",
@@ -5477,14 +5334,15 @@ class SolutionArchitect(Client):
           "forDuplicateProcessing" : false
         }
         """
-        validate_guid(component_guid)
-        validate_guid(role_guid)
+
         url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/solution-architect/"
                f"solution-roles/{role_guid}/solution-roles/{component_guid}/attach")
 
-        await self._async_make_request("POST", url, body_slimmer(body))
+        await self._async_new_relationship_request(url, ["InformationSupplyChainLinkProperties"], body)
+        logger.info(f"Linked Role to Component {role_guid} -> {component_guid}")
 
-    def link_component_to_actor(self, role_guid: str, component_guid: str, body: dict) -> None:
+    @dynamic_catch
+    def link_component_to_actor(self, role_guid: str, component_guid: str, body: dict | NewRelationshipRequestBody) -> None:
         """ Attach a solution component to a solution role.
 
             Parameters
@@ -5493,8 +5351,8 @@ class SolutionArchitect(Client):
                 guid of the role to link.
             component_guid: str
                 guid of the component to link.
-            body: dict
-                The body describing the link.
+            body: dict | NewRelationshipRequestBody
+                A dictionary containing the properties of the relationship to create.
 
             Returns
             -------
@@ -5514,7 +5372,7 @@ class SolutionArchitect(Client):
 
             Body structure:
             {
-              "class" : "RelationshipRequestBody",
+              "class" : "NewRelationshipRequestBody",
               "properties": {
                 "class": "SolutionComponentActorProperties",
                 "role": "Add role here",
@@ -5533,7 +5391,8 @@ class SolutionArchitect(Client):
         loop = asyncio.get_event_loop()
         loop.run_until_complete(self._async_link_component_to_actor(role_guid, component_guid, body))
 
-    async def _async_detach_component_actor(self, role_guid: str, component_guid: str, body: dict = None) -> None:
+    @dynamic_catch
+    async def _async_detach_component_actor(self, role_guid: str, component_guid: str, body: dict | DeleteRequestBody = None) -> None:
         """ Detach a solution role from a solution component.
             Async Version.
 
@@ -5543,8 +5402,8 @@ class SolutionArchitect(Client):
             guid of the role to disconnect from.
         component_guid: str
             guid of the component to disconnect.
-        body: dict
-            The body describing the request.
+        body: dict | DeleteRequestBody, optional
+            A dictionary containing the properties of the relationship to create.
 
         Returns
         -------
@@ -5564,7 +5423,7 @@ class SolutionArchitect(Client):
 
         Body structure:
         {
-          "class": "MetadataSourceRequestBody",
+          "class": "DeleteRequestBody",
           "externalSourceGUID": "add guid here",
           "externalSourceName": "add qualified name here",
           "effectiveTime": {{isotime}},
@@ -5573,14 +5432,16 @@ class SolutionArchitect(Client):
         }
 
         """
-        validate_guid(role_guid)
-        validate_guid(component_guid)
+
         url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/solution-architect/"
                f"solution-components/{role_guid}/solution-component-actors/{component_guid}/detach")
 
-        await self._async_make_request("POST", url, body_slimmer(body))
+        await self._async_delete_request(url, body)
+        logger.info(
+            f"Detached role from component  {role_guid} -> {component_guid}")
 
-    def detach_component_actore(self, role_guid: str, component_guid: str, body: dict = None) -> None:
+    @dynamic_catch
+    def detach_component_actore(self, role_guid: str, component_guid: str, body: dict |DeleteRequestBody = None) -> None:
         """ Detach a solution role from a solution component.
 
         Parameters
@@ -5589,8 +5450,8 @@ class SolutionArchitect(Client):
             guid of the role to disconnect from.
         component_guid: str
             guid of the component to disconnect.
-        body: dict
-            The body describing the request.
+        body: dict | DeleteRequestBody, optional
+            A dictionary containing the properties of the relationship to create.
 
         Returns
         -------
@@ -5610,7 +5471,7 @@ class SolutionArchitect(Client):
 
         Body structure:
         {
-          "class": "MetadataSourceRequestBody",
+          "class": "DeleteRequestBody",
           "externalSourceGUID": "add guid here",
           "externalSourceName": "add qualified name here",
           "effectiveTime": {{isotime}},
@@ -5621,15 +5482,15 @@ class SolutionArchitect(Client):
         loop = asyncio.get_event_loop()
         loop.run_until_complete(self._async_detach_component_actor(role_guid, component_guid, body))
 
-
-    async def _async_delete_solution_role(self, guid: str,  body: dict = None, cascade_delete: bool = False,) -> None:
+    @dynamic_catch
+    async def _async_delete_solution_role(self, guid: str,  body: dict | DeleteRequestBody= None, cascade_delete: bool = False,) -> None:
         """Delete a solution role. Async Version.
 
            Parameters
            ----------
            guid: str
                guid of the role to delete.
-            body: dict, optional
+            body: dict | DeleteRequestBody, optional
                A dictionary containing parameters for the deletion.
            cascade_delete: bool, optional, default: False
                Cascade the delete to dependent objects?
@@ -5653,7 +5514,7 @@ class SolutionArchitect(Client):
 
            Body structure:
             {
-              "class": "MetadataSourceRequestBody",
+              "class": "DeleteRequestBody",
               "externalSourceGUID": "add guid here",
               "externalSourceName": "add qualified name here",
               "effectiveTime": {{isotime}},
@@ -5661,22 +5522,22 @@ class SolutionArchitect(Client):
               "forDuplicateProcessing": false
             }
            """
-        validate_guid(guid)
-        cascaded_s = str(cascade_delete).lower()
 
         url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/solution-architect/"
-               f"solution-roles/{guid}/delete?cascadedDelete={cascaded_s}")
+               f"solution-roles/{guid}/delete")
 
-        await self._async_make_request("POST", url, body_slimmer(body))
+        await self._async_delete_request(url, body, cascade_delete=cascade_delete)
+        logger.info(f"Delete solution rule  {guid} with cascade {cascade_delete}")
 
-    def delete_solution_role(self, guid: str, body: dict = None,cascade_delete: bool = False) -> None:
+    @dynamic_catch
+    def delete_solution_role(self, guid: str, body: dict | DeleteRequestBody = None,cascade_delete: bool = False) -> None:
         """Delete a solution role. Async Version.
 
            Parameters
            ----------
            guid: str
                guid of the role to delete.
-           body: dict, optional
+           body: dict | DeleteRequestBody, optional
                A dictionary containing parameters for the deletion.
            cascade_delete: bool, optional, default: False
                Cascade the delete to dependent objects?
@@ -5699,7 +5560,7 @@ class SolutionArchitect(Client):
 
            Body structure:
             {
-              "class": "MetadataSourceRequestBody",
+              "class": "DeleteRequestBody",
               "externalSourceGUID": "add guid here",
               "externalSourceName": "add qualified name here",
               "effectiveTime": {{isotime}},
@@ -5710,10 +5571,13 @@ class SolutionArchitect(Client):
         loop = asyncio.get_event_loop()
         loop.run_until_complete(self._async_delete_solution_role(guid, cascade_delete, body))
 
-    async def _async_find_solution_roles(self, search_filter: str = "*", body: dict = 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", ) -> list[dict] | str:
+    async def _async_find_solution_roles(self, search_string: str = "*", classification_names: list[str] = None,
+                                    metadata_element_types: list[str] = None,
+                                    starts_with: bool = True, ends_with: bool = False,
+                                    ignore_case: bool = False, start_from: int = 0,
+                                    page_size: int = 0, output_format: str = 'JSON',
+                                    output_format_set: str = None,
+                                    body: dict| SearchStringRequestBody = None) -> list[dict] | str:
         """Retrieve the solution role elements that contain the search string.
            https://egeria-project.org/concepts/actor
            Async version.
@@ -5769,34 +5633,26 @@ class SolutionArchitect(Client):
           "filter": "Add name here"
         }
         """
-        starts_with_s = str(starts_with).lower()
-        ends_with_s = str(ends_with).lower()
-        ignore_case_s = str(ignore_case).lower()
-
-        possible_query_params = query_string(
-            [ ("startFrom", start_from), ("pageSize", page_size),
-             ("startsWith", starts_with_s), ("endsWith", ends_with_s), ("ignoreCase", ignore_case_s), ])
-        if search_filter is None or search_filter == "*":
-            search_filter = None
 
-        if body is None:
-            body = {
-                "filter": search_filter,
-                }
-
-        url = (f"{self.solution_architect_command_root}/solution-roles/by-search-string"
-               f"{possible_query_params}")
-        response: Response = await self._async_make_request("POST", url, body_slimmer(body))
-        element = response.json().get("elements", NO_ELEMENTS_FOUND)
-        if element == NO_ELEMENTS_FOUND:
-            return NO_ELEMENTS_FOUND
-        if output_format != 'JSON':  # return a simplified markdown representation
-            return self.generate_solution_roles_output(element, filter, output_format)
-        return response.json().get("elements", NO_ELEMENTS_FOUND)
 
-    def find_solution_roles(self, search_filter: str = "*", body: dict = None, starts_with: bool = True, ends_with: bool = False,
-                            ignore_case: bool = False, start_from: int = 0, page_size: int = max_paging_size,
-                            output_format: str = "JSON", ) -> list[dict] | str:
+        url = f"{self.solution_architect_command_root}/solution-roles/by-search-string"
+
+        return await self._async_find_request(url, _type="GovernanceDefinition",
+                                              _gen_output=self.generate_info_supply_chain_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)
+
+    def find_solution_roles(self, search_string: str = "*", classification_names: list[str] = None,
+                                    metadata_element_types: list[str] = None,
+                                    starts_with: bool = True, ends_with: bool = False,
+                                    ignore_case: bool = False, start_from: int = 0,
+                                    page_size: int = 0, output_format: str = 'JSON',
+                                    output_format_set: str = None,
+                                    body: dict| SearchStringRequestBody = None) -> list[dict] | str:
         """Retrieve the list of solution role elements that contain the search string.
            https://egeria-project.org/concepts/actor
 
@@ -5860,16 +5716,20 @@ class SolutionArchitect(Client):
 
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
-            self._async_find_solution_roles(search_filter, body, starts_with, ends_with, ignore_case, start_from, page_size,
-                                             output_format=output_format, ))
+            self._async_find_solution_roles(search_string, classification_names, metadata_element_types, starts_with, ends_with, ignore_case, start_from, page_size, output_format, output_format_set, body))
         return response
 
-    def find_all_solution_roles(self, body: dict = None, start_from: int = 0, page_size: int = max_paging_size,
-                                output_format: str = "JSON") -> list[dict] | str:
+    def find_all_solution_roles(self,  classification_names: list[str] = None,
+                                    metadata_element_types: list[str] = None,
+                                    starts_with: bool = True, ends_with: bool = False,
+                                    ignore_case: bool = False, start_from: int = 0,
+                                    page_size: int = 0, output_format: str = 'JSON',
+                                    output_format_set: str = None,
+                                    body: dict| SearchStringRequestBody = None) -> list[dict] | str:
         """Retrieve a list of all solution blueprint elements
         https://egeria-project.org/concepts/actor
         """
-        return self.find_solution_roles("*", body,  start_from=start_from, page_size=page_size, output_format=output_format)
+        return self.find_solution_roles("*", classification_names, metadata_element_types, starts_with, ends_with, ignore_case, start_from, page_size, output_format, output_format_set, body)
 
 
     async def _async_get_solution_roles_by_name(self, search_filter: str, body: dict = None, start_from: int = 0,