oci 2.149.1__py3-none-any.whl → 2.149.2__py3-none-any.whl

oci/data_science/data_science_client_composite_operations.py

@@ -232,6 +232,132 @@ class DataScienceClientCompositeOperations(object):
         except Exception as e:
             raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
 
+    def change_ml_application_implementation_compartment_and_wait_for_state(self, ml_application_implementation_id, change_ml_application_implementation_compartment_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
+        """
+        Calls :py:func:`~oci.data_science.DataScienceClient.change_ml_application_implementation_compartment` and waits for the :py:class:`~oci.data_science.models.WorkRequest`
+        to enter the given state(s).
+
+        :param str ml_application_implementation_id: (required)
+            unique MlApplicationImplementation identifier
+
+        :param oci.data_science.models.ChangeMlApplicationImplementationCompartmentDetails change_ml_application_implementation_compartment_details: (required)
+            The information to be updated.
+
+        :param list[str] wait_for_states:
+            An array of states to wait on. These should be valid values for :py:attr:`~oci.data_science.models.WorkRequest.status`
+
+        :param dict operation_kwargs:
+            A dictionary of keyword arguments to pass to :py:func:`~oci.data_science.DataScienceClient.change_ml_application_implementation_compartment`
+
+        :param dict waiter_kwargs:
+            A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds``
+            as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
+        """
+        operation_result = self.client.change_ml_application_implementation_compartment(ml_application_implementation_id, change_ml_application_implementation_compartment_details, **operation_kwargs)
+        if not wait_for_states:
+            return operation_result
+        lowered_wait_for_states = [w.lower() for w in wait_for_states]
+        if 'opc-work-request-id' not in operation_result.headers:
+            return operation_result
+        wait_for_resource_id = operation_result.headers['opc-work-request-id']
+
+        try:
+            waiter_result = oci.wait_until(
+                self.client,
+                self.client.get_work_request(wait_for_resource_id),
+                evaluate_response=lambda r: getattr(r.data, 'status') and getattr(r.data, 'status').lower() in lowered_wait_for_states,
+                **waiter_kwargs
+            )
+            result_to_return = waiter_result
+
+            return result_to_return
+        except Exception as e:
+            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
+
+    def change_ml_application_instance_compartment_and_wait_for_state(self, ml_application_instance_id, change_ml_application_instance_compartment_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
+        """
+        Calls :py:func:`~oci.data_science.DataScienceClient.change_ml_application_instance_compartment` and waits for the :py:class:`~oci.data_science.models.WorkRequest`
+        to enter the given state(s).
+
+        :param str ml_application_instance_id: (required)
+            unique MlApplicationInstance identifier
+
+        :param oci.data_science.models.ChangeMlApplicationInstanceCompartmentDetails change_ml_application_instance_compartment_details: (required)
+            The information to be updated.
+
+        :param list[str] wait_for_states:
+            An array of states to wait on. These should be valid values for :py:attr:`~oci.data_science.models.WorkRequest.status`
+
+        :param dict operation_kwargs:
+            A dictionary of keyword arguments to pass to :py:func:`~oci.data_science.DataScienceClient.change_ml_application_instance_compartment`
+
+        :param dict waiter_kwargs:
+            A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds``
+            as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
+        """
+        operation_result = self.client.change_ml_application_instance_compartment(ml_application_instance_id, change_ml_application_instance_compartment_details, **operation_kwargs)
+        if not wait_for_states:
+            return operation_result
+        lowered_wait_for_states = [w.lower() for w in wait_for_states]
+        if 'opc-work-request-id' not in operation_result.headers:
+            return operation_result
+        wait_for_resource_id = operation_result.headers['opc-work-request-id']
+
+        try:
+            waiter_result = oci.wait_until(
+                self.client,
+                self.client.get_work_request(wait_for_resource_id),
+                evaluate_response=lambda r: getattr(r.data, 'status') and getattr(r.data, 'status').lower() in lowered_wait_for_states,
+                **waiter_kwargs
+            )
+            result_to_return = waiter_result
+
+            return result_to_return
+        except Exception as e:
+            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
+
+    def change_ml_application_instance_view_compartment_and_wait_for_state(self, ml_application_instance_view_id, change_ml_application_instance_view_compartment_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
+        """
+        Calls :py:func:`~oci.data_science.DataScienceClient.change_ml_application_instance_view_compartment` and waits for the :py:class:`~oci.data_science.models.WorkRequest`
+        to enter the given state(s).
+
+        :param str ml_application_instance_view_id: (required)
+            unique MlApplicationInstanceView identifier
+
+        :param oci.data_science.models.ChangeMlApplicationInstanceViewCompartmentDetails change_ml_application_instance_view_compartment_details: (required)
+            The information to be updated.
+
+        :param list[str] wait_for_states:
+            An array of states to wait on. These should be valid values for :py:attr:`~oci.data_science.models.WorkRequest.status`
+
+        :param dict operation_kwargs:
+            A dictionary of keyword arguments to pass to :py:func:`~oci.data_science.DataScienceClient.change_ml_application_instance_view_compartment`
+
+        :param dict waiter_kwargs:
+            A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds``
+            as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
+        """
+        operation_result = self.client.change_ml_application_instance_view_compartment(ml_application_instance_view_id, change_ml_application_instance_view_compartment_details, **operation_kwargs)
+        if not wait_for_states:
+            return operation_result
+        lowered_wait_for_states = [w.lower() for w in wait_for_states]
+        if 'opc-work-request-id' not in operation_result.headers:
+            return operation_result
+        wait_for_resource_id = operation_result.headers['opc-work-request-id']
+
+        try:
+            waiter_result = oci.wait_until(
+                self.client,
+                self.client.get_work_request(wait_for_resource_id),
+                evaluate_response=lambda r: getattr(r.data, 'status') and getattr(r.data, 'status').lower() in lowered_wait_for_states,
+                **waiter_kwargs
+            )
+            result_to_return = waiter_result
+
+            return result_to_return
+        except Exception as e:
+            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
+
     def change_model_version_set_compartment_and_wait_for_state(self, model_version_set_id, change_model_version_set_compartment_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
         """
         Calls :py:func:`~oci.data_science.DataScienceClient.change_model_version_set_compartment` and waits for the :py:class:`~oci.data_science.models.WorkRequest`
@@ -441,6 +567,129 @@ class DataScienceClientCompositeOperations(object):
         except Exception as e:
             raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
 
+    def create_ml_application_and_wait_for_state(self, create_ml_application_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
+        """
+        Calls :py:func:`~oci.data_science.DataScienceClient.create_ml_application` and waits for the :py:class:`~oci.data_science.models.MlApplication` acted upon
+        to enter the given state(s).
+
+        :param oci.data_science.models.CreateMlApplicationDetails create_ml_application_details: (required)
+            Details for the new MlApplication.
+
+        :param list[str] wait_for_states:
+            An array of states to wait on. These should be valid values for :py:attr:`~oci.data_science.models.MlApplication.lifecycle_state`
+
+        :param dict operation_kwargs:
+            A dictionary of keyword arguments to pass to :py:func:`~oci.data_science.DataScienceClient.create_ml_application`
+
+        :param dict waiter_kwargs:
+            A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds``
+            as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
+        """
+        operation_result = self.client.create_ml_application(create_ml_application_details, **operation_kwargs)
+        if not wait_for_states:
+            return operation_result
+        lowered_wait_for_states = [w.lower() for w in wait_for_states]
+        ml_application_id = operation_result.data.id
+
+        try:
+            waiter_result = oci.wait_until(
+                self.client,
+                self.client.get_ml_application(ml_application_id),  # noqa: F821
+                evaluate_response=lambda r: getattr(r.data, 'lifecycle_state') and getattr(r.data, 'lifecycle_state').lower() in lowered_wait_for_states,
+                **waiter_kwargs
+            )
+            result_to_return = waiter_result
+
+            return result_to_return
+        except (NameError, TypeError) as e:
+            if not e.args:
+                e.args = ('',)
+            e.args = e.args + ('This composite operation is currently not supported in the SDK. Please use the operation from the service client and use waiters as an alternative. For more information on waiters, visit: "https://docs.oracle.com/en-us/iaas/tools/python/latest/api/waiters.html"', )
+            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
+        except Exception as e:
+            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
+
+    def create_ml_application_implementation_and_wait_for_state(self, create_ml_application_implementation_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
+        """
+        Calls :py:func:`~oci.data_science.DataScienceClient.create_ml_application_implementation` and waits for the :py:class:`~oci.data_science.models.MlApplicationImplementation` acted upon
+        to enter the given state(s).
+
+        :param oci.data_science.models.CreateMlApplicationImplementationDetails create_ml_application_implementation_details: (required)
+            Details for the new MlApplicationImplementation.
+
+        :param list[str] wait_for_states:
+            An array of states to wait on. These should be valid values for :py:attr:`~oci.data_science.models.MlApplicationImplementation.lifecycle_state`
+
+        :param dict operation_kwargs:
+            A dictionary of keyword arguments to pass to :py:func:`~oci.data_science.DataScienceClient.create_ml_application_implementation`
+
+        :param dict waiter_kwargs:
+            A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds``
+            as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
+        """
+        operation_result = self.client.create_ml_application_implementation(create_ml_application_implementation_details, **operation_kwargs)
+        if not wait_for_states:
+            return operation_result
+        lowered_wait_for_states = [w.lower() for w in wait_for_states]
+        ml_application_implementation_id = operation_result.data.id
+
+        try:
+            waiter_result = oci.wait_until(
+                self.client,
+                self.client.get_ml_application_implementation(ml_application_implementation_id),  # noqa: F821
+                evaluate_response=lambda r: getattr(r.data, 'lifecycle_state') and getattr(r.data, 'lifecycle_state').lower() in lowered_wait_for_states,
+                **waiter_kwargs
+            )
+            result_to_return = waiter_result
+
+            return result_to_return
+        except (NameError, TypeError) as e:
+            if not e.args:
+                e.args = ('',)
+            e.args = e.args + ('This composite operation is currently not supported in the SDK. Please use the operation from the service client and use waiters as an alternative. For more information on waiters, visit: "https://docs.oracle.com/en-us/iaas/tools/python/latest/api/waiters.html"', )
+            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
+        except Exception as e:
+            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
+
+    def create_ml_application_instance_and_wait_for_state(self, create_ml_application_instance_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
+        """
+        Calls :py:func:`~oci.data_science.DataScienceClient.create_ml_application_instance` and waits for the :py:class:`~oci.data_science.models.WorkRequest`
+        to enter the given state(s).
+
+        :param oci.data_science.models.CreateMlApplicationInstanceDetails create_ml_application_instance_details: (required)
+            Details for the new MlApplicationInstance.
+
+        :param list[str] wait_for_states:
+            An array of states to wait on. These should be valid values for :py:attr:`~oci.data_science.models.WorkRequest.status`
+
+        :param dict operation_kwargs:
+            A dictionary of keyword arguments to pass to :py:func:`~oci.data_science.DataScienceClient.create_ml_application_instance`
+
+        :param dict waiter_kwargs:
+            A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds``
+            as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
+        """
+        operation_result = self.client.create_ml_application_instance(create_ml_application_instance_details, **operation_kwargs)
+        if not wait_for_states:
+            return operation_result
+        lowered_wait_for_states = [w.lower() for w in wait_for_states]
+        if 'opc-work-request-id' not in operation_result.headers:
+            return operation_result
+        wait_for_resource_id = operation_result.headers['opc-work-request-id']
+
+        try:
+            waiter_result = oci.wait_until(
+                self.client,
+                self.client.get_work_request(wait_for_resource_id),
+                evaluate_response=lambda r: getattr(r.data, 'status') and getattr(r.data, 'status').lower() in lowered_wait_for_states,
+                **waiter_kwargs
+            )
+            result_to_return = waiter_result
+
+            return result_to_return
+        except Exception as e:
+            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
+
     def create_model_and_wait_for_state(self, create_model_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
         """
         Calls :py:func:`~oci.data_science.DataScienceClient.create_model` and waits for the :py:class:`~oci.data_science.models.Model` acted upon
@@ -1090,30 +1339,28 @@ class DataScienceClientCompositeOperations(object):
         except Exception as e:
             raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
 
-    def delete_model_and_wait_for_state(self, model_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
+    def delete_ml_application_and_wait_for_state(self, ml_application_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
         """
-        Calls :py:func:`~oci.data_science.DataScienceClient.delete_model` and waits for the :py:class:`~oci.data_science.models.Model` acted upon
+        Calls :py:func:`~oci.data_science.DataScienceClient.delete_ml_application` and waits for the :py:class:`~oci.data_science.models.MlApplication` acted upon
         to enter the given state(s).
 
-        :param str model_id: (required)
-            The `OCID`__ of the model.
-
-            __ https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm
+        :param str ml_application_id: (required)
+            unique MlApplication identifier
 
         :param list[str] wait_for_states:
-            An array of states to wait on. These should be valid values for :py:attr:`~oci.data_science.models.Model.lifecycle_state`
+            An array of states to wait on. These should be valid values for :py:attr:`~oci.data_science.models.MlApplication.lifecycle_state`
 
         :param dict operation_kwargs:
-            A dictionary of keyword arguments to pass to :py:func:`~oci.data_science.DataScienceClient.delete_model`
+            A dictionary of keyword arguments to pass to :py:func:`~oci.data_science.DataScienceClient.delete_ml_application`
 
         :param dict waiter_kwargs:
             A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds``
             as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
         """
-        initial_get_result = self.client.get_model(model_id)
+        initial_get_result = self.client.get_ml_application(ml_application_id)
         operation_result = None
         try:
-            operation_result = self.client.delete_model(model_id, **operation_kwargs)
+            operation_result = self.client.delete_ml_application(ml_application_id, **operation_kwargs)
         except oci.exceptions.ServiceError as e:
             if e.status == 404:
                 return WAIT_RESOURCE_NOT_FOUND
@@ -1126,7 +1373,7 @@ class DataScienceClientCompositeOperations(object):
 
         try:
             if ("succeed_on_not_found" in waiter_kwargs) and (waiter_kwargs["succeed_on_not_found"] is False):
-                self.client.base_client.logger.warning("The waiter kwarg succeed_on_not_found was passed as False for the delete composite operation delete_model, this would result in the operation to fail if the resource is not found! Please, do not pass this kwarg if this was not intended")
+                self.client.base_client.logger.warning("The waiter kwarg succeed_on_not_found was passed as False for the delete composite operation delete_ml_application, this would result in the operation to fail if the resource is not found! Please, do not pass this kwarg if this was not intended")
             else:
                 """
                 If the user does not send in this value, we set it to True by default.
@@ -1151,21 +1398,19 @@ class DataScienceClientCompositeOperations(object):
         except Exception as e:
             raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
 
-    def delete_model_deployment_and_wait_for_state(self, model_deployment_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
+    def delete_ml_application_implementation_and_wait_for_state(self, ml_application_implementation_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
         """
-        Calls :py:func:`~oci.data_science.DataScienceClient.delete_model_deployment` and waits for the :py:class:`~oci.data_science.models.WorkRequest`
+        Calls :py:func:`~oci.data_science.DataScienceClient.delete_ml_application_implementation` and waits for the :py:class:`~oci.data_science.models.WorkRequest`
         to enter the given state(s).
 
-        :param str model_deployment_id: (required)
-            The `OCID`__ of the model deployment.
-
-            __ https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm
+        :param str ml_application_implementation_id: (required)
+            unique MlApplicationImplementation identifier
 
         :param list[str] wait_for_states:
             An array of states to wait on. These should be valid values for :py:attr:`~oci.data_science.models.WorkRequest.status`
 
         :param dict operation_kwargs:
-            A dictionary of keyword arguments to pass to :py:func:`~oci.data_science.DataScienceClient.delete_model_deployment`
+            A dictionary of keyword arguments to pass to :py:func:`~oci.data_science.DataScienceClient.delete_ml_application_implementation`
 
         :param dict waiter_kwargs:
             A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds``
@@ -1173,7 +1418,7 @@ class DataScienceClientCompositeOperations(object):
         """
         operation_result = None
         try:
-            operation_result = self.client.delete_model_deployment(model_deployment_id, **operation_kwargs)
+            operation_result = self.client.delete_ml_application_implementation(ml_application_implementation_id, **operation_kwargs)
         except oci.exceptions.ServiceError as e:
             if e.status == 404:
                 return WAIT_RESOURCE_NOT_FOUND
@@ -1200,21 +1445,19 @@ class DataScienceClientCompositeOperations(object):
         except Exception as e:
             raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
 
-    def delete_model_version_set_and_wait_for_state(self, model_version_set_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
+    def delete_ml_application_instance_and_wait_for_state(self, ml_application_instance_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
         """
-        Calls :py:func:`~oci.data_science.DataScienceClient.delete_model_version_set` and waits for the :py:class:`~oci.data_science.models.WorkRequest`
+        Calls :py:func:`~oci.data_science.DataScienceClient.delete_ml_application_instance` and waits for the :py:class:`~oci.data_science.models.WorkRequest`
         to enter the given state(s).
 
-        :param str model_version_set_id: (required)
-            The `OCID`__ of the model version set.
-
-            __ https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm
+        :param str ml_application_instance_id: (required)
+            unique MlApplicationInstance identifier
 
         :param list[str] wait_for_states:
             An array of states to wait on. These should be valid values for :py:attr:`~oci.data_science.models.WorkRequest.status`
 
         :param dict operation_kwargs:
-            A dictionary of keyword arguments to pass to :py:func:`~oci.data_science.DataScienceClient.delete_model_version_set`
+            A dictionary of keyword arguments to pass to :py:func:`~oci.data_science.DataScienceClient.delete_ml_application_instance`
 
         :param dict waiter_kwargs:
             A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds``
@@ -1222,7 +1465,7 @@ class DataScienceClientCompositeOperations(object):
         """
         operation_result = None
         try:
-            operation_result = self.client.delete_model_version_set(model_version_set_id, **operation_kwargs)
+            operation_result = self.client.delete_ml_application_instance(ml_application_instance_id, **operation_kwargs)
         except oci.exceptions.ServiceError as e:
             if e.status == 404:
                 return WAIT_RESOURCE_NOT_FOUND
@@ -1249,29 +1492,30 @@ class DataScienceClientCompositeOperations(object):
         except Exception as e:
             raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
 
-    def delete_notebook_session_and_wait_for_state(self, notebook_session_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
+    def delete_model_and_wait_for_state(self, model_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
         """
-        Calls :py:func:`~oci.data_science.DataScienceClient.delete_notebook_session` and waits for the :py:class:`~oci.data_science.models.WorkRequest`
+        Calls :py:func:`~oci.data_science.DataScienceClient.delete_model` and waits for the :py:class:`~oci.data_science.models.Model` acted upon
         to enter the given state(s).
 
-        :param str notebook_session_id: (required)
-            The `OCID`__ of the notebook session.
+        :param str model_id: (required)
+            The `OCID`__ of the model.
 
             __ https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm
 
         :param list[str] wait_for_states:
-            An array of states to wait on. These should be valid values for :py:attr:`~oci.data_science.models.WorkRequest.status`
+            An array of states to wait on. These should be valid values for :py:attr:`~oci.data_science.models.Model.lifecycle_state`
 
         :param dict operation_kwargs:
-            A dictionary of keyword arguments to pass to :py:func:`~oci.data_science.DataScienceClient.delete_notebook_session`
+            A dictionary of keyword arguments to pass to :py:func:`~oci.data_science.DataScienceClient.delete_model`
 
         :param dict waiter_kwargs:
             A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds``
             as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
         """
+        initial_get_result = self.client.get_model(model_id)
         operation_result = None
         try:
-            operation_result = self.client.delete_notebook_session(notebook_session_id, **operation_kwargs)
+            operation_result = self.client.delete_model(model_id, **operation_kwargs)
         except oci.exceptions.ServiceError as e:
             if e.status == 404:
                 return WAIT_RESOURCE_NOT_FOUND
@@ -1281,18 +1525,176 @@ class DataScienceClientCompositeOperations(object):
         if not wait_for_states:
             return operation_result
         lowered_wait_for_states = [w.lower() for w in wait_for_states]
-        if 'opc-work-request-id' not in operation_result.headers:
-            return operation_result
-        wait_for_resource_id = operation_result.headers['opc-work-request-id']
 
         try:
-            waiter_result = oci.wait_until(
-                self.client,
-                self.client.get_work_request(wait_for_resource_id),
-                evaluate_response=lambda r: getattr(r.data, 'status') and getattr(r.data, 'status').lower() in lowered_wait_for_states,
-                **waiter_kwargs
-            )
-            result_to_return = waiter_result
+            if ("succeed_on_not_found" in waiter_kwargs) and (waiter_kwargs["succeed_on_not_found"] is False):
+                self.client.base_client.logger.warning("The waiter kwarg succeed_on_not_found was passed as False for the delete composite operation delete_model, this would result in the operation to fail if the resource is not found! Please, do not pass this kwarg if this was not intended")
+            else:
+                """
+                If the user does not send in this value, we set it to True by default.
+                We are doing this because during a delete resource scenario and waiting on its state, the service can
+                return a 404 NOT FOUND exception as the resource was deleted and a get on its state would fail
+                """
+                waiter_kwargs["succeed_on_not_found"] = True
+            waiter_result = oci.wait_until(
+                self.client,
+                initial_get_result,  # noqa: F821
+                evaluate_response=lambda r: getattr(r.data, 'lifecycle_state') and getattr(r.data, 'lifecycle_state').lower() in lowered_wait_for_states,
+                **waiter_kwargs
+            )
+            result_to_return = waiter_result
+
+            return result_to_return
+        except (NameError, TypeError) as e:
+            if not e.args:
+                e.args = ('',)
+            e.args = e.args + ('This composite operation is currently not supported in the SDK. Please use the operation from the service client and use waiters as an alternative. For more information on waiters, visit: "https://docs.oracle.com/en-us/iaas/tools/python/latest/api/waiters.html"', )
+            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
+        except Exception as e:
+            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
+
+    def delete_model_deployment_and_wait_for_state(self, model_deployment_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
+        """
+        Calls :py:func:`~oci.data_science.DataScienceClient.delete_model_deployment` and waits for the :py:class:`~oci.data_science.models.WorkRequest`
+        to enter the given state(s).
+
+        :param str model_deployment_id: (required)
+            The `OCID`__ of the model deployment.
+
+            __ https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm
+
+        :param list[str] wait_for_states:
+            An array of states to wait on. These should be valid values for :py:attr:`~oci.data_science.models.WorkRequest.status`
+
+        :param dict operation_kwargs:
+            A dictionary of keyword arguments to pass to :py:func:`~oci.data_science.DataScienceClient.delete_model_deployment`
+
+        :param dict waiter_kwargs:
+            A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds``
+            as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
+        """
+        operation_result = None
+        try:
+            operation_result = self.client.delete_model_deployment(model_deployment_id, **operation_kwargs)
+        except oci.exceptions.ServiceError as e:
+            if e.status == 404:
+                return WAIT_RESOURCE_NOT_FOUND
+            else:
+                raise e
+
+        if not wait_for_states:
+            return operation_result
+        lowered_wait_for_states = [w.lower() for w in wait_for_states]
+        if 'opc-work-request-id' not in operation_result.headers:
+            return operation_result
+        wait_for_resource_id = operation_result.headers['opc-work-request-id']
+
+        try:
+            waiter_result = oci.wait_until(
+                self.client,
+                self.client.get_work_request(wait_for_resource_id),
+                evaluate_response=lambda r: getattr(r.data, 'status') and getattr(r.data, 'status').lower() in lowered_wait_for_states,
+                **waiter_kwargs
+            )
+            result_to_return = waiter_result
+
+            return result_to_return
+        except Exception as e:
+            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
+
+    def delete_model_version_set_and_wait_for_state(self, model_version_set_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
+        """
+        Calls :py:func:`~oci.data_science.DataScienceClient.delete_model_version_set` and waits for the :py:class:`~oci.data_science.models.WorkRequest`
+        to enter the given state(s).
+
+        :param str model_version_set_id: (required)
+            The `OCID`__ of the model version set.
+
+            __ https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm
+
+        :param list[str] wait_for_states:
+            An array of states to wait on. These should be valid values for :py:attr:`~oci.data_science.models.WorkRequest.status`
+
+        :param dict operation_kwargs:
+            A dictionary of keyword arguments to pass to :py:func:`~oci.data_science.DataScienceClient.delete_model_version_set`
+
+        :param dict waiter_kwargs:
+            A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds``
+            as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
+        """
+        operation_result = None
+        try:
+            operation_result = self.client.delete_model_version_set(model_version_set_id, **operation_kwargs)
+        except oci.exceptions.ServiceError as e:
+            if e.status == 404:
+                return WAIT_RESOURCE_NOT_FOUND
+            else:
+                raise e
+
+        if not wait_for_states:
+            return operation_result
+        lowered_wait_for_states = [w.lower() for w in wait_for_states]
+        if 'opc-work-request-id' not in operation_result.headers:
+            return operation_result
+        wait_for_resource_id = operation_result.headers['opc-work-request-id']
+
+        try:
+            waiter_result = oci.wait_until(
+                self.client,
+                self.client.get_work_request(wait_for_resource_id),
+                evaluate_response=lambda r: getattr(r.data, 'status') and getattr(r.data, 'status').lower() in lowered_wait_for_states,
+                **waiter_kwargs
+            )
+            result_to_return = waiter_result
+
+            return result_to_return
+        except Exception as e:
+            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
+
+    def delete_notebook_session_and_wait_for_state(self, notebook_session_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
+        """
+        Calls :py:func:`~oci.data_science.DataScienceClient.delete_notebook_session` and waits for the :py:class:`~oci.data_science.models.WorkRequest`
+        to enter the given state(s).
+
+        :param str notebook_session_id: (required)
+            The `OCID`__ of the notebook session.
+
+            __ https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm
+
+        :param list[str] wait_for_states:
+            An array of states to wait on. These should be valid values for :py:attr:`~oci.data_science.models.WorkRequest.status`
+
+        :param dict operation_kwargs:
+            A dictionary of keyword arguments to pass to :py:func:`~oci.data_science.DataScienceClient.delete_notebook_session`
+
+        :param dict waiter_kwargs:
+            A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds``
+            as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
+        """
+        operation_result = None
+        try:
+            operation_result = self.client.delete_notebook_session(notebook_session_id, **operation_kwargs)
+        except oci.exceptions.ServiceError as e:
+            if e.status == 404:
+                return WAIT_RESOURCE_NOT_FOUND
+            else:
+                raise e
+
+        if not wait_for_states:
+            return operation_result
+        lowered_wait_for_states = [w.lower() for w in wait_for_states]
+        if 'opc-work-request-id' not in operation_result.headers:
+            return operation_result
+        wait_for_resource_id = operation_result.headers['opc-work-request-id']
+
+        try:
+            waiter_result = oci.wait_until(
+                self.client,
+                self.client.get_work_request(wait_for_resource_id),
+                evaluate_response=lambda r: getattr(r.data, 'status') and getattr(r.data, 'status').lower() in lowered_wait_for_states,
+                **waiter_kwargs
+            )
+            result_to_return = waiter_result
 
             return result_to_return
         except Exception as e:
@@ -1504,118 +1906,120 @@ class DataScienceClientCompositeOperations(object):
         except Exception as e:
             raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
 
-    def export_model_artifact_and_wait_for_state(self, model_id, export_model_artifact_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
+    def disable_ml_application_instance_view_trigger_and_wait_for_state(self, disable_ml_application_instance_view_trigger_details, ml_application_instance_view_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
         """
-        Calls :py:func:`~oci.data_science.DataScienceClient.export_model_artifact` and waits for the :py:class:`~oci.data_science.models.WorkRequest`
+        Calls :py:func:`~oci.data_science.DataScienceClient.disable_ml_application_instance_view_trigger` and waits for the :py:class:`~oci.data_science.models.MlApplicationInstanceView` acted upon
         to enter the given state(s).
 
-        :param str model_id: (required)
-            The `OCID`__ of the model.
-
-            __ https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm
+        :param oci.data_science.models.DisableMlApplicationInstanceViewTriggerDetails disable_ml_application_instance_view_trigger_details: (required)
+            Details for disable trigger request.
 
-        :param oci.data_science.models.ExportModelArtifactDetails export_model_artifact_details: (required)
-            Model artifact source details for exporting.
+        :param str ml_application_instance_view_id: (required)
+            unique MlApplicationInstanceView identifier
 
         :param list[str] wait_for_states:
-            An array of states to wait on. These should be valid values for :py:attr:`~oci.data_science.models.WorkRequest.status`
+            An array of states to wait on. These should be valid values for :py:attr:`~oci.data_science.models.MlApplicationInstanceView.lifecycle_state`
 
         :param dict operation_kwargs:
-            A dictionary of keyword arguments to pass to :py:func:`~oci.data_science.DataScienceClient.export_model_artifact`
+            A dictionary of keyword arguments to pass to :py:func:`~oci.data_science.DataScienceClient.disable_ml_application_instance_view_trigger`
 
         :param dict waiter_kwargs:
             A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds``
             as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
         """
-        operation_result = self.client.export_model_artifact(model_id, export_model_artifact_details, **operation_kwargs)
+        operation_result = self.client.disable_ml_application_instance_view_trigger(disable_ml_application_instance_view_trigger_details, ml_application_instance_view_id, **operation_kwargs)
         if not wait_for_states:
             return operation_result
         lowered_wait_for_states = [w.lower() for w in wait_for_states]
-        if 'opc-work-request-id' not in operation_result.headers:
-            return operation_result
-        wait_for_resource_id = operation_result.headers['opc-work-request-id']
+        ml_application_instance_view_id = operation_result.data.id
 
         try:
             waiter_result = oci.wait_until(
                 self.client,
-                self.client.get_work_request(wait_for_resource_id),
-                evaluate_response=lambda r: getattr(r.data, 'status') and getattr(r.data, 'status').lower() in lowered_wait_for_states,
+                self.client.get_ml_application_instance_view(ml_application_instance_view_id),  # noqa: F821
+                evaluate_response=lambda r: getattr(r.data, 'lifecycle_state') and getattr(r.data, 'lifecycle_state').lower() in lowered_wait_for_states,
                 **waiter_kwargs
             )
             result_to_return = waiter_result
 
             return result_to_return
+        except (NameError, TypeError) as e:
+            if not e.args:
+                e.args = ('',)
+            e.args = e.args + ('This composite operation is currently not supported in the SDK. Please use the operation from the service client and use waiters as an alternative. For more information on waiters, visit: "https://docs.oracle.com/en-us/iaas/tools/python/latest/api/waiters.html"', )
+            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
         except Exception as e:
             raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
 
-    def import_model_artifact_and_wait_for_state(self, model_id, import_model_artifact_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
+    def enable_ml_application_instance_view_trigger_and_wait_for_state(self, enable_ml_application_instance_view_trigger_details, ml_application_instance_view_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
         """
-        Calls :py:func:`~oci.data_science.DataScienceClient.import_model_artifact` and waits for the :py:class:`~oci.data_science.models.WorkRequest`
+        Calls :py:func:`~oci.data_science.DataScienceClient.enable_ml_application_instance_view_trigger` and waits for the :py:class:`~oci.data_science.models.MlApplicationInstanceView` acted upon
         to enter the given state(s).
 
-        :param str model_id: (required)
-            The `OCID`__ of the model.
-
-            __ https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm
+        :param oci.data_science.models.EnableMlApplicationInstanceViewTriggerDetails enable_ml_application_instance_view_trigger_details: (required)
+            Details for enable trigger request.
 
-        :param oci.data_science.models.ImportModelArtifactDetails import_model_artifact_details: (required)
-            Model artifact source details for importing.
+        :param str ml_application_instance_view_id: (required)
+            unique MlApplicationInstanceView identifier
 
         :param list[str] wait_for_states:
-            An array of states to wait on. These should be valid values for :py:attr:`~oci.data_science.models.WorkRequest.status`
+            An array of states to wait on. These should be valid values for :py:attr:`~oci.data_science.models.MlApplicationInstanceView.lifecycle_state`
 
         :param dict operation_kwargs:
-            A dictionary of keyword arguments to pass to :py:func:`~oci.data_science.DataScienceClient.import_model_artifact`
+            A dictionary of keyword arguments to pass to :py:func:`~oci.data_science.DataScienceClient.enable_ml_application_instance_view_trigger`
 
         :param dict waiter_kwargs:
             A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds``
             as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
         """
-        operation_result = self.client.import_model_artifact(model_id, import_model_artifact_details, **operation_kwargs)
+        operation_result = self.client.enable_ml_application_instance_view_trigger(enable_ml_application_instance_view_trigger_details, ml_application_instance_view_id, **operation_kwargs)
         if not wait_for_states:
             return operation_result
         lowered_wait_for_states = [w.lower() for w in wait_for_states]
-        if 'opc-work-request-id' not in operation_result.headers:
-            return operation_result
-        wait_for_resource_id = operation_result.headers['opc-work-request-id']
+        ml_application_instance_view_id = operation_result.data.id
 
         try:
             waiter_result = oci.wait_until(
                 self.client,
-                self.client.get_work_request(wait_for_resource_id),
-                evaluate_response=lambda r: getattr(r.data, 'status') and getattr(r.data, 'status').lower() in lowered_wait_for_states,
+                self.client.get_ml_application_instance_view(ml_application_instance_view_id),  # noqa: F821
+                evaluate_response=lambda r: getattr(r.data, 'lifecycle_state') and getattr(r.data, 'lifecycle_state').lower() in lowered_wait_for_states,
                 **waiter_kwargs
             )
             result_to_return = waiter_result
 
             return result_to_return
+        except (NameError, TypeError) as e:
+            if not e.args:
+                e.args = ('',)
+            e.args = e.args + ('This composite operation is currently not supported in the SDK. Please use the operation from the service client and use waiters as an alternative. For more information on waiters, visit: "https://docs.oracle.com/en-us/iaas/tools/python/latest/api/waiters.html"', )
+            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
         except Exception as e:
             raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
 
-    def register_model_artifact_reference_and_wait_for_state(self, register_model_artifact_reference_details, model_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
+    def export_model_artifact_and_wait_for_state(self, model_id, export_model_artifact_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
         """
-        Calls :py:func:`~oci.data_science.DataScienceClient.register_model_artifact_reference` and waits for the :py:class:`~oci.data_science.models.WorkRequest`
+        Calls :py:func:`~oci.data_science.DataScienceClient.export_model_artifact` and waits for the :py:class:`~oci.data_science.models.WorkRequest`
         to enter the given state(s).
 
-        :param oci.data_science.models.RegisterModelArtifactReferenceDetails register_model_artifact_reference_details: (required)
-            register model artifact reference metadata
-
         :param str model_id: (required)
             The `OCID`__ of the model.
 
             __ https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm
 
+        :param oci.data_science.models.ExportModelArtifactDetails export_model_artifact_details: (required)
+            Model artifact source details for exporting.
+
         :param list[str] wait_for_states:
             An array of states to wait on. These should be valid values for :py:attr:`~oci.data_science.models.WorkRequest.status`
 
         :param dict operation_kwargs:
-            A dictionary of keyword arguments to pass to :py:func:`~oci.data_science.DataScienceClient.register_model_artifact_reference`
+            A dictionary of keyword arguments to pass to :py:func:`~oci.data_science.DataScienceClient.export_model_artifact`
 
         :param dict waiter_kwargs:
             A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds``
             as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
         """
-        operation_result = self.client.register_model_artifact_reference(register_model_artifact_reference_details, model_id, **operation_kwargs)
+        operation_result = self.client.export_model_artifact(model_id, export_model_artifact_details, **operation_kwargs)
         if not wait_for_states:
             return operation_result
         lowered_wait_for_states = [w.lower() for w in wait_for_states]
@@ -1636,9 +2040,9 @@ class DataScienceClientCompositeOperations(object):
         except Exception as e:
             raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
 
-    def restore_archived_model_artifact_and_wait_for_state(self, model_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
+    def import_model_artifact_and_wait_for_state(self, model_id, import_model_artifact_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
         """
-        Calls :py:func:`~oci.data_science.DataScienceClient.restore_archived_model_artifact` and waits for the :py:class:`~oci.data_science.models.WorkRequest`
+        Calls :py:func:`~oci.data_science.DataScienceClient.import_model_artifact` and waits for the :py:class:`~oci.data_science.models.WorkRequest`
         to enter the given state(s).
 
         :param str model_id: (required)
@@ -1646,17 +2050,20 @@ class DataScienceClientCompositeOperations(object):
 
             __ https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm
 
+        :param oci.data_science.models.ImportModelArtifactDetails import_model_artifact_details: (required)
+            Model artifact source details for importing.
+
         :param list[str] wait_for_states:
             An array of states to wait on. These should be valid values for :py:attr:`~oci.data_science.models.WorkRequest.status`
 
         :param dict operation_kwargs:
-            A dictionary of keyword arguments to pass to :py:func:`~oci.data_science.DataScienceClient.restore_archived_model_artifact`
+            A dictionary of keyword arguments to pass to :py:func:`~oci.data_science.DataScienceClient.import_model_artifact`
 
         :param dict waiter_kwargs:
             A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds``
             as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
         """
-        operation_result = self.client.restore_archived_model_artifact(model_id, **operation_kwargs)
+        operation_result = self.client.import_model_artifact(model_id, import_model_artifact_details, **operation_kwargs)
         if not wait_for_states:
             return operation_result
         lowered_wait_for_states = [w.lower() for w in wait_for_states]
@@ -1677,28 +2084,28 @@ class DataScienceClientCompositeOperations(object):
         except Exception as e:
             raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
 
-    def update_data_science_private_endpoint_and_wait_for_state(self, data_science_private_endpoint_id, update_data_science_private_endpoint_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
+    def put_ml_application_package_and_wait_for_state(self, ml_application_implementation_id, put_ml_application_package, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
         """
-        Calls :py:func:`~oci.data_science.DataScienceClient.update_data_science_private_endpoint` and waits for the :py:class:`~oci.data_science.models.WorkRequest`
+        Calls :py:func:`~oci.data_science.DataScienceClient.put_ml_application_package` and waits for the :py:class:`~oci.data_science.models.WorkRequest`
         to enter the given state(s).
 
-        :param str data_science_private_endpoint_id: (required)
-            The unique ID for a Data Science private endpoint.
+        :param str ml_application_implementation_id: (required)
+            unique MlApplicationImplementation identifier
 
-        :param oci.data_science.models.UpdateDataSciencePrivateEndpointDetails update_data_science_private_endpoint_details: (required)
-            Details for updating a private endpoint.
+        :param stream put_ml_application_package: (required)
+            ML Application Package to upload
 
         :param list[str] wait_for_states:
             An array of states to wait on. These should be valid values for :py:attr:`~oci.data_science.models.WorkRequest.status`
 
         :param dict operation_kwargs:
-            A dictionary of keyword arguments to pass to :py:func:`~oci.data_science.DataScienceClient.update_data_science_private_endpoint`
+            A dictionary of keyword arguments to pass to :py:func:`~oci.data_science.DataScienceClient.put_ml_application_package`
 
         :param dict waiter_kwargs:
             A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds``
             as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
         """
-        operation_result = self.client.update_data_science_private_endpoint(data_science_private_endpoint_id, update_data_science_private_endpoint_details, **operation_kwargs)
+        operation_result = self.client.put_ml_application_package(ml_application_implementation_id, put_ml_application_package, **operation_kwargs)
         if not wait_for_states:
             return operation_result
         lowered_wait_for_states = [w.lower() for w in wait_for_states]
@@ -1719,21 +2126,271 @@ class DataScienceClientCompositeOperations(object):
         except Exception as e:
             raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
 
-    def update_job_and_wait_for_state(self, job_id, update_job_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
+    def recover_ml_application_instance_view_and_wait_for_state(self, ml_application_instance_view_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
         """
-        Calls :py:func:`~oci.data_science.DataScienceClient.update_job` and waits for the :py:class:`~oci.data_science.models.Job` acted upon
+        Calls :py:func:`~oci.data_science.DataScienceClient.recover_ml_application_instance_view` and waits for the :py:class:`~oci.data_science.models.WorkRequest`
         to enter the given state(s).
 
-        :param str job_id: (required)
-            The `OCID`__ of the job.
-
-            __ https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm
-
-        :param oci.data_science.models.UpdateJobDetails update_job_details: (required)
-            Details for updating a job.
+        :param str ml_application_instance_view_id: (required)
+            unique MlApplicationInstanceView identifier
 
         :param list[str] wait_for_states:
-            An array of states to wait on. These should be valid values for :py:attr:`~oci.data_science.models.Job.lifecycle_state`
+            An array of states to wait on. These should be valid values for :py:attr:`~oci.data_science.models.WorkRequest.status`
+
+        :param dict operation_kwargs:
+            A dictionary of keyword arguments to pass to :py:func:`~oci.data_science.DataScienceClient.recover_ml_application_instance_view`
+
+        :param dict waiter_kwargs:
+            A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds``
+            as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
+        """
+        operation_result = self.client.recover_ml_application_instance_view(ml_application_instance_view_id, **operation_kwargs)
+        if not wait_for_states:
+            return operation_result
+        lowered_wait_for_states = [w.lower() for w in wait_for_states]
+        if 'opc-work-request-id' not in operation_result.headers:
+            return operation_result
+        wait_for_resource_id = operation_result.headers['opc-work-request-id']
+
+        try:
+            waiter_result = oci.wait_until(
+                self.client,
+                self.client.get_work_request(wait_for_resource_id),
+                evaluate_response=lambda r: getattr(r.data, 'status') and getattr(r.data, 'status').lower() in lowered_wait_for_states,
+                **waiter_kwargs
+            )
+            result_to_return = waiter_result
+
+            return result_to_return
+        except Exception as e:
+            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
+
+    def register_model_artifact_reference_and_wait_for_state(self, register_model_artifact_reference_details, model_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
+        """
+        Calls :py:func:`~oci.data_science.DataScienceClient.register_model_artifact_reference` and waits for the :py:class:`~oci.data_science.models.WorkRequest`
+        to enter the given state(s).
+
+        :param oci.data_science.models.RegisterModelArtifactReferenceDetails register_model_artifact_reference_details: (required)
+            register model artifact reference metadata
+
+        :param str model_id: (required)
+            The `OCID`__ of the model.
+
+            __ https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm
+
+        :param list[str] wait_for_states:
+            An array of states to wait on. These should be valid values for :py:attr:`~oci.data_science.models.WorkRequest.status`
+
+        :param dict operation_kwargs:
+            A dictionary of keyword arguments to pass to :py:func:`~oci.data_science.DataScienceClient.register_model_artifact_reference`
+
+        :param dict waiter_kwargs:
+            A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds``
+            as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
+        """
+        operation_result = self.client.register_model_artifact_reference(register_model_artifact_reference_details, model_id, **operation_kwargs)
+        if not wait_for_states:
+            return operation_result
+        lowered_wait_for_states = [w.lower() for w in wait_for_states]
+        if 'opc-work-request-id' not in operation_result.headers:
+            return operation_result
+        wait_for_resource_id = operation_result.headers['opc-work-request-id']
+
+        try:
+            waiter_result = oci.wait_until(
+                self.client,
+                self.client.get_work_request(wait_for_resource_id),
+                evaluate_response=lambda r: getattr(r.data, 'status') and getattr(r.data, 'status').lower() in lowered_wait_for_states,
+                **waiter_kwargs
+            )
+            result_to_return = waiter_result
+
+            return result_to_return
+        except Exception as e:
+            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
+
+    def restore_archived_model_artifact_and_wait_for_state(self, model_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
+        """
+        Calls :py:func:`~oci.data_science.DataScienceClient.restore_archived_model_artifact` and waits for the :py:class:`~oci.data_science.models.WorkRequest`
+        to enter the given state(s).
+
+        :param str model_id: (required)
+            The `OCID`__ of the model.
+
+            __ https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm
+
+        :param list[str] wait_for_states:
+            An array of states to wait on. These should be valid values for :py:attr:`~oci.data_science.models.WorkRequest.status`
+
+        :param dict operation_kwargs:
+            A dictionary of keyword arguments to pass to :py:func:`~oci.data_science.DataScienceClient.restore_archived_model_artifact`
+
+        :param dict waiter_kwargs:
+            A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds``
+            as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
+        """
+        operation_result = self.client.restore_archived_model_artifact(model_id, **operation_kwargs)
+        if not wait_for_states:
+            return operation_result
+        lowered_wait_for_states = [w.lower() for w in wait_for_states]
+        if 'opc-work-request-id' not in operation_result.headers:
+            return operation_result
+        wait_for_resource_id = operation_result.headers['opc-work-request-id']
+
+        try:
+            waiter_result = oci.wait_until(
+                self.client,
+                self.client.get_work_request(wait_for_resource_id),
+                evaluate_response=lambda r: getattr(r.data, 'status') and getattr(r.data, 'status').lower() in lowered_wait_for_states,
+                **waiter_kwargs
+            )
+            result_to_return = waiter_result
+
+            return result_to_return
+        except Exception as e:
+            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
+
+    def trigger_ml_application_instance_flow_and_wait_for_state(self, trigger_ml_application_instance_flow_details, ml_application_instance_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
+        """
+        Calls :py:func:`~oci.data_science.DataScienceClient.trigger_ml_application_instance_flow` and waits for the :py:class:`~oci.data_science.models.WorkRequest`
+        to enter the given state(s).
+
+        :param oci.data_science.models.TriggerMlApplicationInstanceFlowDetails trigger_ml_application_instance_flow_details: (required)
+            Details for trigger request.
+
+        :param str ml_application_instance_id: (required)
+            unique MlApplicationInstance identifier
+
+        :param list[str] wait_for_states:
+            An array of states to wait on. These should be valid values for :py:attr:`~oci.data_science.models.WorkRequest.status`
+
+        :param dict operation_kwargs:
+            A dictionary of keyword arguments to pass to :py:func:`~oci.data_science.DataScienceClient.trigger_ml_application_instance_flow`
+
+        :param dict waiter_kwargs:
+            A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds``
+            as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
+        """
+        operation_result = self.client.trigger_ml_application_instance_flow(trigger_ml_application_instance_flow_details, ml_application_instance_id, **operation_kwargs)
+        if not wait_for_states:
+            return operation_result
+        lowered_wait_for_states = [w.lower() for w in wait_for_states]
+        if 'opc-work-request-id' not in operation_result.headers:
+            return operation_result
+        wait_for_resource_id = operation_result.headers['opc-work-request-id']
+
+        try:
+            waiter_result = oci.wait_until(
+                self.client,
+                self.client.get_work_request(wait_for_resource_id),
+                evaluate_response=lambda r: getattr(r.data, 'status') and getattr(r.data, 'status').lower() in lowered_wait_for_states,
+                **waiter_kwargs
+            )
+            result_to_return = waiter_result
+
+            return result_to_return
+        except Exception as e:
+            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
+
+    def trigger_ml_application_instance_view_flow_and_wait_for_state(self, trigger_ml_application_instance_view_flow_details, ml_application_instance_view_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
+        """
+        Calls :py:func:`~oci.data_science.DataScienceClient.trigger_ml_application_instance_view_flow` and waits for the :py:class:`~oci.data_science.models.WorkRequest`
+        to enter the given state(s).
+
+        :param oci.data_science.models.TriggerMlApplicationInstanceViewFlowDetails trigger_ml_application_instance_view_flow_details: (required)
+            Details for trigger request.
+
+        :param str ml_application_instance_view_id: (required)
+            unique MlApplicationInstanceView identifier
+
+        :param list[str] wait_for_states:
+            An array of states to wait on. These should be valid values for :py:attr:`~oci.data_science.models.WorkRequest.status`
+
+        :param dict operation_kwargs:
+            A dictionary of keyword arguments to pass to :py:func:`~oci.data_science.DataScienceClient.trigger_ml_application_instance_view_flow`
+
+        :param dict waiter_kwargs:
+            A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds``
+            as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
+        """
+        operation_result = self.client.trigger_ml_application_instance_view_flow(trigger_ml_application_instance_view_flow_details, ml_application_instance_view_id, **operation_kwargs)
+        if not wait_for_states:
+            return operation_result
+        lowered_wait_for_states = [w.lower() for w in wait_for_states]
+        if 'opc-work-request-id' not in operation_result.headers:
+            return operation_result
+        wait_for_resource_id = operation_result.headers['opc-work-request-id']
+
+        try:
+            waiter_result = oci.wait_until(
+                self.client,
+                self.client.get_work_request(wait_for_resource_id),
+                evaluate_response=lambda r: getattr(r.data, 'status') and getattr(r.data, 'status').lower() in lowered_wait_for_states,
+                **waiter_kwargs
+            )
+            result_to_return = waiter_result
+
+            return result_to_return
+        except Exception as e:
+            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
+
+    def update_data_science_private_endpoint_and_wait_for_state(self, data_science_private_endpoint_id, update_data_science_private_endpoint_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
+        """
+        Calls :py:func:`~oci.data_science.DataScienceClient.update_data_science_private_endpoint` and waits for the :py:class:`~oci.data_science.models.WorkRequest`
+        to enter the given state(s).
+
+        :param str data_science_private_endpoint_id: (required)
+            The unique ID for a Data Science private endpoint.
+
+        :param oci.data_science.models.UpdateDataSciencePrivateEndpointDetails update_data_science_private_endpoint_details: (required)
+            Details for updating a private endpoint.
+
+        :param list[str] wait_for_states:
+            An array of states to wait on. These should be valid values for :py:attr:`~oci.data_science.models.WorkRequest.status`
+
+        :param dict operation_kwargs:
+            A dictionary of keyword arguments to pass to :py:func:`~oci.data_science.DataScienceClient.update_data_science_private_endpoint`
+
+        :param dict waiter_kwargs:
+            A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds``
+            as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
+        """
+        operation_result = self.client.update_data_science_private_endpoint(data_science_private_endpoint_id, update_data_science_private_endpoint_details, **operation_kwargs)
+        if not wait_for_states:
+            return operation_result
+        lowered_wait_for_states = [w.lower() for w in wait_for_states]
+        if 'opc-work-request-id' not in operation_result.headers:
+            return operation_result
+        wait_for_resource_id = operation_result.headers['opc-work-request-id']
+
+        try:
+            waiter_result = oci.wait_until(
+                self.client,
+                self.client.get_work_request(wait_for_resource_id),
+                evaluate_response=lambda r: getattr(r.data, 'status') and getattr(r.data, 'status').lower() in lowered_wait_for_states,
+                **waiter_kwargs
+            )
+            result_to_return = waiter_result
+
+            return result_to_return
+        except Exception as e:
+            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
+
+    def update_job_and_wait_for_state(self, job_id, update_job_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
+        """
+        Calls :py:func:`~oci.data_science.DataScienceClient.update_job` and waits for the :py:class:`~oci.data_science.models.Job` acted upon
+        to enter the given state(s).
+
+        :param str job_id: (required)
+            The `OCID`__ of the job.
+
+            __ https://docs.cloud.oracle.com/iaas/Content/General/Concepts/identifiers.htm
+
+        :param oci.data_science.models.UpdateJobDetails update_job_details: (required)
+            Details for updating a job.
+
+        :param list[str] wait_for_states:
+            An array of states to wait on. These should be valid values for :py:attr:`~oci.data_science.models.Job.lifecycle_state`
 
         :param dict operation_kwargs:
             A dictionary of keyword arguments to pass to :py:func:`~oci.data_science.DataScienceClient.update_job`
@@ -1813,6 +2470,225 @@ class DataScienceClientCompositeOperations(object):
         except Exception as e:
             raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
 
+    def update_ml_application_and_wait_for_state(self, ml_application_id, update_ml_application_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
+        """
+        Calls :py:func:`~oci.data_science.DataScienceClient.update_ml_application` and waits for the :py:class:`~oci.data_science.models.MlApplication` acted upon
+        to enter the given state(s).
+
+        :param str ml_application_id: (required)
+            unique MlApplication identifier
+
+        :param oci.data_science.models.UpdateMlApplicationDetails update_ml_application_details: (required)
+            The information to be updated.
+
+        :param list[str] wait_for_states:
+            An array of states to wait on. These should be valid values for :py:attr:`~oci.data_science.models.MlApplication.lifecycle_state`
+
+        :param dict operation_kwargs:
+            A dictionary of keyword arguments to pass to :py:func:`~oci.data_science.DataScienceClient.update_ml_application`
+
+        :param dict waiter_kwargs:
+            A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds``
+            as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
+        """
+        operation_result = self.client.update_ml_application(ml_application_id, update_ml_application_details, **operation_kwargs)
+        if not wait_for_states:
+            return operation_result
+        lowered_wait_for_states = [w.lower() for w in wait_for_states]
+        ml_application_id = operation_result.data.id
+
+        try:
+            waiter_result = oci.wait_until(
+                self.client,
+                self.client.get_ml_application(ml_application_id),  # noqa: F821
+                evaluate_response=lambda r: getattr(r.data, 'lifecycle_state') and getattr(r.data, 'lifecycle_state').lower() in lowered_wait_for_states,
+                **waiter_kwargs
+            )
+            result_to_return = waiter_result
+
+            return result_to_return
+        except (NameError, TypeError) as e:
+            if not e.args:
+                e.args = ('',)
+            e.args = e.args + ('This composite operation is currently not supported in the SDK. Please use the operation from the service client and use waiters as an alternative. For more information on waiters, visit: "https://docs.oracle.com/en-us/iaas/tools/python/latest/api/waiters.html"', )
+            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
+        except Exception as e:
+            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
+
+    def update_ml_application_implementation_and_wait_for_state(self, ml_application_implementation_id, update_ml_application_implementation_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
+        """
+        Calls :py:func:`~oci.data_science.DataScienceClient.update_ml_application_implementation` and waits for the :py:class:`~oci.data_science.models.WorkRequest`
+        to enter the given state(s).
+
+        :param str ml_application_implementation_id: (required)
+            unique MlApplicationImplementation identifier
+
+        :param oci.data_science.models.UpdateMlApplicationImplementationDetails update_ml_application_implementation_details: (required)
+            The information to be updated.
+
+        :param list[str] wait_for_states:
+            An array of states to wait on. These should be valid values for :py:attr:`~oci.data_science.models.WorkRequest.status`
+
+        :param dict operation_kwargs:
+            A dictionary of keyword arguments to pass to :py:func:`~oci.data_science.DataScienceClient.update_ml_application_implementation`
+
+        :param dict waiter_kwargs:
+            A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds``
+            as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
+        """
+        operation_result = self.client.update_ml_application_implementation(ml_application_implementation_id, update_ml_application_implementation_details, **operation_kwargs)
+        if not wait_for_states:
+            return operation_result
+        lowered_wait_for_states = [w.lower() for w in wait_for_states]
+        if 'opc-work-request-id' not in operation_result.headers:
+            return operation_result
+        wait_for_resource_id = operation_result.headers['opc-work-request-id']
+
+        try:
+            waiter_result = oci.wait_until(
+                self.client,
+                self.client.get_work_request(wait_for_resource_id),
+                evaluate_response=lambda r: getattr(r.data, 'status') and getattr(r.data, 'status').lower() in lowered_wait_for_states,
+                **waiter_kwargs
+            )
+            result_to_return = waiter_result
+
+            return result_to_return
+        except Exception as e:
+            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
+
+    def update_ml_application_implementation_version_and_wait_for_state(self, ml_application_implementation_version_id, update_ml_application_implementation_version_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
+        """
+        Calls :py:func:`~oci.data_science.DataScienceClient.update_ml_application_implementation_version` and waits for the :py:class:`~oci.data_science.models.MlApplicationImplementationVersion` acted upon
+        to enter the given state(s).
+
+        :param str ml_application_implementation_version_id: (required)
+            unique MlApplicationImplementationVersion identifier
+
+        :param oci.data_science.models.UpdateMlApplicationImplementationVersionDetails update_ml_application_implementation_version_details: (required)
+            The information to be updated.
+
+        :param list[str] wait_for_states:
+            An array of states to wait on. These should be valid values for :py:attr:`~oci.data_science.models.MlApplicationImplementationVersion.lifecycle_state`
+
+        :param dict operation_kwargs:
+            A dictionary of keyword arguments to pass to :py:func:`~oci.data_science.DataScienceClient.update_ml_application_implementation_version`
+
+        :param dict waiter_kwargs:
+            A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds``
+            as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
+        """
+        operation_result = self.client.update_ml_application_implementation_version(ml_application_implementation_version_id, update_ml_application_implementation_version_details, **operation_kwargs)
+        if not wait_for_states:
+            return operation_result
+        lowered_wait_for_states = [w.lower() for w in wait_for_states]
+        ml_application_implementation_version_id = operation_result.data.id
+
+        try:
+            waiter_result = oci.wait_until(
+                self.client,
+                self.client.get_ml_application_implementation_version(ml_application_implementation_version_id),  # noqa: F821
+                evaluate_response=lambda r: getattr(r.data, 'lifecycle_state') and getattr(r.data, 'lifecycle_state').lower() in lowered_wait_for_states,
+                **waiter_kwargs
+            )
+            result_to_return = waiter_result
+
+            return result_to_return
+        except (NameError, TypeError) as e:
+            if not e.args:
+                e.args = ('',)
+            e.args = e.args + ('This composite operation is currently not supported in the SDK. Please use the operation from the service client and use waiters as an alternative. For more information on waiters, visit: "https://docs.oracle.com/en-us/iaas/tools/python/latest/api/waiters.html"', )
+            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
+        except Exception as e:
+            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
+
+    def update_ml_application_instance_and_wait_for_state(self, ml_application_instance_id, update_ml_application_instance_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
+        """
+        Calls :py:func:`~oci.data_science.DataScienceClient.update_ml_application_instance` and waits for the :py:class:`~oci.data_science.models.WorkRequest`
+        to enter the given state(s).
+
+        :param str ml_application_instance_id: (required)
+            unique MlApplicationInstance identifier
+
+        :param oci.data_science.models.UpdateMlApplicationInstanceDetails update_ml_application_instance_details: (required)
+            The information to be updated.
+
+        :param list[str] wait_for_states:
+            An array of states to wait on. These should be valid values for :py:attr:`~oci.data_science.models.WorkRequest.status`
+
+        :param dict operation_kwargs:
+            A dictionary of keyword arguments to pass to :py:func:`~oci.data_science.DataScienceClient.update_ml_application_instance`
+
+        :param dict waiter_kwargs:
+            A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds``
+            as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
+        """
+        operation_result = self.client.update_ml_application_instance(ml_application_instance_id, update_ml_application_instance_details, **operation_kwargs)
+        if not wait_for_states:
+            return operation_result
+        lowered_wait_for_states = [w.lower() for w in wait_for_states]
+        if 'opc-work-request-id' not in operation_result.headers:
+            return operation_result
+        wait_for_resource_id = operation_result.headers['opc-work-request-id']
+
+        try:
+            waiter_result = oci.wait_until(
+                self.client,
+                self.client.get_work_request(wait_for_resource_id),
+                evaluate_response=lambda r: getattr(r.data, 'status') and getattr(r.data, 'status').lower() in lowered_wait_for_states,
+                **waiter_kwargs
+            )
+            result_to_return = waiter_result
+
+            return result_to_return
+        except Exception as e:
+            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
+
+    def update_ml_application_instance_view_and_wait_for_state(self, ml_application_instance_view_id, update_ml_application_instance_view_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
+        """
+        Calls :py:func:`~oci.data_science.DataScienceClient.update_ml_application_instance_view` and waits for the :py:class:`~oci.data_science.models.MlApplicationInstanceView` acted upon
+        to enter the given state(s).
+
+        :param str ml_application_instance_view_id: (required)
+            unique MlApplicationInstanceView identifier
+
+        :param oci.data_science.models.UpdateMlApplicationInstanceViewDetails update_ml_application_instance_view_details: (required)
+            The information to be updated.
+
+        :param list[str] wait_for_states:
+            An array of states to wait on. These should be valid values for :py:attr:`~oci.data_science.models.MlApplicationInstanceView.lifecycle_state`
+
+        :param dict operation_kwargs:
+            A dictionary of keyword arguments to pass to :py:func:`~oci.data_science.DataScienceClient.update_ml_application_instance_view`
+
+        :param dict waiter_kwargs:
+            A dictionary of keyword arguments to pass to the :py:func:`oci.wait_until` function. For example, you could pass ``max_interval_seconds`` or ``max_interval_seconds``
+            as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
+        """
+        operation_result = self.client.update_ml_application_instance_view(ml_application_instance_view_id, update_ml_application_instance_view_details, **operation_kwargs)
+        if not wait_for_states:
+            return operation_result
+        lowered_wait_for_states = [w.lower() for w in wait_for_states]
+        ml_application_instance_view_id = operation_result.data.id
+
+        try:
+            waiter_result = oci.wait_until(
+                self.client,
+                self.client.get_ml_application_instance_view(ml_application_instance_view_id),  # noqa: F821
+                evaluate_response=lambda r: getattr(r.data, 'lifecycle_state') and getattr(r.data, 'lifecycle_state').lower() in lowered_wait_for_states,
+                **waiter_kwargs
+            )
+            result_to_return = waiter_result
+
+            return result_to_return
+        except (NameError, TypeError) as e:
+            if not e.args:
+                e.args = ('',)
+            e.args = e.args + ('This composite operation is currently not supported in the SDK. Please use the operation from the service client and use waiters as an alternative. For more information on waiters, visit: "https://docs.oracle.com/en-us/iaas/tools/python/latest/api/waiters.html"', )
+            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
+        except Exception as e:
+            raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
+
     def update_model_and_wait_for_state(self, model_id, update_model_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
         """
         Calls :py:func:`~oci.data_science.DataScienceClient.update_model` and waits for the :py:class:`~oci.data_science.models.Model` acted upon