async def METHOD_NAME(  # pylint: disable=inconsistent-return-statements
    self, vault_name: str, resource_group_name: str, operation_id: str, **kwargs: Any
) -> None:
    """Provides the status of the delete operations such as deleting backed up item. Once the
    operation has started, the
    status code in the response would be Accepted. It will continue to be in this state till it
    reaches completion. On
    successful completion, the status code will be OK. This method expects OperationID as an
    argument. OperationID is
    part of the Location header of the operation response.
    :param vault_name: The name of the recovery services vault. Required.
    :type vault_name: str
    :param resource_group_name: The name of the resource group where the recovery services vault is
     present. Required.
    :type resource_group_name: str
    :param operation_id: OperationID which represents the operation. Required.
    :type operation_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", self._config.api_version))
    cls: ClsType[None] = kwargs.pop("cls", None)
    request = build_get_request(
        vault_name=vault_name,
        resource_group_name=resource_group_name,
        operation_id=operation_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, 202, 204]:
        map_error(status_code=response.status_code, response=response, error_map=error_map)
        raise HttpResponseError(response=response, error_format=ARMErrorFormat)
    if cls:
        return cls(pipeline_response, None, {})