def METHOD_NAME(self, **kwargs: Any) -> Iterable["_models.CsmOperationDescription"]:
    """Implements Csm operations Api to exposes the list of available Csm Apis under the resource
    provider.
    Implements Csm operations Api to exposes the list of available Csm Apis under the resource
    provider.
    :keyword callable cls: A custom type or function that will be passed the direct response
    :return: An iterator like instance of either CsmOperationDescription or the result of
     cls(response)
    :rtype:
     ~azure.core.paging.ItemPaged[~azure.mgmt.web.v2021_01_01.models.CsmOperationDescription]
    :raises ~azure.core.exceptions.HttpResponseError:
    """
    _headers = kwargs.pop("headers", {}) or {}
    _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
    api_version: Literal["2021-01-01"] = kwargs.pop("api_version", _params.pop("api-version", "2021-01-01"))
    cls: ClsType[_models.CsmOperationCollection] = 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_operations_request(
                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
    def extract_data(pipeline_response):
        deserialized = self._deserialize("CsmOperationCollection", pipeline_response)
        list_of_elem = deserialized.value
        if cls:
            list_of_elem = cls(list_of_elem)  # type: ignore
        return deserialized.next_link or None, iter(list_of_elem)
    def get_next(next_link=None):
        request = prepare_request(next_link)
        _stream = False
        pipeline_response: PipelineResponse = 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)
            error = self._deserialize.failsafe_deserialize(_models.DefaultErrorResponse, pipeline_response)
            raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
        return pipeline_response
    return ItemPaged(get_next, extract_data)