text: # coding: utf-8
  # Copyright (c) 2016, 2022, Oracle and/or its affiliates.  All rights reserved.
  # This software is dual-licensed to you under the Universal Permissive License (UPL) 1.0 as shown at https://oss.oracle.com/licenses/upl or Apache License 2.0 as shown at http://www.apache.org/licenses/LICENSE-2.0. You may choose either license.
  
  import oci  # noqa: F401
  from oci.util import WAIT_RESOURCE_NOT_FOUND  # noqa: F401
  
  
  class DevopsClientCompositeOperations(object):
      """
      This class provides a wrapper around :py:class:`~oci.devops.DevopsClient` and offers convenience methods
      for operations that would otherwise need to be chained together. For example, instead of performing an action
      on a resource (e.g. launching an instance, creating a load balancer) and then using a waiter to wait for the resource
      to enter a given state, you can call a single method in this class to accomplish the same functionality
      """
  
      def __init__(self, client, **kwargs):
          """
          Creates a new DevopsClientCompositeOperations object
  
          :param DevopsClient client:
              The service client which will be wrapped by this object
          """
          self.client = client
  
      def approve_deployment_and_wait_for_state(self, deployment_id, approve_deployment_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
          """
          Calls :py:func:`~oci.devops.DevopsClient.approve_deployment` and waits for the :py:class:`~oci.devops.models.Deployment` acted upon
          to enter the given state(s).
  
          :param str deployment_id: (required)
              Unique deployment identifier.
  
          :param oci.devops.models.ApproveDeploymentDetails approve_deployment_details: (required)
              The stage information for approval.
  
          :param list[str] wait_for_states:
              An array of states to wait on. These should be valid values for :py:attr:`~oci.devops.models.Deployment.lifecycle_state`
  
          :param dict operation_kwargs:
              A dictionary of keyword arguments to pass to :py:func:`~oci.devops.DevopsClient.approve_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 = self.client.approve_deployment(deployment_id, approve_deployment_details, **operation_kwargs)
          if not wait_for_states:
              return operation_result
  
          lowered_wait_for_states = [w.lower() for w in wait_for_states]
          wait_for_resource_id = operation_result.data.id
  
          try:
              waiter_result = oci.wait_until(
                  self.client,
                  self.client.get_deployment(wait_for_resource_id),
                  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 Exception as e:
              raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
  
      def cancel_build_run_and_wait_for_state(self, cancel_build_run_details, build_run_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
          """
          Calls :py:func:`~oci.devops.DevopsClient.cancel_build_run` and waits for the :py:class:`~oci.devops.models.BuildRun` acted upon
          to enter the given state(s).
  
          :param oci.devops.models.CancelBuildRunDetails cancel_build_run_details: (required)
              Parameter details required to cancel a build run.
  
          :param str build_run_id: (required)
              Unique build run identifier.
  
          :param list[str] wait_for_states:
              An array of states to wait on. These should be valid values for :py:attr:`~oci.devops.models.BuildRun.lifecycle_state`
  
          :param dict operation_kwargs:
              A dictionary of keyword arguments to pass to :py:func:`~oci.devops.DevopsClient.cancel_build_run`
  
          :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.cancel_build_run(cancel_build_run_details, build_run_id, **operation_kwargs)
          if not wait_for_states:
              return operation_result
  
          lowered_wait_for_states = [w.lower() for w in wait_for_states]
          wait_for_resource_id = operation_result.data.id
  
          try:
              waiter_result = oci.wait_until(
                  self.client,
                  self.client.get_build_run(wait_for_resource_id),
                  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 Exception as e:
              raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
  
      def cancel_deployment_and_wait_for_state(self, deployment_id, cancel_deployment_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
          """
          Calls :py:func:`~oci.devops.DevopsClient.cancel_deployment` and waits for the :py:class:`~oci.devops.models.Deployment` acted upon
          to enter the given state(s).
  
          :param str deployment_id: (required)
              Unique deployment identifier.
  
          :param oci.devops.models.CancelDeploymentDetails cancel_deployment_details: (required)
              The information regarding the deployment to be canceled.
  
          :param list[str] wait_for_states:
              An array of states to wait on. These should be valid values for :py:attr:`~oci.devops.models.Deployment.lifecycle_state`
  
          :param dict operation_kwargs:
              A dictionary of keyword arguments to pass to :py:func:`~oci.devops.DevopsClient.cancel_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 = self.client.cancel_deployment(deployment_id, cancel_deployment_details, **operation_kwargs)
          if not wait_for_states:
              return operation_result
  
          lowered_wait_for_states = [w.lower() for w in wait_for_states]
          wait_for_resource_id = operation_result.data.id
  
          try:
              waiter_result = oci.wait_until(
                  self.client,
                  self.client.get_deployment(wait_for_resource_id),
                  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 Exception as e:
              raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
  
      def change_project_compartment_and_wait_for_state(self, project_id, change_project_compartment_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
          """
          Calls :py:func:`~oci.devops.DevopsClient.change_project_compartment` and waits for the :py:class:`~oci.devops.models.WorkRequest`
          to enter the given state(s).
  
          :param str project_id: (required)
              Unique project identifier.
  
          :param oci.devops.models.ChangeProjectCompartmentDetails change_project_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.devops.models.WorkRequest.status`
  
          :param dict operation_kwargs:
              A dictionary of keyword arguments to pass to :py:func:`~oci.devops.DevopsClient.change_project_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_project_compartment(project_id, change_project_compartment_details, **operation_kwargs)
          if not wait_for_states:
              return operation_result
  
          lowered_wait_for_states = [w.lower() for w in wait_for_states]
          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_build_pipeline_and_wait_for_state(self, create_build_pipeline_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
          """
          Calls :py:func:`~oci.devops.DevopsClient.create_build_pipeline` and waits for the :py:class:`~oci.devops.models.WorkRequest`
          to enter the given state(s).
  
          :param oci.devops.models.CreateBuildPipelineDetails create_build_pipeline_details: (required)
              Details for the new build pipeline.
  
          :param list[str] wait_for_states:
              An array of states to wait on. These should be valid values for :py:attr:`~oci.devops.models.WorkRequest.status`
  
          :param dict operation_kwargs:
              A dictionary of keyword arguments to pass to :py:func:`~oci.devops.DevopsClient.create_build_pipeline`
  
          :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_build_pipeline(create_build_pipeline_details, **operation_kwargs)
          if not wait_for_states:
              return operation_result
  
          lowered_wait_for_states = [w.lower() for w in wait_for_states]
          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_build_pipeline_stage_and_wait_for_state(self, create_build_pipeline_stage_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
          """
          Calls :py:func:`~oci.devops.DevopsClient.create_build_pipeline_stage` and waits for the :py:class:`~oci.devops.models.WorkRequest`
          to enter the given state(s).
  
          :param oci.devops.models.CreateBuildPipelineStageDetails create_build_pipeline_stage_details: (required)
              Details for the new stage.
  
          :param list[str] wait_for_states:
              An array of states to wait on. These should be valid values for :py:attr:`~oci.devops.models.WorkRequest.status`
  
          :param dict operation_kwargs:
              A dictionary of keyword arguments to pass to :py:func:`~oci.devops.DevopsClient.create_build_pipeline_stage`
  
          :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_build_pipeline_stage(create_build_pipeline_stage_details, **operation_kwargs)
          if not wait_for_states:
              return operation_result
  
          lowered_wait_for_states = [w.lower() for w in wait_for_states]
          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_build_run_and_wait_for_state(self, create_build_run_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
          """
          Calls :py:func:`~oci.devops.DevopsClient.create_build_run` and waits for the :py:class:`~oci.devops.models.BuildRun` acted upon
          to enter the given state(s).
  
          :param oci.devops.models.CreateBuildRunDetails create_build_run_details: (required)
              Parameter details required to create a new build run.
  
          :param list[str] wait_for_states:
              An array of states to wait on. These should be valid values for :py:attr:`~oci.devops.models.BuildRun.lifecycle_state`
  
          :param dict operation_kwargs:
              A dictionary of keyword arguments to pass to :py:func:`~oci.devops.DevopsClient.create_build_run`
  
          :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_build_run(create_build_run_details, **operation_kwargs)
          if not wait_for_states:
              return operation_result
  
          lowered_wait_for_states = [w.lower() for w in wait_for_states]
          wait_for_resource_id = operation_result.data.id
  
          try:
              waiter_result = oci.wait_until(
                  self.client,
                  self.client.get_build_run(wait_for_resource_id),
                  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 Exception as e:
              raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
  
      def create_connection_and_wait_for_state(self, create_connection_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
          """
          Calls :py:func:`~oci.devops.DevopsClient.create_connection` and waits for the :py:class:`~oci.devops.models.WorkRequest`
          to enter the given state(s).
  
          :param oci.devops.models.CreateConnectionDetails create_connection_details: (required)
              Details for the new connection.
  
          :param list[str] wait_for_states:
              An array of states to wait on. These should be valid values for :py:attr:`~oci.devops.models.WorkRequest.status`
  
          :param dict operation_kwargs:
              A dictionary of keyword arguments to pass to :py:func:`~oci.devops.DevopsClient.create_connection`
  
          :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_connection(create_connection_details, **operation_kwargs)
          if not wait_for_states:
              return operation_result
  
          lowered_wait_for_states = [w.lower() for w in wait_for_states]
          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_deploy_artifact_and_wait_for_state(self, create_deploy_artifact_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
          """
          Calls :py:func:`~oci.devops.DevopsClient.create_deploy_artifact` and waits for the :py:class:`~oci.devops.models.WorkRequest`
          to enter the given state(s).
  
          :param oci.devops.models.CreateDeployArtifactDetails create_deploy_artifact_details: (required)
              Details for the new deployment artifact.
  
          :param list[str] wait_for_states:
              An array of states to wait on. These should be valid values for :py:attr:`~oci.devops.models.WorkRequest.status`
  
          :param dict operation_kwargs:
              A dictionary of keyword arguments to pass to :py:func:`~oci.devops.DevopsClient.create_deploy_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.create_deploy_artifact(create_deploy_artifact_details, **operation_kwargs)
          if not wait_for_states:
              return operation_result
  
          lowered_wait_for_states = [w.lower() for w in wait_for_states]
          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_deploy_environment_and_wait_for_state(self, create_deploy_environment_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
          """
          Calls :py:func:`~oci.devops.DevopsClient.create_deploy_environment` and waits for the :py:class:`~oci.devops.models.WorkRequest`
          to enter the given state(s).
  
          :param oci.devops.models.CreateDeployEnvironmentDetails create_deploy_environment_details: (required)
              Details for the new deployment environment.
  
          :param list[str] wait_for_states:
              An array of states to wait on. These should be valid values for :py:attr:`~oci.devops.models.WorkRequest.status`
  
          :param dict operation_kwargs:
              A dictionary of keyword arguments to pass to :py:func:`~oci.devops.DevopsClient.create_deploy_environment`
  
          :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_deploy_environment(create_deploy_environment_details, **operation_kwargs)
          if not wait_for_states:
              return operation_result
  
          lowered_wait_for_states = [w.lower() for w in wait_for_states]
          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_deploy_pipeline_and_wait_for_state(self, create_deploy_pipeline_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
          """
          Calls :py:func:`~oci.devops.DevopsClient.create_deploy_pipeline` and waits for the :py:class:`~oci.devops.models.WorkRequest`
          to enter the given state(s).
  
          :param oci.devops.models.CreateDeployPipelineDetails create_deploy_pipeline_details: (required)
              Details for the new deployment pipeline.
  
          :param list[str] wait_for_states:
              An array of states to wait on. These should be valid values for :py:attr:`~oci.devops.models.WorkRequest.status`
  
          :param dict operation_kwargs:
              A dictionary of keyword arguments to pass to :py:func:`~oci.devops.DevopsClient.create_deploy_pipeline`
  
          :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_deploy_pipeline(create_deploy_pipeline_details, **operation_kwargs)
          if not wait_for_states:
              return operation_result
  
          lowered_wait_for_states = [w.lower() for w in wait_for_states]
          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_deploy_stage_and_wait_for_state(self, create_deploy_stage_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
          """
          Calls :py:func:`~oci.devops.DevopsClient.create_deploy_stage` and waits for the :py:class:`~oci.devops.models.WorkRequest`
          to enter the given state(s).
  
          :param oci.devops.models.CreateDeployStageDetails create_deploy_stage_details: (required)
              Details for the new DeployStage.
  
          :param list[str] wait_for_states:
              An array of states to wait on. These should be valid values for :py:attr:`~oci.devops.models.WorkRequest.status`
  
          :param dict operation_kwargs:
              A dictionary of keyword arguments to pass to :py:func:`~oci.devops.DevopsClient.create_deploy_stage`
  
          :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_deploy_stage(create_deploy_stage_details, **operation_kwargs)
          if not wait_for_states:
              return operation_result
  
          lowered_wait_for_states = [w.lower() for w in wait_for_states]
          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_deployment_and_wait_for_state(self, create_deployment_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
          """
          Calls :py:func:`~oci.devops.DevopsClient.create_deployment` and waits for the :py:class:`~oci.devops.models.Deployment` acted upon
          to enter the given state(s).
  
          :param oci.devops.models.CreateDeploymentDetails create_deployment_details: (required)
              Details for the new deployment.
  
          :param list[str] wait_for_states:
              An array of states to wait on. These should be valid values for :py:attr:`~oci.devops.models.Deployment.lifecycle_state`
  
          :param dict operation_kwargs:
              A dictionary of keyword arguments to pass to :py:func:`~oci.devops.DevopsClient.create_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 = self.client.create_deployment(create_deployment_details, **operation_kwargs)
          if not wait_for_states:
              return operation_result
  
          lowered_wait_for_states = [w.lower() for w in wait_for_states]
          wait_for_resource_id = operation_result.data.id
  
          try:
              waiter_result = oci.wait_until(
                  self.client,
                  self.client.get_deployment(wait_for_resource_id),
                  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 Exception as e:
              raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
  
      def create_project_and_wait_for_state(self, create_project_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
          """
          Calls :py:func:`~oci.devops.DevopsClient.create_project` and waits for the :py:class:`~oci.devops.models.WorkRequest`
          to enter the given state(s).
  
          :param oci.devops.models.CreateProjectDetails create_project_details: (required)
              Details for the new project.
  
          :param list[str] wait_for_states:
              An array of states to wait on. These should be valid values for :py:attr:`~oci.devops.models.WorkRequest.status`
  
          :param dict operation_kwargs:
              A dictionary of keyword arguments to pass to :py:func:`~oci.devops.DevopsClient.create_project`
  
          :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_project(create_project_details, **operation_kwargs)
          if not wait_for_states:
              return operation_result
  
          lowered_wait_for_states = [w.lower() for w in wait_for_states]
          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_repository_and_wait_for_state(self, create_repository_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
          """
          Calls :py:func:`~oci.devops.DevopsClient.create_repository` and waits for the :py:class:`~oci.devops.models.WorkRequest`
          to enter the given state(s).
  
          :param oci.devops.models.CreateRepositoryDetails create_repository_details: (required)
              Details for the new repository.
  
          :param list[str] wait_for_states:
              An array of states to wait on. These should be valid values for :py:attr:`~oci.devops.models.WorkRequest.status`
  
          :param dict operation_kwargs:
              A dictionary of keyword arguments to pass to :py:func:`~oci.devops.DevopsClient.create_repository`
  
          :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_repository(create_repository_details, **operation_kwargs)
          if not wait_for_states:
              return operation_result
  
          lowered_wait_for_states = [w.lower() for w in wait_for_states]
          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_trigger_and_wait_for_state(self, create_trigger_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
          """
          Calls :py:func:`~oci.devops.DevopsClient.create_trigger` and waits for the :py:class:`~oci.devops.models.WorkRequest`
          to enter the given state(s).
  
          :param oci.devops.models.CreateTriggerDetails create_trigger_details: (required)
              Details for the new trigger.
  
          :param list[str] wait_for_states:
              An array of states to wait on. These should be valid values for :py:attr:`~oci.devops.models.WorkRequest.status`
  
          :param dict operation_kwargs:
              A dictionary of keyword arguments to pass to :py:func:`~oci.devops.DevopsClient.create_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.create_trigger(create_trigger_details, **operation_kwargs)
          if not wait_for_states:
              return operation_result
  
          lowered_wait_for_states = [w.lower() for w in wait_for_states]
          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_build_pipeline_and_wait_for_state(self, build_pipeline_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
          """
          Calls :py:func:`~oci.devops.DevopsClient.delete_build_pipeline` and waits for the :py:class:`~oci.devops.models.WorkRequest`
          to enter the given state(s).
  
          :param str build_pipeline_id: (required)
              Unique build pipeline identifier.
  
          :param list[str] wait_for_states:
              An array of states to wait on. These should be valid values for :py:attr:`~oci.devops.models.WorkRequest.status`
  
          :param dict operation_kwargs:
              A dictionary of keyword arguments to pass to :py:func:`~oci.devops.DevopsClient.delete_build_pipeline`
  
          :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_build_pipeline(build_pipeline_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]
          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_build_pipeline_stage_and_wait_for_state(self, build_pipeline_stage_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
          """
          Calls :py:func:`~oci.devops.DevopsClient.delete_build_pipeline_stage` and waits for the :py:class:`~oci.devops.models.WorkRequest`
          to enter the given state(s).
  
          :param str build_pipeline_stage_id: (required)
              Unique stage identifier.
  
          :param list[str] wait_for_states:
              An array of states to wait on. These should be valid values for :py:attr:`~oci.devops.models.WorkRequest.status`
  
          :param dict operation_kwargs:
              A dictionary of keyword arguments to pass to :py:func:`~oci.devops.DevopsClient.delete_build_pipeline_stage`
  
          :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_build_pipeline_stage(build_pipeline_stage_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]
          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_connection_and_wait_for_state(self, connection_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
          """
          Calls :py:func:`~oci.devops.DevopsClient.delete_connection` and waits for the :py:class:`~oci.devops.models.WorkRequest`
          to enter the given state(s).
  
          :param str connection_id: (required)
              Unique connection identifier.
  
          :param list[str] wait_for_states:
              An array of states to wait on. These should be valid values for :py:attr:`~oci.devops.models.WorkRequest.status`
  
          :param dict operation_kwargs:
              A dictionary of keyword arguments to pass to :py:func:`~oci.devops.DevopsClient.delete_connection`
  
          :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_connection(connection_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]
          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_deploy_artifact_and_wait_for_state(self, deploy_artifact_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
          """
          Calls :py:func:`~oci.devops.DevopsClient.delete_deploy_artifact` and waits for the :py:class:`~oci.devops.models.WorkRequest`
          to enter the given state(s).
  
          :param str deploy_artifact_id: (required)
              Unique artifact identifier.
  
          :param list[str] wait_for_states:
              An array of states to wait on. These should be valid values for :py:attr:`~oci.devops.models.WorkRequest.status`
  
          :param dict operation_kwargs:
              A dictionary of keyword arguments to pass to :py:func:`~oci.devops.DevopsClient.delete_deploy_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 = None
          try:
              operation_result = self.client.delete_deploy_artifact(deploy_artifact_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]
          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_deploy_environment_and_wait_for_state(self, deploy_environment_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
          """
          Calls :py:func:`~oci.devops.DevopsClient.delete_deploy_environment` and waits for the :py:class:`~oci.devops.models.WorkRequest`
          to enter the given state(s).
  
          :param str deploy_environment_id: (required)
              Unique environment identifier.
  
          :param list[str] wait_for_states:
              An array of states to wait on. These should be valid values for :py:attr:`~oci.devops.models.WorkRequest.status`
  
          :param dict operation_kwargs:
              A dictionary of keyword arguments to pass to :py:func:`~oci.devops.DevopsClient.delete_deploy_environment`
  
          :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_deploy_environment(deploy_environment_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]
          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_deploy_pipeline_and_wait_for_state(self, deploy_pipeline_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
          """
          Calls :py:func:`~oci.devops.DevopsClient.delete_deploy_pipeline` and waits for the :py:class:`~oci.devops.models.WorkRequest`
          to enter the given state(s).
  
          :param str deploy_pipeline_id: (required)
              Unique pipeline identifier.
  
          :param list[str] wait_for_states:
              An array of states to wait on. These should be valid values for :py:attr:`~oci.devops.models.WorkRequest.status`
  
          :param dict operation_kwargs:
              A dictionary of keyword arguments to pass to :py:func:`~oci.devops.DevopsClient.delete_deploy_pipeline`
  
          :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_deploy_pipeline(deploy_pipeline_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]
          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_deploy_stage_and_wait_for_state(self, deploy_stage_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
          """
          Calls :py:func:`~oci.devops.DevopsClient.delete_deploy_stage` and waits for the :py:class:`~oci.devops.models.WorkRequest`
          to enter the given state(s).
  
          :param str deploy_stage_id: (required)
              Unique stage identifier.
  
          :param list[str] wait_for_states:
              An array of states to wait on. These should be valid values for :py:attr:`~oci.devops.models.WorkRequest.status`
  
          :param dict operation_kwargs:
              A dictionary of keyword arguments to pass to :py:func:`~oci.devops.DevopsClient.delete_deploy_stage`
  
          :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_deploy_stage(deploy_stage_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]
          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_project_and_wait_for_state(self, project_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
          """
          Calls :py:func:`~oci.devops.DevopsClient.delete_project` and waits for the :py:class:`~oci.devops.models.WorkRequest`
          to enter the given state(s).
  
          :param str project_id: (required)
              Unique project identifier.
  
          :param list[str] wait_for_states:
              An array of states to wait on. These should be valid values for :py:attr:`~oci.devops.models.WorkRequest.status`
  
          :param dict operation_kwargs:
              A dictionary of keyword arguments to pass to :py:func:`~oci.devops.DevopsClient.delete_project`
  
          :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_project(project_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]
          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_ref_and_wait_for_state(self, repository_id, ref_name, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
          """
          Calls :py:func:`~oci.devops.DevopsClient.delete_ref` and waits for the :py:class:`~oci.devops.models.WorkRequest`
          to enter the given state(s).
  
          :param str repository_id: (required)
              Unique repository identifier.
  
          :param str ref_name: (required)
              A filter to return only resources that match the given reference name.
  
          :param list[str] wait_for_states:
              An array of states to wait on. These should be valid values for :py:attr:`~oci.devops.models.WorkRequest.status`
  
          :param dict operation_kwargs:
              A dictionary of keyword arguments to pass to :py:func:`~oci.devops.DevopsClient.delete_ref`
  
          :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_ref(repository_id, ref_name, **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]
          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_repository_and_wait_for_state(self, repository_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
          """
          Calls :py:func:`~oci.devops.DevopsClient.delete_repository` and waits for the :py:class:`~oci.devops.models.WorkRequest`
          to enter the given state(s).
  
          :param str repository_id: (required)
              Unique repository identifier.
  
          :param list[str] wait_for_states:
              An array of states to wait on. These should be valid values for :py:attr:`~oci.devops.models.WorkRequest.status`
  
          :param dict operation_kwargs:
              A dictionary of keyword arguments to pass to :py:func:`~oci.devops.DevopsClient.delete_repository`
  
          :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_repository(repository_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]
          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_trigger_and_wait_for_state(self, trigger_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
          """
          Calls :py:func:`~oci.devops.DevopsClient.delete_trigger` and waits for the :py:class:`~oci.devops.models.WorkRequest`
          to enter the given state(s).
  
          :param str trigger_id: (required)
              Unique trigger identifier.
  
          :param list[str] wait_for_states:
              An array of states to wait on. These should be valid values for :py:attr:`~oci.devops.models.WorkRequest.status`
  
          :param dict operation_kwargs:
              A dictionary of keyword arguments to pass to :py:func:`~oci.devops.DevopsClient.delete_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 = None
          try:
              operation_result = self.client.delete_trigger(trigger_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]
          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 mirror_repository_and_wait_for_state(self, repository_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
          """
          Calls :py:func:`~oci.devops.DevopsClient.mirror_repository` and waits for the :py:class:`~oci.devops.models.WorkRequest`
          to enter the given state(s).
  
          :param str repository_id: (required)
              Unique repository identifier.
  
          :param list[str] wait_for_states:
              An array of states to wait on. These should be valid values for :py:attr:`~oci.devops.models.WorkRequest.status`
  
          :param dict operation_kwargs:
              A dictionary of keyword arguments to pass to :py:func:`~oci.devops.DevopsClient.mirror_repository`
  
          :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.mirror_repository(repository_id, **operation_kwargs)
          if not wait_for_states:
              return operation_result
  
          lowered_wait_for_states = [w.lower() for w in wait_for_states]
          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 put_repository_ref_and_wait_for_state(self, repository_id, ref_name, put_repository_ref_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
          """
          Calls :py:func:`~oci.devops.DevopsClient.put_repository_ref` and waits for the :py:class:`~oci.devops.models.WorkRequest`
          to enter the given state(s).
  
          :param str repository_id: (required)
              Unique repository identifier.
  
          :param str ref_name: (required)
              A filter to return only resources that match the given reference name.
  
          :param oci.devops.models.PutRepositoryRefDetails put_repository_ref_details: (required)
              The information to create a reference with the type specified in the query.
  
          :param list[str] wait_for_states:
              An array of states to wait on. These should be valid values for :py:attr:`~oci.devops.models.WorkRequest.status`
  
          :param dict operation_kwargs:
              A dictionary of keyword arguments to pass to :py:func:`~oci.devops.DevopsClient.put_repository_ref`
  
          :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.put_repository_ref(repository_id, ref_name, put_repository_ref_details, **operation_kwargs)
          if not wait_for_states:
              return operation_result
  
          lowered_wait_for_states = [w.lower() for w in wait_for_states]
          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_build_pipeline_and_wait_for_state(self, build_pipeline_id, update_build_pipeline_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
          """
          Calls :py:func:`~oci.devops.DevopsClient.update_build_pipeline` and waits for the :py:class:`~oci.devops.models.WorkRequest`
          to enter the given state(s).
  
          :param str build_pipeline_id: (required)
              Unique build pipeline identifier.
  
          :param oci.devops.models.UpdateBuildPipelineDetails update_build_pipeline_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.devops.models.WorkRequest.status`
  
          :param dict operation_kwargs:
              A dictionary of keyword arguments to pass to :py:func:`~oci.devops.DevopsClient.update_build_pipeline`
  
          :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_build_pipeline(build_pipeline_id, update_build_pipeline_details, **operation_kwargs)
          if not wait_for_states:
              return operation_result
  
          lowered_wait_for_states = [w.lower() for w in wait_for_states]
          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_build_pipeline_stage_and_wait_for_state(self, build_pipeline_stage_id, update_build_pipeline_stage_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
          """
          Calls :py:func:`~oci.devops.DevopsClient.update_build_pipeline_stage` and waits for the :py:class:`~oci.devops.models.WorkRequest`
          to enter the given state(s).
  
          :param str build_pipeline_stage_id: (required)
              Unique stage identifier.
  
          :param oci.devops.models.UpdateBuildPipelineStageDetails update_build_pipeline_stage_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.devops.models.WorkRequest.status`
  
          :param dict operation_kwargs:
              A dictionary of keyword arguments to pass to :py:func:`~oci.devops.DevopsClient.update_build_pipeline_stage`
  
          :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_build_pipeline_stage(build_pipeline_stage_id, update_build_pipeline_stage_details, **operation_kwargs)
          if not wait_for_states:
              return operation_result
  
          lowered_wait_for_states = [w.lower() for w in wait_for_states]
          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_build_run_and_wait_for_state(self, build_run_id, update_build_run_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
          """
          Calls :py:func:`~oci.devops.DevopsClient.update_build_run` and waits for the :py:class:`~oci.devops.models.BuildRun` acted upon
          to enter the given state(s).
  
          :param str build_run_id: (required)
              Unique build run identifier.
  
          :param oci.devops.models.UpdateBuildRunDetails update_build_run_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.devops.models.BuildRun.lifecycle_state`
  
          :param dict operation_kwargs:
              A dictionary of keyword arguments to pass to :py:func:`~oci.devops.DevopsClient.update_build_run`
  
          :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_build_run(build_run_id, update_build_run_details, **operation_kwargs)
          if not wait_for_states:
              return operation_result
  
          lowered_wait_for_states = [w.lower() for w in wait_for_states]
          wait_for_resource_id = operation_result.data.id
  
          try:
              waiter_result = oci.wait_until(
                  self.client,
                  self.client.get_build_run(wait_for_resource_id),
                  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 Exception as e:
              raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
  
      def update_connection_and_wait_for_state(self, connection_id, update_connection_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
          """
          Calls :py:func:`~oci.devops.DevopsClient.update_connection` and waits for the :py:class:`~oci.devops.models.WorkRequest`
          to enter the given state(s).
  
          :param str connection_id: (required)
              Unique connection identifier.
  
          :param oci.devops.models.UpdateConnectionDetails update_connection_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.devops.models.WorkRequest.status`
  
          :param dict operation_kwargs:
              A dictionary of keyword arguments to pass to :py:func:`~oci.devops.DevopsClient.update_connection`
  
          :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_connection(connection_id, update_connection_details, **operation_kwargs)
          if not wait_for_states:
              return operation_result
  
          lowered_wait_for_states = [w.lower() for w in wait_for_states]
          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_deploy_artifact_and_wait_for_state(self, deploy_artifact_id, update_deploy_artifact_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
          """
          Calls :py:func:`~oci.devops.DevopsClient.update_deploy_artifact` and waits for the :py:class:`~oci.devops.models.WorkRequest`
          to enter the given state(s).
  
          :param str deploy_artifact_id: (required)
              Unique artifact identifier.
  
          :param oci.devops.models.UpdateDeployArtifactDetails update_deploy_artifact_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.devops.models.WorkRequest.status`
  
          :param dict operation_kwargs:
              A dictionary of keyword arguments to pass to :py:func:`~oci.devops.DevopsClient.update_deploy_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.update_deploy_artifact(deploy_artifact_id, update_deploy_artifact_details, **operation_kwargs)
          if not wait_for_states:
              return operation_result
  
          lowered_wait_for_states = [w.lower() for w in wait_for_states]
          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_deploy_environment_and_wait_for_state(self, deploy_environment_id, update_deploy_environment_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
          """
          Calls :py:func:`~oci.devops.DevopsClient.update_deploy_environment` and waits for the :py:class:`~oci.devops.models.WorkRequest`
          to enter the given state(s).
  
          :param str deploy_environment_id: (required)
              Unique environment identifier.
  
          :param oci.devops.models.UpdateDeployEnvironmentDetails update_deploy_environment_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.devops.models.WorkRequest.status`
  
          :param dict operation_kwargs:
              A dictionary of keyword arguments to pass to :py:func:`~oci.devops.DevopsClient.update_deploy_environment`
  
          :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_deploy_environment(deploy_environment_id, update_deploy_environment_details, **operation_kwargs)
          if not wait_for_states:
              return operation_result
  
          lowered_wait_for_states = [w.lower() for w in wait_for_states]
          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_deploy_pipeline_and_wait_for_state(self, deploy_pipeline_id, update_deploy_pipeline_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
          """
          Calls :py:func:`~oci.devops.DevopsClient.update_deploy_pipeline` and waits for the :py:class:`~oci.devops.models.WorkRequest`
          to enter the given state(s).
  
          :param str deploy_pipeline_id: (required)
              Unique pipeline identifier.
  
          :param oci.devops.models.UpdateDeployPipelineDetails update_deploy_pipeline_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.devops.models.WorkRequest.status`
  
          :param dict operation_kwargs:
              A dictionary of keyword arguments to pass to :py:func:`~oci.devops.DevopsClient.update_deploy_pipeline`
  
          :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_deploy_pipeline(deploy_pipeline_id, update_deploy_pipeline_details, **operation_kwargs)
          if not wait_for_states:
              return operation_result
  
          lowered_wait_for_states = [w.lower() for w in wait_for_states]
          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_deploy_stage_and_wait_for_state(self, deploy_stage_id, update_deploy_stage_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
          """
          Calls :py:func:`~oci.devops.DevopsClient.update_deploy_stage` and waits for the :py:class:`~oci.devops.models.WorkRequest`
          to enter the given state(s).
  
          :param str deploy_stage_id: (required)
              Unique stage identifier.
  
          :param oci.devops.models.UpdateDeployStageDetails update_deploy_stage_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.devops.models.WorkRequest.status`
  
          :param dict operation_kwargs:
              A dictionary of keyword arguments to pass to :py:func:`~oci.devops.DevopsClient.update_deploy_stage`
  
          :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_deploy_stage(deploy_stage_id, update_deploy_stage_details, **operation_kwargs)
          if not wait_for_states:
              return operation_result
  
          lowered_wait_for_states = [w.lower() for w in wait_for_states]
          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_deployment_and_wait_for_state(self, deployment_id, update_deployment_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
          """
          Calls :py:func:`~oci.devops.DevopsClient.update_deployment` and waits for the :py:class:`~oci.devops.models.Deployment` acted upon
          to enter the given state(s).
  
          :param str deployment_id: (required)
              Unique deployment identifier.
  
          :param oci.devops.models.UpdateDeploymentDetails update_deployment_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.devops.models.Deployment.lifecycle_state`
  
          :param dict operation_kwargs:
              A dictionary of keyword arguments to pass to :py:func:`~oci.devops.DevopsClient.update_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 = self.client.update_deployment(deployment_id, update_deployment_details, **operation_kwargs)
          if not wait_for_states:
              return operation_result
  
          lowered_wait_for_states = [w.lower() for w in wait_for_states]
          wait_for_resource_id = operation_result.data.id
  
          try:
              waiter_result = oci.wait_until(
                  self.client,
                  self.client.get_deployment(wait_for_resource_id),
                  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 Exception as e:
              raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
  
      def update_project_and_wait_for_state(self, project_id, update_project_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
          """
          Calls :py:func:`~oci.devops.DevopsClient.update_project` and waits for the :py:class:`~oci.devops.models.WorkRequest`
          to enter the given state(s).
  
          :param str project_id: (required)
              Unique project identifier.
  
          :param oci.devops.models.UpdateProjectDetails update_project_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.devops.models.WorkRequest.status`
  
          :param dict operation_kwargs:
              A dictionary of keyword arguments to pass to :py:func:`~oci.devops.DevopsClient.update_project`
  
          :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_project(project_id, update_project_details, **operation_kwargs)
          if not wait_for_states:
              return operation_result
  
          lowered_wait_for_states = [w.lower() for w in wait_for_states]
          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_repository_and_wait_for_state(self, repository_id, update_repository_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
          """
          Calls :py:func:`~oci.devops.DevopsClient.update_repository` and waits for the :py:class:`~oci.devops.models.WorkRequest`
          to enter the given state(s).
  
          :param str repository_id: (required)
              Unique repository identifier.
  
          :param oci.devops.models.UpdateRepositoryDetails update_repository_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.devops.models.WorkRequest.status`
  
          :param dict operation_kwargs:
              A dictionary of keyword arguments to pass to :py:func:`~oci.devops.DevopsClient.update_repository`
  
          :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_repository(repository_id, update_repository_details, **operation_kwargs)
          if not wait_for_states:
              return operation_result
  
          lowered_wait_for_states = [w.lower() for w in wait_for_states]
          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_trigger_and_wait_for_state(self, trigger_id, update_trigger_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}):
          """
          Calls :py:func:`~oci.devops.DevopsClient.update_trigger` and waits for the :py:class:`~oci.devops.models.WorkRequest`
          to enter the given state(s).
  
          :param str trigger_id: (required)
              Unique trigger identifier.
  
          :param oci.devops.models.UpdateTriggerDetails update_trigger_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.devops.models.WorkRequest.status`
  
          :param dict operation_kwargs:
              A dictionary of keyword arguments to pass to :py:func:`~oci.devops.DevopsClient.update_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.update_trigger(trigger_id, update_trigger_details, **operation_kwargs)
          if not wait_for_states:
              return operation_result
  
          lowered_wait_for_states = [w.lower() for w in wait_for_states]
          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)
  