def METHOD_NAME(
    self,
    resource_group_name: str,
    account_name: str,
    source_region: str,
    target_region: str,
    filter: str,
    **kwargs: Any
) -> AsyncIterable["_models.PercentileMetric"]:
    """Retrieves the metrics determined by the given filter for the given account, source and target
    region. This url is only for PBS and Replication Latency data.
    :param resource_group_name: The name of the resource group. The name is case insensitive.
     Required.
    :type resource_group_name: str
    :param account_name: Cosmos DB database account name. Required.
    :type account_name: str
    :param source_region: Source region from which data is written. Cosmos DB region, with spaces
     between words and each word capitalized. Required.
    :type source_region: str
    :param target_region: Target region to which data is written. Cosmos DB region, with spaces
     between words and each word capitalized. Required.
    :type target_region: str
    :param filter: An OData filter expression that describes a subset of metrics to return. The
     parameters that can be filtered are name.value (name of the metric, can have an or of multiple
     names), startTime, endTime, and timeGrain. The supported operator is eq. Required.
    :type filter: str
    :keyword callable cls: A custom type or function that will be passed the direct response
    :return: An iterator like instance of either PercentileMetric or the result of cls(response)
    :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.cosmosdb.models.PercentileMetric]
    :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.PercentileMetricListResult] = 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_metrics_request(
                resource_group_name=resource_group_name,
                account_name=account_name,
                source_region=source_region,
                target_region=target_region,
                subscription_id=self._config.subscription_id,
                filter=filter,
                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("PercentileMetricListResult", 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)