text: # coding: utf-8
  # Copyright (c) 2016, 2021, 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.
  
  from __future__ import absolute_import
  
  from oci._vendor import requests  # noqa: F401
  from oci._vendor import six
  
  from oci import retry, circuit_breaker  # noqa: F401
  from oci.base_client import BaseClient
  from oci.config import get_config_value_or_default, validate_config
  from oci.signer import Signer
  from oci.util import Sentinel, get_signer_from_authentication_type, AUTHENTICATION_TYPE_FIELD_NAME
  from .models import vulnerability_scanning_type_mapping
  missing = Sentinel("Missing")
  
  
  class VulnerabilityScanningClient(object):
      """
      Use the Vulnerability Scanning Service (VSS) APIs to manage scan recipes, targets, and reports.
      """
  
      def __init__(self, config, **kwargs):
          """
          Creates a new service client
  
          :param dict config:
              Configuration keys and values as per `SDK and Tool Configuration <https://docs.cloud.oracle.com/Content/API/Concepts/sdkconfig.htm>`__.
              The :py:meth:`~oci.config.from_file` method can be used to load configuration from a file. Alternatively, a ``dict`` can be passed. You can validate_config
              the dict using :py:meth:`~oci.config.validate_config`
  
          :param str service_endpoint: (optional)
              The endpoint of the service to call using this client. For example ``https://iaas.us-ashburn-1.oraclecloud.com``. If this keyword argument is
              not provided then it will be derived using the region in the config parameter. You should only provide this keyword argument if you have an explicit
              need to specify a service endpoint.
  
          :param timeout: (optional)
              The connection and read timeouts for the client. The default values are connection timeout 10 seconds and read timeout 60 seconds. This keyword argument can be provided
              as a single float, in which case the value provided is used for both the read and connection timeouts, or as a tuple of two floats. If
              a tuple is provided then the first value is used as the connection timeout and the second value as the read timeout.
          :type timeout: float or tuple(float, float)
  
          :param signer: (optional)
              The signer to use when signing requests made by the service client. The default is to use a :py:class:`~oci.signer.Signer` based on the values
              provided in the config parameter.
  
              One use case for this parameter is for `Instance Principals authentication <https://docs.cloud.oracle.com/Content/Identity/Tasks/callingservicesfrominstances.htm>`__
              by passing an instance of :py:class:`~oci.auth.signers.InstancePrincipalsSecurityTokenSigner` as the value for this keyword argument
          :type signer: :py:class:`~oci.signer.AbstractBaseSigner`
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to all calls made by this service client (i.e. at the client level). There is no retry strategy applied by default.
              Retry strategies can also be applied at the operation level by passing a ``retry_strategy`` keyword argument as part of calling the operation.
              Any value provided at the operation level will override whatever is specified at the client level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. A convenience :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY`
              is also available. The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
          :param obj circuit_breaker_strategy: (optional)
              A circuit breaker strategy to apply to all calls made by this service client (i.e. at the client level).
              This client will not have circuit breakers enabled by default, users can use their own circuit breaker strategy or the convenient :py:data:`~oci.circuit_breaker.DEFAULT_CIRCUIT_BREAKER_STRATEGY` provided by the SDK to enable it.
              The specifics of circuit breaker strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/circuit_breakers.html>`__.
  
          :param function circuit_breaker_callback: (optional)
              Callback function to receive any exceptions triggerred by the circuit breaker.
          """
          validate_config(config, signer=kwargs.get('signer'))
          if 'signer' in kwargs:
              signer = kwargs['signer']
  
          elif AUTHENTICATION_TYPE_FIELD_NAME in config:
              signer = get_signer_from_authentication_type(config)
  
          else:
              signer = Signer(
                  tenancy=config["tenancy"],
                  user=config["user"],
                  fingerprint=config["fingerprint"],
                  private_key_file_location=config.get("key_file"),
                  pass_phrase=get_config_value_or_default(config, "pass_phrase"),
                  private_key_content=config.get("key_content")
              )
  
          base_client_init_kwargs = {
              'regional_client': True,
              'service_endpoint': kwargs.get('service_endpoint'),
              'base_path': '/20210215',
              'service_endpoint_template': 'https://vss-cp-api.{region}.oci.{secondLevelDomain}',
              'skip_deserialization': kwargs.get('skip_deserialization', False),
              'circuit_breaker_strategy': kwargs.get('circuit_breaker_strategy', circuit_breaker.GLOBAL_CIRCUIT_BREAKER_STRATEGY)
          }
          if 'timeout' in kwargs:
              base_client_init_kwargs['timeout'] = kwargs.get('timeout')
          self.base_client = BaseClient("vulnerability_scanning", config, signer, vulnerability_scanning_type_mapping, **base_client_init_kwargs)
          self.retry_strategy = kwargs.get('retry_strategy')
          self.circuit_breaker_callback = kwargs.get('circuit_breaker_callback')
  
      def change_container_scan_recipe_compartment(self, container_scan_recipe_id, change_container_scan_recipe_compartment_details, **kwargs):
          """
          Moves a ContainerScanRecipe into a different compartment. When provided, If-Match is checked against ETag values of the resource.
  
  
          :param str container_scan_recipe_id: (required)
              unique ContainerScanRecipe identifier
  
          :param oci.vulnerability_scanning.models.ChangeContainerScanRecipeCompartmentDetails change_container_scan_recipe_compartment_details: (required)
              The compartment information to update.
  
          :param str if_match: (optional)
              For optimistic concurrency control. In the PUT or DELETE call
              for a resource, set the `if-match` parameter to the value of the
              etag from a previous GET or POST response for that resource.
              The resource will be updated or deleted only if the etag you
              provide matches the resource's current etag value.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param str opc_retry_token: (optional)
              A token that uniquely identifies a request so it can be retried in case of a timeout or
              server error without risk of executing that same action again. Retry tokens expire after 24
              hours, but can be invalidated before then due to conflicting operations. For example, if a resource
              has been deleted and purged from the system, then a retry of the original creation request
              might be rejected.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :return: A :class:`~oci.response.Response` object with data of type None
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/vulnerabilityscanning/change_container_scan_recipe_compartment.py.html>`__ to see an example of how to use change_container_scan_recipe_compartment API.
          """
          resource_path = "/containerScanRecipes/{containerScanRecipeId}/actions/changeCompartment"
          method = "POST"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "retry_strategy",
              "if_match",
              "opc_request_id",
              "opc_retry_token"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "change_container_scan_recipe_compartment got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "containerScanRecipeId": container_scan_recipe_id
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "if-match": kwargs.get("if_match", missing),
              "opc-request-id": kwargs.get("opc_request_id", missing),
              "opc-retry-token": kwargs.get("opc_retry_token", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_retry_token_if_needed(header_params)
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=change_container_scan_recipe_compartment_details)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=change_container_scan_recipe_compartment_details)
  
      def change_container_scan_result_compartment(self, container_scan_result_id, change_container_scan_result_compartment_details, **kwargs):
          """
          Moves a ContainerScanResult into a different compartment. When provided, If-Match is checked against ETag values of the resource.
  
  
          :param str container_scan_result_id: (required)
              unique container scan identifier
  
          :param oci.vulnerability_scanning.models.ChangeContainerScanResultCompartmentDetails change_container_scan_result_compartment_details: (required)
              The compartment information to update.
  
          :param str if_match: (optional)
              For optimistic concurrency control. In the PUT or DELETE call
              for a resource, set the `if-match` parameter to the value of the
              etag from a previous GET or POST response for that resource.
              The resource will be updated or deleted only if the etag you
              provide matches the resource's current etag value.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param str opc_retry_token: (optional)
              A token that uniquely identifies a request so it can be retried in case of a timeout or
              server error without risk of executing that same action again. Retry tokens expire after 24
              hours, but can be invalidated before then due to conflicting operations. For example, if a resource
              has been deleted and purged from the system, then a retry of the original creation request
              might be rejected.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :return: A :class:`~oci.response.Response` object with data of type None
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/vulnerabilityscanning/change_container_scan_result_compartment.py.html>`__ to see an example of how to use change_container_scan_result_compartment API.
          """
          resource_path = "/containerScanResults/{containerScanResultId}/actions/changeCompartment"
          method = "POST"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "retry_strategy",
              "if_match",
              "opc_request_id",
              "opc_retry_token"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "change_container_scan_result_compartment got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "containerScanResultId": container_scan_result_id
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "if-match": kwargs.get("if_match", missing),
              "opc-request-id": kwargs.get("opc_request_id", missing),
              "opc-retry-token": kwargs.get("opc_retry_token", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_retry_token_if_needed(header_params)
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=change_container_scan_result_compartment_details)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=change_container_scan_result_compartment_details)
  
      def change_container_scan_target_compartment(self, container_scan_target_id, change_container_scan_target_compartment_details, **kwargs):
          """
          Moves a ContainerScanTarget into a different compartment. When provided, If-Match is checked against ETag values of the resource.
  
  
          :param str container_scan_target_id: (required)
              unique ContainerScanTarget identifier
  
          :param oci.vulnerability_scanning.models.ChangeContainerScanTargetCompartmentDetails change_container_scan_target_compartment_details: (required)
              The compartment information to update.
  
          :param str if_match: (optional)
              For optimistic concurrency control. In the PUT or DELETE call
              for a resource, set the `if-match` parameter to the value of the
              etag from a previous GET or POST response for that resource.
              The resource will be updated or deleted only if the etag you
              provide matches the resource's current etag value.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param str opc_retry_token: (optional)
              A token that uniquely identifies a request so it can be retried in case of a timeout or
              server error without risk of executing that same action again. Retry tokens expire after 24
              hours, but can be invalidated before then due to conflicting operations. For example, if a resource
              has been deleted and purged from the system, then a retry of the original creation request
              might be rejected.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :return: A :class:`~oci.response.Response` object with data of type None
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/vulnerabilityscanning/change_container_scan_target_compartment.py.html>`__ to see an example of how to use change_container_scan_target_compartment API.
          """
          resource_path = "/containerScanTargets/{containerScanTargetId}/actions/changeCompartment"
          method = "POST"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "retry_strategy",
              "if_match",
              "opc_request_id",
              "opc_retry_token"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "change_container_scan_target_compartment got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "containerScanTargetId": container_scan_target_id
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "if-match": kwargs.get("if_match", missing),
              "opc-request-id": kwargs.get("opc_request_id", missing),
              "opc-retry-token": kwargs.get("opc_retry_token", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_retry_token_if_needed(header_params)
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=change_container_scan_target_compartment_details)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=change_container_scan_target_compartment_details)
  
      def change_host_agent_scan_result_compartment(self, host_agent_scan_result_id, change_host_agent_scan_result_compartment_details, **kwargs):
          """
          Moves a HostAgentScanResult into a different compartment. When provided, If-Match is checked against ETag values of the resource.
  
  
          :param str host_agent_scan_result_id: (required)
              unique host agent scan identifier
  
          :param oci.vulnerability_scanning.models.ChangeHostAgentScanResultCompartmentDetails change_host_agent_scan_result_compartment_details: (required)
              The compartment information to update.
  
          :param str if_match: (optional)
              For optimistic concurrency control. In the PUT or DELETE call
              for a resource, set the `if-match` parameter to the value of the
              etag from a previous GET or POST response for that resource.
              The resource will be updated or deleted only if the etag you
              provide matches the resource's current etag value.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param str opc_retry_token: (optional)
              A token that uniquely identifies a request so it can be retried in case of a timeout or
              server error without risk of executing that same action again. Retry tokens expire after 24
              hours, but can be invalidated before then due to conflicting operations. For example, if a resource
              has been deleted and purged from the system, then a retry of the original creation request
              might be rejected.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :return: A :class:`~oci.response.Response` object with data of type None
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/vulnerabilityscanning/change_host_agent_scan_result_compartment.py.html>`__ to see an example of how to use change_host_agent_scan_result_compartment API.
          """
          resource_path = "/hostAgentScanResults/{hostAgentScanResultId}/actions/changeCompartment"
          method = "POST"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "retry_strategy",
              "if_match",
              "opc_request_id",
              "opc_retry_token"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "change_host_agent_scan_result_compartment got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "hostAgentScanResultId": host_agent_scan_result_id
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "if-match": kwargs.get("if_match", missing),
              "opc-request-id": kwargs.get("opc_request_id", missing),
              "opc-retry-token": kwargs.get("opc_retry_token", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_retry_token_if_needed(header_params)
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=change_host_agent_scan_result_compartment_details)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=change_host_agent_scan_result_compartment_details)
  
      def change_host_cis_benchmark_scan_result_compartment(self, host_cis_benchmark_scan_result_id, change_host_cis_benchmark_scan_result_compartment_details, **kwargs):
          """
          Moves a HostCisBenchmarkScanResult into a different compartment. When provided, If-Match is checked against ETag values of the resource.
  
  
          :param str host_cis_benchmark_scan_result_id: (required)
              unique host Cis benchmark scan identifier
  
          :param oci.vulnerability_scanning.models.ChangeHostCisBenchmarkScanResultCompartmentDetails change_host_cis_benchmark_scan_result_compartment_details: (required)
              The compartment information to update.
  
          :param str if_match: (optional)
              For optimistic concurrency control. In the PUT or DELETE call
              for a resource, set the `if-match` parameter to the value of the
              etag from a previous GET or POST response for that resource.
              The resource will be updated or deleted only if the etag you
              provide matches the resource's current etag value.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param str opc_retry_token: (optional)
              A token that uniquely identifies a request so it can be retried in case of a timeout or
              server error without risk of executing that same action again. Retry tokens expire after 24
              hours, but can be invalidated before then due to conflicting operations. For example, if a resource
              has been deleted and purged from the system, then a retry of the original creation request
              might be rejected.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :return: A :class:`~oci.response.Response` object with data of type None
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/vulnerabilityscanning/change_host_cis_benchmark_scan_result_compartment.py.html>`__ to see an example of how to use change_host_cis_benchmark_scan_result_compartment API.
          """
          resource_path = "/hostCisBenchmarkScanResults/{hostCisBenchmarkScanResultId}/actions/changeCompartment"
          method = "POST"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "retry_strategy",
              "if_match",
              "opc_request_id",
              "opc_retry_token"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "change_host_cis_benchmark_scan_result_compartment got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "hostCisBenchmarkScanResultId": host_cis_benchmark_scan_result_id
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "if-match": kwargs.get("if_match", missing),
              "opc-request-id": kwargs.get("opc_request_id", missing),
              "opc-retry-token": kwargs.get("opc_retry_token", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_retry_token_if_needed(header_params)
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=change_host_cis_benchmark_scan_result_compartment_details)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=change_host_cis_benchmark_scan_result_compartment_details)
  
      def change_host_endpoint_protection_scan_result_compartment(self, host_endpoint_protection_scan_result_id, change_host_endpoint_protection_scan_result_compartment_details, **kwargs):
          """
          Moves a HostEndpointProtectionScanResult into a different compartment. When provided, If-Match is checked against ETag values of the resource.
  
  
          :param str host_endpoint_protection_scan_result_id: (required)
              unique host endpoint protection scan identifier
  
          :param oci.vulnerability_scanning.models.ChangeHostEndpointProtectionScanResultCompartmentDetails change_host_endpoint_protection_scan_result_compartment_details: (required)
              The compartment information to update.
  
          :param str if_match: (optional)
              For optimistic concurrency control. In the PUT or DELETE call
              for a resource, set the `if-match` parameter to the value of the
              etag from a previous GET or POST response for that resource.
              The resource will be updated or deleted only if the etag you
              provide matches the resource's current etag value.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param str opc_retry_token: (optional)
              A token that uniquely identifies a request so it can be retried in case of a timeout or
              server error without risk of executing that same action again. Retry tokens expire after 24
              hours, but can be invalidated before then due to conflicting operations. For example, if a resource
              has been deleted and purged from the system, then a retry of the original creation request
              might be rejected.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :return: A :class:`~oci.response.Response` object with data of type None
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/vulnerabilityscanning/change_host_endpoint_protection_scan_result_compartment.py.html>`__ to see an example of how to use change_host_endpoint_protection_scan_result_compartment API.
          """
          resource_path = "/hostEndpointProtectionScanResults/{hostEndpointProtectionScanResultId}/actions/changeCompartment"
          method = "POST"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "retry_strategy",
              "if_match",
              "opc_request_id",
              "opc_retry_token"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "change_host_endpoint_protection_scan_result_compartment got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "hostEndpointProtectionScanResultId": host_endpoint_protection_scan_result_id
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "if-match": kwargs.get("if_match", missing),
              "opc-request-id": kwargs.get("opc_request_id", missing),
              "opc-retry-token": kwargs.get("opc_retry_token", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_retry_token_if_needed(header_params)
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=change_host_endpoint_protection_scan_result_compartment_details)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=change_host_endpoint_protection_scan_result_compartment_details)
  
      def change_host_port_scan_result_compartment(self, host_port_scan_result_id, change_host_port_scan_result_compartment_details, **kwargs):
          """
          Moves a HostPortScanResult into a different compartment. When provided, If-Match is checked against ETag values of the resource.
  
  
          :param str host_port_scan_result_id: (required)
              unique host port scan identifier
  
          :param oci.vulnerability_scanning.models.ChangeHostPortScanResultCompartmentDetails change_host_port_scan_result_compartment_details: (required)
              The compartment information to update.
  
          :param str if_match: (optional)
              For optimistic concurrency control. In the PUT or DELETE call
              for a resource, set the `if-match` parameter to the value of the
              etag from a previous GET or POST response for that resource.
              The resource will be updated or deleted only if the etag you
              provide matches the resource's current etag value.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param str opc_retry_token: (optional)
              A token that uniquely identifies a request so it can be retried in case of a timeout or
              server error without risk of executing that same action again. Retry tokens expire after 24
              hours, but can be invalidated before then due to conflicting operations. For example, if a resource
              has been deleted and purged from the system, then a retry of the original creation request
              might be rejected.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :return: A :class:`~oci.response.Response` object with data of type None
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/vulnerabilityscanning/change_host_port_scan_result_compartment.py.html>`__ to see an example of how to use change_host_port_scan_result_compartment API.
          """
          resource_path = "/hostPortScanResults/{hostPortScanResultId}/actions/changeCompartment"
          method = "POST"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "retry_strategy",
              "if_match",
              "opc_request_id",
              "opc_retry_token"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "change_host_port_scan_result_compartment got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "hostPortScanResultId": host_port_scan_result_id
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "if-match": kwargs.get("if_match", missing),
              "opc-request-id": kwargs.get("opc_request_id", missing),
              "opc-retry-token": kwargs.get("opc_retry_token", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_retry_token_if_needed(header_params)
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=change_host_port_scan_result_compartment_details)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=change_host_port_scan_result_compartment_details)
  
      def change_host_scan_recipe_compartment(self, host_scan_recipe_id, change_host_scan_recipe_compartment_details, **kwargs):
          """
          Moves a HostScanRecipe into a different compartment. When provided, If-Match is checked against ETag values of the resource.
  
  
          :param str host_scan_recipe_id: (required)
              unique HostScanRecipe identifier
  
          :param oci.vulnerability_scanning.models.ChangeHostScanRecipeCompartmentDetails change_host_scan_recipe_compartment_details: (required)
              The compartment information to update.
  
          :param str if_match: (optional)
              For optimistic concurrency control. In the PUT or DELETE call
              for a resource, set the `if-match` parameter to the value of the
              etag from a previous GET or POST response for that resource.
              The resource will be updated or deleted only if the etag you
              provide matches the resource's current etag value.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param str opc_retry_token: (optional)
              A token that uniquely identifies a request so it can be retried in case of a timeout or
              server error without risk of executing that same action again. Retry tokens expire after 24
              hours, but can be invalidated before then due to conflicting operations. For example, if a resource
              has been deleted and purged from the system, then a retry of the original creation request
              might be rejected.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :return: A :class:`~oci.response.Response` object with data of type None
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/vulnerabilityscanning/change_host_scan_recipe_compartment.py.html>`__ to see an example of how to use change_host_scan_recipe_compartment API.
          """
          resource_path = "/hostScanRecipes/{hostScanRecipeId}/actions/changeCompartment"
          method = "POST"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "retry_strategy",
              "if_match",
              "opc_request_id",
              "opc_retry_token"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "change_host_scan_recipe_compartment got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "hostScanRecipeId": host_scan_recipe_id
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "if-match": kwargs.get("if_match", missing),
              "opc-request-id": kwargs.get("opc_request_id", missing),
              "opc-retry-token": kwargs.get("opc_retry_token", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_retry_token_if_needed(header_params)
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=change_host_scan_recipe_compartment_details)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=change_host_scan_recipe_compartment_details)
  
      def change_host_scan_target_compartment(self, host_scan_target_id, change_host_scan_target_compartment_details, **kwargs):
          """
          Moves a HostScanTarget into a different compartment. When provided, If-Match is checked against ETag values of the resource.
  
  
          :param str host_scan_target_id: (required)
              unique HostScanTarget identifier
  
          :param oci.vulnerability_scanning.models.ChangeHostScanTargetCompartmentDetails change_host_scan_target_compartment_details: (required)
              The compartment information to update.
  
          :param str if_match: (optional)
              For optimistic concurrency control. In the PUT or DELETE call
              for a resource, set the `if-match` parameter to the value of the
              etag from a previous GET or POST response for that resource.
              The resource will be updated or deleted only if the etag you
              provide matches the resource's current etag value.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param str opc_retry_token: (optional)
              A token that uniquely identifies a request so it can be retried in case of a timeout or
              server error without risk of executing that same action again. Retry tokens expire after 24
              hours, but can be invalidated before then due to conflicting operations. For example, if a resource
              has been deleted and purged from the system, then a retry of the original creation request
              might be rejected.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :return: A :class:`~oci.response.Response` object with data of type None
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/vulnerabilityscanning/change_host_scan_target_compartment.py.html>`__ to see an example of how to use change_host_scan_target_compartment API.
          """
          resource_path = "/hostScanTargets/{hostScanTargetId}/actions/changeCompartment"
          method = "POST"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "retry_strategy",
              "if_match",
              "opc_request_id",
              "opc_retry_token"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "change_host_scan_target_compartment got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "hostScanTargetId": host_scan_target_id
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "if-match": kwargs.get("if_match", missing),
              "opc-request-id": kwargs.get("opc_request_id", missing),
              "opc-retry-token": kwargs.get("opc_retry_token", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_retry_token_if_needed(header_params)
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=change_host_scan_target_compartment_details)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=change_host_scan_target_compartment_details)
  
      def create_container_scan_recipe(self, create_container_scan_recipe_details, **kwargs):
          """
          Creates a new ContainerScanRecipe
  
  
          :param oci.vulnerability_scanning.models.CreateContainerScanRecipeDetails create_container_scan_recipe_details: (required)
              Details for the new ContainerScanRecipe
  
          :param str opc_retry_token: (optional)
              A token that uniquely identifies a request so it can be retried in case of a timeout or
              server error without risk of executing that same action again. Retry tokens expire after 24
              hours, but can be invalidated before then due to conflicting operations. For example, if a resource
              has been deleted and purged from the system, then a retry of the original creation request
              might be rejected.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.vulnerability_scanning.models.ContainerScanRecipe`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/vulnerabilityscanning/create_container_scan_recipe.py.html>`__ to see an example of how to use create_container_scan_recipe API.
          """
          resource_path = "/containerScanRecipes"
          method = "POST"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "retry_strategy",
              "opc_retry_token",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "create_container_scan_recipe got unknown kwargs: {!r}".format(extra_kwargs))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-retry-token": kwargs.get("opc_retry_token", missing),
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_retry_token_if_needed(header_params)
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  header_params=header_params,
                  body=create_container_scan_recipe_details,
                  response_type="ContainerScanRecipe")
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  header_params=header_params,
                  body=create_container_scan_recipe_details,
                  response_type="ContainerScanRecipe")
  
      def create_container_scan_target(self, create_container_scan_target_details, **kwargs):
          """
          Creates a new ContainerScanTarget
  
  
          :param oci.vulnerability_scanning.models.CreateContainerScanTargetDetails create_container_scan_target_details: (required)
              Details for the new ContainerScanTarget
  
          :param str opc_retry_token: (optional)
              A token that uniquely identifies a request so it can be retried in case of a timeout or
              server error without risk of executing that same action again. Retry tokens expire after 24
              hours, but can be invalidated before then due to conflicting operations. For example, if a resource
              has been deleted and purged from the system, then a retry of the original creation request
              might be rejected.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.vulnerability_scanning.models.ContainerScanTarget`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/vulnerabilityscanning/create_container_scan_target.py.html>`__ to see an example of how to use create_container_scan_target API.
          """
          resource_path = "/containerScanTargets"
          method = "POST"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "retry_strategy",
              "opc_retry_token",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "create_container_scan_target got unknown kwargs: {!r}".format(extra_kwargs))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-retry-token": kwargs.get("opc_retry_token", missing),
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_retry_token_if_needed(header_params)
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  header_params=header_params,
                  body=create_container_scan_target_details,
                  response_type="ContainerScanTarget")
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  header_params=header_params,
                  body=create_container_scan_target_details,
                  response_type="ContainerScanTarget")
  
      def create_host_scan_recipe(self, create_host_scan_recipe_details, **kwargs):
          """
          Creates a new HostScanRecipe. A recipe determines the types of security issues that you want scanned, and how often to scan.
  
  
          :param oci.vulnerability_scanning.models.CreateHostScanRecipeDetails create_host_scan_recipe_details: (required)
              Details for the new HostScanRecipe
  
          :param str opc_retry_token: (optional)
              A token that uniquely identifies a request so it can be retried in case of a timeout or
              server error without risk of executing that same action again. Retry tokens expire after 24
              hours, but can be invalidated before then due to conflicting operations. For example, if a resource
              has been deleted and purged from the system, then a retry of the original creation request
              might be rejected.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.vulnerability_scanning.models.HostScanRecipe`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/vulnerabilityscanning/create_host_scan_recipe.py.html>`__ to see an example of how to use create_host_scan_recipe API.
          """
          resource_path = "/hostScanRecipes"
          method = "POST"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "retry_strategy",
              "opc_retry_token",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "create_host_scan_recipe got unknown kwargs: {!r}".format(extra_kwargs))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-retry-token": kwargs.get("opc_retry_token", missing),
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_retry_token_if_needed(header_params)
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  header_params=header_params,
                  body=create_host_scan_recipe_details,
                  response_type="HostScanRecipe")
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  header_params=header_params,
                  body=create_host_scan_recipe_details,
                  response_type="HostScanRecipe")
  
      def create_host_scan_target(self, create_host_scan_target_details, **kwargs):
          """
          Creates a new HostScanTarget. A host scan target is a collection of compute instances that you want routinely scanned for security vulnerabilities.
  
  
          :param oci.vulnerability_scanning.models.CreateHostScanTargetDetails create_host_scan_target_details: (required)
              Details for the new HostScanTarget
  
          :param str opc_retry_token: (optional)
              A token that uniquely identifies a request so it can be retried in case of a timeout or
              server error without risk of executing that same action again. Retry tokens expire after 24
              hours, but can be invalidated before then due to conflicting operations. For example, if a resource
              has been deleted and purged from the system, then a retry of the original creation request
              might be rejected.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.vulnerability_scanning.models.HostScanTarget`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/vulnerabilityscanning/create_host_scan_target.py.html>`__ to see an example of how to use create_host_scan_target API.
          """
          resource_path = "/hostScanTargets"
          method = "POST"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "retry_strategy",
              "opc_retry_token",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "create_host_scan_target got unknown kwargs: {!r}".format(extra_kwargs))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-retry-token": kwargs.get("opc_retry_token", missing),
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_retry_token_if_needed(header_params)
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  header_params=header_params,
                  body=create_host_scan_target_details,
                  response_type="HostScanTarget")
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  header_params=header_params,
                  body=create_host_scan_target_details,
                  response_type="HostScanTarget")
  
      def delete_container_scan_recipe(self, container_scan_recipe_id, **kwargs):
          """
          Deletes the ContainerScanRecipe identified by the id
  
  
          :param str container_scan_recipe_id: (required)
              unique ContainerScanRecipe identifier
  
          :param str if_match: (optional)
              For optimistic concurrency control. In the PUT or DELETE call
              for a resource, set the `if-match` parameter to the value of the
              etag from a previous GET or POST response for that resource.
              The resource will be updated or deleted only if the etag you
              provide matches the resource's current etag value.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :return: A :class:`~oci.response.Response` object with data of type None
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/vulnerabilityscanning/delete_container_scan_recipe.py.html>`__ to see an example of how to use delete_container_scan_recipe API.
          """
          resource_path = "/containerScanRecipes/{containerScanRecipeId}"
          method = "DELETE"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "retry_strategy",
              "if_match",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "delete_container_scan_recipe got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "containerScanRecipeId": container_scan_recipe_id
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "if-match": kwargs.get("if_match", missing),
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params)
  
      def delete_container_scan_result(self, container_scan_result_id, **kwargs):
          """
          Deletes the ContainerScanResult identified by the id
  
  
          :param str container_scan_result_id: (required)
              unique container scan identifier
  
          :param str if_match: (optional)
              For optimistic concurrency control. In the PUT or DELETE call
              for a resource, set the `if-match` parameter to the value of the
              etag from a previous GET or POST response for that resource.
              The resource will be updated or deleted only if the etag you
              provide matches the resource's current etag value.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :return: A :class:`~oci.response.Response` object with data of type None
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/vulnerabilityscanning/delete_container_scan_result.py.html>`__ to see an example of how to use delete_container_scan_result API.
          """
          resource_path = "/containerScanResults/{containerScanResultId}"
          method = "DELETE"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "retry_strategy",
              "if_match",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "delete_container_scan_result got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "containerScanResultId": container_scan_result_id
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "if-match": kwargs.get("if_match", missing),
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params)
  
      def delete_container_scan_target(self, container_scan_target_id, **kwargs):
          """
          Deletes the ContainerScanTarget identified by the id
  
  
          :param str container_scan_target_id: (required)
              unique ContainerScanTarget identifier
  
          :param str if_match: (optional)
              For optimistic concurrency control. In the PUT or DELETE call
              for a resource, set the `if-match` parameter to the value of the
              etag from a previous GET or POST response for that resource.
              The resource will be updated or deleted only if the etag you
              provide matches the resource's current etag value.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :return: A :class:`~oci.response.Response` object with data of type None
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/vulnerabilityscanning/delete_container_scan_target.py.html>`__ to see an example of how to use delete_container_scan_target API.
          """
          resource_path = "/containerScanTargets/{containerScanTargetId}"
          method = "DELETE"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "retry_strategy",
              "if_match",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "delete_container_scan_target got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "containerScanTargetId": container_scan_target_id
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "if-match": kwargs.get("if_match", missing),
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params)
  
      def delete_host_agent_scan_result(self, host_agent_scan_result_id, **kwargs):
          """
          Removes the HostAgentScanResult identified by the host agent scan ID.
  
  
          :param str host_agent_scan_result_id: (required)
              unique host agent scan identifier
  
          :param str if_match: (optional)
              For optimistic concurrency control. In the PUT or DELETE call
              for a resource, set the `if-match` parameter to the value of the
              etag from a previous GET or POST response for that resource.
              The resource will be updated or deleted only if the etag you
              provide matches the resource's current etag value.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :return: A :class:`~oci.response.Response` object with data of type None
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/vulnerabilityscanning/delete_host_agent_scan_result.py.html>`__ to see an example of how to use delete_host_agent_scan_result API.
          """
          resource_path = "/hostAgentScanResults/{hostAgentScanResultId}"
          method = "DELETE"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "retry_strategy",
              "if_match",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "delete_host_agent_scan_result got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "hostAgentScanResultId": host_agent_scan_result_id
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "if-match": kwargs.get("if_match", missing),
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params)
  
      def delete_host_cis_benchmark_scan_result(self, host_cis_benchmark_scan_result_id, **kwargs):
          """
          Deletes the HostCisBenchmarkScanResult identified by the id
  
  
          :param str host_cis_benchmark_scan_result_id: (required)
              unique host Cis benchmark scan identifier
  
          :param str if_match: (optional)
              For optimistic concurrency control. In the PUT or DELETE call
              for a resource, set the `if-match` parameter to the value of the
              etag from a previous GET or POST response for that resource.
              The resource will be updated or deleted only if the etag you
              provide matches the resource's current etag value.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :return: A :class:`~oci.response.Response` object with data of type None
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/vulnerabilityscanning/delete_host_cis_benchmark_scan_result.py.html>`__ to see an example of how to use delete_host_cis_benchmark_scan_result API.
          """
          resource_path = "/hostCisBenchmarkScanResults/{hostCisBenchmarkScanResultId}"
          method = "DELETE"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "retry_strategy",
              "if_match",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "delete_host_cis_benchmark_scan_result got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "hostCisBenchmarkScanResultId": host_cis_benchmark_scan_result_id
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "if-match": kwargs.get("if_match", missing),
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params)
  
      def delete_host_endpoint_protection_scan_result(self, host_endpoint_protection_scan_result_id, **kwargs):
          """
          Deletes the HostEndpointProtectionScanResult identified by the id
  
  
          :param str host_endpoint_protection_scan_result_id: (required)
              unique host endpoint protection scan identifier
  
          :param str if_match: (optional)
              For optimistic concurrency control. In the PUT or DELETE call
              for a resource, set the `if-match` parameter to the value of the
              etag from a previous GET or POST response for that resource.
              The resource will be updated or deleted only if the etag you
              provide matches the resource's current etag value.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :return: A :class:`~oci.response.Response` object with data of type None
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/vulnerabilityscanning/delete_host_endpoint_protection_scan_result.py.html>`__ to see an example of how to use delete_host_endpoint_protection_scan_result API.
          """
          resource_path = "/hostEndpointProtectionScanResults/{hostEndpointProtectionScanResultId}"
          method = "DELETE"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "retry_strategy",
              "if_match",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "delete_host_endpoint_protection_scan_result got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "hostEndpointProtectionScanResultId": host_endpoint_protection_scan_result_id
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "if-match": kwargs.get("if_match", missing),
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params)
  
      def delete_host_port_scan_result(self, host_port_scan_result_id, **kwargs):
          """
          Removes the HostPortScanResult identified by the host port scan ID.
  
  
          :param str host_port_scan_result_id: (required)
              unique host port scan identifier
  
          :param str if_match: (optional)
              For optimistic concurrency control. In the PUT or DELETE call
              for a resource, set the `if-match` parameter to the value of the
              etag from a previous GET or POST response for that resource.
              The resource will be updated or deleted only if the etag you
              provide matches the resource's current etag value.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :return: A :class:`~oci.response.Response` object with data of type None
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/vulnerabilityscanning/delete_host_port_scan_result.py.html>`__ to see an example of how to use delete_host_port_scan_result API.
          """
          resource_path = "/hostPortScanResults/{hostPortScanResultId}"
          method = "DELETE"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "retry_strategy",
              "if_match",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "delete_host_port_scan_result got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "hostPortScanResultId": host_port_scan_result_id
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "if-match": kwargs.get("if_match", missing),
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params)
  
      def delete_host_scan_recipe(self, host_scan_recipe_id, **kwargs):
          """
          Removes the HostScanRecipe identified by the recipe ID.
  
  
          :param str host_scan_recipe_id: (required)
              unique HostScanRecipe identifier
  
          :param str if_match: (optional)
              For optimistic concurrency control. In the PUT or DELETE call
              for a resource, set the `if-match` parameter to the value of the
              etag from a previous GET or POST response for that resource.
              The resource will be updated or deleted only if the etag you
              provide matches the resource's current etag value.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :return: A :class:`~oci.response.Response` object with data of type None
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/vulnerabilityscanning/delete_host_scan_recipe.py.html>`__ to see an example of how to use delete_host_scan_recipe API.
          """
          resource_path = "/hostScanRecipes/{hostScanRecipeId}"
          method = "DELETE"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "retry_strategy",
              "if_match",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "delete_host_scan_recipe got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "hostScanRecipeId": host_scan_recipe_id
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "if-match": kwargs.get("if_match", missing),
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params)
  
      def delete_host_scan_target(self, host_scan_target_id, **kwargs):
          """
          Removes the HostScanTarget identified by the target ID.
  
  
          :param str host_scan_target_id: (required)
              unique HostScanTarget identifier
  
          :param str if_match: (optional)
              For optimistic concurrency control. In the PUT or DELETE call
              for a resource, set the `if-match` parameter to the value of the
              etag from a previous GET or POST response for that resource.
              The resource will be updated or deleted only if the etag you
              provide matches the resource's current etag value.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :return: A :class:`~oci.response.Response` object with data of type None
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/vulnerabilityscanning/delete_host_scan_target.py.html>`__ to see an example of how to use delete_host_scan_target API.
          """
          resource_path = "/hostScanTargets/{hostScanTargetId}"
          method = "DELETE"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "retry_strategy",
              "if_match",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "delete_host_scan_target got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "hostScanTargetId": host_scan_target_id
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "if-match": kwargs.get("if_match", missing),
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params)
  
      def export_host_agent_scan_result_csv(self, export_host_agent_scan_result_csv_details, **kwargs):
          """
          Exports a list of HostAgentScanResultSummary objects within a compartment and during a specified time range in CSV format. You can filter the results by problem severity.
  
  
          :param oci.vulnerability_scanning.models.ExportHostAgentScanResultCsvDetails export_host_agent_scan_result_csv_details: (required)
              Information on which scan results to export to CSV
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :return: A :class:`~oci.response.Response` object with data of type stream
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/vulnerabilityscanning/export_host_agent_scan_result_csv.py.html>`__ to see an example of how to use export_host_agent_scan_result_csv API.
          """
          resource_path = "/hostAgentScanResults/actions/exportCsv"
          method = "POST"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "retry_strategy",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "export_host_agent_scan_result_csv got unknown kwargs: {!r}".format(extra_kwargs))
  
          header_params = {
              "accept": "text/csv",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  header_params=header_params,
                  body=export_host_agent_scan_result_csv_details,
                  response_type="stream")
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  header_params=header_params,
                  body=export_host_agent_scan_result_csv_details,
                  response_type="stream")
  
      def export_host_vulnerability_csv(self, export_host_vulnerability_csv_details, **kwargs):
          """
          Exports a list of HostVulnerabilitySummary objects in a compartment in CSV format.
  
  
          :param oci.vulnerability_scanning.models.ExportHostVulnerabilityCsvDetails export_host_vulnerability_csv_details: (required)
              Information on which scan results to export to CSV
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :return: A :class:`~oci.response.Response` object with data of type stream
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/vulnerabilityscanning/export_host_vulnerability_csv.py.html>`__ to see an example of how to use export_host_vulnerability_csv API.
          """
          resource_path = "/hostVulnerabilities/actions/exportCsv"
          method = "POST"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "retry_strategy",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "export_host_vulnerability_csv got unknown kwargs: {!r}".format(extra_kwargs))
  
          header_params = {
              "accept": "text/csv",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  header_params=header_params,
                  body=export_host_vulnerability_csv_details,
                  response_type="stream")
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  header_params=header_params,
                  body=export_host_vulnerability_csv_details,
                  response_type="stream")
  
      def get_container_scan_recipe(self, container_scan_recipe_id, **kwargs):
          """
          Gets a ContainerScanRecipe by identifier
  
  
          :param str container_scan_recipe_id: (required)
              unique ContainerScanRecipe identifier
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.vulnerability_scanning.models.ContainerScanRecipe`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/vulnerabilityscanning/get_container_scan_recipe.py.html>`__ to see an example of how to use get_container_scan_recipe API.
          """
          resource_path = "/containerScanRecipes/{containerScanRecipeId}"
          method = "GET"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "retry_strategy",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "get_container_scan_recipe got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "containerScanRecipeId": container_scan_recipe_id
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  response_type="ContainerScanRecipe")
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  response_type="ContainerScanRecipe")
  
      def get_container_scan_result(self, container_scan_result_id, **kwargs):
          """
          Returns a ContainerScanResult of the given container scan ID.
  
  
          :param str container_scan_result_id: (required)
              unique container scan identifier
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.vulnerability_scanning.models.ContainerScanResult`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/vulnerabilityscanning/get_container_scan_result.py.html>`__ to see an example of how to use get_container_scan_result API.
          """
          resource_path = "/containerScanResults/{containerScanResultId}"
          method = "GET"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "retry_strategy",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "get_container_scan_result got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "containerScanResultId": container_scan_result_id
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  response_type="ContainerScanResult")
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  response_type="ContainerScanResult")
  
      def get_container_scan_target(self, container_scan_target_id, **kwargs):
          """
          Gets a ContainerScanTarget by identifier
  
  
          :param str container_scan_target_id: (required)
              unique ContainerScanTarget identifier
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.vulnerability_scanning.models.ContainerScanTarget`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/vulnerabilityscanning/get_container_scan_target.py.html>`__ to see an example of how to use get_container_scan_target API.
          """
          resource_path = "/containerScanTargets/{containerScanTargetId}"
          method = "GET"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "retry_strategy",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "get_container_scan_target got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "containerScanTargetId": container_scan_target_id
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  response_type="ContainerScanTarget")
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  response_type="ContainerScanTarget")
  
      def get_host_agent_scan_result(self, host_agent_scan_result_id, **kwargs):
          """
          Retrieves a HostAgentScanResult identified by the host agent scan ID. The result includes a list of problems detected in a specific compute instance.
  
  
          :param str host_agent_scan_result_id: (required)
              unique host agent scan identifier
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.vulnerability_scanning.models.HostAgentScanResult`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/vulnerabilityscanning/get_host_agent_scan_result.py.html>`__ to see an example of how to use get_host_agent_scan_result API.
          """
          resource_path = "/hostAgentScanResults/{hostAgentScanResultId}"
          method = "GET"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "retry_strategy",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "get_host_agent_scan_result got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "hostAgentScanResultId": host_agent_scan_result_id
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  response_type="HostAgentScanResult")
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  response_type="HostAgentScanResult")
  
      def get_host_cis_benchmark_scan_result(self, host_cis_benchmark_scan_result_id, **kwargs):
          """
          Returns HostCisBenchmarkScanResults for the given host CIS (Center for Internet Security) benchmark scan result ID.
  
  
          :param str host_cis_benchmark_scan_result_id: (required)
              unique host Cis benchmark scan identifier
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.vulnerability_scanning.models.HostCisBenchmarkScanResult`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/vulnerabilityscanning/get_host_cis_benchmark_scan_result.py.html>`__ to see an example of how to use get_host_cis_benchmark_scan_result API.
          """
          resource_path = "/hostCisBenchmarkScanResults/{hostCisBenchmarkScanResultId}"
          method = "GET"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "retry_strategy",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "get_host_cis_benchmark_scan_result got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "hostCisBenchmarkScanResultId": host_cis_benchmark_scan_result_id
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  response_type="HostCisBenchmarkScanResult")
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  response_type="HostCisBenchmarkScanResult")
  
      def get_host_endpoint_protection_scan_result(self, host_endpoint_protection_scan_result_id, **kwargs):
          """
          Returns HostEndpointProtectionScanResults for the given host endpoint protection scan result ID.
  
  
          :param str host_endpoint_protection_scan_result_id: (required)
              unique host endpoint protection scan identifier
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.vulnerability_scanning.models.HostEndpointProtectionScanResult`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/vulnerabilityscanning/get_host_endpoint_protection_scan_result.py.html>`__ to see an example of how to use get_host_endpoint_protection_scan_result API.
          """
          resource_path = "/hostEndpointProtectionScanResults/{hostEndpointProtectionScanResultId}"
          method = "GET"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "retry_strategy",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "get_host_endpoint_protection_scan_result got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "hostEndpointProtectionScanResultId": host_endpoint_protection_scan_result_id
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  response_type="HostEndpointProtectionScanResult")
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  response_type="HostEndpointProtectionScanResult")
  
      def get_host_port_scan_result(self, host_port_scan_result_id, **kwargs):
          """
          Retrieves a HostPortScanResult identified by the host port scan ID. The result includes a list of open ports that were detected in a specific compute instance.
  
  
          :param str host_port_scan_result_id: (required)
              unique host port scan identifier
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.vulnerability_scanning.models.HostPortScanResult`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/vulnerabilityscanning/get_host_port_scan_result.py.html>`__ to see an example of how to use get_host_port_scan_result API.
          """
          resource_path = "/hostPortScanResults/{hostPortScanResultId}"
          method = "GET"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "retry_strategy",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "get_host_port_scan_result got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "hostPortScanResultId": host_port_scan_result_id
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  response_type="HostPortScanResult")
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  response_type="HostPortScanResult")
  
      def get_host_scan_recipe(self, host_scan_recipe_id, **kwargs):
          """
          Retrieves a HostScanRecipe identified by the recipe ID. A recipe determines the types of security issues that you want scanned, and how often to scan.
  
  
          :param str host_scan_recipe_id: (required)
              unique HostScanRecipe identifier
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.vulnerability_scanning.models.HostScanRecipe`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/vulnerabilityscanning/get_host_scan_recipe.py.html>`__ to see an example of how to use get_host_scan_recipe API.
          """
          resource_path = "/hostScanRecipes/{hostScanRecipeId}"
          method = "GET"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "retry_strategy",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "get_host_scan_recipe got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "hostScanRecipeId": host_scan_recipe_id
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  response_type="HostScanRecipe")
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  response_type="HostScanRecipe")
  
      def get_host_scan_target(self, host_scan_target_id, **kwargs):
          """
          Retrieves a HostScanTarget identified by the target ID. A host scan target is a collection of compute instances that you want routinely scanned for security vulnerabilities.
  
  
          :param str host_scan_target_id: (required)
              unique HostScanTarget identifier
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.vulnerability_scanning.models.HostScanTarget`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/vulnerabilityscanning/get_host_scan_target.py.html>`__ to see an example of how to use get_host_scan_target API.
          """
          resource_path = "/hostScanTargets/{hostScanTargetId}"
          method = "GET"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "retry_strategy",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "get_host_scan_target got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "hostScanTargetId": host_scan_target_id
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  response_type="HostScanTarget")
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  response_type="HostScanTarget")
  
      def get_host_vulnerability(self, host_vulnerability_id, **kwargs):
          """
          Retrieves a HostVulnerability identified by the host vulnerability ID. A host vulnerability describes a security issue that was detected in scans of one or more compute instances. Common Vulnerabilities and Exposures (CVE) numbers identify security vulnerabilities for operating systems and other software, including Critical Patch Updates and Security Alert advisories.
  
  
          :param str host_vulnerability_id: (required)
              unique host scan vulnerability identifier
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.vulnerability_scanning.models.HostVulnerability`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/vulnerabilityscanning/get_host_vulnerability.py.html>`__ to see an example of how to use get_host_vulnerability API.
          """
          resource_path = "/hostVulnerabilities/{hostVulnerabilityId}"
          method = "GET"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "retry_strategy",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "get_host_vulnerability got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "hostVulnerabilityId": host_vulnerability_id
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  response_type="HostVulnerability")
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  response_type="HostVulnerability")
  
      def get_work_request(self, work_request_id, **kwargs):
          """
          Gets the status of the work request with the given ID.
  
  
          :param str work_request_id: (required)
              The ID of the asynchronous request.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.vulnerability_scanning.models.WorkRequest`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/vulnerabilityscanning/get_work_request.py.html>`__ to see an example of how to use get_work_request API.
          """
          resource_path = "/workRequests/{workRequestId}"
          method = "GET"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "retry_strategy",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "get_work_request got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "workRequestId": work_request_id
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  response_type="WorkRequest")
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  response_type="WorkRequest")
  
      def list_container_scan_recipes(self, compartment_id, **kwargs):
          """
          Returns a list of ContainerScanRecipeSummaries
  
  
          :param str compartment_id: (required)
              The ID of the compartment in which to list resources.
  
          :param str lifecycle_state: (optional)
              A filter to return only resources whose lifecycleState matches the given lifecycleState.
  
              Allowed values are: "CREATING", "UPDATING", "ACTIVE", "DELETING", "DELETED", "FAILED"
  
          :param str display_name: (optional)
              A filter to return only resources that match the entire display name given.
  
          :param int limit: (optional)
              The maximum number of items to return.
  
          :param str page: (optional)
              The page token representing the page at which to start retrieving results. This is usually retrieved from a previous list call.
  
          :param str sort_order: (optional)
              The sort order to use, either 'ASC' or 'DESC'.
  
              Allowed values are: "ASC", "DESC"
  
          :param str sort_by: (optional)
              The field to sort by. Only one sort order may be provided. Default order for timeCreated is descending. Default order for displayName is ascending. If no value is specified timeCreated is default.
  
              Allowed values are: "timeCreated", "displayName"
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.vulnerability_scanning.models.ContainerScanRecipeSummaryCollection`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/vulnerabilityscanning/list_container_scan_recipes.py.html>`__ to see an example of how to use list_container_scan_recipes API.
          """
          resource_path = "/containerScanRecipes"
          method = "GET"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "retry_strategy",
              "lifecycle_state",
              "display_name",
              "limit",
              "page",
              "sort_order",
              "sort_by",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "list_container_scan_recipes got unknown kwargs: {!r}".format(extra_kwargs))
  
          if 'lifecycle_state' in kwargs:
              lifecycle_state_allowed_values = ["CREATING", "UPDATING", "ACTIVE", "DELETING", "DELETED", "FAILED"]
              if kwargs['lifecycle_state'] not in lifecycle_state_allowed_values:
                  raise ValueError(
                      "Invalid value for `lifecycle_state`, must be one of {0}".format(lifecycle_state_allowed_values)
                  )
  
          if 'sort_order' in kwargs:
              sort_order_allowed_values = ["ASC", "DESC"]
              if kwargs['sort_order'] not in sort_order_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_order`, must be one of {0}".format(sort_order_allowed_values)
                  )
  
          if 'sort_by' in kwargs:
              sort_by_allowed_values = ["timeCreated", "displayName"]
              if kwargs['sort_by'] not in sort_by_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_by`, must be one of {0}".format(sort_by_allowed_values)
                  )
  
          query_params = {
              "compartmentId": compartment_id,
              "lifecycleState": kwargs.get("lifecycle_state", missing),
              "displayName": kwargs.get("display_name", missing),
              "limit": kwargs.get("limit", missing),
              "page": kwargs.get("page", missing),
              "sortOrder": kwargs.get("sort_order", missing),
              "sortBy": kwargs.get("sort_by", missing)
          }
          query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="ContainerScanRecipeSummaryCollection")
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="ContainerScanRecipeSummaryCollection")
  
      def list_container_scan_results(self, compartment_id, **kwargs):
          """
          Returns a collection of ContainerScanResultSummary objects
  
  
          :param str compartment_id: (required)
              The ID of the compartment in which to list resources.
  
          :param str repository: (optional)
              Repository name
  
          :param str image: (optional)
              Image name
  
          :param bool are_subcompartments_included: (optional)
              When listing with one or more filters, whether to include subcompartments for the compartmentId being listed for. Does nothing if no filters are present in the query.
  
          :param str highest_problem_severity: (optional)
              Parameter to filter by highestProblemSeverity for scan results
  
              Allowed values are: "NONE", "LOW", "MEDIUM", "HIGH", "CRITICAL"
  
          :param datetime time_started_greater_than_or_equal_to: (optional)
              Date and time on or after which scans were started, as described in `RFC 3339`__
  
              __ https://tools.ietf.org/rfc/rfc3339
  
          :param datetime time_started_less_than_or_equal_to: (optional)
              Date and time on or before which scans were started, as described in `RFC 3339`__
  
              __ https://tools.ietf.org/rfc/rfc3339
  
          :param str sort_order: (optional)
              The sort order to use, either 'ASC' or 'DESC'.
  
              Allowed values are: "ASC", "DESC"
  
          :param str sort_by: (optional)
              The field to sort by. Only one sort order may be provided. Default order is descending. If no value is specified timeFinished is default.
  
              Allowed values are: "timeStarted", "problemCount", "highestProblemSeverity"
  
          :param int limit: (optional)
              The maximum number of items to return.
  
          :param str page: (optional)
              The page token representing the page at which to start retrieving results. This is usually retrieved from a previous list call.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.vulnerability_scanning.models.ContainerScanResultSummaryCollection`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/vulnerabilityscanning/list_container_scan_results.py.html>`__ to see an example of how to use list_container_scan_results API.
          """
          resource_path = "/containerScanResults"
          method = "GET"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "retry_strategy",
              "repository",
              "image",
              "are_subcompartments_included",
              "highest_problem_severity",
              "time_started_greater_than_or_equal_to",
              "time_started_less_than_or_equal_to",
              "sort_order",
              "sort_by",
              "limit",
              "page",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "list_container_scan_results got unknown kwargs: {!r}".format(extra_kwargs))
  
          if 'highest_problem_severity' in kwargs:
              highest_problem_severity_allowed_values = ["NONE", "LOW", "MEDIUM", "HIGH", "CRITICAL"]
              if kwargs['highest_problem_severity'] not in highest_problem_severity_allowed_values:
                  raise ValueError(
                      "Invalid value for `highest_problem_severity`, must be one of {0}".format(highest_problem_severity_allowed_values)
                  )
  
          if 'sort_order' in kwargs:
              sort_order_allowed_values = ["ASC", "DESC"]
              if kwargs['sort_order'] not in sort_order_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_order`, must be one of {0}".format(sort_order_allowed_values)
                  )
  
          if 'sort_by' in kwargs:
              sort_by_allowed_values = ["timeStarted", "problemCount", "highestProblemSeverity"]
              if kwargs['sort_by'] not in sort_by_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_by`, must be one of {0}".format(sort_by_allowed_values)
                  )
  
          query_params = {
              "compartmentId": compartment_id,
              "repository": kwargs.get("repository", missing),
              "image": kwargs.get("image", missing),
              "areSubcompartmentsIncluded": kwargs.get("are_subcompartments_included", missing),
              "highestProblemSeverity": kwargs.get("highest_problem_severity", missing),
              "timeStartedGreaterThanOrEqualTo": kwargs.get("time_started_greater_than_or_equal_to", missing),
              "timeStartedLessThanOrEqualTo": kwargs.get("time_started_less_than_or_equal_to", missing),
              "sortOrder": kwargs.get("sort_order", missing),
              "sortBy": kwargs.get("sort_by", missing),
              "limit": kwargs.get("limit", missing),
              "page": kwargs.get("page", missing)
          }
          query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="ContainerScanResultSummaryCollection")
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="ContainerScanResultSummaryCollection")
  
      def list_container_scan_targets(self, compartment_id, **kwargs):
          """
          Returns a list of ContainerScanTargetSummaries
  
  
          :param str compartment_id: (required)
              The ID of the compartment in which to list resources.
  
          :param str lifecycle_state: (optional)
              A filter to return only resources whose lifecycleState matches the given lifecycleState.
  
              Allowed values are: "CREATING", "UPDATING", "ACTIVE", "DELETING", "DELETED", "FAILED"
  
          :param str display_name: (optional)
              A filter to return only resources that match the entire display name given.
  
          :param int limit: (optional)
              The maximum number of items to return.
  
          :param str page: (optional)
              The page token representing the page at which to start retrieving results. This is usually retrieved from a previous list call.
  
          :param str sort_order: (optional)
              The sort order to use, either 'ASC' or 'DESC'.
  
              Allowed values are: "ASC", "DESC"
  
          :param str sort_by: (optional)
              The field to sort by. Only one sort order may be provided. Default order for timeCreated is descending. Default order for displayName is ascending. If no value is specified timeCreated is default.
  
              Allowed values are: "timeCreated", "displayName"
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.vulnerability_scanning.models.ContainerScanTargetSummaryCollection`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/vulnerabilityscanning/list_container_scan_targets.py.html>`__ to see an example of how to use list_container_scan_targets API.
          """
          resource_path = "/containerScanTargets"
          method = "GET"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "retry_strategy",
              "lifecycle_state",
              "display_name",
              "limit",
              "page",
              "sort_order",
              "sort_by",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "list_container_scan_targets got unknown kwargs: {!r}".format(extra_kwargs))
  
          if 'lifecycle_state' in kwargs:
              lifecycle_state_allowed_values = ["CREATING", "UPDATING", "ACTIVE", "DELETING", "DELETED", "FAILED"]
              if kwargs['lifecycle_state'] not in lifecycle_state_allowed_values:
                  raise ValueError(
                      "Invalid value for `lifecycle_state`, must be one of {0}".format(lifecycle_state_allowed_values)
                  )
  
          if 'sort_order' in kwargs:
              sort_order_allowed_values = ["ASC", "DESC"]
              if kwargs['sort_order'] not in sort_order_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_order`, must be one of {0}".format(sort_order_allowed_values)
                  )
  
          if 'sort_by' in kwargs:
              sort_by_allowed_values = ["timeCreated", "displayName"]
              if kwargs['sort_by'] not in sort_by_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_by`, must be one of {0}".format(sort_by_allowed_values)
                  )
  
          query_params = {
              "compartmentId": compartment_id,
              "lifecycleState": kwargs.get("lifecycle_state", missing),
              "displayName": kwargs.get("display_name", missing),
              "limit": kwargs.get("limit", missing),
              "page": kwargs.get("page", missing),
              "sortOrder": kwargs.get("sort_order", missing),
              "sortBy": kwargs.get("sort_by", missing)
          }
          query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="ContainerScanTargetSummaryCollection")
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="ContainerScanTargetSummaryCollection")
  
      def list_host_agent_scan_results(self, compartment_id, **kwargs):
          """
          Retrieves a list of HostAgentScanResultSummary objects in a compartment. You can filter and sort the results by problem severity and time. An agent scan result includes a list of problems detected in a specific compute instance.
  
  
          :param str compartment_id: (required)
              The ID of the compartment in which to list resources.
  
          :param str instance_id: (optional)
              The ID of a compute instance
  
          :param str highest_problem_severity: (optional)
              Parameter to filter by highestProblemSeverity for scan results
  
              Allowed values are: "NONE", "LOW", "MEDIUM", "HIGH", "CRITICAL"
  
          :param str operating_system: (optional)
              Parameter to filter by operating system for scan results
  
          :param datetime time_started_greater_than_or_equal_to: (optional)
              Date and time on or after which scans were started, as described in `RFC 3339`__
  
              __ https://tools.ietf.org/rfc/rfc3339
  
          :param datetime time_started_less_than_or_equal_to: (optional)
              Date and time on or before which scans were started, as described in `RFC 3339`__
  
              __ https://tools.ietf.org/rfc/rfc3339
  
          :param str sort_order: (optional)
              The sort order to use, either 'ASC' or 'DESC'.
  
              Allowed values are: "ASC", "DESC"
  
          :param str sort_by: (optional)
              The field to sort by. Only one sort order may be provided. Default order is descending. If no value is specified timeStarted is default.
  
              Allowed values are: "timeStarted", "timeFinished", "problemCount", "highestProblemSeverity", "timeCompleted"
  
          :param int limit: (optional)
              The maximum number of items to return.
  
          :param str page: (optional)
              The page token representing the page at which to start retrieving results. This is usually retrieved from a previous list call.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param str display_name: (optional)
              A filter to return only resources that match the entire display name given.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.vulnerability_scanning.models.HostAgentScanResultSummaryCollection`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/vulnerabilityscanning/list_host_agent_scan_results.py.html>`__ to see an example of how to use list_host_agent_scan_results API.
          """
          resource_path = "/hostAgentScanResults"
          method = "GET"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "retry_strategy",
              "instance_id",
              "highest_problem_severity",
              "operating_system",
              "time_started_greater_than_or_equal_to",
              "time_started_less_than_or_equal_to",
              "sort_order",
              "sort_by",
              "limit",
              "page",
              "opc_request_id",
              "display_name"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "list_host_agent_scan_results got unknown kwargs: {!r}".format(extra_kwargs))
  
          if 'highest_problem_severity' in kwargs:
              highest_problem_severity_allowed_values = ["NONE", "LOW", "MEDIUM", "HIGH", "CRITICAL"]
              if kwargs['highest_problem_severity'] not in highest_problem_severity_allowed_values:
                  raise ValueError(
                      "Invalid value for `highest_problem_severity`, must be one of {0}".format(highest_problem_severity_allowed_values)
                  )
  
          if 'sort_order' in kwargs:
              sort_order_allowed_values = ["ASC", "DESC"]
              if kwargs['sort_order'] not in sort_order_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_order`, must be one of {0}".format(sort_order_allowed_values)
                  )
  
          if 'sort_by' in kwargs:
              sort_by_allowed_values = ["timeStarted", "timeFinished", "problemCount", "highestProblemSeverity", "timeCompleted"]
              if kwargs['sort_by'] not in sort_by_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_by`, must be one of {0}".format(sort_by_allowed_values)
                  )
  
          query_params = {
              "compartmentId": compartment_id,
              "instanceId": kwargs.get("instance_id", missing),
              "highestProblemSeverity": kwargs.get("highest_problem_severity", missing),
              "operatingSystem": kwargs.get("operating_system", missing),
              "timeStartedGreaterThanOrEqualTo": kwargs.get("time_started_greater_than_or_equal_to", missing),
              "timeStartedLessThanOrEqualTo": kwargs.get("time_started_less_than_or_equal_to", missing),
              "sortOrder": kwargs.get("sort_order", missing),
              "sortBy": kwargs.get("sort_by", missing),
              "limit": kwargs.get("limit", missing),
              "page": kwargs.get("page", missing),
              "displayName": kwargs.get("display_name", missing)
          }
          query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="HostAgentScanResultSummaryCollection")
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="HostAgentScanResultSummaryCollection")
  
      def list_host_cis_benchmark_scan_results(self, compartment_id, **kwargs):
          """
          Returns a collection of HostCisBenchmarkScanResultSummary objects
  
  
          :param str compartment_id: (required)
              The ID of the compartment in which to list resources.
  
          :param str instance_id: (optional)
              The ID of a compute instance
  
          :param str highest_problem_severity: (optional)
              Parameter to filter by highestProblemSeverity for scan results
  
              Allowed values are: "NONE", "LOW", "MEDIUM", "HIGH", "CRITICAL"
  
          :param datetime time_started_greater_than_or_equal_to: (optional)
              Date and time on or after which scans were started, as described in `RFC 3339`__
  
              __ https://tools.ietf.org/rfc/rfc3339
  
          :param datetime time_started_less_than_or_equal_to: (optional)
              Date and time on or before which scans were started, as described in `RFC 3339`__
  
              __ https://tools.ietf.org/rfc/rfc3339
  
          :param str sort_order: (optional)
              The sort order to use, either 'ASC' or 'DESC'.
  
              Allowed values are: "ASC", "DESC"
  
          :param str sort_by: (optional)
              The field to sort by. Only one sort order may be provided. Default order is descending. If no value is specified timeFinished is default.
  
              Allowed values are: "timeStarted", "timeFinished", "cisBenchmarkScanIssuesCount"
  
          :param int limit: (optional)
              The maximum number of items to return.
  
          :param str page: (optional)
              The page token representing the page at which to start retrieving results. This is usually retrieved from a previous list call.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param str display_name: (optional)
              A filter to return only resources that match the entire display name given.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.vulnerability_scanning.models.HostCisBenchmarkScanResultSummaryCollection`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/vulnerabilityscanning/list_host_cis_benchmark_scan_results.py.html>`__ to see an example of how to use list_host_cis_benchmark_scan_results API.
          """
          resource_path = "/hostCisBenchmarkScanResults"
          method = "GET"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "retry_strategy",
              "instance_id",
              "highest_problem_severity",
              "time_started_greater_than_or_equal_to",
              "time_started_less_than_or_equal_to",
              "sort_order",
              "sort_by",
              "limit",
              "page",
              "opc_request_id",
              "display_name"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "list_host_cis_benchmark_scan_results got unknown kwargs: {!r}".format(extra_kwargs))
  
          if 'highest_problem_severity' in kwargs:
              highest_problem_severity_allowed_values = ["NONE", "LOW", "MEDIUM", "HIGH", "CRITICAL"]
              if kwargs['highest_problem_severity'] not in highest_problem_severity_allowed_values:
                  raise ValueError(
                      "Invalid value for `highest_problem_severity`, must be one of {0}".format(highest_problem_severity_allowed_values)
                  )
  
          if 'sort_order' in kwargs:
              sort_order_allowed_values = ["ASC", "DESC"]
              if kwargs['sort_order'] not in sort_order_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_order`, must be one of {0}".format(sort_order_allowed_values)
                  )
  
          if 'sort_by' in kwargs:
              sort_by_allowed_values = ["timeStarted", "timeFinished", "cisBenchmarkScanIssuesCount"]
              if kwargs['sort_by'] not in sort_by_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_by`, must be one of {0}".format(sort_by_allowed_values)
                  )
  
          query_params = {
              "compartmentId": compartment_id,
              "instanceId": kwargs.get("instance_id", missing),
              "highestProblemSeverity": kwargs.get("highest_problem_severity", missing),
              "timeStartedGreaterThanOrEqualTo": kwargs.get("time_started_greater_than_or_equal_to", missing),
              "timeStartedLessThanOrEqualTo": kwargs.get("time_started_less_than_or_equal_to", missing),
              "sortOrder": kwargs.get("sort_order", missing),
              "sortBy": kwargs.get("sort_by", missing),
              "limit": kwargs.get("limit", missing),
              "page": kwargs.get("page", missing),
              "displayName": kwargs.get("display_name", missing)
          }
          query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="HostCisBenchmarkScanResultSummaryCollection")
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="HostCisBenchmarkScanResultSummaryCollection")
  
      def list_host_endpoint_protection_scan_results(self, compartment_id, **kwargs):
          """
          Returns a collection of HostEndpointProtectionScanResultSummary objects
  
  
          :param str compartment_id: (required)
              The ID of the compartment in which to list resources.
  
          :param str instance_id: (optional)
              The ID of a compute instance
  
          :param str highest_problem_severity: (optional)
              Parameter to filter by highestProblemSeverity for scan results
  
              Allowed values are: "NONE", "LOW", "MEDIUM", "HIGH", "CRITICAL"
  
          :param datetime time_started_greater_than_or_equal_to: (optional)
              Date and time on or after which scans were started, as described in `RFC 3339`__
  
              __ https://tools.ietf.org/rfc/rfc3339
  
          :param datetime time_started_less_than_or_equal_to: (optional)
              Date and time on or before which scans were started, as described in `RFC 3339`__
  
              __ https://tools.ietf.org/rfc/rfc3339
  
          :param str sort_order: (optional)
              The sort order to use, either 'ASC' or 'DESC'.
  
              Allowed values are: "ASC", "DESC"
  
          :param str sort_by: (optional)
              The field to sort by. Only one sort order may be provided. Default order is descending. If no value is specified timeFinished is default.
  
              Allowed values are: "timeStarted", "timeFinished", "problemSeverity"
  
          :param int limit: (optional)
              The maximum number of items to return.
  
          :param str page: (optional)
              The page token representing the page at which to start retrieving results. This is usually retrieved from a previous list call.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param str display_name: (optional)
              A filter to return only resources that match the entire display name given.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.vulnerability_scanning.models.HostEndpointProtectionScanResultSummaryCollection`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/vulnerabilityscanning/list_host_endpoint_protection_scan_results.py.html>`__ to see an example of how to use list_host_endpoint_protection_scan_results API.
          """
          resource_path = "/hostEndpointProtectionScanResults"
          method = "GET"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "retry_strategy",
              "instance_id",
              "highest_problem_severity",
              "time_started_greater_than_or_equal_to",
              "time_started_less_than_or_equal_to",
              "sort_order",
              "sort_by",
              "limit",
              "page",
              "opc_request_id",
              "display_name"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "list_host_endpoint_protection_scan_results got unknown kwargs: {!r}".format(extra_kwargs))
  
          if 'highest_problem_severity' in kwargs:
              highest_problem_severity_allowed_values = ["NONE", "LOW", "MEDIUM", "HIGH", "CRITICAL"]
              if kwargs['highest_problem_severity'] not in highest_problem_severity_allowed_values:
                  raise ValueError(
                      "Invalid value for `highest_problem_severity`, must be one of {0}".format(highest_problem_severity_allowed_values)
                  )
  
          if 'sort_order' in kwargs:
              sort_order_allowed_values = ["ASC", "DESC"]
              if kwargs['sort_order'] not in sort_order_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_order`, must be one of {0}".format(sort_order_allowed_values)
                  )
  
          if 'sort_by' in kwargs:
              sort_by_allowed_values = ["timeStarted", "timeFinished", "problemSeverity"]
              if kwargs['sort_by'] not in sort_by_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_by`, must be one of {0}".format(sort_by_allowed_values)
                  )
  
          query_params = {
              "compartmentId": compartment_id,
              "instanceId": kwargs.get("instance_id", missing),
              "highestProblemSeverity": kwargs.get("highest_problem_severity", missing),
              "timeStartedGreaterThanOrEqualTo": kwargs.get("time_started_greater_than_or_equal_to", missing),
              "timeStartedLessThanOrEqualTo": kwargs.get("time_started_less_than_or_equal_to", missing),
              "sortOrder": kwargs.get("sort_order", missing),
              "sortBy": kwargs.get("sort_by", missing),
              "limit": kwargs.get("limit", missing),
              "page": kwargs.get("page", missing),
              "displayName": kwargs.get("display_name", missing)
          }
          query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="HostEndpointProtectionScanResultSummaryCollection")
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="HostEndpointProtectionScanResultSummaryCollection")
  
      def list_host_port_scan_results(self, compartment_id, **kwargs):
          """
          Retrieves a list of HostPortScanResultSummary objects in a compartment. You can filter and sort the results by problem severity and time. A port scan result includes a list of open ports that were detected in a specific compute instance.
  
  
          :param str compartment_id: (required)
              The ID of the compartment in which to list resources.
  
          :param str instance_id: (optional)
              The ID of a compute instance
  
          :param str highest_problem_severity: (optional)
              Parameter to filter by highestProblemSeverity for scan results
  
              Allowed values are: "NONE", "LOW", "MEDIUM", "HIGH", "CRITICAL"
  
          :param datetime time_started_greater_than_or_equal_to: (optional)
              Date and time on or after which scans were started, as described in `RFC 3339`__
  
              __ https://tools.ietf.org/rfc/rfc3339
  
          :param datetime time_started_less_than_or_equal_to: (optional)
              Date and time on or before which scans were started, as described in `RFC 3339`__
  
              __ https://tools.ietf.org/rfc/rfc3339
  
          :param str sort_order: (optional)
              The sort order to use, either 'ASC' or 'DESC'.
  
              Allowed values are: "ASC", "DESC"
  
          :param str sort_by: (optional)
              The field to sort by. Only one sort order may be provided. Default order is descending. If no value is specified timeFinished is default.
  
              Allowed values are: "timeStarted", "timeFinished", "openPortCount", "highestProblemSeverity", "timeCompleted"
  
          :param int limit: (optional)
              The maximum number of items to return.
  
          :param str page: (optional)
              The page token representing the page at which to start retrieving results. This is usually retrieved from a previous list call.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param str display_name: (optional)
              A filter to return only resources that match the entire display name given.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.vulnerability_scanning.models.HostPortScanResultSummaryCollection`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/vulnerabilityscanning/list_host_port_scan_results.py.html>`__ to see an example of how to use list_host_port_scan_results API.
          """
          resource_path = "/hostPortScanResults"
          method = "GET"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "retry_strategy",
              "instance_id",
              "highest_problem_severity",
              "time_started_greater_than_or_equal_to",
              "time_started_less_than_or_equal_to",
              "sort_order",
              "sort_by",
              "limit",
              "page",
              "opc_request_id",
              "display_name"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "list_host_port_scan_results got unknown kwargs: {!r}".format(extra_kwargs))
  
          if 'highest_problem_severity' in kwargs:
              highest_problem_severity_allowed_values = ["NONE", "LOW", "MEDIUM", "HIGH", "CRITICAL"]
              if kwargs['highest_problem_severity'] not in highest_problem_severity_allowed_values:
                  raise ValueError(
                      "Invalid value for `highest_problem_severity`, must be one of {0}".format(highest_problem_severity_allowed_values)
                  )
  
          if 'sort_order' in kwargs:
              sort_order_allowed_values = ["ASC", "DESC"]
              if kwargs['sort_order'] not in sort_order_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_order`, must be one of {0}".format(sort_order_allowed_values)
                  )
  
          if 'sort_by' in kwargs:
              sort_by_allowed_values = ["timeStarted", "timeFinished", "openPortCount", "highestProblemSeverity", "timeCompleted"]
              if kwargs['sort_by'] not in sort_by_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_by`, must be one of {0}".format(sort_by_allowed_values)
                  )
  
          query_params = {
              "compartmentId": compartment_id,
              "instanceId": kwargs.get("instance_id", missing),
              "highestProblemSeverity": kwargs.get("highest_problem_severity", missing),
              "timeStartedGreaterThanOrEqualTo": kwargs.get("time_started_greater_than_or_equal_to", missing),
              "timeStartedLessThanOrEqualTo": kwargs.get("time_started_less_than_or_equal_to", missing),
              "sortOrder": kwargs.get("sort_order", missing),
              "sortBy": kwargs.get("sort_by", missing),
              "limit": kwargs.get("limit", missing),
              "page": kwargs.get("page", missing),
              "displayName": kwargs.get("display_name", missing)
          }
          query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="HostPortScanResultSummaryCollection")
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="HostPortScanResultSummaryCollection")
  
      def list_host_scan_recipes(self, compartment_id, **kwargs):
          """
          Retrieves a list of HostScanRecipeSummary objects in a compartment. A recipe determines the types of security issues that you want scanned, and how often to scan.
  
  
          :param str compartment_id: (required)
              The ID of the compartment in which to list resources.
  
          :param str lifecycle_state: (optional)
              A filter to return only resources whose lifecycleState matches the given lifecycleState.
  
              Allowed values are: "CREATING", "UPDATING", "ACTIVE", "DELETING", "DELETED", "FAILED"
  
          :param str display_name: (optional)
              A filter to return only resources that match the entire display name given.
  
          :param int limit: (optional)
              The maximum number of items to return.
  
          :param str page: (optional)
              The page token representing the page at which to start retrieving results. This is usually retrieved from a previous list call.
  
          :param str sort_order: (optional)
              The sort order to use, either 'ASC' or 'DESC'.
  
              Allowed values are: "ASC", "DESC"
  
          :param str sort_by: (optional)
              The field to sort by. Only one sort order may be provided. Default order for timeCreated is descending. Default order for displayName is ascending. If no value is specified timeCreated is default.
  
              Allowed values are: "timeCreated", "displayName"
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.vulnerability_scanning.models.HostScanRecipeSummaryCollection`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/vulnerabilityscanning/list_host_scan_recipes.py.html>`__ to see an example of how to use list_host_scan_recipes API.
          """
          resource_path = "/hostScanRecipes"
          method = "GET"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "retry_strategy",
              "lifecycle_state",
              "display_name",
              "limit",
              "page",
              "sort_order",
              "sort_by",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "list_host_scan_recipes got unknown kwargs: {!r}".format(extra_kwargs))
  
          if 'lifecycle_state' in kwargs:
              lifecycle_state_allowed_values = ["CREATING", "UPDATING", "ACTIVE", "DELETING", "DELETED", "FAILED"]
              if kwargs['lifecycle_state'] not in lifecycle_state_allowed_values:
                  raise ValueError(
                      "Invalid value for `lifecycle_state`, must be one of {0}".format(lifecycle_state_allowed_values)
                  )
  
          if 'sort_order' in kwargs:
              sort_order_allowed_values = ["ASC", "DESC"]
              if kwargs['sort_order'] not in sort_order_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_order`, must be one of {0}".format(sort_order_allowed_values)
                  )
  
          if 'sort_by' in kwargs:
              sort_by_allowed_values = ["timeCreated", "displayName"]
              if kwargs['sort_by'] not in sort_by_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_by`, must be one of {0}".format(sort_by_allowed_values)
                  )
  
          query_params = {
              "compartmentId": compartment_id,
              "lifecycleState": kwargs.get("lifecycle_state", missing),
              "displayName": kwargs.get("display_name", missing),
              "limit": kwargs.get("limit", missing),
              "page": kwargs.get("page", missing),
              "sortOrder": kwargs.get("sort_order", missing),
              "sortBy": kwargs.get("sort_by", missing)
          }
          query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="HostScanRecipeSummaryCollection")
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="HostScanRecipeSummaryCollection")
  
      def list_host_scan_targets(self, compartment_id, **kwargs):
          """
          Retrieves a list of HostScanTargetSummary objects in a compartment. A host scan target is a collection of compute instances that you want routinely scanned for security vulnerabilities.
  
  
          :param str compartment_id: (required)
              The ID of the compartment in which to list resources.
  
          :param str lifecycle_state: (optional)
              A filter to return only resources whose lifecycleState matches the given lifecycleState.
  
              Allowed values are: "CREATING", "UPDATING", "ACTIVE", "DELETING", "DELETED", "FAILED"
  
          :param str display_name: (optional)
              A filter to return only resources that match the entire display name given.
  
          :param int limit: (optional)
              The maximum number of items to return.
  
          :param str page: (optional)
              The page token representing the page at which to start retrieving results. This is usually retrieved from a previous list call.
  
          :param str sort_order: (optional)
              The sort order to use, either 'ASC' or 'DESC'.
  
              Allowed values are: "ASC", "DESC"
  
          :param str sort_by: (optional)
              The field to sort by. Only one sort order may be provided. Default order for timeCreated is descending. Default order for displayName is ascending. If no value is specified timeCreated is default.
  
              Allowed values are: "timeCreated", "displayName"
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.vulnerability_scanning.models.HostScanTargetSummaryCollection`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/vulnerabilityscanning/list_host_scan_targets.py.html>`__ to see an example of how to use list_host_scan_targets API.
          """
          resource_path = "/hostScanTargets"
          method = "GET"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "retry_strategy",
              "lifecycle_state",
              "display_name",
              "limit",
              "page",
              "sort_order",
              "sort_by",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "list_host_scan_targets got unknown kwargs: {!r}".format(extra_kwargs))
  
          if 'lifecycle_state' in kwargs:
              lifecycle_state_allowed_values = ["CREATING", "UPDATING", "ACTIVE", "DELETING", "DELETED", "FAILED"]
              if kwargs['lifecycle_state'] not in lifecycle_state_allowed_values:
                  raise ValueError(
                      "Invalid value for `lifecycle_state`, must be one of {0}".format(lifecycle_state_allowed_values)
                  )
  
          if 'sort_order' in kwargs:
              sort_order_allowed_values = ["ASC", "DESC"]
              if kwargs['sort_order'] not in sort_order_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_order`, must be one of {0}".format(sort_order_allowed_values)
                  )
  
          if 'sort_by' in kwargs:
              sort_by_allowed_values = ["timeCreated", "displayName"]
              if kwargs['sort_by'] not in sort_by_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_by`, must be one of {0}".format(sort_by_allowed_values)
                  )
  
          query_params = {
              "compartmentId": compartment_id,
              "lifecycleState": kwargs.get("lifecycle_state", missing),
              "displayName": kwargs.get("display_name", missing),
              "limit": kwargs.get("limit", missing),
              "page": kwargs.get("page", missing),
              "sortOrder": kwargs.get("sort_order", missing),
              "sortBy": kwargs.get("sort_by", missing)
          }
          query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="HostScanTargetSummaryCollection")
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="HostScanTargetSummaryCollection")
  
      def list_host_vulnerabilities(self, compartment_id, **kwargs):
          """
          Retrieves a list of HostVulnerabilitySummary objects in a compartment. You can filter and sort the vulnerabilities by problem severity and time. A host vulnerability describes a security issue that was detected in scans of one or more compute instances.
  
  
          :param str compartment_id: (required)
              The ID of the compartment in which to list resources.
  
          :param int limit: (optional)
              The maximum number of items to return.
  
          :param str page: (optional)
              The page token representing the page at which to start retrieving results. This is usually retrieved from a previous list call.
  
          :param str severity: (optional)
              A filter to return only resources that have a severity that matches the given severity
  
              Allowed values are: "NONE", "LOW", "MEDIUM", "HIGH", "CRITICAL"
  
          :param str name: (optional)
              A filter to return only resources that match the entire name given.
  
          :param str cve_reference: (optional)
              Parameter to filter by CVE reference number for vulnerabilities
  
          :param str vulnerability_type: (optional)
              The field to filter vulnerabilities based on its type. Only one value can be provided.
  
              Allowed values are: "CVE", "PROBLEM"
  
          :param str sort_order: (optional)
              The sort order to use, either 'ASC' or 'DESC'.
  
              Allowed values are: "ASC", "DESC"
  
          :param str sort_by: (optional)
              The field to sort by. Only one sort order may be provided. Default order for 'name' is Ascending. Default order for other values is descending. If no value is specified name is default.
  
              Allowed values are: "name", "severity", "impactedHosts", "firstDetected", "lastDetected"
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.vulnerability_scanning.models.HostVulnerabilitySummaryCollection`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/vulnerabilityscanning/list_host_vulnerabilities.py.html>`__ to see an example of how to use list_host_vulnerabilities API.
          """
          resource_path = "/hostVulnerabilities"
          method = "GET"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "retry_strategy",
              "limit",
              "page",
              "severity",
              "name",
              "cve_reference",
              "vulnerability_type",
              "sort_order",
              "sort_by",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "list_host_vulnerabilities got unknown kwargs: {!r}".format(extra_kwargs))
  
          if 'severity' in kwargs:
              severity_allowed_values = ["NONE", "LOW", "MEDIUM", "HIGH", "CRITICAL"]
              if kwargs['severity'] not in severity_allowed_values:
                  raise ValueError(
                      "Invalid value for `severity`, must be one of {0}".format(severity_allowed_values)
                  )
  
          if 'vulnerability_type' in kwargs:
              vulnerability_type_allowed_values = ["CVE", "PROBLEM"]
              if kwargs['vulnerability_type'] not in vulnerability_type_allowed_values:
                  raise ValueError(
                      "Invalid value for `vulnerability_type`, must be one of {0}".format(vulnerability_type_allowed_values)
                  )
  
          if 'sort_order' in kwargs:
              sort_order_allowed_values = ["ASC", "DESC"]
              if kwargs['sort_order'] not in sort_order_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_order`, must be one of {0}".format(sort_order_allowed_values)
                  )
  
          if 'sort_by' in kwargs:
              sort_by_allowed_values = ["name", "severity", "impactedHosts", "firstDetected", "lastDetected"]
              if kwargs['sort_by'] not in sort_by_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_by`, must be one of {0}".format(sort_by_allowed_values)
                  )
  
          query_params = {
              "compartmentId": compartment_id,
              "limit": kwargs.get("limit", missing),
              "page": kwargs.get("page", missing),
              "severity": kwargs.get("severity", missing),
              "name": kwargs.get("name", missing),
              "cveReference": kwargs.get("cve_reference", missing),
              "vulnerabilityType": kwargs.get("vulnerability_type", missing),
              "sortOrder": kwargs.get("sort_order", missing),
              "sortBy": kwargs.get("sort_by", missing)
          }
          query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="HostVulnerabilitySummaryCollection")
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="HostVulnerabilitySummaryCollection")
  
      def list_host_vulnerability_impacted_hosts(self, host_vulnerability_id, **kwargs):
          """
          Retrieves a list of HostVulnerabilityImpactedHostSummary objects for a specific host vulnerability ID. An impacted host summary identifies a compute instance on which the specified vulnerability was detected.
  
  
          :param str host_vulnerability_id: (required)
              unique host scan vulnerability identifier
  
          :param str sort_order: (optional)
              The sort order to use, either 'ASC' or 'DESC'.
  
              Allowed values are: "ASC", "DESC"
  
          :param str sort_by: (optional)
              The field to sort by. Only one sort order may be provided. Default order is Ascending. If no value is specified instanceId is default.
  
              Allowed values are: "instanceId"
  
          :param int limit: (optional)
              The maximum number of items to return.
  
          :param str page: (optional)
              The page token representing the page at which to start retrieving results. This is usually retrieved from a previous list call.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.vulnerability_scanning.models.HostVulnerabilityImpactedHostSummaryCollection`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/vulnerabilityscanning/list_host_vulnerability_impacted_hosts.py.html>`__ to see an example of how to use list_host_vulnerability_impacted_hosts API.
          """
          resource_path = "/hostVulnerabilities/{hostVulnerabilityId}/impactedHosts"
          method = "GET"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "retry_strategy",
              "sort_order",
              "sort_by",
              "limit",
              "page",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "list_host_vulnerability_impacted_hosts got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "hostVulnerabilityId": host_vulnerability_id
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          if 'sort_order' in kwargs:
              sort_order_allowed_values = ["ASC", "DESC"]
              if kwargs['sort_order'] not in sort_order_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_order`, must be one of {0}".format(sort_order_allowed_values)
                  )
  
          if 'sort_by' in kwargs:
              sort_by_allowed_values = ["instanceId"]
              if kwargs['sort_by'] not in sort_by_allowed_values:
                  raise ValueError(
                      "Invalid value for `sort_by`, must be one of {0}".format(sort_by_allowed_values)
                  )
  
          query_params = {
              "sortOrder": kwargs.get("sort_order", missing),
              "sortBy": kwargs.get("sort_by", missing),
              "limit": kwargs.get("limit", missing),
              "page": kwargs.get("page", missing)
          }
          query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="HostVulnerabilityImpactedHostSummaryCollection")
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="HostVulnerabilityImpactedHostSummaryCollection")
  
      def list_work_request_errors(self, work_request_id, **kwargs):
          """
          Return a (paginated) list of errors for a given work request.
  
  
          :param str work_request_id: (required)
              The ID of the asynchronous request.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param str page: (optional)
              The page token representing the page at which to start retrieving results. This is usually retrieved from a previous list call.
  
          :param int limit: (optional)
              The maximum number of items to return.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.vulnerability_scanning.models.WorkRequestErrorCollection`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/vulnerabilityscanning/list_work_request_errors.py.html>`__ to see an example of how to use list_work_request_errors API.
          """
          resource_path = "/workRequests/{workRequestId}/errors"
          method = "GET"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "retry_strategy",
              "opc_request_id",
              "page",
              "limit"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "list_work_request_errors got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "workRequestId": work_request_id
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          query_params = {
              "page": kwargs.get("page", missing),
              "limit": kwargs.get("limit", missing)
          }
          query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="WorkRequestErrorCollection")
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="WorkRequestErrorCollection")
  
      def list_work_request_logs(self, work_request_id, **kwargs):
          """
          Return a (paginated) list of logs for a given work request.
  
  
          :param str work_request_id: (required)
              The ID of the asynchronous request.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param str page: (optional)
              The page token representing the page at which to start retrieving results. This is usually retrieved from a previous list call.
  
          :param int limit: (optional)
              The maximum number of items to return.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.vulnerability_scanning.models.WorkRequestLogEntryCollection`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/vulnerabilityscanning/list_work_request_logs.py.html>`__ to see an example of how to use list_work_request_logs API.
          """
          resource_path = "/workRequests/{workRequestId}/logs"
          method = "GET"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "retry_strategy",
              "opc_request_id",
              "page",
              "limit"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "list_work_request_logs got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "workRequestId": work_request_id
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          query_params = {
              "page": kwargs.get("page", missing),
              "limit": kwargs.get("limit", missing)
          }
          query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="WorkRequestLogEntryCollection")
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="WorkRequestLogEntryCollection")
  
      def list_work_requests(self, compartment_id, **kwargs):
          """
          Lists the work requests in a compartment.
  
  
          :param str compartment_id: (required)
              The ID of the compartment in which to list resources.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param str page: (optional)
              The page token representing the page at which to start retrieving results. This is usually retrieved from a previous list call.
  
          :param int limit: (optional)
              The maximum number of items to return.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :return: A :class:`~oci.response.Response` object with data of type :class:`~oci.vulnerability_scanning.models.WorkRequestCollection`
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/vulnerabilityscanning/list_work_requests.py.html>`__ to see an example of how to use list_work_requests API.
          """
          resource_path = "/workRequests"
          method = "GET"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "retry_strategy",
              "opc_request_id",
              "page",
              "limit"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "list_work_requests got unknown kwargs: {!r}".format(extra_kwargs))
  
          query_params = {
              "compartmentId": compartment_id,
              "page": kwargs.get("page", missing),
              "limit": kwargs.get("limit", missing)
          }
          query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="WorkRequestCollection")
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  query_params=query_params,
                  header_params=header_params,
                  response_type="WorkRequestCollection")
  
      def update_container_scan_recipe(self, container_scan_recipe_id, update_container_scan_recipe_details, **kwargs):
          """
          Updates the ContainerScanRecipe identified by the id
  
  
          :param str container_scan_recipe_id: (required)
              unique ContainerScanRecipe identifier
  
          :param oci.vulnerability_scanning.models.UpdateContainerScanRecipeDetails update_container_scan_recipe_details: (required)
              The information to be updated.
  
          :param str if_match: (optional)
              For optimistic concurrency control. In the PUT or DELETE call
              for a resource, set the `if-match` parameter to the value of the
              etag from a previous GET or POST response for that resource.
              The resource will be updated or deleted only if the etag you
              provide matches the resource's current etag value.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :return: A :class:`~oci.response.Response` object with data of type None
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/vulnerabilityscanning/update_container_scan_recipe.py.html>`__ to see an example of how to use update_container_scan_recipe API.
          """
          resource_path = "/containerScanRecipes/{containerScanRecipeId}"
          method = "PUT"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "retry_strategy",
              "if_match",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "update_container_scan_recipe got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "containerScanRecipeId": container_scan_recipe_id
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "if-match": kwargs.get("if_match", missing),
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=update_container_scan_recipe_details)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=update_container_scan_recipe_details)
  
      def update_container_scan_target(self, container_scan_target_id, update_container_scan_target_details, **kwargs):
          """
          Updates the ContainerScanTarget identified by the id
  
  
          :param str container_scan_target_id: (required)
              unique ContainerScanTarget identifier
  
          :param oci.vulnerability_scanning.models.UpdateContainerScanTargetDetails update_container_scan_target_details: (required)
              The information to be updated.
  
          :param str if_match: (optional)
              For optimistic concurrency control. In the PUT or DELETE call
              for a resource, set the `if-match` parameter to the value of the
              etag from a previous GET or POST response for that resource.
              The resource will be updated or deleted only if the etag you
              provide matches the resource's current etag value.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :return: A :class:`~oci.response.Response` object with data of type None
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/vulnerabilityscanning/update_container_scan_target.py.html>`__ to see an example of how to use update_container_scan_target API.
          """
          resource_path = "/containerScanTargets/{containerScanTargetId}"
          method = "PUT"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "retry_strategy",
              "if_match",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "update_container_scan_target got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "containerScanTargetId": container_scan_target_id
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "if-match": kwargs.get("if_match", missing),
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=update_container_scan_target_details)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=update_container_scan_target_details)
  
      def update_host_scan_recipe(self, host_scan_recipe_id, update_host_scan_recipe_details, **kwargs):
          """
          Updates the HostScanRecipe identified by the recipe ID. A recipe determines the types of security issues that you want scanned, and how often to scan.
  
  
          :param str host_scan_recipe_id: (required)
              unique HostScanRecipe identifier
  
          :param oci.vulnerability_scanning.models.UpdateHostScanRecipeDetails update_host_scan_recipe_details: (required)
              The information to be updated.
  
          :param str if_match: (optional)
              For optimistic concurrency control. In the PUT or DELETE call
              for a resource, set the `if-match` parameter to the value of the
              etag from a previous GET or POST response for that resource.
              The resource will be updated or deleted only if the etag you
              provide matches the resource's current etag value.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :return: A :class:`~oci.response.Response` object with data of type None
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/vulnerabilityscanning/update_host_scan_recipe.py.html>`__ to see an example of how to use update_host_scan_recipe API.
          """
          resource_path = "/hostScanRecipes/{hostScanRecipeId}"
          method = "PUT"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "retry_strategy",
              "if_match",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "update_host_scan_recipe got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "hostScanRecipeId": host_scan_recipe_id
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "if-match": kwargs.get("if_match", missing),
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=update_host_scan_recipe_details)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=update_host_scan_recipe_details)
  
      def update_host_scan_target(self, host_scan_target_id, update_host_scan_target_details, **kwargs):
          """
          Updates the HostScanTarget identified by the target ID. A host scan target is a collection of compute instances that you want routinely scanned for security vulnerabilities.
  
  
          :param str host_scan_target_id: (required)
              unique HostScanTarget identifier
  
          :param oci.vulnerability_scanning.models.UpdateHostScanTargetDetails update_host_scan_target_details: (required)
              The information to be updated.
  
          :param str if_match: (optional)
              For optimistic concurrency control. In the PUT or DELETE call
              for a resource, set the `if-match` parameter to the value of the
              etag from a previous GET or POST response for that resource.
              The resource will be updated or deleted only if the etag you
              provide matches the resource's current etag value.
  
          :param str opc_request_id: (optional)
              The client request ID for tracing.
  
          :param obj retry_strategy: (optional)
              A retry strategy to apply to this specific operation/call. This will override any retry strategy set at the client-level.
  
              This should be one of the strategies available in the :py:mod:`~oci.retry` module. This operation will not retry by default, users can also use the convenient :py:data:`~oci.retry.DEFAULT_RETRY_STRATEGY` provided by the SDK to enable retries for it.
              The specifics of the default retry strategy are described `here <https://docs.oracle.com/en-us/iaas/tools/python/latest/sdk_behaviors/retries.html>`__.
  
              To have this operation explicitly not perform any retries, pass an instance of :py:class:`~oci.retry.NoneRetryStrategy`.
  
          :return: A :class:`~oci.response.Response` object with data of type None
          :rtype: :class:`~oci.response.Response`
  
          :example:
          Click `here <https://docs.cloud.oracle.com/en-us/iaas/tools/python-sdk-examples/latest/vulnerabilityscanning/update_host_scan_target.py.html>`__ to see an example of how to use update_host_scan_target API.
          """
          resource_path = "/hostScanTargets/{hostScanTargetId}"
          method = "PUT"
  
          # Don't accept unknown kwargs
          expected_kwargs = [
              "retry_strategy",
              "if_match",
              "opc_request_id"
          ]
          extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]
          if extra_kwargs:
              raise ValueError(
                  "update_host_scan_target got unknown kwargs: {!r}".format(extra_kwargs))
  
          path_params = {
              "hostScanTargetId": host_scan_target_id
          }
  
          path_params = {k: v for (k, v) in six.iteritems(path_params) if v is not missing}
  
          for (k, v) in six.iteritems(path_params):
              if v is None or (isinstance(v, six.string_types) and len(v.strip()) == 0):
                  raise ValueError('Parameter {} cannot be None, whitespace or empty string'.format(k))
  
          header_params = {
              "accept": "application/json",
              "content-type": "application/json",
              "if-match": kwargs.get("if_match", missing),
              "opc-request-id": kwargs.get("opc_request_id", missing)
          }
          header_params = {k: v for (k, v) in six.iteritems(header_params) if v is not missing and v is not None}
  
          retry_strategy = self.base_client.get_preferred_retry_strategy(
              operation_retry_strategy=kwargs.get('retry_strategy'),
              client_retry_strategy=self.retry_strategy
          )
  
          if retry_strategy:
              if not isinstance(retry_strategy, retry.NoneRetryStrategy):
                  self.base_client.add_opc_client_retries_header(header_params)
                  retry_strategy.add_circuit_breaker_callback(self.circuit_breaker_callback)
              return retry_strategy.make_retrying_call(
                  self.base_client.call_api,
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=update_host_scan_target_details)
          else:
              return self.base_client.call_api(
                  resource_path=resource_path,
                  method=method,
                  path_params=path_params,
                  header_params=header_params,
                  body=update_host_scan_target_details)
  