async def METHOD_NAME(  # pylint: disable=inconsistent-return-statements
    self, resource_group_name: str, service_name: str, api_collection_id: str, **kwargs: Any
) -> None:
    """Offboard an Azure API Management API from Defender for APIs.
    Offboard an Azure API Management API from Defender for APIs. The system will stop monitoring
    the operations within the Azure API Management API for intrusive behaviors.
    :param resource_group_name: The name of the resource group. The name is case insensitive.
     Required.
    :type resource_group_name: str
    :param service_name: The name of the API Management service. Required.
    :type service_name: str
    :param api_collection_id: A string representing the apiCollections resource within the
     Microsoft.Security provider namespace. This string matches the Azure API Management API name.
     Required.
    :type api_collection_id: str
    :keyword callable cls: A custom type or function that will be passed the direct response
    :return: None or the result of cls(response)
    :rtype: None
    :raises ~azure.core.exceptions.HttpResponseError:
    """
    error_map = {
        401: ClientAuthenticationError,
        404: ResourceNotFoundError,
        409: ResourceExistsError,
        304: ResourceNotModifiedError,
    }
    error_map.update(kwargs.pop("error_map", {}) or {})
    _headers = kwargs.pop("headers", {}) or {}
    _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
    api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2022-11-20-preview"))
    cls: ClsType[None] = kwargs.pop("cls", None)
    request = build_delete_request(
        resource_group_name=resource_group_name,
        service_name=service_name,
        api_collection_id=api_collection_id,
        subscription_id=self._config.subscription_id,
        api_version=api_version,
        template_url=self.METHOD_NAME.metadata["url"],
        headers=_headers,
        params=_params,
    )
    request = _convert_request(request)
    request.url = self._client.format_url(request.url)
    _stream = False
    pipeline_response: PipelineResponse = await self._client._pipeline.run(  # pylint: disable=protected-access
        request, stream=_stream, **kwargs
    )
    response = pipeline_response.http_response
    if response.status_code not in [200, 204]:
        map_error(status_code=response.status_code, response=response, error_map=error_map)
        error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response)
        raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
    if cls:
        return cls(pipeline_response, None, {})