def METHOD_NAME(
    self, **kwargs  # type: Any
):
    # type: (...) -> Iterable["models.ResourceProviderOperationList"]
    """Retrieves a list of available API operations under this Resource Provider.
    Retrieves a list of available API operations.
    :keyword callable cls: A custom type or function that will be passed the direct response
    :return: An iterator like instance of either ResourceProviderOperationList or the result of cls(response)
    :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.confidentialledger.models.ResourceProviderOperationList]
    :raises: ~azure.core.exceptions.HttpResponseError
    """
    cls = kwargs.pop(
        "cls", None
    )  # type: ClsType["models.ResourceProviderOperationList"]
    error_map = {
        401: ClientAuthenticationError,
        404: ResourceNotFoundError,
        409: ResourceExistsError,
    }
    error_map.update(kwargs.pop("error_map", {}))
    api_version = "2022-05-13"
    accept = "application/json"
    def prepare_request(next_link=None):
        # Construct headers
        header_parameters = {}  # type: Dict[str, Any]
        header_parameters["Accept"] = self._serialize.header(
            "accept", accept, "str"
        )
        if not next_link:
            # Construct URL
            url = self.METHOD_NAME.metadata["url"]  # type: ignore
            # Construct parameters
            query_parameters = {}  # type: Dict[str, Any]
            query_parameters["api-version"] = self._serialize.query(
                "api_version", api_version, "str"
            )
            request = self._client.get(url, query_parameters, header_parameters)
        else:
            url = next_link
            query_parameters = {}  # type: Dict[str, Any]
            request = self._client.get(url, query_parameters, header_parameters)
        return request
    def extract_data(pipeline_response):
        deserialized = self._deserialize(
            "ResourceProviderOperationList", pipeline_response
        )
        list_of_elem = deserialized.value
        if cls:
            list_of_elem = cls(list_of_elem)
        return deserialized.next_link or None, iter(list_of_elem)
    def get_next(next_link=None):
        request = prepare_request(next_link)
        pipeline_response = self._client._pipeline.run(
            request, stream=False, **kwargs
        )
        response = pipeline_response.http_response
        if response.status_code not in [200]:
            error = self._deserialize(models.ErrorResponse, response)
            map_error(
                status_code=response.status_code,
                response=response,
                error_map=error_map,
            )
            raise HttpResponseError(
                response=response, model=error, error_format=ARMErrorFormat
            )
        return pipeline_response
    return ItemPaged(get_next, extract_data)