pyegeria 5.4.4.6__py3-none-any.whl → 5.4.4.7__py3-none-any.whl

pyegeria/{automated_curation_omvs.py → automated_curation.py}

@@ -11,20 +11,18 @@ import datetime
 
 from httpx import Response
 
-from pyegeria.utils import body_slimmer
-from pyegeria._globals import NO_ELEMENTS_FOUND
-from pyegeria._client import Client
-from pyegeria import TEMPLATE_GUIDS, max_paging_size
+from pyegeria._client_new import Client2
 from pyegeria._exceptions import (
     InvalidParameterException,
     PropertyServerException,
     UserNotAuthorizedException,
 )
-
+from pyegeria.models import GetRequestBody, FilterRequestBody
+from pyegeria.utils import body_slimmer
 from ._validators import validate_guid, validate_name, validate_search_string
 
 
-class AutomatedCuration(Client):
+class AutomatedCuration(Client2):
     """Set up and maintain automation services in Egeria.
 
     Attributes:
@@ -42,18 +40,18 @@ class AutomatedCuration(Client):
     """
 
     def __init__(
-        self,
-        view_server: str,
-        platform_url: str,
-        user_id: str,
-        user_pwd: str = None,
-        token: str = None,
+            self,
+            view_server: str,
+            platform_url: str,
+            user_id: str,
+            user_pwd: str = None,
+            token: str = None,
     ):
         self.view_server = view_server
         self.platform_url = platform_url
         self.user_id = user_id
         self.user_pwd = user_pwd
-        Client.__init__(self, view_server, platform_url, user_id, user_pwd, token=token)
+        Client2.__init__(self, view_server, platform_url, user_id, user_pwd, token=token)
         self.curation_command_root = f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/automated-curation"
 
     async def _async_create_element_from_template(self, body: dict) -> str:
@@ -101,8 +99,7 @@ class AutomatedCuration(Client):
         """
 
         url = f"{self.curation_command_root}/catalog-templates/new-element"
-        response = await self._async_make_request("POST", url, body)
-        return response.json().get("guid", "GUID failed to be returned")
+        return await self._async_create_elem_from_template(url, body)
 
     def create_element_from_template(self, body: dict) -> str:
         """Create a new metadata element from a template.  Async version.
@@ -155,11 +152,11 @@ class AutomatedCuration(Client):
         return response
 
     async def _async_create_kafka_server_element_from_template(
-        self,
-        kafka_server: str,
-        host_name: str,
-        port: str,
-        description: str = None,
+            self,
+            kafka_server: str,
+            host_name: str,
+            port: str,
+            description: str = None,
     ) -> str:
         """Create a Kafka server element from a template. Async version.
 
@@ -184,9 +181,10 @@ class AutomatedCuration(Client):
         str
             The GUID of the Kafka server element.
         """
-
+        template_guid = await self._async_get_template_guid_for_technology_type("Apache Kafka Server")
         body = {
-            "templateGUID": TEMPLATE_GUIDS["Apache Kafka Server"],
+            "class": "TemplateRequestBody",
+            "templateGUID": template_guid,
             "isOwnAnchor": "true",
             "placeholderPropertyValues": {
                 "serverName": kafka_server,
@@ -196,15 +194,14 @@ class AutomatedCuration(Client):
             },
         }
         body_s = body_slimmer(body)
-        response = await self._async_create_element_from_template(body_s)
-        return str(response)
+        return await self._async_create_element_from_template(body_s)
 
     def create_kafka_server_element_from_template(
-        self,
-        kafka_server: str,
-        host_name: str,
-        port: str,
-        description: str = None,
+            self,
+            kafka_server: str,
+            host_name: str,
+            port: str,
+            description: str = None,
     ) -> str:
         """Create a Kafka server element from a template.
 
@@ -237,14 +234,117 @@ class AutomatedCuration(Client):
         )
         return response
 
+    async def _async_create_csv_data_file_element_from_template(
+            self,
+            file_name: str,
+            file_type: str,
+            file_path_name: str,
+            version_identifier: str,
+            file_encoding: str = "UTF-8",
+            file_extension: str = "csv",
+            file_system_name: str = None,
+            description: str = None,
+    ) -> str:
+        """Create a CSV file element from a template. Async version.
+
+        Parameters
+        ----------
+        file_name : str
+            The name of the Kafka server.
+        file_type : str
+            The host name of the Kafka server.
+        file_path_name : str
+            The port number of the Kafka server.
+        version_identifier : str
+            The version identifier of the CSV file..
+        file_encoding: str, opt, default UTF-8
+            The encoding of the CSV file.
+        file_extension: str, opt, default is CSV
+            File extension of the CSV file.
+        file_system_name: str, opt
+            Name of the file system the CSV file is hosted on.
+        description: str, opt
+            A description of the CSV file..
+
+
+        Returns
+        -------
+        str
+            The GUID of the CSV File element.
+        """
+        template_guid = await self._async_get_template_guid_for_technology_type("CSV Data File")
+        body = {
+            "class": "TemplateRequestBody",
+            "templateGUID": template_guid,
+            "isOwnAnchor": "true",
+            "placeholderPropertyValues": {
+                "fileName": file_name,
+                "fileType": file_type,
+                "filePathName": file_path_name,
+                "versionIdentifier": version_identifier,
+                "fileEncoding": file_encoding,
+                "fileExtension": file_extension,
+                "fileSystemName": file_system_name,
+                "description": description
+            },
+        }
+        body_s = body_slimmer(body)
+        return await self._async_create_element_from_template(body_s)
+
+    def create_csv_data_file_element_from_template(
+            self,
+            file_name: str,
+            file_type: str,
+            file_path_name: str,
+            version_identifier: str,
+            file_encoding: str = "UTF-8",
+            file_extension: str = "csv",
+            file_system_name: str = None,
+            description: str = None,
+    ) -> str:
+        """Create a CSV file element from a template. Async version.
+
+        Parameters
+        ----------
+        file_name : str
+            The name of the Kafka server.
+        file_type : str
+            The host name of the Kafka server.
+        file_path_name : str
+            The port number of the Kafka server.
+        version_identifier : str
+            The version identifier of the CSV file..
+        file_encoding: str, opt, default UTF-8
+            The encoding of the CSV file.
+        file_extension: str, opt, default is CSV
+            File extension of the CSV file.
+        file_system_name: str, opt
+            Name of the file system the CSV file is hosted on.
+        description: str, opt
+            A description of the CSV file..
+
+        Returns
+        -------
+        str
+            The GUID of the CSV File element.
+        """
+        loop = asyncio.get_event_loop()
+        response = loop.run_until_complete(
+            self._async_create_csv_data_file_element_from_template(
+                file_name, file_type, file_path_name, version_identifier,
+                file_encoding, file_extension, file_system_name, description
+            )
+        )
+        return response
+
     async def _async_create_postgres_server_element_from_template(
-        self,
-        postgres_server: str,
-        host_name: str,
-        port: str,
-        db_user: str,
-        db_pwd: str,
-        description: str = None,
+            self,
+            postgres_server: str,
+            host_name: str,
+            port: str,
+            db_user: str,
+            db_pwd: str,
+            description: str = None,
     ) -> str:
         """Create a Postgres server element from a template. Async version.
 
@@ -275,8 +375,11 @@ class AutomatedCuration(Client):
         str
             The GUID of the Postgres server element.
         """
+        template_guid = await self._async_get_template_guid_for_technology_type("PostgreSQL Server")
+
         body = {
-            "templateGUID": TEMPLATE_GUIDS["PostgreSQL Server"],
+            "class": "TemplateRequestBody",
+            "templateGUID": template_guid,
             "isOwnAnchor": "true",
             "placeholderPropertyValues": {
                 "serverName": postgres_server,
@@ -288,17 +391,16 @@ class AutomatedCuration(Client):
             },
         }
         body_s = body_slimmer(body)
-        response = await self._async_create_element_from_template(body_s)
-        return str(response)
+        return await self._async_create_element_from_template(body_s)
 
     def create_postgres_server_element_from_template(
-        self,
-        postgres_server: str,
-        host_name: str,
-        port: str,
-        db_user: str,
-        db_pwd: str,
-        description: str = None,
+            self,
+            postgres_server: str,
+            host_name: str,
+            port: str,
+            db_user: str,
+            db_pwd: str,
+            description: str = None,
     ) -> str:
         """Create a Postgres server element from a template.
 
@@ -338,14 +440,14 @@ class AutomatedCuration(Client):
         return response
 
     async def _async_create_postgres_database_element_from_template(
-        self,
-        postgres_database: str,
-        server_name: str,
-        host_identifier: str,
-        port: str,
-        db_user: str,
-        db_pwd: str,
-        description: str = None,
+            self,
+            postgres_database: str,
+            server_name: str,
+            host_identifier: str,
+            port: str,
+            db_user: str,
+            db_pwd: str,
+            description: str = None,
     ) -> str:
         """Create a Postgres database element from a template. Async version.
 
@@ -371,8 +473,11 @@ class AutomatedCuration(Client):
         str
             The GUID of the Postgres database element.
         """
+        template_guid = await self._async_get_template_guid_for_technology_type("PostgreSQL Relational Database")
+
         body = {
-            "templateGUID": TEMPLATE_GUIDS["PostgreSQL Relational Database"],
+            "class": "TemplateRequestBody",
+            "templateGUID": template_guid,
             "isOwnAnchor": "true",
             "placeholderPropertyValues": {
                 "databaseName": postgres_database,
@@ -389,14 +494,14 @@ class AutomatedCuration(Client):
         return str(response)
 
     def create_postgres_database_element_from_template(
-        self,
-        postgres_database: str,
-        server_name: str,
-        host_identifier: str,
-        port: str,
-        db_user: str,
-        db_pwd: str,
-        description: str = None,
+            self,
+            postgres_database: str,
+            server_name: str,
+            host_identifier: str,
+            port: str,
+            db_user: str,
+            db_pwd: str,
+            description: str = None,
     ) -> str:
         """Create a Postgres database element from a template. Async version.
 
@@ -437,12 +542,12 @@ class AutomatedCuration(Client):
         return response
 
     async def _async_create_folder_element_from_template(
-        self,
-        path_name: str,
-        folder_name: str,
-        file_system: str,
-        description: str = None,
-        version: str = None,
+            self,
+            path_name: str,
+            folder_name: str,
+            file_system: str,
+            description: str = None,
+            version: str = None,
     ) -> str:
         """Create a File folder element from a template.
         Async version.
@@ -472,8 +577,11 @@ class AutomatedCuration(Client):
         str
             The GUID of the File Folder element.
         """
+        template_guid = await self._async_get_template_guid_for_technology_type("File System Directory")
+
         body = {
-            "templateGUID": TEMPLATE_GUIDS["File System Directory"],
+            "class": "TemplateRequestBody",
+            "templateGUID": template_guid,
             "isOwnAnchor": "true",
             "placeholderPropertyValues": {
                 "directoryPathName": path_name,
@@ -488,12 +596,12 @@ class AutomatedCuration(Client):
         return str(response)
 
     def create_folder_element_from_template(
-        self,
-        path_name: str,
-        folder_name: str,
-        file_system: str,
-        description: str = None,
-        version: str = None,
+            self,
+            path_name: str,
+            folder_name: str,
+            file_system: str,
+            description: str = None,
+            version: str = None,
     ) -> str:
         """Create a File folder element from a template.
 
@@ -531,12 +639,12 @@ class AutomatedCuration(Client):
         return response
 
     async def _async_create_uc_server_element_from_template(
-        self,
-        server_name: str,
-        host_url: str,
-        port: str,
-        description: str = None,
-        version: str = None,
+            self,
+            server_name: str,
+            host_url: str,
+            port: str,
+            description: str = None,
+            version: str = None,
     ) -> str:
         """Create a Unity Catalog Server element from a template. Async version.
 
@@ -564,8 +672,11 @@ class AutomatedCuration(Client):
         str
             The GUID of the File Folder element.
         """
+        template_guid = await self._async_get_template_guid_for_technology_type("Unity Catalog Server")
+
         body = {
-            "templateGUID": TEMPLATE_GUIDS["Unity Catalog Server"],
+            "class": "TemplateRequestBody",
+            "templateGUID": template_guid,
             "isOwnAnchor": "true",
             "placeholderPropertyValues": {
                 "serverName": server_name,
@@ -580,12 +691,12 @@ class AutomatedCuration(Client):
         return str(response)
 
     def create_uc_server_element_from_template(
-        self,
-        server_name: str,
-        host_url: str,
-        port: str,
-        description: str = None,
-        version: str = None,
+            self,
+            server_name: str,
+            host_url: str,
+            port: str,
+            description: str = None,
+            version: str = None,
     ) -> str:
         """Create a Unity Catalog Server element from a template. Async version.
 
@@ -622,11 +733,11 @@ class AutomatedCuration(Client):
         return response
 
     async def _async_create_uc_catalog_element_from_template(
-        self,
-        uc_catalog: str,
-        network_address: str,
-        description: str = None,
-        version: str = None,
+            self,
+            uc_catalog: str,
+            network_address: str,
+            description: str = None,
+            version: str = None,
     ) -> str:
         """Create a Unity Catalog Catalog element from a template. Async version.
 
@@ -651,8 +762,11 @@ class AutomatedCuration(Client):
         str
             The GUID of the File Folder element.
         """
+        template_guid = await self._async_get_template_guid_for_technology_type("Unity Catalog Catalog")
+
         body = {
-            "templateGUID": TEMPLATE_GUIDS["Unity Catalog Catalog"],
+            "class": "TemplateRequestBody",
+            "templateGUID": template_guid,
             "isOwnAnchor": "true",
             "placeholderPropertyValues": {
                 "ucCatalogName": uc_catalog,
@@ -666,11 +780,11 @@ class AutomatedCuration(Client):
         return str(response)
 
     def create_uc_catalog_element_from_template(
-        self,
-        uc_catalog: str,
-        network_address: str,
-        description: str = None,
-        version: str = None,
+            self,
+            uc_catalog: str,
+            network_address: str,
+            description: str = None,
+            version: str = None,
     ) -> str:
         """Create a Unity Catalog Catalog element from a template.
 
@@ -704,12 +818,12 @@ class AutomatedCuration(Client):
         return response
 
     async def _async_create_uc_schema_element_from_template(
-        self,
-        uc_catalog: str,
-        uc_schema: str,
-        network_address: str,
-        description: str = None,
-        version: str = None,
+            self,
+            uc_catalog: str,
+            uc_schema: str,
+            network_address: str,
+            description: str = None,
+            version: str = None,
     ) -> str:
         """Create a Unity Catalog schema element from a template. Async version.
 
@@ -737,8 +851,11 @@ class AutomatedCuration(Client):
         str
             The GUID of the File Folder element.
         """
+        template_guid = await self._async_get_template_guid_for_technology_type("Unity Catalog Schema")
+
         body = {
-            "templateGUID": TEMPLATE_GUIDS["Unity Catalog Schema"],
+            "class": "TemplateRequestBody",
+            "templateGUID": template_guid,
             "isOwnAnchor": "true",
             "placeholderPropertyValues": {
                 "ucCatalogName": uc_catalog,
@@ -753,12 +870,12 @@ class AutomatedCuration(Client):
         return str(response)
 
     def create_uc_schema_element_from_template(
-        self,
-        uc_catalog: str,
-        uc_schema: str,
-        network_address: str,
-        description: str = None,
-        version: str = None,
+            self,
+            uc_catalog: str,
+            uc_schema: str,
+            network_address: str,
+            description: str = None,
+            version: str = None,
     ) -> str:
         """Create a Unity Catalog schema element from a template. Async version.
 
@@ -795,16 +912,16 @@ class AutomatedCuration(Client):
         return response
 
     async def _async_create_uc_table_element_from_template(
-        self,
-        uc_catalog: str,
-        uc_schema: str,
-        uc_table: str,
-        uc_table_type: str,
-        uc_storage_loc: str,
-        uc_data_source_format: str,
-        network_address: str,
-        description: str = None,
-        version: str = None,
+            self,
+            uc_catalog: str,
+            uc_schema: str,
+            uc_table: str,
+            uc_table_type: str,
+            uc_storage_loc: str,
+            uc_data_source_format: str,
+            network_address: str,
+            description: str = None,
+            version: str = None,
     ) -> str:
         """Create a Unity Catalog table element from a template. Async version.
 
@@ -841,8 +958,11 @@ class AutomatedCuration(Client):
         str
             The GUID of the File Folder element.
         """
+        template_guid = await self._async_get_template_guid_for_technology_type("Unity Catalog Table")
+
         body = {
-            "templateGUID": TEMPLATE_GUIDS["Unity Catalog Table"],
+            "class": "TemplateRequestBody",
+            "templateGUID": template_guid,
             "isOwnAnchor": "true",
             "placeholderPropertyValues": {
                 "ucCatalogName": uc_catalog,
@@ -861,16 +981,16 @@ class AutomatedCuration(Client):
         return str(response)
 
     def create_uc_table_element_from_template(
-        self,
-        uc_catalog: str,
-        uc_schema: str,
-        uc_table: str,
-        uc_table_type: str,
-        uc_storage_loc: str,
-        uc_data_source_format: str,
-        network_address: str,
-        description: str = None,
-        version: str = None,
+            self,
+            uc_catalog: str,
+            uc_schema: str,
+            uc_table: str,
+            uc_table_type: str,
+            uc_storage_loc: str,
+            uc_data_source_format: str,
+            network_address: str,
+            description: str = None,
+            version: str = None,
     ) -> str:
         """Create a Unity Catalog table element from a template.
 
@@ -924,13 +1044,13 @@ class AutomatedCuration(Client):
         return response
 
     async def _async_create_uc_function_element_from_template(
-        self,
-        uc_catalog: str,
-        uc_schema: str,
-        uc_function: str,
-        network_address: str,
-        description: str = None,
-        version: str = None,
+            self,
+            uc_catalog: str,
+            uc_schema: str,
+            uc_function: str,
+            network_address: str,
+            description: str = None,
+            version: str = None,
     ) -> str:
         """Create a Unity Catalog function element from a template. Async version.
 
@@ -961,8 +1081,11 @@ class AutomatedCuration(Client):
         str
             The GUID of the File Folder element.
         """
+        template_guid = await self._async_get_template_guid_for_technology_type("Unity Catalog Function")
+
         body = {
-            "templateGUID": TEMPLATE_GUIDS["Unity Catalog Function"],
+            "class": "TemplateRequestBody",
+            "templateGUID": template_guid,
             "isOwnAnchor": "true",
             "placeholderPropertyValues": {
                 "ucCatalogName": uc_catalog,
@@ -978,13 +1101,13 @@ class AutomatedCuration(Client):
         return str(response)
 
     def create_uc_function_element_from_template(
-        self,
-        uc_catalog: str,
-        uc_schema: str,
-        uc_function: str,
-        network_address: str,
-        description: str = None,
-        version: str = None,
+            self,
+            uc_catalog: str,
+            uc_schema: str,
+            uc_function: str,
+            network_address: str,
+            description: str = None,
+            version: str = None,
     ) -> str:
         """Create a Unity Catalog function element from a template.
 
@@ -1029,15 +1152,15 @@ class AutomatedCuration(Client):
         return response
 
     async def _async_create_uc_volume_element_from_template(
-        self,
-        uc_catalog: str,
-        uc_schema: str,
-        uc_volume: str,
-        uc_vol_type: str,
-        uc_storage_loc: str,
-        network_address: str,
-        description: str = None,
-        version: str = None,
+            self,
+            uc_catalog: str,
+            uc_schema: str,
+            uc_volume: str,
+            uc_vol_type: str,
+            uc_storage_loc: str,
+            network_address: str,
+            description: str = None,
+            version: str = None,
     ) -> str:
         """Create a Unity Catalog volume element from a template. Async version.
 
@@ -1073,8 +1196,11 @@ class AutomatedCuration(Client):
         str
             The GUID of the File Folder element.
         """
+        template_guid = await self._async_get_template_guid_for_technology_type("Unity Catalog Volume")
+
         body = {
-            "templateGUID": TEMPLATE_GUIDS["Unity Catalog Volume"],
+            "class": "TemplateRequestBody",
+            "templateGUID": template_guid,
             "isOwnAnchor": "true",
             "placeholderPropertyValues": {
                 "ucCatalogName": uc_catalog,
@@ -1092,15 +1218,15 @@ class AutomatedCuration(Client):
         return str(response)
 
     def create_uc_volume_element_from_template(
-        self,
-        uc_catalog: str,
-        uc_schema: str,
-        uc_volume: str,
-        uc_vol_type: str,
-        uc_storage_loc: str,
-        network_address: str,
-        description: str = None,
-        version: str = None,
+            self,
+            uc_catalog: str,
+            uc_schema: str,
+            uc_volume: str,
+            uc_vol_type: str,
+            uc_storage_loc: str,
+            network_address: str,
+            description: str = None,
+            version: str = None,
     ) -> str:
         """Create a Unity Catalog volume element from a template. Async version.
 
@@ -1156,7 +1282,7 @@ class AutomatedCuration(Client):
     # Engine Actions
     #
     async def _async_get_engine_actions(
-        self, start_from: int = 0, page_size: int = max_paging_size
+            self, start_from: int = 0, page_size: int = 0, body: dict | GetRequestBody = None
     ) -> list:
         """Retrieve the engine actions that are known to the server. Async version.
         Parameters
@@ -1166,6 +1292,8 @@ class AutomatedCuration(Client):
             The starting index of the actions to retrieve. Default is 0.
         page_size : int, optional
             The maximum number of actions to retrieve per page. Default is the global maximum paging size.
+        body: dict, optional
+            If provided, supersedes the other parameters. Allows advanced options.
 
         Returns
         -------
@@ -1174,34 +1302,42 @@ class AutomatedCuration(Client):
 
         Raises
         ------
-        InvalidParameterException
-        PropertyServerException
-        UserNotAuthorizedException
+        PyegeriaException
+        ValidationError
 
         Notes
         -----
         For more information see: https://egeria-project.org/concepts/engine-action
+        sample body:
+            {
+              "class": "GetRequestBody",
+              "asOfTime": "{{$isoTimestamp}}",
+              "effectiveTime": "{{$isoTimestamp}}",
+              "forLineage": false,
+              "forDuplicateProcessing": false
+            }
         """
-
         url = (
-            f"{self.curation_command_root}/engine-actions?"
-            f"startFrom={start_from}&pageSize={page_size}"
+            f"{self.curation_command_root}/engine-actions?startFrom={start_from}&pageSize={page_size}"
         )
 
+        # return await self._async_get_guid_request(url, "EngineAction", _generate_default_output,
+        #                                          output_format="JSON", output_format_set="Referenceable", body=body )
         response = await self._async_make_request("GET", url)
-        return response.json().get("elements", "No elements")
+        return response.json().get("element", "No element found")
 
     def get_engine_actions(
-        self, start_from: int = 0, page_size: int = max_paging_size
+            self, start_from: int = 0, page_size: int = 0, body: dict | GetRequestBody = None
     ) -> list:
         """Retrieve the engine actions that are known to the server.
         Parameters
         ----------
-
         start_from : int, optional
             The starting index of the actions to retrieve. Default is 0.
         page_size : int, optional
             The maximum number of actions to retrieve per page. Default is the global maximum paging size.
+        body: dict, optional
+            If provided, supersedes the other parameters. Allows advanced options.
 
         Returns
         -------
@@ -1210,17 +1346,24 @@ class AutomatedCuration(Client):
 
         Raises
         ------
-        InvalidParameterException
-        PropertyServerException
-        UserNotAuthorizedException
+        PyegeriaException
+        ValidationError
 
         Notes
         -----
         For more information see: https://egeria-project.org/concepts/engine-action
+        sample body:
+            {
+              "class": "GetRequestBody",
+              "asOfTime": "{{$isoTimestamp}}",
+              "effectiveTime": "{{$isoTimestamp}}",
+              "forLineage": false,
+              "forDuplicateProcessing": false
+            }
         """
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
-            self._async_get_engine_actions(start_from, page_size)
+            self._async_get_engine_actions(start_from, page_size, body)
         )
         return response
 
@@ -1240,16 +1383,16 @@ class AutomatedCuration(Client):
 
         Raises
         ------
-        InvalidParameterException
-        PropertyServerException
-        UserNotAuthorizedException
+        PyegeriaException
+        ValidationError
+
 
         Notes
         -----
         For more information see: https://egeria-project.org/concepts/engine-action
         """
 
-        url = f"{self.curation_command_root}/engine-actions/" f"{engine_action_guid}"
+        url = f"{self.curation_command_root}/engine-actions/{engine_action_guid}"
 
         response = await self._async_make_request("GET", url)
         return response.json().get("element", "No element found")
@@ -1347,7 +1490,7 @@ class AutomatedCuration(Client):
         return
 
     async def _async_get_active_engine_actions(
-        self, start_from: int = 0, page_size: int = max_paging_size
+            self, start_from: int = 0, page_size: int = 0
     ) -> list | str:
         """Retrieve the engine actions that are still in process. Async Version.
 
@@ -1375,15 +1518,14 @@ class AutomatedCuration(Client):
         """
 
         url = (
-            f"{self.curation_command_root}/engine-actions/active?"
-            f"startFrom={start_from}&pageSize={page_size}"
+            f"{self.curation_command_root}/engine-actions/active"
         )
 
         response = await self._async_make_request("GET", url)
         return response.json().get("elements", "no actions")
 
     def get_active_engine_actions(
-        self, start_from: int = 0, page_size: int = 0
+            self, start_from: int = 0, page_size: int = 0
     ) -> list | str:
         """Retrieve the engine actions that are still in process.
 
@@ -1415,10 +1557,10 @@ class AutomatedCuration(Client):
         return response
 
     async def _async_get_engine_actions_by_name(
-        self,
-        name: str,
-        start_from: int = 0,
-        page_size: int = max_paging_size,
+            self,
+            name: str,
+            start_from: int = 0,
+            page_size: int = 0,
     ) -> list | str:
         """Retrieve the list of engine action metadata elements with a matching qualified or display name.
         There are no wildcards supported on this request. Async Version.
@@ -1453,18 +1595,17 @@ class AutomatedCuration(Client):
         validate_name(name)
 
         url = (
-            f"{self.curation_command_root}/engine-actions/by-name?"
-            f"startFrom={start_from}&pageSize={page_size}"
+            f"{self.curation_command_root}/engine-actions/by-name"
         )
         body = {"filter": name}
         response = await self._async_make_request("POST", url, body)
         return response.json().get("elements", "no actions")
 
     def get_engine_actions_by_name(
-        self,
-        name: str,
-        start_from: int = 0,
-        page_size: int = max_paging_size,
+            self,
+            name: str,
+            start_from: int = 0,
+            page_size: int = 0,
     ) -> list | str:
         """Retrieve the list of engine action metadata elements with a matching qualified or display name.
         There are no wildcards supported on this request.
@@ -1503,13 +1644,13 @@ class AutomatedCuration(Client):
         return response
 
     async def _async_find_engine_actions(
-        self,
-        search_string: str,
-        starts_with: bool = False,
-        ends_with: bool = False,
-        ignore_case: bool = False,
-        start_from: int = 0,
-        page_size: int = max_paging_size,
+            self,
+            search_string: str,
+            starts_with: bool = False,
+            ends_with: bool = False,
+            ignore_case: bool = False,
+            start_from: int = 0,
+            page_size: int = 0,
     ) -> list | str:
         """Retrieve the list of engine action metadata elements that contain the search string. Async Version.
         Parameters
@@ -1532,7 +1673,7 @@ class AutomatedCuration(Client):
             The index from which to start fetching the engine actions. Default is 0.
 
         page_size : int, optional
-            The maximum number of engine actions to fetch in a single request. Default is `max_paging_size`.
+            The maximum number of engine actions to fetch in a single request. Default is `0`.
 
         Returns
         -------
@@ -1560,21 +1701,20 @@ class AutomatedCuration(Client):
 
         url = (
             f"{self.curation_command_root}/engine-actions/"
-            f"by-search-string?startFrom={start_from}&pageSize={page_size}&startsWith={starts_with_s}&"
-            f"endsWith={ends_with_s}&ignoreCase={ignore_case_s}"
+            f"by-search-string"
         )
         body = {"class": "SearchStringRequestBody", "name": search_string}
         response = await self._async_make_request("POST", url, body)
         return response.json().get("elements", "no actions")
 
     def find_engine_actions(
-        self,
-        search_string: str = "*",
-        starts_with: bool = False,
-        ends_with: bool = False,
-        ignore_case: bool = False,
-        start_from: int = 0,
-        page_size: int = max_paging_size,
+            self,
+            search_string: str = "*",
+            starts_with: bool = False,
+            ends_with: bool = False,
+            ignore_case: bool = False,
+            start_from: int = 0,
+            page_size: int = 0,
     ) -> list | str:
         """Retrieve the list of engine action metadata elements that contain the search string.
         Parameters
@@ -1597,7 +1737,7 @@ class AutomatedCuration(Client):
             The index from which to start fetching the engine actions. Default is 0.
 
         page_size : int, optional
-            The maximum number of engine actions to fetch in a single request. Default is `max_paging_size`.
+            The maximum number of engine actions to fetch in a single request. Default is `0`.
 
         Returns
         -------
@@ -1634,7 +1774,7 @@ class AutomatedCuration(Client):
     #
 
     async def _async_get_governance_action_process_by_guid(
-        self, process_guid: str
+            self, process_guid: str
     ) -> dict | str:
         """Retrieve the governance action process metadata element with the supplied unique identifier. Async Version.
 
@@ -1692,7 +1832,7 @@ class AutomatedCuration(Client):
         return response
 
     async def _async_get_gov_action_process_graph(
-        self, process_guid: str
+            self, process_guid: str
     ) -> dict | str:
         """Retrieve the governance action process metadata element with the supplied unique
             identifier along with the flow definition describing its implementation. Async Version.
@@ -1753,10 +1893,10 @@ class AutomatedCuration(Client):
         return response
 
     async def _async_get_gov_action_processes_by_name(
-        self,
-        name: str,
-        start_from: int = None,
-        page_size: int = max_paging_size,
+            self,
+            name: str,
+            start_from: int = None,
+            page_size: int = 0,
     ) -> list | str:
         """Retrieve the list of governance action process metadata elements with a matching qualified or display name.
          There are no wildcards supported on this request. Async Version.
@@ -1788,17 +1928,17 @@ class AutomatedCuration(Client):
 
         url = (
             f"{self.curation_command_root}/governance-action-processes/"
-            f"by-name?startFrom={start_from}&pageSize={page_size}"
+            f"by-name"
         )
         body = {"filter": name}
         response = await self._async_make_request("POST", url, body)
         return response.json().get("elements", "no actions")
 
     def get_gov_action_processes_by_name(
-        self,
-        name: str,
-        start_from: int = 0,
-        page_size: int = max_paging_size,
+            self,
+            name: str,
+            start_from: int = 0,
+            page_size: int = 0,
     ) -> list | str:
         """Retrieve the list of governance action process metadata elements with a matching qualified or display name.
          There are no wildcards supported on this request.
@@ -1832,13 +1972,13 @@ class AutomatedCuration(Client):
         return response
 
     async def _async_find_gov_action_processes(
-        self,
-        search_string: str,
-        starts_with: bool = False,
-        ends_with: bool = False,
-        ignore_case: bool = False,
-        start_from: int = 0,
-        page_size: int = max_paging_size,
+            self,
+            search_string: str,
+            starts_with: bool = False,
+            ends_with: bool = False,
+            ignore_case: bool = False,
+            start_from: int = 0,
+            page_size: int = 0,
     ) -> list | str:
         """Retrieve the list of governance action process metadata elements that contain the search string. Async ver.
 
@@ -1862,7 +2002,7 @@ class AutomatedCuration(Client):
             The index from which to start fetching the engine actions. Default is 0.
 
         page_size : int, optional
-            The maximum number of engine actions to fetch in a single request. Default is `max_paging_size`.
+            The maximum number of engine actions to fetch in a single request. Default is `0`.
 
         Returns
         -------
@@ -1886,8 +2026,7 @@ class AutomatedCuration(Client):
 
         url = (
             f"{self.curation_command_root}/governance-action-processes/"
-            f"by-search-string?startFrom={start_from}&pageSize={page_size}&startsWith={starts_with_s}&"
-            f"endsWith={ends_with_s}&ignoreCase={ignore_case_s}"
+            f"by-search-string"
         )
 
         if search_string:
@@ -1899,13 +2038,13 @@ class AutomatedCuration(Client):
         return response.json().get("elements", "no actions")
 
     def find_gov_action_processes(
-        self,
-        search_string: str = "*",
-        starts_with: bool = False,
-        ends_with: bool = False,
-        ignore_case: bool = False,
-        start_from: int = 0,
-        page_size: int = max_paging_size,
+            self,
+            search_string: str = "*",
+            starts_with: bool = False,
+            ends_with: bool = False,
+            ignore_case: bool = False,
+            start_from: int = 0,
+            page_size: int = 0,
     ) -> list | str:
         """Retrieve the list of governance action process metadata elements that contain the search string.
 
@@ -1929,7 +2068,7 @@ class AutomatedCuration(Client):
             The index from which to start fetching the engine actions. Default is 0.
 
         page_size : int, optional
-            The maximum number of engine actions to fetch in a single request. Default is `max_paging_size`.
+            The maximum number of engine actions to fetch in a single request. Default is `0`.
 
         Returns
         -------
@@ -1958,14 +2097,14 @@ class AutomatedCuration(Client):
         return response
 
     async def _async_initiate_gov_action_process(
-        self,
-        action_type_qualified_name: str,
-        request_source_guids: [str] = None,
-        action_targets: list = None,
-        start_time: datetime = None,
-        request_parameters: dict = None,
-        orig_service_name: str = None,
-        orig_engine_name: str = None,
+            self,
+            action_type_qualified_name: str,
+            request_source_guids: [str] = None,
+            action_targets: list = None,
+            start_time: datetime = None,
+            request_parameters: dict = None,
+            orig_service_name: str = None,
+            orig_engine_name: str = None,
     ) -> str:
         """Using the named governance action process as a template, initiate a chain of engine actions. Async version.
 
@@ -2018,14 +2157,14 @@ class AutomatedCuration(Client):
         return response.json().get("guid", "Action not initiated")
 
     def initiate_gov_action_process(
-        self,
-        action_type_qualified_name: str,
-        request_source_guids: [str] = None,
-        action_targets: [str] = None,
-        start_time: datetime = None,
-        request_parameters: dict = None,
-        orig_service_name: str = None,
-        orig_engine_name: str = None,
+            self,
+            action_type_qualified_name: str,
+            request_source_guids: [str] = None,
+            action_targets: [str] = None,
+            start_time: datetime = None,
+            request_parameters: dict = None,
+            orig_service_name: str = None,
+            orig_engine_name: str = None,
     ) -> str:
         """Using the named governance action process as a template, initiate a chain of engine actions.
 
@@ -2072,7 +2211,7 @@ class AutomatedCuration(Client):
         return response
 
     async def _async_get_gov_action_types_by_guid(
-        self, gov_action_type_guid: str
+            self, gov_action_type_guid: str
     ) -> dict | str:
         """Retrieve the governance action type metadata element with the supplied unique identifier. Async version.
 
@@ -2129,10 +2268,10 @@ class AutomatedCuration(Client):
         return response
 
     async def _async_get_gov_action_types_by_name(
-        self,
-        action_type_name,
-        start_from: int = 0,
-        page_size: int = max_paging_size,
+            self,
+            action_type_name,
+            start_from: int = 0,
+            page_size: int = 0,
     ) -> list | str:
         """Retrieve the list of governance action type metadata elements with a matching qualified or display name.
         There are no wildcards supported on this request. Async version.
@@ -2158,7 +2297,7 @@ class AutomatedCuration(Client):
 
         url = (
             f"{self.curation_command_root}/"
-            f"governance-action-types/by-name?startFrom={start_from}&pageSize={page_size}"
+            f"governance-action-types/by-name"
         )
 
         body = {"filter": action_type_name}
@@ -2167,10 +2306,10 @@ class AutomatedCuration(Client):
         return response.json().get("elements", "no actions")
 
     def get_gov_action_types_by_name(
-        self,
-        action_type_name,
-        start_from: int = 0,
-        page_size: int = max_paging_size,
+            self,
+            action_type_name,
+            start_from: int = 0,
+            page_size: int = 0,
     ) -> list | str:
         """Retrieve the list of governance action type metadata elements with a matching qualified or display name.
         There are no wildcards supported on this request. Async version.
@@ -2200,13 +2339,13 @@ class AutomatedCuration(Client):
         return response
 
     async def _async_find_gov_action_types(
-        self,
-        search_string: str = "*",
-        starts_with: bool = False,
-        ends_with: bool = False,
-        ignore_case: bool = True,
-        start_from: int = 0,
-        page_size: int = max_paging_size,
+            self,
+            search_string: str = "*",
+            starts_with: bool = False,
+            ends_with: bool = False,
+            ignore_case: bool = True,
+            start_from: int = 0,
+            page_size: int = 0,
     ) -> list | str:
         """Retrieve the list of governance action type metadata elements that contain the search string.
          Async Version.
@@ -2231,7 +2370,7 @@ class AutomatedCuration(Client):
             The index from which to start fetching the engine actions. Default is 0.
 
         page_size : int, optional
-            The maximum number of engine actions to fetch in a single request. Default is `max_paging_size`.
+            The maximum number of engine actions to fetch in a single request. Default is `0`.
 
         Returns
         -------
@@ -2256,21 +2395,20 @@ class AutomatedCuration(Client):
 
         url = (
             f"{self.curation_command_root}/governance-action-types/"
-            f"by-search-string?startFrom={start_from}&pageSize={page_size}&startsWith={starts_with_s}&"
-            f"endsWith={ends_with_s}&ignoreCase={ignore_case_s}"
+            f"by-search-string"
         )
         body = {"filter": search_string}
         response = await self._async_make_request("POST", url, body)
         return response.json().get("elements", "no action types")
 
     def find_gov_action_types(
-        self,
-        search_string: str = "*",
-        starts_with: bool = False,
-        ends_with: bool = False,
-        ignore_case: bool = False,
-        start_from: int = 0,
-        page_size: int = max_paging_size,
+            self,
+            search_string: str = "*",
+            starts_with: bool = False,
+            ends_with: bool = False,
+            ignore_case: bool = False,
+            start_from: int = 0,
+            page_size: int = 0,
     ) -> list | str:
         """Retrieve the list of governance action type metadata elements that contain the search string.
 
@@ -2293,7 +2431,7 @@ class AutomatedCuration(Client):
             The index from which to start fetching the engine actions. Default is 0.
 
         page_size : int, optional
-            The maximum number of engine actions to fetch in a single request. Default is `max_paging_size`.
+            The maximum number of engine actions to fetch in a single request. Default is `0`.
 
         Returns
         -------
@@ -2322,14 +2460,14 @@ class AutomatedCuration(Client):
         return response
 
     async def _async_initiate_gov_action_type(
-        self,
-        action_type_qualified_name: str,
-        request_source_guids: [str],
-        action_targets: list,
-        start_time: datetime = None,
-        request_parameters: dict = None,
-        orig_service_name: str = None,
-        orig_engine_name: str = None,
+            self,
+            action_type_qualified_name: str,
+            request_source_guids: [str],
+            action_targets: list,
+            start_time: datetime = None,
+            request_parameters: dict = None,
+            orig_service_name: str = None,
+            orig_engine_name: str = None,
     ) -> str:
         """Using the named governance action type as a template, initiate an engine action. Async version.
 
@@ -2362,7 +2500,7 @@ class AutomatedCuration(Client):
 
         """
 
-        url = f"{self.curation_command_root}/governance-action-types/" f"initiate"
+        url = f"{self.curation_command_root}/governance-action-types/initiate"
         start = int(start_time.timestamp() * 1000) if start_time else None
         body = {
             "class": "InitiateGovernanceActionTypeRequestBody",
@@ -2379,14 +2517,14 @@ class AutomatedCuration(Client):
         return response.json().get("guid", "Action not initiated")
 
     def initiate_gov_action_type(
-        self,
-        action_type_qualified_name: str,
-        request_source_guids: [str],
-        action_targets: list,
-        start_time: datetime = None,
-        request_parameters: dict = None,
-        orig_service_name: str = None,
-        orig_engine_name: str = None,
+            self,
+            action_type_qualified_name: str,
+            request_source_guids: [str],
+            action_targets: list,
+            start_time: datetime = None,
+            request_parameters: dict = None,
+            orig_service_name: str = None,
+            orig_engine_name: str = None,
     ) -> str:
         """Using the named governance action type as a template, initiate an engine action.
 
@@ -2489,9 +2627,9 @@ class AutomatedCuration(Client):
         return response
 
     def initiate_file_folder_survey(
-        self,
-        file_folder_guid: str,
-        survey_name: str = "FileSurveys:survey-folder",
+            self,
+            file_folder_guid: str,
+            survey_name: str = "FileSurveys:survey-folder",
     ) -> str:
         """Initiate a file folder survey - async version
 
@@ -2753,21 +2891,21 @@ class AutomatedCuration(Client):
     #
 
     async def _async_initiate_engine_action(
-        self,
-        qualified_name: str,
-        domain_identifier: int,
-        display_name: str,
-        description: str,
-        request_source_guids: str,
-        action_targets: str,
-        received_guards: [str],
-        start_time: datetime,
-        request_type: str,
-        request_parameters: dict,
-        process_name: str,
-        request_src_name: str = None,
-        originator_svc_name: str = None,
-        originator_eng_name: str = None,
+            self,
+            qualified_name: str,
+            domain_identifier: int,
+            display_name: str,
+            description: str,
+            request_source_guids: str,
+            action_targets: str,
+            received_guards: [str],
+            start_time: datetime,
+            request_type: str,
+            request_parameters: dict,
+            process_name: str,
+            request_src_name: str = None,
+            originator_svc_name: str = None,
+            originator_eng_name: str = None,
     ) -> str:
         """Create an engine action in the metadata store that will trigger the governance service associated with
         the supplied request type. The engine action remains to act as a record of the actions taken for auditing.
@@ -2833,21 +2971,21 @@ class AutomatedCuration(Client):
         return response.json().get("guid", "Action not initiated")
 
     def initiate_engine_action(
-        self,
-        qualified_name: str,
-        domain_identifier: int,
-        display_name: str,
-        description: str,
-        request_source_guids: str,
-        action_targets: str,
-        received_guards: [str],
-        start_time: datetime,
-        request_type: str,
-        request_parameters: dict,
-        process_name: str,
-        request_src_name: str = None,
-        originator_svc_name: str = None,
-        originator_eng_name: str = None,
+            self,
+            qualified_name: str,
+            domain_identifier: int,
+            display_name: str,
+            description: str,
+            request_source_guids: str,
+            action_targets: str,
+            received_guards: [str],
+            start_time: datetime,
+            request_type: str,
+            request_parameters: dict,
+            process_name: str,
+            request_src_name: str = None,
+            originator_svc_name: str = None,
+            originator_eng_name: str = None,
     ) -> str:
         """Create an engine action in the metadata store that will trigger the governance service associated with
         the supplied request type. The engine action remains to act as a record of the actions taken for auditing.
@@ -2906,10 +3044,10 @@ class AutomatedCuration(Client):
         return response
 
     async def _async_get_catalog_targets(
-        self,
-        integ_connector_guid: str,
-        start_from: int = 0,
-        page_size: int = max_paging_size,
+            self,
+            integ_connector_guid: str,
+            start_from: int = 0,
+            page_size: int = 0,
     ) -> list | str:
         """Retrieve the details of the metadata elements identified as catalog targets with an integration connector.
         Async version.
@@ -2934,17 +3072,17 @@ class AutomatedCuration(Client):
 
         url = (
             f"{self.curation_command_root}/integration-connectors/"
-            f"{integ_connector_guid}/catalog-targets?startFrom={start_from}&pageSize={page_size}"
+            f"{integ_connector_guid}/catalog-targets"
         )
 
         response = await self._async_make_request("GET", url)
         return response.json().get("elements", "no targets")
 
     def get_catalog_targets(
-        self,
-        integ_connector_guid: str,
-        start_from: int = 0,
-        page_size: int = max_paging_size,
+            self,
+            integ_connector_guid: str,
+            start_from: int = 0,
+            page_size: int = 0,
     ) -> list | str:
         """Retrieve the details of the metadata elements identified as catalog targets with an integration connector.
 
@@ -2993,7 +3131,7 @@ class AutomatedCuration(Client):
 
         validate_guid(relationship_guid)
 
-        url = f"{self.curation_command_root}/catalog-targets/" f"{relationship_guid}"
+        url = f"{self.curation_command_root}/catalog-targets/{relationship_guid}"
 
         response = await self._async_make_request("GET", url)
         return response.json().get("element", "no actions")
@@ -3026,16 +3164,16 @@ class AutomatedCuration(Client):
         return response
 
     async def _async_add_catalog_target(
-        self,
-        integ_connector_guid: str,
-        metadata_element_guid: str,
-        catalog_target_name: str,
-        connection_name: str = None,
-        metadata_src_qual_name: str = None,
-        config_properties: dict = None,
-        template_properties: dict = None,
-        permitted_sync: str = "BOTH_DIRECTIONS",
-        delete_method: str = "ARCHIVE",
+            self,
+            integ_connector_guid: str,
+            metadata_element_guid: str,
+            catalog_target_name: str,
+            connection_name: str = None,
+            metadata_src_qual_name: str = None,
+            config_properties: dict = None,
+            template_properties: dict = None,
+            permitted_sync: str = "BOTH_DIRECTIONS",
+            delete_method: str = "ARCHIVE",
     ) -> str:
         """Add a catalog target to an integration connector and .
         Async version.
@@ -3093,16 +3231,16 @@ class AutomatedCuration(Client):
         return response.json().get("guid", "No Guid returned")
 
     def add_catalog_target(
-        self,
-        integ_connector_guid: str,
-        metadata_element_guid: str,
-        catalog_target_name: str,
-        connection_name: str = None,
-        metadata_src_qual_name: str = None,
-        config_properties: dict = None,
-        template_properties: dict = None,
-        permitted_sync: str = "BOTH_DIRECTIONS",
-        delete_method: str = "ARCHIVE",
+            self,
+            integ_connector_guid: str,
+            metadata_element_guid: str,
+            catalog_target_name: str,
+            connection_name: str = None,
+            metadata_src_qual_name: str = None,
+            config_properties: dict = None,
+            template_properties: dict = None,
+            permitted_sync: str = "BOTH_DIRECTIONS",
+            delete_method: str = "ARCHIVE",
     ) -> str:
         """Add a catalog target to an integration connector and .
 
@@ -3154,15 +3292,15 @@ class AutomatedCuration(Client):
         return response
 
     async def _async_update_catalog_target(
-        self,
-        relationship_guid: str,
-        catalog_target_name: str,
-        connection_name: str = None,
-        metadata_src_qual_name: str = None,
-        config_properties: dict = None,
-        template_properties: dict = None,
-        permitted_sync: str = "BOTH_DIRECTIONS",
-        delete_method: str = "ARCHIVE",
+            self,
+            relationship_guid: str,
+            catalog_target_name: str,
+            connection_name: str = None,
+            metadata_src_qual_name: str = None,
+            config_properties: dict = None,
+            template_properties: dict = None,
+            permitted_sync: str = "BOTH_DIRECTIONS",
+            delete_method: str = "ARCHIVE",
     ) -> None:
         """Update a catalog target to an integration connector.
         Async version.
@@ -3216,15 +3354,15 @@ class AutomatedCuration(Client):
         return
 
     def update_catalog_target(
-        self,
-        relationship_guid: str,
-        catalog_target_name: str,
-        connection_name: str = None,
-        metadata_src_qual_name: str = None,
-        config_properties: dict = None,
-        template_properties: dict = None,
-        permitted_sync: str = "BOTH_DIRECTIONS",
-        delete_method: str = "ARCHIVE",
+            self,
+            relationship_guid: str,
+            catalog_target_name: str,
+            connection_name: str = None,
+            metadata_src_qual_name: str = None,
+            config_properties: dict = None,
+            template_properties: dict = None,
+            permitted_sync: str = "BOTH_DIRECTIONS",
+            delete_method: str = "ARCHIVE",
     ) -> None:
         """Update a catalog target to an integration connector.
 
@@ -3323,11 +3461,11 @@ class AutomatedCuration(Client):
     #
 
     async def _async_get_tech_types_for_open_metadata_type(
-        self,
-        type_name: str,
-        tech_name: str,
-        start_from: int = 0,
-        page_size: int = max_paging_size,
+            self,
+            type_name: str,
+            tech_name: str,
+            start_from: int = 0,
+            page_size: int = 0,
     ) -> list | str:
         """Retrieve the list of deployed implementation type metadata elements linked to a particular
         open metadata type.. Async version.
@@ -3358,19 +3496,19 @@ class AutomatedCuration(Client):
         # validate_name(type_name)
         url = (
             f"{self.curation_command_root}/open-metadata-types/"
-            f"{type_name}/technology-types?startFrom={start_from}&pageSize={page_size}"
+            f"{type_name}/technology-types"
         )
         body = {"filter": tech_name}
 
-        response = await self._async_make_request("GET", url, body)
+        response = await self._async_make_request("POST", url, body)
         return response.json().get("elements", "no tech found")
 
     def get_tech_types_for_open_metadata_type(
-        self,
-        type_name: str,
-        tech_name: str,
-        start_from: int = 0,
-        page_size: int = max_paging_size,
+            self,
+            type_name: str,
+            tech_name: str,
+            start_from: int = 0,
+            page_size: int = 0,
     ) -> list | str:
         """Retrieve the list of deployed implementation type metadata elements linked to a particular
         open metadata type.
@@ -3405,13 +3543,19 @@ class AutomatedCuration(Client):
         )
         return response
 
-    async def _async_get_technology_type_detail(self, type_name: str) -> list | str:
+    async def _async_get_technology_type_detail(self, type_name: str, template_only: bool = False,
+                                                body: dict | FilterRequestBody = None) -> list | str:
         """Retrieve the details of the named technology type. This name should be the name of the technology type
             and contain no wild cards. Async version.
         Parameters
         ----------
         type_name : str
             The name of the technology type to retrieve detailed information for.
+        template_only : bool
+            If true, only the template information will be returned.
+        body: dict | FilterRequestBody
+            If provided, the information in the body supersedes the other parameters and allows more advanced requests.
+
 
 
         Returns
@@ -3421,63 +3565,116 @@ class AutomatedCuration(Client):
             If the technology type is not found, returns the string "no type found".
         Raises
         ------
-        InvalidParameterException: If the API response indicates an error (non-200 status code),
-                                   this exception is raised with details from the response content.
-        PropertyServerException: If the API response indicates a server side error.
-        UserNotAuthorizedException:
+        PyegeriaException
+        ValidationError
 
         Notes
         -----
         More information can be found at: https://egeria-project.org/concepts/deployed-implementation-type
+        Sample body:
+        {
+          "class" : "FilterRequestBody",
+          "filter" : "Root Technology Type",
+          "startFrom": 0,
+          "pageSize": 10,
+          "asOfTime" : "{{$isoTimestamp}}",
+          "effectiveTime" : "{{$isoTimestamp}}",
+          "includeOnlyClassifiedElements" : ["Template"]
+          "forLineage" : false,
+          "forDuplicateProcessing" : false,
+          "limitResultsByStatus" : ["ACTIVE"],
+          "sequencingOrder" : "PROPERTY_ASCENDING",
+          "sequencingProperty" : "qualifiedName"
+        }
         """
 
         # validate_name(type_name)
         url = f"{self.curation_command_root}/technology-types/by-name"
-
-        body = {"filter": type_name}
+        if body is None:
+            classified_elements = ["Template"] if template_only else []
+            body = {
+                "class": "FilterRequestBody",
+                "filter": type_name,
+                "includeOnlyClassifiedElements": classified_elements
+            }
 
         response = await self._async_make_request("POST", url, body)
         return response.json().get("element", "no type found")
 
-    def get_technology_type_detail(self, type_name: str) -> list | str:
+    def get_technology_type_detail(self, type_name: str, template_only: bool = False,
+                                   body: dict | FilterRequestBody = None) -> list | str:
         """Retrieve the details of the named technology type. This name should be the name of the technology type
-        and contain no wild cards.
-        Parameters
-        ----------
-        type_name : str
-            The name of the technology type to retrieve detailed information for.
+                 and contain no wild cards.
+             Parameters
+             ----------
+             type_name : str
+                 The name of the technology type to retrieve detailed information for.
+             template_only : bool
+                 If true, only the template information will be returned.
+             body: dict | FilterRequestBody
+                 If provided, the information in the body supersedes the other parameters and allows more advanced requests.
+
+
+
+             Returns
+             -------
+             list[dict] | str
+                 A list of dictionaries containing the detailed information for the specified technology type.
+                 If the technology type is not found, returns the string "no type found".
+             Raises
+             ------
+             PyegeriaException
+             ValidationError
+
+             Notes
+             -----
+             More information can be found at: https://egeria-project.org/concepts/deployed-implementation-type
+             Sample body:
+             {
+               "class" : "FilterRequestBody",
+               "filter" : "Root Technology Type",
+               "startFrom": 0,
+               "pageSize": 10,
+               "asOfTime" : "{{$isoTimestamp}}",
+               "effectiveTime" : "{{$isoTimestamp}}",
+               "includeOnlyClassifiedElements" : ["Template"]
+               "forLineage" : false,
+               "forDuplicateProcessing" : false,
+               "limitResultsByStatus" : ["ACTIVE"],
+               "sequencingOrder" : "PROPERTY_ASCENDING",
+               "sequencingProperty" : "qualifiedName"
+             }
+             """
 
-        Returns
-        -------
-        list[dict] | str
-            A list of dictionaries containing the detailed information for the specified technology type.
-            If the technology type is not found, returns the string "no type found".
-        Raises
-        ------
-        InvalidParameterException: If the API response indicates an error (non-200 status code),
-                                   this exception is raised with details from the response content.
-        PropertyServerException: If the API response indicates a server side error.
-        UserNotAuthorizedException:
+        loop = asyncio.get_event_loop()
+        response = loop.run_until_complete(
+            self._async_get_technology_type_detail(type_name, template_only=template_only, body=body)
+        )
+        return response
 
-        Notes
-        -----
-        More information can be found at: https://egeria-project.org/concepts/deployed-implementation-type
-        """
+    async def _async_get_template_guid_for_technology_type(self, type_name: str) -> str:
+        details = await self._async_get_technology_type_detail(type_name)
+        if isinstance(details, dict):
+            return details.get("catalogTemplates", {})[0].get("relatedElement", {}).get("elementHeader", {}).get("guid",
+                                                                                                                 None)
+        else:
+            return None
 
+    def get_template_guid_for_technology_type(self, type_name: str) -> str:
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
-            self._async_get_technology_type_detail(type_name)
+            self._async_get_template_guid_for_technology_type(type_name)
         )
         return response
 
     async def _async_find_technology_types(
-        self,
-        search_string: str = "*",
-        start_from: int = 0,
-        page_size: int = max_paging_size,
-        starts_with: bool = False,
-        ends_with: bool = False,
-        ignore_case: bool = True,
+            self,
+            search_string: str = "*",
+            start_from: int = 0,
+            page_size: int = 0,
+            starts_with: bool = False,
+            ends_with: bool = False,
+            ignore_case: bool = True,
     ) -> list | str:
         """Retrieve the list of technology types that contain the search string. Async version.
 
@@ -3498,7 +3695,7 @@ class AutomatedCuration(Client):
            The index from which to start fetching the engine actions. Default is 0.
 
         page_size : int, optional
-           The maximum number of engine actions to fetch in a single request. Default is `max_paging_size`.
+           The maximum number of engine actions to fetch in a single request. Default is `0`.
         Returns:
         -------
             [dict] | str: List of elements describing the technology - or "no tech found" if not found.
@@ -3520,26 +3717,36 @@ class AutomatedCuration(Client):
         ignore_case_s = str(ignore_case).lower()
         validate_name(search_string)
         if search_string == "*":
-            search_string = ""
+            search_string = None
 
         url = (
             f"{self.curation_command_root}/technology-types/"
-            f"by-search-string?startFrom={start_from}&pageSize={page_size}&startsWith={starts_with_s}&"
-            f"endsWith={ends_with_s}&ignoreCase={ignore_case_s}"
+            f"by-search-string"
         )
-        body = {"filter": search_string}
+        body = {
+            "class": "SearchStringRequestBody",
+            "searchString": search_string,
+            "startsWith": True,
+            "endsWith": False,
+            "ignoreCase": True,
+            "startFrom": 0,
+            "pageSize": 0,
+            "limitResultsByStatus": ["ACTIVE"],
+            "sequencingOrder": "PROPERTY_ASCENDING",
+            "sequencingProperty": "qualifiedName"
+        }
 
         response = await self._async_make_request("POST", url, body)
         return response.json().get("elements", "no tech found")
 
     def find_technology_types(
-        self,
-        search_string: str = "*",
-        start_from: int = 0,
-        page_size: int = max_paging_size,
-        starts_with: bool = False,
-        ends_with: bool = False,
-        ignore_case: bool = True,
+            self,
+            search_string: str = "*",
+            start_from: int = 0,
+            page_size: int = 0,
+            starts_with: bool = False,
+            ends_with: bool = False,
+            ignore_case: bool = True,
     ) -> list | str:
         """Retrieve the list of technology types that contain the search string. Async version.
 
@@ -3578,13 +3785,13 @@ class AutomatedCuration(Client):
         return response
 
     async def _async_get_all_technology_types(
-        self, start_from: int = 0, page_size: int = max_paging_size
+            self, start_from: int = 0, page_size: int = 0
     ) -> list | str:
         """Get all technology types - async version"""
         return await self._async_find_technology_types("*", start_from, page_size)
 
     def get_all_technology_types(
-        self, start_from: int = 0, page_size: int = max_paging_size
+            self, start_from: int = 0, page_size: int = 0
     ) -> list | str:
         """Get all technology types"""
         return self.find_technology_types("*", start_from, page_size)
@@ -3659,12 +3866,12 @@ class AutomatedCuration(Client):
                 self.print_engine_action_summary(governance_actions[x])
 
     async def _async_get_technology_type_elements(
-        self,
-        filter: str,
-        effective_time: str = None,
-        start_from: int = 0,
-        page_size: int = max_paging_size,
-        get_templates: bool = False,
+            self,
+            filter: str,
+            effective_time: str = None,
+            start_from: int = 0,
+            page_size: int = 0,
+            get_templates: bool = False,
     ) -> list | str:
         """Retrieve the elements for the requested deployed implementation type. There are no wildcards allowed
         in the name. Async version.
@@ -3681,7 +3888,7 @@ class AutomatedCuration(Client):
            The index from which to start fetching the engine actions. Default is 0.
 
         page_size : int, optional
-           The maximum number of engine actions to fetch in a single request. Default is `max_paging_size`.
+           The maximum number of engine actions to fetch in a single request. Default is `0`.
 
         Returns:
         -------
@@ -3703,8 +3910,7 @@ class AutomatedCuration(Client):
         validate_name(filter)
 
         url = (
-            f"{self.curation_command_root}/technology-types/elements?"
-            f"startFrom={start_from}&pageSize={page_size}&getTemplates={get_templates_s}"
+            f"{self.curation_command_root}/technology-types/elements"
         )
         body = {"filter": filter, "effective_time": effective_time}
 
@@ -3712,12 +3918,12 @@ class AutomatedCuration(Client):
         return response.json().get("elements", "no tech found")
 
     def get_technology_type_elements(
-        self,
-        filter: str,
-        effective_time: str = None,
-        start_from: int = 0,
-        page_size: int = max_paging_size,
-        get_templates: bool = False,
+            self,
+            filter: str,
+            effective_time: str = None,
+            start_from: int = 0,
+            page_size: int = 0,
+            get_templates: bool = False,
     ) -> list | str:
         """Retrieve the elements for the requested deployed implementation type. There are no wildcards allowed
         in the name.
@@ -3734,7 +3940,7 @@ class AutomatedCuration(Client):
            The index from which to start fetching the engine actions. Default is 0.
 
         page_size : int, optional
-           The maximum number of engine actions to fetch in a single request. Default is `max_paging_size`.
+           The maximum number of engine actions to fetch in a single request. Default is `0`.
 
         Returns:
         -------