def METHOD_NAME(
    self, location: str, instance_id: str, **kwargs: Any
) -> AsyncIterable["_models.RestorableMongodbDatabaseGetResult"]:
    """Show the event feed of all mutations done on all the Azure Cosmos DB MongoDB databases under
    the restorable account.  This helps in scenario where database was accidentally deleted to get
    the deletion time.  This API requires
    'Microsoft.DocumentDB/locations/restorableDatabaseAccounts/.../read' permission.
    :param location: Cosmos DB region, with spaces between words and each word capitalized.
     Required.
    :type location: str
    :param instance_id: The instanceId GUID of a restorable database account. Required.
    :type instance_id: str
    :keyword callable cls: A custom type or function that will be passed the direct response
    :return: An iterator like instance of either RestorableMongodbDatabaseGetResult or the result
     of cls(response)
    :rtype:
     ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.cosmosdb.models.RestorableMongodbDatabaseGetResult]
    :raises ~azure.core.exceptions.HttpResponseError:
    """
    _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[_models.RestorableMongodbDatabasesListResult] = kwargs.pop("cls", None)
    error_map = {
        401: ClientAuthenticationError,
        404: ResourceNotFoundError,
        409: ResourceExistsError,
        304: ResourceNotModifiedError,
    }
    error_map.update(kwargs.pop("error_map", {}) or {})
    def prepare_request(next_link=None):
        if not next_link:
            request = build_list_request(
                location=location,
                instance_id=instance_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)
        else:
            # make call to next link with the client's api-version
            _parsed_next_link = urllib.parse.urlparse(next_link)
            _next_request_params = case_insensitive_dict(
                {
                    key: [urllib.parse.quote(v) for v in value]
                    for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items()
                }
            )
            _next_request_params["api-version"] = self._config.api_version
            request = HttpRequest(
                "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params
            )
            request = _convert_request(request)
            request.url = self._client.format_url(request.url)
            request.method = "GET"
        return request
    async def extract_data(pipeline_response):
        deserialized = self._deserialize("RestorableMongodbDatabasesListResult", pipeline_response)
        list_of_elem = deserialized.value
        if cls:
            list_of_elem = cls(list_of_elem)  # type: ignore
        return None, AsyncList(list_of_elem)
    async def get_next(next_link=None):
        request = prepare_request(next_link)
        _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]:
            map_error(status_code=response.status_code, response=response, error_map=error_map)
            raise HttpResponseError(response=response, error_format=ARMErrorFormat)
        return pipeline_response
    return AsyncItemPaged(get_next, extract_data)