text: # coding=utf-8
  # --------------------------------------------------------------------------
  # Copyright (c) Microsoft Corporation. All rights reserved.
  # Licensed under the MIT License. See License.txt in the project root for license information.
  # Code generated by Microsoft (R) AutoRest Code Generator.
  # Changes may cause incorrect behavior and will be lost if the code is regenerated.
  # --------------------------------------------------------------------------
  from typing import TYPE_CHECKING
  import warnings
  
  from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error
  from azure.core.paging import ItemPaged
  from azure.core.pipeline import PipelineResponse
  from azure.core.pipeline.transport import HttpRequest, HttpResponse
  from azure.core.polling import LROPoller, NoPolling, PollingMethod
  from azure.mgmt.core.exceptions import ARMErrorFormat
  from azure.mgmt.core.polling.arm_polling import ARMPolling
  
  from .. import models as _models
  
  if TYPE_CHECKING:
      # pylint: disable=unused-import,ungrouped-imports
      from typing import Any, Callable, Dict, Generic, Iterable, List, Optional, TypeVar, Union
  
      T = TypeVar('T')
      ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]]
  
  class AppServiceEnvironmentsOperations(object):
      """AppServiceEnvironmentsOperations operations.
  
      You should not instantiate this class directly. Instead, you should create a Client instance that
      instantiates it for you and attaches it as an attribute.
  
      :ivar models: Alias to model classes used in this operation group.
      :type models: ~azure.mgmt.web.v2016_09_01.models
      :param client: Client for service requests.
      :param config: Configuration of service client.
      :param serializer: An object model serializer.
      :param deserializer: An object model deserializer.
      """
  
      models = _models
  
      def __init__(self, client, config, serializer, deserializer):
          self._client = client
          self._serialize = serializer
          self._deserialize = deserializer
          self._config = config
  
      def list(
          self,
          **kwargs  # type: Any
      ):
          # type: (...) -> Iterable["_models.AppServiceEnvironmentCollection"]
          """Get all App Service Environments for a subscription.
  
          Get all App Service Environments for a subscription.
  
          :keyword callable cls: A custom type or function that will be passed the direct response
          :return: An iterator like instance of either AppServiceEnvironmentCollection or the result of cls(response)
          :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.web.v2016_09_01.models.AppServiceEnvironmentCollection]
          :raises: ~azure.core.exceptions.HttpResponseError
          """
          cls = kwargs.pop('cls', None)  # type: ClsType["_models.AppServiceEnvironmentCollection"]
          error_map = {
              401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
          }
          error_map.update(kwargs.pop('error_map', {}))
          api_version = "2016-09-01"
          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.list.metadata['url']  # type: ignore
                  path_format_arguments = {
                      'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str'),
                  }
                  url = self._client.format_url(url, **path_format_arguments)
                  # 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('AppServiceEnvironmentCollection', 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]:
                  map_error(status_code=response.status_code, response=response, error_map=error_map)
                  raise HttpResponseError(response=response, error_format=ARMErrorFormat)
  
              return pipeline_response
  
          return ItemPaged(
              get_next, extract_data
          )
      list.metadata = {'url': '/subscriptions/{subscriptionId}/providers/Microsoft.Web/hostingEnvironments'}  # type: ignore
  
      def list_by_resource_group(
          self,
          resource_group_name,  # type: str
          **kwargs  # type: Any
      ):
          # type: (...) -> Iterable["_models.AppServiceEnvironmentCollection"]
          """Get all App Service Environments in a resource group.
  
          Get all App Service Environments in a resource group.
  
          :param resource_group_name: Name of the resource group to which the resource belongs.
          :type resource_group_name: str
          :keyword callable cls: A custom type or function that will be passed the direct response
          :return: An iterator like instance of either AppServiceEnvironmentCollection or the result of cls(response)
          :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.web.v2016_09_01.models.AppServiceEnvironmentCollection]
          :raises: ~azure.core.exceptions.HttpResponseError
          """
          cls = kwargs.pop('cls', None)  # type: ClsType["_models.AppServiceEnvironmentCollection"]
          error_map = {
              401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
          }
          error_map.update(kwargs.pop('error_map', {}))
          api_version = "2016-09-01"
          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.list_by_resource_group.metadata['url']  # type: ignore
                  path_format_arguments = {
                      'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+[^\.]$'),
                      'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str'),
                  }
                  url = self._client.format_url(url, **path_format_arguments)
                  # 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('AppServiceEnvironmentCollection', 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]:
                  map_error(status_code=response.status_code, response=response, error_map=error_map)
                  raise HttpResponseError(response=response, error_format=ARMErrorFormat)
  
              return pipeline_response
  
          return ItemPaged(
              get_next, extract_data
          )
      list_by_resource_group.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments'}  # type: ignore
  
      def get(
          self,
          resource_group_name,  # type: str
          name,  # type: str
          **kwargs  # type: Any
      ):
          # type: (...) -> "_models.AppServiceEnvironmentResource"
          """Get the properties of an App Service Environment.
  
          Get the properties of an App Service Environment.
  
          :param resource_group_name: Name of the resource group to which the resource belongs.
          :type resource_group_name: str
          :param name: Name of the App Service Environment.
          :type name: str
          :keyword callable cls: A custom type or function that will be passed the direct response
          :return: AppServiceEnvironmentResource, or the result of cls(response)
          :rtype: ~azure.mgmt.web.v2016_09_01.models.AppServiceEnvironmentResource
          :raises: ~azure.core.exceptions.HttpResponseError
          """
          cls = kwargs.pop('cls', None)  # type: ClsType["_models.AppServiceEnvironmentResource"]
          error_map = {
              401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
          }
          error_map.update(kwargs.pop('error_map', {}))
          api_version = "2016-09-01"
          accept = "application/json"
  
          # Construct URL
          url = self.get.metadata['url']  # type: ignore
          path_format_arguments = {
              'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+[^\.]$'),
              'name': self._serialize.url("name", name, 'str'),
              'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str'),
          }
          url = self._client.format_url(url, **path_format_arguments)
  
          # Construct parameters
          query_parameters = {}  # type: Dict[str, Any]
          query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str')
  
          # Construct headers
          header_parameters = {}  # type: Dict[str, Any]
          header_parameters['Accept'] = self._serialize.header("accept", accept, 'str')
  
          request = self._client.get(url, query_parameters, header_parameters)
          pipeline_response = self._client._pipeline.run(request, stream=False, **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)
  
          deserialized = self._deserialize('AppServiceEnvironmentResource', pipeline_response)
  
          if cls:
              return cls(pipeline_response, deserialized, {})
  
          return deserialized
      get.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}'}  # type: ignore
  
      def _create_or_update_initial(
          self,
          resource_group_name,  # type: str
          name,  # type: str
          hosting_environment_envelope,  # type: "_models.AppServiceEnvironmentResource"
          **kwargs  # type: Any
      ):
          # type: (...) -> Optional["_models.AppServiceEnvironmentResource"]
          cls = kwargs.pop('cls', None)  # type: ClsType[Optional["_models.AppServiceEnvironmentResource"]]
          error_map = {
              401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
          }
          error_map.update(kwargs.pop('error_map', {}))
          api_version = "2016-09-01"
          content_type = kwargs.pop("content_type", "application/json")
          accept = "application/json"
  
          # Construct URL
          url = self._create_or_update_initial.metadata['url']  # type: ignore
          path_format_arguments = {
              'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+[^\.]$'),
              'name': self._serialize.url("name", name, 'str'),
              'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str'),
          }
          url = self._client.format_url(url, **path_format_arguments)
  
          # Construct parameters
          query_parameters = {}  # type: Dict[str, Any]
          query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str')
  
          # Construct headers
          header_parameters = {}  # type: Dict[str, Any]
          header_parameters['Content-Type'] = self._serialize.header("content_type", content_type, 'str')
          header_parameters['Accept'] = self._serialize.header("accept", accept, 'str')
  
          body_content_kwargs = {}  # type: Dict[str, Any]
          body_content = self._serialize.body(hosting_environment_envelope, 'AppServiceEnvironmentResource')
          body_content_kwargs['content'] = body_content
          request = self._client.put(url, query_parameters, header_parameters, **body_content_kwargs)
          pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs)
          response = pipeline_response.http_response
  
          if response.status_code not in [200, 202, 400, 404, 409]:
              map_error(status_code=response.status_code, response=response, error_map=error_map)
              raise HttpResponseError(response=response, error_format=ARMErrorFormat)
  
          deserialized = None
          if response.status_code == 200:
              deserialized = self._deserialize('AppServiceEnvironmentResource', pipeline_response)
  
          if response.status_code == 202:
              deserialized = self._deserialize('AppServiceEnvironmentResource', pipeline_response)
  
          if cls:
              return cls(pipeline_response, deserialized, {})
  
          return deserialized
      _create_or_update_initial.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}'}  # type: ignore
  
      def begin_create_or_update(
          self,
          resource_group_name,  # type: str
          name,  # type: str
          hosting_environment_envelope,  # type: "_models.AppServiceEnvironmentResource"
          **kwargs  # type: Any
      ):
          # type: (...) -> LROPoller["_models.AppServiceEnvironmentResource"]
          """Create or update an App Service Environment.
  
          Create or update an App Service Environment.
  
          :param resource_group_name: Name of the resource group to which the resource belongs.
          :type resource_group_name: str
          :param name: Name of the App Service Environment.
          :type name: str
          :param hosting_environment_envelope: Configuration details of the App Service Environment.
          :type hosting_environment_envelope: ~azure.mgmt.web.v2016_09_01.models.AppServiceEnvironmentResource
          :keyword callable cls: A custom type or function that will be passed the direct response
          :keyword str continuation_token: A continuation token to restart a poller from a saved state.
          :keyword polling: True for ARMPolling, False for no polling, or a
           polling object for personal polling strategy
          :paramtype polling: bool or ~azure.core.polling.PollingMethod
          :keyword int polling_interval: Default waiting time between two polls for LRO operations if no Retry-After header is present.
          :return: An instance of LROPoller that returns either AppServiceEnvironmentResource or the result of cls(response)
          :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.web.v2016_09_01.models.AppServiceEnvironmentResource]
          :raises ~azure.core.exceptions.HttpResponseError:
          """
          polling = kwargs.pop('polling', True)  # type: Union[bool, PollingMethod]
          cls = kwargs.pop('cls', None)  # type: ClsType["_models.AppServiceEnvironmentResource"]
          lro_delay = kwargs.pop(
              'polling_interval',
              self._config.polling_interval
          )
          cont_token = kwargs.pop('continuation_token', None)  # type: Optional[str]
          if cont_token is None:
              raw_result = self._create_or_update_initial(
                  resource_group_name=resource_group_name,
                  name=name,
                  hosting_environment_envelope=hosting_environment_envelope,
                  cls=lambda x,y,z: x,
                  **kwargs
              )
  
          kwargs.pop('error_map', None)
          kwargs.pop('content_type', None)
  
          def get_long_running_output(pipeline_response):
              deserialized = self._deserialize('AppServiceEnvironmentResource', pipeline_response)
  
              if cls:
                  return cls(pipeline_response, deserialized, {})
              return deserialized
  
          path_format_arguments = {
              'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+[^\.]$'),
              'name': self._serialize.url("name", name, 'str'),
              'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str'),
          }
  
          if polling is True: polling_method = ARMPolling(lro_delay, path_format_arguments=path_format_arguments,  **kwargs)
          elif polling is False: polling_method = NoPolling()
          else: polling_method = polling
          if cont_token:
              return LROPoller.from_continuation_token(
                  polling_method=polling_method,
                  continuation_token=cont_token,
                  client=self._client,
                  deserialization_callback=get_long_running_output
              )
          else:
              return LROPoller(self._client, raw_result, get_long_running_output, polling_method)
      begin_create_or_update.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}'}  # type: ignore
  
      def _delete_initial(
          self,
          resource_group_name,  # type: str
          name,  # type: str
          force_delete=None,  # type: Optional[bool]
          **kwargs  # type: Any
      ):
          # type: (...) -> None
          cls = kwargs.pop('cls', None)  # type: ClsType[None]
          error_map = {
              401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
          }
          error_map.update(kwargs.pop('error_map', {}))
          api_version = "2016-09-01"
  
          # Construct URL
          url = self._delete_initial.metadata['url']  # type: ignore
          path_format_arguments = {
              'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+[^\.]$'),
              'name': self._serialize.url("name", name, 'str'),
              'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str'),
          }
          url = self._client.format_url(url, **path_format_arguments)
  
          # Construct parameters
          query_parameters = {}  # type: Dict[str, Any]
          if force_delete is not None:
              query_parameters['forceDelete'] = self._serialize.query("force_delete", force_delete, 'bool')
          query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str')
  
          # Construct headers
          header_parameters = {}  # type: Dict[str, Any]
  
          request = self._client.delete(url, query_parameters, header_parameters)
          pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs)
          response = pipeline_response.http_response
  
          if response.status_code not in [202, 204, 400, 404, 409]:
              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, {})
  
      _delete_initial.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}'}  # type: ignore
  
      def begin_delete(
          self,
          resource_group_name,  # type: str
          name,  # type: str
          force_delete=None,  # type: Optional[bool]
          **kwargs  # type: Any
      ):
          # type: (...) -> LROPoller[None]
          """Delete an App Service Environment.
  
          Delete an App Service Environment.
  
          :param resource_group_name: Name of the resource group to which the resource belongs.
          :type resource_group_name: str
          :param name: Name of the App Service Environment.
          :type name: str
          :param force_delete: Specify :code:`<code>true</code>` to force the deletion even if the App
           Service Environment contains resources. The default is :code:`<code>false</code>`.
          :type force_delete: bool
          :keyword callable cls: A custom type or function that will be passed the direct response
          :keyword str continuation_token: A continuation token to restart a poller from a saved state.
          :keyword polling: True for ARMPolling, False for no polling, or a
           polling object for personal polling strategy
          :paramtype polling: bool or ~azure.core.polling.PollingMethod
          :keyword int polling_interval: Default waiting time between two polls for LRO operations if no Retry-After header is present.
          :return: An instance of LROPoller that returns either None or the result of cls(response)
          :rtype: ~azure.core.polling.LROPoller[None]
          :raises ~azure.core.exceptions.HttpResponseError:
          """
          polling = kwargs.pop('polling', True)  # type: Union[bool, PollingMethod]
          cls = kwargs.pop('cls', None)  # type: ClsType[None]
          lro_delay = kwargs.pop(
              'polling_interval',
              self._config.polling_interval
          )
          cont_token = kwargs.pop('continuation_token', None)  # type: Optional[str]
          if cont_token is None:
              raw_result = self._delete_initial(
                  resource_group_name=resource_group_name,
                  name=name,
                  force_delete=force_delete,
                  cls=lambda x,y,z: x,
                  **kwargs
              )
  
          kwargs.pop('error_map', None)
          kwargs.pop('content_type', None)
  
          def get_long_running_output(pipeline_response):
              if cls:
                  return cls(pipeline_response, None, {})
  
          path_format_arguments = {
              'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+[^\.]$'),
              'name': self._serialize.url("name", name, 'str'),
              'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str'),
          }
  
          if polling is True: polling_method = ARMPolling(lro_delay, path_format_arguments=path_format_arguments,  **kwargs)
          elif polling is False: polling_method = NoPolling()
          else: polling_method = polling
          if cont_token:
              return LROPoller.from_continuation_token(
                  polling_method=polling_method,
                  continuation_token=cont_token,
                  client=self._client,
                  deserialization_callback=get_long_running_output
              )
          else:
              return LROPoller(self._client, raw_result, get_long_running_output, polling_method)
      begin_delete.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}'}  # type: ignore
  
      def update(
          self,
          resource_group_name,  # type: str
          name,  # type: str
          hosting_environment_envelope,  # type: "_models.AppServiceEnvironmentPatchResource"
          **kwargs  # type: Any
      ):
          # type: (...) -> Optional["_models.AppServiceEnvironmentResource"]
          """Create or update an App Service Environment.
  
          Create or update an App Service Environment.
  
          :param resource_group_name: Name of the resource group to which the resource belongs.
          :type resource_group_name: str
          :param name: Name of the App Service Environment.
          :type name: str
          :param hosting_environment_envelope: Configuration details of the App Service Environment.
          :type hosting_environment_envelope: ~azure.mgmt.web.v2016_09_01.models.AppServiceEnvironmentPatchResource
          :keyword callable cls: A custom type or function that will be passed the direct response
          :return: AppServiceEnvironmentResource, or the result of cls(response)
          :rtype: ~azure.mgmt.web.v2016_09_01.models.AppServiceEnvironmentResource or None
          :raises: ~azure.core.exceptions.HttpResponseError
          """
          cls = kwargs.pop('cls', None)  # type: ClsType[Optional["_models.AppServiceEnvironmentResource"]]
          error_map = {
              401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
          }
          error_map.update(kwargs.pop('error_map', {}))
          api_version = "2016-09-01"
          content_type = kwargs.pop("content_type", "application/json")
          accept = "application/json"
  
          # Construct URL
          url = self.update.metadata['url']  # type: ignore
          path_format_arguments = {
              'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+[^\.]$'),
              'name': self._serialize.url("name", name, 'str'),
              'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str'),
          }
          url = self._client.format_url(url, **path_format_arguments)
  
          # Construct parameters
          query_parameters = {}  # type: Dict[str, Any]
          query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str')
  
          # Construct headers
          header_parameters = {}  # type: Dict[str, Any]
          header_parameters['Content-Type'] = self._serialize.header("content_type", content_type, 'str')
          header_parameters['Accept'] = self._serialize.header("accept", accept, 'str')
  
          body_content_kwargs = {}  # type: Dict[str, Any]
          body_content = self._serialize.body(hosting_environment_envelope, 'AppServiceEnvironmentPatchResource')
          body_content_kwargs['content'] = body_content
          request = self._client.patch(url, query_parameters, header_parameters, **body_content_kwargs)
          pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs)
          response = pipeline_response.http_response
  
          if response.status_code not in [200, 202, 400, 404, 409]:
              map_error(status_code=response.status_code, response=response, error_map=error_map)
              raise HttpResponseError(response=response, error_format=ARMErrorFormat)
  
          deserialized = None
          if response.status_code == 200:
              deserialized = self._deserialize('AppServiceEnvironmentResource', pipeline_response)
  
          if response.status_code == 202:
              deserialized = self._deserialize('AppServiceEnvironmentResource', pipeline_response)
  
          if cls:
              return cls(pipeline_response, deserialized, {})
  
          return deserialized
      update.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}'}  # type: ignore
  
      def list_capacities(
          self,
          resource_group_name,  # type: str
          name,  # type: str
          **kwargs  # type: Any
      ):
          # type: (...) -> Iterable["_models.StampCapacityCollection"]
          """Get the used, available, and total worker capacity an App Service Environment.
  
          Get the used, available, and total worker capacity an App Service Environment.
  
          :param resource_group_name: Name of the resource group to which the resource belongs.
          :type resource_group_name: str
          :param name: Name of the App Service Environment.
          :type name: str
          :keyword callable cls: A custom type or function that will be passed the direct response
          :return: An iterator like instance of either StampCapacityCollection or the result of cls(response)
          :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.web.v2016_09_01.models.StampCapacityCollection]
          :raises: ~azure.core.exceptions.HttpResponseError
          """
          cls = kwargs.pop('cls', None)  # type: ClsType["_models.StampCapacityCollection"]
          error_map = {
              401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
          }
          error_map.update(kwargs.pop('error_map', {}))
          api_version = "2016-09-01"
          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.list_capacities.metadata['url']  # type: ignore
                  path_format_arguments = {
                      'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+[^\.]$'),
                      'name': self._serialize.url("name", name, 'str'),
                      'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str'),
                  }
                  url = self._client.format_url(url, **path_format_arguments)
                  # 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('StampCapacityCollection', 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]:
                  map_error(status_code=response.status_code, response=response, error_map=error_map)
                  raise HttpResponseError(response=response, error_format=ARMErrorFormat)
  
              return pipeline_response
  
          return ItemPaged(
              get_next, extract_data
          )
      list_capacities.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/capacities/compute'}  # type: ignore
  
      def list_vips(
          self,
          resource_group_name,  # type: str
          name,  # type: str
          **kwargs  # type: Any
      ):
          # type: (...) -> "_models.AddressResponse"
          """Get IP addresses assigned to an App Service Environment.
  
          Get IP addresses assigned to an App Service Environment.
  
          :param resource_group_name: Name of the resource group to which the resource belongs.
          :type resource_group_name: str
          :param name: Name of the App Service Environment.
          :type name: str
          :keyword callable cls: A custom type or function that will be passed the direct response
          :return: AddressResponse, or the result of cls(response)
          :rtype: ~azure.mgmt.web.v2016_09_01.models.AddressResponse
          :raises: ~azure.core.exceptions.HttpResponseError
          """
          cls = kwargs.pop('cls', None)  # type: ClsType["_models.AddressResponse"]
          error_map = {
              401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
          }
          error_map.update(kwargs.pop('error_map', {}))
          api_version = "2016-09-01"
          accept = "application/json"
  
          # Construct URL
          url = self.list_vips.metadata['url']  # type: ignore
          path_format_arguments = {
              'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+[^\.]$'),
              'name': self._serialize.url("name", name, 'str'),
              'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str'),
          }
          url = self._client.format_url(url, **path_format_arguments)
  
          # Construct parameters
          query_parameters = {}  # type: Dict[str, Any]
          query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str')
  
          # Construct headers
          header_parameters = {}  # type: Dict[str, Any]
          header_parameters['Accept'] = self._serialize.header("accept", accept, 'str')
  
          request = self._client.get(url, query_parameters, header_parameters)
          pipeline_response = self._client._pipeline.run(request, stream=False, **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)
  
          deserialized = self._deserialize('AddressResponse', pipeline_response)
  
          if cls:
              return cls(pipeline_response, deserialized, {})
  
          return deserialized
      list_vips.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/capacities/virtualip'}  # type: ignore
  
      def list_diagnostics(
          self,
          resource_group_name,  # type: str
          name,  # type: str
          **kwargs  # type: Any
      ):
          # type: (...) -> List["_models.HostingEnvironmentDiagnostics"]
          """Get diagnostic information for an App Service Environment.
  
          Get diagnostic information for an App Service Environment.
  
          :param resource_group_name: Name of the resource group to which the resource belongs.
          :type resource_group_name: str
          :param name: Name of the App Service Environment.
          :type name: str
          :keyword callable cls: A custom type or function that will be passed the direct response
          :return: list of HostingEnvironmentDiagnostics, or the result of cls(response)
          :rtype: list[~azure.mgmt.web.v2016_09_01.models.HostingEnvironmentDiagnostics]
          :raises: ~azure.core.exceptions.HttpResponseError
          """
          cls = kwargs.pop('cls', None)  # type: ClsType[List["_models.HostingEnvironmentDiagnostics"]]
          error_map = {
              401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
          }
          error_map.update(kwargs.pop('error_map', {}))
          api_version = "2016-09-01"
          accept = "application/json"
  
          # Construct URL
          url = self.list_diagnostics.metadata['url']  # type: ignore
          path_format_arguments = {
              'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+[^\.]$'),
              'name': self._serialize.url("name", name, 'str'),
              'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str'),
          }
          url = self._client.format_url(url, **path_format_arguments)
  
          # Construct parameters
          query_parameters = {}  # type: Dict[str, Any]
          query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str')
  
          # Construct headers
          header_parameters = {}  # type: Dict[str, Any]
          header_parameters['Accept'] = self._serialize.header("accept", accept, 'str')
  
          request = self._client.get(url, query_parameters, header_parameters)
          pipeline_response = self._client._pipeline.run(request, stream=False, **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)
  
          deserialized = self._deserialize('[HostingEnvironmentDiagnostics]', pipeline_response)
  
          if cls:
              return cls(pipeline_response, deserialized, {})
  
          return deserialized
      list_diagnostics.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/diagnostics'}  # type: ignore
  
      def get_diagnostics_item(
          self,
          resource_group_name,  # type: str
          name,  # type: str
          diagnostics_name,  # type: str
          **kwargs  # type: Any
      ):
          # type: (...) -> "_models.HostingEnvironmentDiagnostics"
          """Get a diagnostics item for an App Service Environment.
  
          Get a diagnostics item for an App Service Environment.
  
          :param resource_group_name: Name of the resource group to which the resource belongs.
          :type resource_group_name: str
          :param name: Name of the App Service Environment.
          :type name: str
          :param diagnostics_name: Name of the diagnostics item.
          :type diagnostics_name: str
          :keyword callable cls: A custom type or function that will be passed the direct response
          :return: HostingEnvironmentDiagnostics, or the result of cls(response)
          :rtype: ~azure.mgmt.web.v2016_09_01.models.HostingEnvironmentDiagnostics
          :raises: ~azure.core.exceptions.HttpResponseError
          """
          cls = kwargs.pop('cls', None)  # type: ClsType["_models.HostingEnvironmentDiagnostics"]
          error_map = {
              401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
          }
          error_map.update(kwargs.pop('error_map', {}))
          api_version = "2016-09-01"
          accept = "application/json"
  
          # Construct URL
          url = self.get_diagnostics_item.metadata['url']  # type: ignore
          path_format_arguments = {
              'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+[^\.]$'),
              'name': self._serialize.url("name", name, 'str'),
              'diagnosticsName': self._serialize.url("diagnostics_name", diagnostics_name, 'str'),
              'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str'),
          }
          url = self._client.format_url(url, **path_format_arguments)
  
          # Construct parameters
          query_parameters = {}  # type: Dict[str, Any]
          query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str')
  
          # Construct headers
          header_parameters = {}  # type: Dict[str, Any]
          header_parameters['Accept'] = self._serialize.header("accept", accept, 'str')
  
          request = self._client.get(url, query_parameters, header_parameters)
          pipeline_response = self._client._pipeline.run(request, stream=False, **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)
  
          deserialized = self._deserialize('HostingEnvironmentDiagnostics', pipeline_response)
  
          if cls:
              return cls(pipeline_response, deserialized, {})
  
          return deserialized
      get_diagnostics_item.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/diagnostics/{diagnosticsName}'}  # type: ignore
  
      def list_metric_definitions(
          self,
          resource_group_name,  # type: str
          name,  # type: str
          **kwargs  # type: Any
      ):
          # type: (...) -> "_models.MetricDefinition"
          """Get global metric definitions of an App Service Environment.
  
          Get global metric definitions of an App Service Environment.
  
          :param resource_group_name: Name of the resource group to which the resource belongs.
          :type resource_group_name: str
          :param name: Name of the App Service Environment.
          :type name: str
          :keyword callable cls: A custom type or function that will be passed the direct response
          :return: MetricDefinition, or the result of cls(response)
          :rtype: ~azure.mgmt.web.v2016_09_01.models.MetricDefinition
          :raises: ~azure.core.exceptions.HttpResponseError
          """
          cls = kwargs.pop('cls', None)  # type: ClsType["_models.MetricDefinition"]
          error_map = {
              401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
          }
          error_map.update(kwargs.pop('error_map', {}))
          api_version = "2016-09-01"
          accept = "application/json"
  
          # Construct URL
          url = self.list_metric_definitions.metadata['url']  # type: ignore
          path_format_arguments = {
              'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+[^\.]$'),
              'name': self._serialize.url("name", name, 'str'),
              'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str'),
          }
          url = self._client.format_url(url, **path_format_arguments)
  
          # Construct parameters
          query_parameters = {}  # type: Dict[str, Any]
          query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str')
  
          # Construct headers
          header_parameters = {}  # type: Dict[str, Any]
          header_parameters['Accept'] = self._serialize.header("accept", accept, 'str')
  
          request = self._client.get(url, query_parameters, header_parameters)
          pipeline_response = self._client._pipeline.run(request, stream=False, **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)
  
          deserialized = self._deserialize('MetricDefinition', pipeline_response)
  
          if cls:
              return cls(pipeline_response, deserialized, {})
  
          return deserialized
      list_metric_definitions.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/metricdefinitions'}  # type: ignore
  
      def list_metrics(
          self,
          resource_group_name,  # type: str
          name,  # type: str
          details=None,  # type: Optional[bool]
          filter=None,  # type: Optional[str]
          **kwargs  # type: Any
      ):
          # type: (...) -> Iterable["_models.ResourceMetricCollection"]
          """Get global metrics of an App Service Environment.
  
          Get global metrics of an App Service Environment.
  
          :param resource_group_name: Name of the resource group to which the resource belongs.
          :type resource_group_name: str
          :param name: Name of the App Service Environment.
          :type name: str
          :param details: Specify :code:`<code>true</code>` to include instance details. The default is
           :code:`<code>false</code>`.
          :type details: bool
          :param filter: Return only usages/metrics specified in the filter. Filter conforms to odata
           syntax. Example: $filter=(name.value eq 'Metric1' or name.value eq 'Metric2') and startTime eq
           '2014-01-01T00:00:00Z' and endTime eq '2014-12-31T23:59:59Z' and timeGrain eq
           duration'[Hour|Minute|Day]'.
          :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 ResourceMetricCollection or the result of cls(response)
          :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.web.v2016_09_01.models.ResourceMetricCollection]
          :raises: ~azure.core.exceptions.HttpResponseError
          """
          cls = kwargs.pop('cls', None)  # type: ClsType["_models.ResourceMetricCollection"]
          error_map = {
              401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
          }
          error_map.update(kwargs.pop('error_map', {}))
          api_version = "2016-09-01"
          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.list_metrics.metadata['url']  # type: ignore
                  path_format_arguments = {
                      'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+[^\.]$'),
                      'name': self._serialize.url("name", name, 'str'),
                      'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str'),
                  }
                  url = self._client.format_url(url, **path_format_arguments)
                  # Construct parameters
                  query_parameters = {}  # type: Dict[str, Any]
                  if details is not None:
                      query_parameters['details'] = self._serialize.query("details", details, 'bool')
                  if filter is not None:
                      query_parameters['$filter'] = self._serialize.query("filter", filter, 'str', skip_quote=True)
                  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('ResourceMetricCollection', 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]:
                  map_error(status_code=response.status_code, response=response, error_map=error_map)
                  raise HttpResponseError(response=response, error_format=ARMErrorFormat)
  
              return pipeline_response
  
          return ItemPaged(
              get_next, extract_data
          )
      list_metrics.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/metrics'}  # type: ignore
  
      def list_multi_role_pools(
          self,
          resource_group_name,  # type: str
          name,  # type: str
          **kwargs  # type: Any
      ):
          # type: (...) -> Iterable["_models.WorkerPoolCollection"]
          """Get all multi-role pools.
  
          Get all multi-role pools.
  
          :param resource_group_name: Name of the resource group to which the resource belongs.
          :type resource_group_name: str
          :param name: Name of the App Service Environment.
          :type name: str
          :keyword callable cls: A custom type or function that will be passed the direct response
          :return: An iterator like instance of either WorkerPoolCollection or the result of cls(response)
          :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.web.v2016_09_01.models.WorkerPoolCollection]
          :raises: ~azure.core.exceptions.HttpResponseError
          """
          cls = kwargs.pop('cls', None)  # type: ClsType["_models.WorkerPoolCollection"]
          error_map = {
              401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
          }
          error_map.update(kwargs.pop('error_map', {}))
          api_version = "2016-09-01"
          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.list_multi_role_pools.metadata['url']  # type: ignore
                  path_format_arguments = {
                      'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+[^\.]$'),
                      'name': self._serialize.url("name", name, 'str'),
                      'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str'),
                  }
                  url = self._client.format_url(url, **path_format_arguments)
                  # 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('WorkerPoolCollection', 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]:
                  map_error(status_code=response.status_code, response=response, error_map=error_map)
                  raise HttpResponseError(response=response, error_format=ARMErrorFormat)
  
              return pipeline_response
  
          return ItemPaged(
              get_next, extract_data
          )
      list_multi_role_pools.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/multiRolePools'}  # type: ignore
  
      def get_multi_role_pool(
          self,
          resource_group_name,  # type: str
          name,  # type: str
          **kwargs  # type: Any
      ):
          # type: (...) -> "_models.WorkerPoolResource"
          """Get properties of a multi-role pool.
  
          Get properties of a multi-role pool.
  
          :param resource_group_name: Name of the resource group to which the resource belongs.
          :type resource_group_name: str
          :param name: Name of the App Service Environment.
          :type name: str
          :keyword callable cls: A custom type or function that will be passed the direct response
          :return: WorkerPoolResource, or the result of cls(response)
          :rtype: ~azure.mgmt.web.v2016_09_01.models.WorkerPoolResource
          :raises: ~azure.core.exceptions.HttpResponseError
          """
          cls = kwargs.pop('cls', None)  # type: ClsType["_models.WorkerPoolResource"]
          error_map = {
              401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
          }
          error_map.update(kwargs.pop('error_map', {}))
          api_version = "2016-09-01"
          accept = "application/json"
  
          # Construct URL
          url = self.get_multi_role_pool.metadata['url']  # type: ignore
          path_format_arguments = {
              'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+[^\.]$'),
              'name': self._serialize.url("name", name, 'str'),
              'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str'),
          }
          url = self._client.format_url(url, **path_format_arguments)
  
          # Construct parameters
          query_parameters = {}  # type: Dict[str, Any]
          query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str')
  
          # Construct headers
          header_parameters = {}  # type: Dict[str, Any]
          header_parameters['Accept'] = self._serialize.header("accept", accept, 'str')
  
          request = self._client.get(url, query_parameters, header_parameters)
          pipeline_response = self._client._pipeline.run(request, stream=False, **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)
  
          deserialized = self._deserialize('WorkerPoolResource', pipeline_response)
  
          if cls:
              return cls(pipeline_response, deserialized, {})
  
          return deserialized
      get_multi_role_pool.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/multiRolePools/default'}  # type: ignore
  
      def _create_or_update_multi_role_pool_initial(
          self,
          resource_group_name,  # type: str
          name,  # type: str
          multi_role_pool_envelope,  # type: "_models.WorkerPoolResource"
          **kwargs  # type: Any
      ):
          # type: (...) -> Optional["_models.WorkerPoolResource"]
          cls = kwargs.pop('cls', None)  # type: ClsType[Optional["_models.WorkerPoolResource"]]
          error_map = {
              401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
          }
          error_map.update(kwargs.pop('error_map', {}))
          api_version = "2016-09-01"
          content_type = kwargs.pop("content_type", "application/json")
          accept = "application/json"
  
          # Construct URL
          url = self._create_or_update_multi_role_pool_initial.metadata['url']  # type: ignore
          path_format_arguments = {
              'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+[^\.]$'),
              'name': self._serialize.url("name", name, 'str'),
              'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str'),
          }
          url = self._client.format_url(url, **path_format_arguments)
  
          # Construct parameters
          query_parameters = {}  # type: Dict[str, Any]
          query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str')
  
          # Construct headers
          header_parameters = {}  # type: Dict[str, Any]
          header_parameters['Content-Type'] = self._serialize.header("content_type", content_type, 'str')
          header_parameters['Accept'] = self._serialize.header("accept", accept, 'str')
  
          body_content_kwargs = {}  # type: Dict[str, Any]
          body_content = self._serialize.body(multi_role_pool_envelope, 'WorkerPoolResource')
          body_content_kwargs['content'] = body_content
          request = self._client.put(url, query_parameters, header_parameters, **body_content_kwargs)
          pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs)
          response = pipeline_response.http_response
  
          if response.status_code not in [200, 202, 400, 404, 409]:
              map_error(status_code=response.status_code, response=response, error_map=error_map)
              raise HttpResponseError(response=response, error_format=ARMErrorFormat)
  
          deserialized = None
          if response.status_code == 200:
              deserialized = self._deserialize('WorkerPoolResource', pipeline_response)
  
          if response.status_code == 202:
              deserialized = self._deserialize('WorkerPoolResource', pipeline_response)
  
          if cls:
              return cls(pipeline_response, deserialized, {})
  
          return deserialized
      _create_or_update_multi_role_pool_initial.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/multiRolePools/default'}  # type: ignore
  
      def begin_create_or_update_multi_role_pool(
          self,
          resource_group_name,  # type: str
          name,  # type: str
          multi_role_pool_envelope,  # type: "_models.WorkerPoolResource"
          **kwargs  # type: Any
      ):
          # type: (...) -> LROPoller["_models.WorkerPoolResource"]
          """Create or update a multi-role pool.
  
          Create or update a multi-role pool.
  
          :param resource_group_name: Name of the resource group to which the resource belongs.
          :type resource_group_name: str
          :param name: Name of the App Service Environment.
          :type name: str
          :param multi_role_pool_envelope: Properties of the multi-role pool.
          :type multi_role_pool_envelope: ~azure.mgmt.web.v2016_09_01.models.WorkerPoolResource
          :keyword callable cls: A custom type or function that will be passed the direct response
          :keyword str continuation_token: A continuation token to restart a poller from a saved state.
          :keyword polling: True for ARMPolling, False for no polling, or a
           polling object for personal polling strategy
          :paramtype polling: bool or ~azure.core.polling.PollingMethod
          :keyword int polling_interval: Default waiting time between two polls for LRO operations if no Retry-After header is present.
          :return: An instance of LROPoller that returns either WorkerPoolResource or the result of cls(response)
          :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.web.v2016_09_01.models.WorkerPoolResource]
          :raises ~azure.core.exceptions.HttpResponseError:
          """
          polling = kwargs.pop('polling', True)  # type: Union[bool, PollingMethod]
          cls = kwargs.pop('cls', None)  # type: ClsType["_models.WorkerPoolResource"]
          lro_delay = kwargs.pop(
              'polling_interval',
              self._config.polling_interval
          )
          cont_token = kwargs.pop('continuation_token', None)  # type: Optional[str]
          if cont_token is None:
              raw_result = self._create_or_update_multi_role_pool_initial(
                  resource_group_name=resource_group_name,
                  name=name,
                  multi_role_pool_envelope=multi_role_pool_envelope,
                  cls=lambda x,y,z: x,
                  **kwargs
              )
  
          kwargs.pop('error_map', None)
          kwargs.pop('content_type', None)
  
          def get_long_running_output(pipeline_response):
              deserialized = self._deserialize('WorkerPoolResource', pipeline_response)
  
              if cls:
                  return cls(pipeline_response, deserialized, {})
              return deserialized
  
          path_format_arguments = {
              'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+[^\.]$'),
              'name': self._serialize.url("name", name, 'str'),
              'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str'),
          }
  
          if polling is True: polling_method = ARMPolling(lro_delay, path_format_arguments=path_format_arguments,  **kwargs)
          elif polling is False: polling_method = NoPolling()
          else: polling_method = polling
          if cont_token:
              return LROPoller.from_continuation_token(
                  polling_method=polling_method,
                  continuation_token=cont_token,
                  client=self._client,
                  deserialization_callback=get_long_running_output
              )
          else:
              return LROPoller(self._client, raw_result, get_long_running_output, polling_method)
      begin_create_or_update_multi_role_pool.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/multiRolePools/default'}  # type: ignore
  
      def update_multi_role_pool(
          self,
          resource_group_name,  # type: str
          name,  # type: str
          multi_role_pool_envelope,  # type: "_models.WorkerPoolResource"
          **kwargs  # type: Any
      ):
          # type: (...) -> Optional["_models.WorkerPoolResource"]
          """Create or update a multi-role pool.
  
          Create or update a multi-role pool.
  
          :param resource_group_name: Name of the resource group to which the resource belongs.
          :type resource_group_name: str
          :param name: Name of the App Service Environment.
          :type name: str
          :param multi_role_pool_envelope: Properties of the multi-role pool.
          :type multi_role_pool_envelope: ~azure.mgmt.web.v2016_09_01.models.WorkerPoolResource
          :keyword callable cls: A custom type or function that will be passed the direct response
          :return: WorkerPoolResource, or the result of cls(response)
          :rtype: ~azure.mgmt.web.v2016_09_01.models.WorkerPoolResource or None
          :raises: ~azure.core.exceptions.HttpResponseError
          """
          cls = kwargs.pop('cls', None)  # type: ClsType[Optional["_models.WorkerPoolResource"]]
          error_map = {
              401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
          }
          error_map.update(kwargs.pop('error_map', {}))
          api_version = "2016-09-01"
          content_type = kwargs.pop("content_type", "application/json")
          accept = "application/json"
  
          # Construct URL
          url = self.update_multi_role_pool.metadata['url']  # type: ignore
          path_format_arguments = {
              'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+[^\.]$'),
              'name': self._serialize.url("name", name, 'str'),
              'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str'),
          }
          url = self._client.format_url(url, **path_format_arguments)
  
          # Construct parameters
          query_parameters = {}  # type: Dict[str, Any]
          query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str')
  
          # Construct headers
          header_parameters = {}  # type: Dict[str, Any]
          header_parameters['Content-Type'] = self._serialize.header("content_type", content_type, 'str')
          header_parameters['Accept'] = self._serialize.header("accept", accept, 'str')
  
          body_content_kwargs = {}  # type: Dict[str, Any]
          body_content = self._serialize.body(multi_role_pool_envelope, 'WorkerPoolResource')
          body_content_kwargs['content'] = body_content
          request = self._client.patch(url, query_parameters, header_parameters, **body_content_kwargs)
          pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs)
          response = pipeline_response.http_response
  
          if response.status_code not in [200, 202, 400, 404, 409]:
              map_error(status_code=response.status_code, response=response, error_map=error_map)
              raise HttpResponseError(response=response, error_format=ARMErrorFormat)
  
          deserialized = None
          if response.status_code == 200:
              deserialized = self._deserialize('WorkerPoolResource', pipeline_response)
  
          if response.status_code == 202:
              deserialized = self._deserialize('WorkerPoolResource', pipeline_response)
  
          if cls:
              return cls(pipeline_response, deserialized, {})
  
          return deserialized
      update_multi_role_pool.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/multiRolePools/default'}  # type: ignore
  
      def list_multi_role_pool_instance_metric_definitions(
          self,
          resource_group_name,  # type: str
          name,  # type: str
          instance,  # type: str
          **kwargs  # type: Any
      ):
          # type: (...) -> Iterable["_models.ResourceMetricDefinitionCollection"]
          """Get metric definitions for a specific instance of a multi-role pool of an App Service Environment.
  
          Get metric definitions for a specific instance of a multi-role pool of an App Service
          Environment.
  
          :param resource_group_name: Name of the resource group to which the resource belongs.
          :type resource_group_name: str
          :param name: Name of the App Service Environment.
          :type name: str
          :param instance: Name of the instance in the multi-role pool.
          :type instance: str
          :keyword callable cls: A custom type or function that will be passed the direct response
          :return: An iterator like instance of either ResourceMetricDefinitionCollection or the result of cls(response)
          :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.web.v2016_09_01.models.ResourceMetricDefinitionCollection]
          :raises: ~azure.core.exceptions.HttpResponseError
          """
          cls = kwargs.pop('cls', None)  # type: ClsType["_models.ResourceMetricDefinitionCollection"]
          error_map = {
              401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
          }
          error_map.update(kwargs.pop('error_map', {}))
          api_version = "2016-09-01"
          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.list_multi_role_pool_instance_metric_definitions.metadata['url']  # type: ignore
                  path_format_arguments = {
                      'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+[^\.]$'),
                      'name': self._serialize.url("name", name, 'str'),
                      'instance': self._serialize.url("instance", instance, 'str'),
                      'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str'),
                  }
                  url = self._client.format_url(url, **path_format_arguments)
                  # 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('ResourceMetricDefinitionCollection', 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]:
                  map_error(status_code=response.status_code, response=response, error_map=error_map)
                  raise HttpResponseError(response=response, error_format=ARMErrorFormat)
  
              return pipeline_response
  
          return ItemPaged(
              get_next, extract_data
          )
      list_multi_role_pool_instance_metric_definitions.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/multiRolePools/default/instances/{instance}/metricdefinitions'}  # type: ignore
  
      def list_multi_role_pool_instance_metrics(
          self,
          resource_group_name,  # type: str
          name,  # type: str
          instance,  # type: str
          details=None,  # type: Optional[bool]
          **kwargs  # type: Any
      ):
          # type: (...) -> Iterable["_models.ResourceMetricCollection"]
          """Get metrics for a specific instance of a multi-role pool of an App Service Environment.
  
          Get metrics for a specific instance of a multi-role pool of an App Service Environment.
  
          :param resource_group_name: Name of the resource group to which the resource belongs.
          :type resource_group_name: str
          :param name: Name of the App Service Environment.
          :type name: str
          :param instance: Name of the instance in the multi-role pool.
          :type instance: str
          :param details: Specify :code:`<code>true</code>` to include instance details. The default is
           :code:`<code>false</code>`.
          :type details: bool
          :keyword callable cls: A custom type or function that will be passed the direct response
          :return: An iterator like instance of either ResourceMetricCollection or the result of cls(response)
          :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.web.v2016_09_01.models.ResourceMetricCollection]
          :raises: ~azure.core.exceptions.HttpResponseError
          """
          cls = kwargs.pop('cls', None)  # type: ClsType["_models.ResourceMetricCollection"]
          error_map = {
              401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
          }
          error_map.update(kwargs.pop('error_map', {}))
          api_version = "2016-09-01"
          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.list_multi_role_pool_instance_metrics.metadata['url']  # type: ignore
                  path_format_arguments = {
                      'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+[^\.]$'),
                      'name': self._serialize.url("name", name, 'str'),
                      'instance': self._serialize.url("instance", instance, 'str'),
                      'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str'),
                  }
                  url = self._client.format_url(url, **path_format_arguments)
                  # Construct parameters
                  query_parameters = {}  # type: Dict[str, Any]
                  if details is not None:
                      query_parameters['details'] = self._serialize.query("details", details, 'bool')
                  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('ResourceMetricCollection', 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]:
                  map_error(status_code=response.status_code, response=response, error_map=error_map)
                  raise HttpResponseError(response=response, error_format=ARMErrorFormat)
  
              return pipeline_response
  
          return ItemPaged(
              get_next, extract_data
          )
      list_multi_role_pool_instance_metrics.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/multiRolePools/default/instances/{instance}/metrics'}  # type: ignore
  
      def list_multi_role_metric_definitions(
          self,
          resource_group_name,  # type: str
          name,  # type: str
          **kwargs  # type: Any
      ):
          # type: (...) -> Iterable["_models.ResourceMetricDefinitionCollection"]
          """Get metric definitions for a multi-role pool of an App Service Environment.
  
          Get metric definitions for a multi-role pool of an App Service Environment.
  
          :param resource_group_name: Name of the resource group to which the resource belongs.
          :type resource_group_name: str
          :param name: Name of the App Service Environment.
          :type name: str
          :keyword callable cls: A custom type or function that will be passed the direct response
          :return: An iterator like instance of either ResourceMetricDefinitionCollection or the result of cls(response)
          :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.web.v2016_09_01.models.ResourceMetricDefinitionCollection]
          :raises: ~azure.core.exceptions.HttpResponseError
          """
          cls = kwargs.pop('cls', None)  # type: ClsType["_models.ResourceMetricDefinitionCollection"]
          error_map = {
              401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
          }
          error_map.update(kwargs.pop('error_map', {}))
          api_version = "2016-09-01"
          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.list_multi_role_metric_definitions.metadata['url']  # type: ignore
                  path_format_arguments = {
                      'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+[^\.]$'),
                      'name': self._serialize.url("name", name, 'str'),
                      'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str'),
                  }
                  url = self._client.format_url(url, **path_format_arguments)
                  # 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('ResourceMetricDefinitionCollection', 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]:
                  map_error(status_code=response.status_code, response=response, error_map=error_map)
                  raise HttpResponseError(response=response, error_format=ARMErrorFormat)
  
              return pipeline_response
  
          return ItemPaged(
              get_next, extract_data
          )
      list_multi_role_metric_definitions.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/multiRolePools/default/metricdefinitions'}  # type: ignore
  
      def list_multi_role_metrics(
          self,
          resource_group_name,  # type: str
          name,  # type: str
          start_time=None,  # type: Optional[str]
          end_time=None,  # type: Optional[str]
          time_grain=None,  # type: Optional[str]
          details=None,  # type: Optional[bool]
          filter=None,  # type: Optional[str]
          **kwargs  # type: Any
      ):
          # type: (...) -> Iterable["_models.ResourceMetricCollection"]
          """Get metrics for a multi-role pool of an App Service Environment.
  
          Get metrics for a multi-role pool of an App Service Environment.
  
          :param resource_group_name: Name of the resource group to which the resource belongs.
          :type resource_group_name: str
          :param name: Name of the App Service Environment.
          :type name: str
          :param start_time: Beginning time of the metrics query.
          :type start_time: str
          :param end_time: End time of the metrics query.
          :type end_time: str
          :param time_grain: Time granularity of the metrics query.
          :type time_grain: str
          :param details: Specify :code:`<code>true</code>` to include instance details. The default is
           :code:`<code>false</code>`.
          :type details: bool
          :param filter: Return only usages/metrics specified in the filter. Filter conforms to odata
           syntax. Example: $filter=(name.value eq 'Metric1' or name.value eq 'Metric2') and startTime eq
           '2014-01-01T00:00:00Z' and endTime eq '2014-12-31T23:59:59Z' and timeGrain eq
           duration'[Hour|Minute|Day]'.
          :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 ResourceMetricCollection or the result of cls(response)
          :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.web.v2016_09_01.models.ResourceMetricCollection]
          :raises: ~azure.core.exceptions.HttpResponseError
          """
          cls = kwargs.pop('cls', None)  # type: ClsType["_models.ResourceMetricCollection"]
          error_map = {
              401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
          }
          error_map.update(kwargs.pop('error_map', {}))
          api_version = "2016-09-01"
          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.list_multi_role_metrics.metadata['url']  # type: ignore
                  path_format_arguments = {
                      'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+[^\.]$'),
                      'name': self._serialize.url("name", name, 'str'),
                      'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str'),
                  }
                  url = self._client.format_url(url, **path_format_arguments)
                  # Construct parameters
                  query_parameters = {}  # type: Dict[str, Any]
                  if start_time is not None:
                      query_parameters['startTime'] = self._serialize.query("start_time", start_time, 'str')
                  if end_time is not None:
                      query_parameters['endTime'] = self._serialize.query("end_time", end_time, 'str')
                  if time_grain is not None:
                      query_parameters['timeGrain'] = self._serialize.query("time_grain", time_grain, 'str')
                  if details is not None:
                      query_parameters['details'] = self._serialize.query("details", details, 'bool')
                  if filter is not None:
                      query_parameters['$filter'] = self._serialize.query("filter", filter, 'str', skip_quote=True)
                  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('ResourceMetricCollection', 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]:
                  map_error(status_code=response.status_code, response=response, error_map=error_map)
                  raise HttpResponseError(response=response, error_format=ARMErrorFormat)
  
              return pipeline_response
  
          return ItemPaged(
              get_next, extract_data
          )
      list_multi_role_metrics.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/multiRolePools/default/metrics'}  # type: ignore
  
      def list_multi_role_pool_skus(
          self,
          resource_group_name,  # type: str
          name,  # type: str
          **kwargs  # type: Any
      ):
          # type: (...) -> Iterable["_models.SkuInfoCollection"]
          """Get available SKUs for scaling a multi-role pool.
  
          Get available SKUs for scaling a multi-role pool.
  
          :param resource_group_name: Name of the resource group to which the resource belongs.
          :type resource_group_name: str
          :param name: Name of the App Service Environment.
          :type name: str
          :keyword callable cls: A custom type or function that will be passed the direct response
          :return: An iterator like instance of either SkuInfoCollection or the result of cls(response)
          :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.web.v2016_09_01.models.SkuInfoCollection]
          :raises: ~azure.core.exceptions.HttpResponseError
          """
          cls = kwargs.pop('cls', None)  # type: ClsType["_models.SkuInfoCollection"]
          error_map = {
              401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
          }
          error_map.update(kwargs.pop('error_map', {}))
          api_version = "2016-09-01"
          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.list_multi_role_pool_skus.metadata['url']  # type: ignore
                  path_format_arguments = {
                      'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+[^\.]$'),
                      'name': self._serialize.url("name", name, 'str'),
                      'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str'),
                  }
                  url = self._client.format_url(url, **path_format_arguments)
                  # 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('SkuInfoCollection', 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]:
                  map_error(status_code=response.status_code, response=response, error_map=error_map)
                  raise HttpResponseError(response=response, error_format=ARMErrorFormat)
  
              return pipeline_response
  
          return ItemPaged(
              get_next, extract_data
          )
      list_multi_role_pool_skus.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/multiRolePools/default/skus'}  # type: ignore
  
      def list_multi_role_usages(
          self,
          resource_group_name,  # type: str
          name,  # type: str
          **kwargs  # type: Any
      ):
          # type: (...) -> Iterable["_models.UsageCollection"]
          """Get usage metrics for a multi-role pool of an App Service Environment.
  
          Get usage metrics for a multi-role pool of an App Service Environment.
  
          :param resource_group_name: Name of the resource group to which the resource belongs.
          :type resource_group_name: str
          :param name: Name of the App Service Environment.
          :type name: str
          :keyword callable cls: A custom type or function that will be passed the direct response
          :return: An iterator like instance of either UsageCollection or the result of cls(response)
          :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.web.v2016_09_01.models.UsageCollection]
          :raises: ~azure.core.exceptions.HttpResponseError
          """
          cls = kwargs.pop('cls', None)  # type: ClsType["_models.UsageCollection"]
          error_map = {
              401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
          }
          error_map.update(kwargs.pop('error_map', {}))
          api_version = "2016-09-01"
          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.list_multi_role_usages.metadata['url']  # type: ignore
                  path_format_arguments = {
                      'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+[^\.]$'),
                      'name': self._serialize.url("name", name, 'str'),
                      'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str'),
                  }
                  url = self._client.format_url(url, **path_format_arguments)
                  # 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('UsageCollection', 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]:
                  map_error(status_code=response.status_code, response=response, error_map=error_map)
                  raise HttpResponseError(response=response, error_format=ARMErrorFormat)
  
              return pipeline_response
  
          return ItemPaged(
              get_next, extract_data
          )
      list_multi_role_usages.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/multiRolePools/default/usages'}  # type: ignore
  
      def list_operations(
          self,
          resource_group_name,  # type: str
          name,  # type: str
          **kwargs  # type: Any
      ):
          # type: (...) -> List["_models.Operation"]
          """List all currently running operations on the App Service Environment.
  
          List all currently running operations on the App Service Environment.
  
          :param resource_group_name: Name of the resource group to which the resource belongs.
          :type resource_group_name: str
          :param name: Name of the App Service Environment.
          :type name: str
          :keyword callable cls: A custom type or function that will be passed the direct response
          :return: list of Operation, or the result of cls(response)
          :rtype: list[~azure.mgmt.web.v2016_09_01.models.Operation]
          :raises: ~azure.core.exceptions.HttpResponseError
          """
          cls = kwargs.pop('cls', None)  # type: ClsType[List["_models.Operation"]]
          error_map = {
              401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
          }
          error_map.update(kwargs.pop('error_map', {}))
          api_version = "2016-09-01"
          accept = "application/json"
  
          # Construct URL
          url = self.list_operations.metadata['url']  # type: ignore
          path_format_arguments = {
              'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+[^\.]$'),
              'name': self._serialize.url("name", name, 'str'),
              'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str'),
          }
          url = self._client.format_url(url, **path_format_arguments)
  
          # Construct parameters
          query_parameters = {}  # type: Dict[str, Any]
          query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str')
  
          # Construct headers
          header_parameters = {}  # type: Dict[str, Any]
          header_parameters['Accept'] = self._serialize.header("accept", accept, 'str')
  
          request = self._client.get(url, query_parameters, header_parameters)
          pipeline_response = self._client._pipeline.run(request, stream=False, **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)
  
          deserialized = self._deserialize('[Operation]', pipeline_response)
  
          if cls:
              return cls(pipeline_response, deserialized, {})
  
          return deserialized
      list_operations.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/operations'}  # type: ignore
  
      def reboot(
          self,
          resource_group_name,  # type: str
          name,  # type: str
          **kwargs  # type: Any
      ):
          # type: (...) -> None
          """Reboot all machines in an App Service Environment.
  
          Reboot all machines in an App Service Environment.
  
          :param resource_group_name: Name of the resource group to which the resource belongs.
          :type resource_group_name: str
          :param name: Name of the App Service Environment.
          :type name: 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
          """
          cls = kwargs.pop('cls', None)  # type: ClsType[None]
          error_map = {
              401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
          }
          error_map.update(kwargs.pop('error_map', {}))
          api_version = "2016-09-01"
  
          # Construct URL
          url = self.reboot.metadata['url']  # type: ignore
          path_format_arguments = {
              'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+[^\.]$'),
              'name': self._serialize.url("name", name, 'str'),
              'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str'),
          }
          url = self._client.format_url(url, **path_format_arguments)
  
          # Construct parameters
          query_parameters = {}  # type: Dict[str, Any]
          query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str')
  
          # Construct headers
          header_parameters = {}  # type: Dict[str, Any]
  
          request = self._client.post(url, query_parameters, header_parameters)
          pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs)
          response = pipeline_response.http_response
  
          if response.status_code not in [202, 400, 404, 409]:
              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, {})
  
      reboot.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/reboot'}  # type: ignore
  
      def _resume_initial(
          self,
          resource_group_name,  # type: str
          name,  # type: str
          **kwargs  # type: Any
      ):
          # type: (...) -> "_models.WebAppCollection"
          cls = kwargs.pop('cls', None)  # type: ClsType["_models.WebAppCollection"]
          error_map = {
              401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
          }
          error_map.update(kwargs.pop('error_map', {}))
          api_version = "2016-09-01"
          accept = "application/json"
  
          # Construct URL
          url = self._resume_initial.metadata['url']  # type: ignore
          path_format_arguments = {
              'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+[^\.]$'),
              'name': self._serialize.url("name", name, 'str'),
              'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str'),
          }
          url = self._client.format_url(url, **path_format_arguments)
  
          # Construct parameters
          query_parameters = {}  # type: Dict[str, Any]
          query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str')
  
          # Construct headers
          header_parameters = {}  # type: Dict[str, Any]
          header_parameters['Accept'] = self._serialize.header("accept", accept, 'str')
  
          request = self._client.post(url, query_parameters, header_parameters)
          pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs)
          response = pipeline_response.http_response
  
          if response.status_code not in [200, 202]:
              map_error(status_code=response.status_code, response=response, error_map=error_map)
              raise HttpResponseError(response=response, error_format=ARMErrorFormat)
  
          if response.status_code == 200:
              deserialized = self._deserialize('WebAppCollection', pipeline_response)
  
          if response.status_code == 202:
              deserialized = self._deserialize('WebAppCollection', pipeline_response)
  
          if cls:
              return cls(pipeline_response, deserialized, {})
  
          return deserialized
      _resume_initial.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/resume'}  # type: ignore
  
      def begin_resume(
          self,
          resource_group_name,  # type: str
          name,  # type: str
          **kwargs  # type: Any
      ):
          # type: (...) -> LROPoller[ItemPaged["_models.WebAppCollection"]]
          """Resume an App Service Environment.
  
          Resume an App Service Environment.
  
          :param resource_group_name: Name of the resource group to which the resource belongs.
          :type resource_group_name: str
          :param name: Name of the App Service Environment.
          :type name: str
          :keyword callable cls: A custom type or function that will be passed the direct response
          :keyword str continuation_token: A continuation token to restart a poller from a saved state.
          :keyword polling: True for ARMPolling, False for no polling, or a
           polling object for personal polling strategy
          :paramtype polling: bool or ~azure.core.polling.PollingMethod
          :keyword int polling_interval: Default waiting time between two polls for LRO operations if no Retry-After header is present.
          :return: An instance of LROPoller that returns an iterator like instance of either WebAppCollection or the result of cls(response)
          :rtype: ~azure.core.polling.LROPoller[~azure.core.paging.ItemPaged[~azure.mgmt.web.v2016_09_01.models.WebAppCollection]]
          :raises ~azure.core.exceptions.HttpResponseError:
          """
          cls = kwargs.pop('cls', None)  # type: ClsType["_models.WebAppCollection"]
          error_map = {
              401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
          }
          error_map.update(kwargs.pop('error_map', {}))
          api_version = "2016-09-01"
          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.resume.metadata['url']  # type: ignore
                  path_format_arguments = {
                      'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+[^\.]$'),
                      'name': self._serialize.url("name", name, 'str'),
                      'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str'),
                  }
                  url = self._client.format_url(url, **path_format_arguments)
                  # Construct parameters
                  query_parameters = {}  # type: Dict[str, Any]
                  query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str')
  
                  request = self._client.post(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('WebAppCollection', 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]:
                  map_error(status_code=response.status_code, response=response, error_map=error_map)
                  raise HttpResponseError(response=response, error_format=ARMErrorFormat)
  
              return pipeline_response
  
          polling = kwargs.pop('polling', True)  # type: Union[bool, PollingMethod]
          cls = kwargs.pop('cls', None)  # type: ClsType["_models.WebAppCollection"]
          lro_delay = kwargs.pop(
              'polling_interval',
              self._config.polling_interval
          )
          cont_token = kwargs.pop('continuation_token', None)  # type: Optional[str]
          if cont_token is None:
              raw_result = self._resume_initial(
                  resource_group_name=resource_group_name,
                  name=name,
                  cls=lambda x,y,z: x,
                  **kwargs
              )
  
          kwargs.pop('error_map', None)
          kwargs.pop('content_type', None)
          def get_long_running_output(pipeline_response):
              def internal_get_next(next_link=None):
                  if next_link is None:
                      return pipeline_response
                  else:
                      return get_next(next_link)
  
              return ItemPaged(
                  internal_get_next, extract_data
              )
          path_format_arguments = {
              'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+[^\.]$'),
              'name': self._serialize.url("name", name, 'str'),
              'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str'),
          }
  
          if polling is True: polling_method = ARMPolling(lro_delay, path_format_arguments=path_format_arguments,  **kwargs)
          elif polling is False: polling_method = NoPolling()
          else: polling_method = polling
          if cont_token:
              return LROPoller.from_continuation_token(
                  polling_method=polling_method,
                  continuation_token=cont_token,
                  client=self._client,
                  deserialization_callback=get_long_running_output
              )
          else:
              return LROPoller(self._client, raw_result, get_long_running_output, polling_method)
      begin_resume.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/resume'}  # type: ignore
  
      def list_app_service_plans(
          self,
          resource_group_name,  # type: str
          name,  # type: str
          **kwargs  # type: Any
      ):
          # type: (...) -> Iterable["_models.AppServicePlanCollection"]
          """Get all App Service plans in an App Service Environment.
  
          Get all App Service plans in an App Service Environment.
  
          :param resource_group_name: Name of the resource group to which the resource belongs.
          :type resource_group_name: str
          :param name: Name of the App Service Environment.
          :type name: str
          :keyword callable cls: A custom type or function that will be passed the direct response
          :return: An iterator like instance of either AppServicePlanCollection or the result of cls(response)
          :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.web.v2016_09_01.models.AppServicePlanCollection]
          :raises: ~azure.core.exceptions.HttpResponseError
          """
          cls = kwargs.pop('cls', None)  # type: ClsType["_models.AppServicePlanCollection"]
          error_map = {
              401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
          }
          error_map.update(kwargs.pop('error_map', {}))
          api_version = "2016-09-01"
          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.list_app_service_plans.metadata['url']  # type: ignore
                  path_format_arguments = {
                      'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+[^\.]$'),
                      'name': self._serialize.url("name", name, 'str'),
                      'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str'),
                  }
                  url = self._client.format_url(url, **path_format_arguments)
                  # 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('AppServicePlanCollection', 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]:
                  map_error(status_code=response.status_code, response=response, error_map=error_map)
                  raise HttpResponseError(response=response, error_format=ARMErrorFormat)
  
              return pipeline_response
  
          return ItemPaged(
              get_next, extract_data
          )
      list_app_service_plans.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/serverfarms'}  # type: ignore
  
      def list_web_apps(
          self,
          resource_group_name,  # type: str
          name,  # type: str
          properties_to_include=None,  # type: Optional[str]
          **kwargs  # type: Any
      ):
          # type: (...) -> Iterable["_models.WebAppCollection"]
          """Get all apps in an App Service Environment.
  
          Get all apps in an App Service Environment.
  
          :param resource_group_name: Name of the resource group to which the resource belongs.
          :type resource_group_name: str
          :param name: Name of the App Service Environment.
          :type name: str
          :param properties_to_include: Comma separated list of app properties to include.
          :type properties_to_include: str
          :keyword callable cls: A custom type or function that will be passed the direct response
          :return: An iterator like instance of either WebAppCollection or the result of cls(response)
          :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.web.v2016_09_01.models.WebAppCollection]
          :raises: ~azure.core.exceptions.HttpResponseError
          """
          cls = kwargs.pop('cls', None)  # type: ClsType["_models.WebAppCollection"]
          error_map = {
              401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
          }
          error_map.update(kwargs.pop('error_map', {}))
          api_version = "2016-09-01"
          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.list_web_apps.metadata['url']  # type: ignore
                  path_format_arguments = {
                      'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+[^\.]$'),
                      'name': self._serialize.url("name", name, 'str'),
                      'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str'),
                  }
                  url = self._client.format_url(url, **path_format_arguments)
                  # Construct parameters
                  query_parameters = {}  # type: Dict[str, Any]
                  if properties_to_include is not None:
                      query_parameters['propertiesToInclude'] = self._serialize.query("properties_to_include", properties_to_include, 'str')
                  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('WebAppCollection', 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]:
                  map_error(status_code=response.status_code, response=response, error_map=error_map)
                  raise HttpResponseError(response=response, error_format=ARMErrorFormat)
  
              return pipeline_response
  
          return ItemPaged(
              get_next, extract_data
          )
      list_web_apps.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/sites'}  # type: ignore
  
      def _suspend_initial(
          self,
          resource_group_name,  # type: str
          name,  # type: str
          **kwargs  # type: Any
      ):
          # type: (...) -> "_models.WebAppCollection"
          cls = kwargs.pop('cls', None)  # type: ClsType["_models.WebAppCollection"]
          error_map = {
              401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
          }
          error_map.update(kwargs.pop('error_map', {}))
          api_version = "2016-09-01"
          accept = "application/json"
  
          # Construct URL
          url = self._suspend_initial.metadata['url']  # type: ignore
          path_format_arguments = {
              'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+[^\.]$'),
              'name': self._serialize.url("name", name, 'str'),
              'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str'),
          }
          url = self._client.format_url(url, **path_format_arguments)
  
          # Construct parameters
          query_parameters = {}  # type: Dict[str, Any]
          query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str')
  
          # Construct headers
          header_parameters = {}  # type: Dict[str, Any]
          header_parameters['Accept'] = self._serialize.header("accept", accept, 'str')
  
          request = self._client.post(url, query_parameters, header_parameters)
          pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs)
          response = pipeline_response.http_response
  
          if response.status_code not in [200, 202]:
              map_error(status_code=response.status_code, response=response, error_map=error_map)
              raise HttpResponseError(response=response, error_format=ARMErrorFormat)
  
          if response.status_code == 200:
              deserialized = self._deserialize('WebAppCollection', pipeline_response)
  
          if response.status_code == 202:
              deserialized = self._deserialize('WebAppCollection', pipeline_response)
  
          if cls:
              return cls(pipeline_response, deserialized, {})
  
          return deserialized
      _suspend_initial.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/suspend'}  # type: ignore
  
      def begin_suspend(
          self,
          resource_group_name,  # type: str
          name,  # type: str
          **kwargs  # type: Any
      ):
          # type: (...) -> LROPoller[ItemPaged["_models.WebAppCollection"]]
          """Suspend an App Service Environment.
  
          Suspend an App Service Environment.
  
          :param resource_group_name: Name of the resource group to which the resource belongs.
          :type resource_group_name: str
          :param name: Name of the App Service Environment.
          :type name: str
          :keyword callable cls: A custom type or function that will be passed the direct response
          :keyword str continuation_token: A continuation token to restart a poller from a saved state.
          :keyword polling: True for ARMPolling, False for no polling, or a
           polling object for personal polling strategy
          :paramtype polling: bool or ~azure.core.polling.PollingMethod
          :keyword int polling_interval: Default waiting time between two polls for LRO operations if no Retry-After header is present.
          :return: An instance of LROPoller that returns an iterator like instance of either WebAppCollection or the result of cls(response)
          :rtype: ~azure.core.polling.LROPoller[~azure.core.paging.ItemPaged[~azure.mgmt.web.v2016_09_01.models.WebAppCollection]]
          :raises ~azure.core.exceptions.HttpResponseError:
          """
          cls = kwargs.pop('cls', None)  # type: ClsType["_models.WebAppCollection"]
          error_map = {
              401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
          }
          error_map.update(kwargs.pop('error_map', {}))
          api_version = "2016-09-01"
          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.suspend.metadata['url']  # type: ignore
                  path_format_arguments = {
                      'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+[^\.]$'),
                      'name': self._serialize.url("name", name, 'str'),
                      'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str'),
                  }
                  url = self._client.format_url(url, **path_format_arguments)
                  # Construct parameters
                  query_parameters = {}  # type: Dict[str, Any]
                  query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str')
  
                  request = self._client.post(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('WebAppCollection', 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]:
                  map_error(status_code=response.status_code, response=response, error_map=error_map)
                  raise HttpResponseError(response=response, error_format=ARMErrorFormat)
  
              return pipeline_response
  
          polling = kwargs.pop('polling', True)  # type: Union[bool, PollingMethod]
          cls = kwargs.pop('cls', None)  # type: ClsType["_models.WebAppCollection"]
          lro_delay = kwargs.pop(
              'polling_interval',
              self._config.polling_interval
          )
          cont_token = kwargs.pop('continuation_token', None)  # type: Optional[str]
          if cont_token is None:
              raw_result = self._suspend_initial(
                  resource_group_name=resource_group_name,
                  name=name,
                  cls=lambda x,y,z: x,
                  **kwargs
              )
  
          kwargs.pop('error_map', None)
          kwargs.pop('content_type', None)
          def get_long_running_output(pipeline_response):
              def internal_get_next(next_link=None):
                  if next_link is None:
                      return pipeline_response
                  else:
                      return get_next(next_link)
  
              return ItemPaged(
                  internal_get_next, extract_data
              )
          path_format_arguments = {
              'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+[^\.]$'),
              'name': self._serialize.url("name", name, 'str'),
              'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str'),
          }
  
          if polling is True: polling_method = ARMPolling(lro_delay, path_format_arguments=path_format_arguments,  **kwargs)
          elif polling is False: polling_method = NoPolling()
          else: polling_method = polling
          if cont_token:
              return LROPoller.from_continuation_token(
                  polling_method=polling_method,
                  continuation_token=cont_token,
                  client=self._client,
                  deserialization_callback=get_long_running_output
              )
          else:
              return LROPoller(self._client, raw_result, get_long_running_output, polling_method)
      begin_suspend.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/suspend'}  # type: ignore
  
      def list_usages(
          self,
          resource_group_name,  # type: str
          name,  # type: str
          filter=None,  # type: Optional[str]
          **kwargs  # type: Any
      ):
          # type: (...) -> Iterable["_models.CsmUsageQuotaCollection"]
          """Get global usage metrics of an App Service Environment.
  
          Get global usage metrics of an App Service Environment.
  
          :param resource_group_name: Name of the resource group to which the resource belongs.
          :type resource_group_name: str
          :param name: Name of the App Service Environment.
          :type name: str
          :param filter: Return only usages/metrics specified in the filter. Filter conforms to odata
           syntax. Example: $filter=(name.value eq 'Metric1' or name.value eq 'Metric2') and startTime eq
           '2014-01-01T00:00:00Z' and endTime eq '2014-12-31T23:59:59Z' and timeGrain eq
           duration'[Hour|Minute|Day]'.
          :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 CsmUsageQuotaCollection or the result of cls(response)
          :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.web.v2016_09_01.models.CsmUsageQuotaCollection]
          :raises: ~azure.core.exceptions.HttpResponseError
          """
          cls = kwargs.pop('cls', None)  # type: ClsType["_models.CsmUsageQuotaCollection"]
          error_map = {
              401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
          }
          error_map.update(kwargs.pop('error_map', {}))
          api_version = "2016-09-01"
          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.list_usages.metadata['url']  # type: ignore
                  path_format_arguments = {
                      'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+[^\.]$'),
                      'name': self._serialize.url("name", name, 'str'),
                      'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str'),
                  }
                  url = self._client.format_url(url, **path_format_arguments)
                  # Construct parameters
                  query_parameters = {}  # type: Dict[str, Any]
                  if filter is not None:
                      query_parameters['$filter'] = self._serialize.query("filter", filter, 'str', skip_quote=True)
                  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('CsmUsageQuotaCollection', 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]:
                  map_error(status_code=response.status_code, response=response, error_map=error_map)
                  raise HttpResponseError(response=response, error_format=ARMErrorFormat)
  
              return pipeline_response
  
          return ItemPaged(
              get_next, extract_data
          )
      list_usages.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/usages'}  # type: ignore
  
      def list_worker_pools(
          self,
          resource_group_name,  # type: str
          name,  # type: str
          **kwargs  # type: Any
      ):
          # type: (...) -> Iterable["_models.WorkerPoolCollection"]
          """Get all worker pools of an App Service Environment.
  
          Get all worker pools of an App Service Environment.
  
          :param resource_group_name: Name of the resource group to which the resource belongs.
          :type resource_group_name: str
          :param name: Name of the App Service Environment.
          :type name: str
          :keyword callable cls: A custom type or function that will be passed the direct response
          :return: An iterator like instance of either WorkerPoolCollection or the result of cls(response)
          :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.web.v2016_09_01.models.WorkerPoolCollection]
          :raises: ~azure.core.exceptions.HttpResponseError
          """
          cls = kwargs.pop('cls', None)  # type: ClsType["_models.WorkerPoolCollection"]
          error_map = {
              401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
          }
          error_map.update(kwargs.pop('error_map', {}))
          api_version = "2016-09-01"
          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.list_worker_pools.metadata['url']  # type: ignore
                  path_format_arguments = {
                      'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+[^\.]$'),
                      'name': self._serialize.url("name", name, 'str'),
                      'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str'),
                  }
                  url = self._client.format_url(url, **path_format_arguments)
                  # 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('WorkerPoolCollection', 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]:
                  map_error(status_code=response.status_code, response=response, error_map=error_map)
                  raise HttpResponseError(response=response, error_format=ARMErrorFormat)
  
              return pipeline_response
  
          return ItemPaged(
              get_next, extract_data
          )
      list_worker_pools.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/workerPools'}  # type: ignore
  
      def get_worker_pool(
          self,
          resource_group_name,  # type: str
          name,  # type: str
          worker_pool_name,  # type: str
          **kwargs  # type: Any
      ):
          # type: (...) -> "_models.WorkerPoolResource"
          """Get properties of a worker pool.
  
          Get properties of a worker pool.
  
          :param resource_group_name: Name of the resource group to which the resource belongs.
          :type resource_group_name: str
          :param name: Name of the App Service Environment.
          :type name: str
          :param worker_pool_name: Name of the worker pool.
          :type worker_pool_name: str
          :keyword callable cls: A custom type or function that will be passed the direct response
          :return: WorkerPoolResource, or the result of cls(response)
          :rtype: ~azure.mgmt.web.v2016_09_01.models.WorkerPoolResource
          :raises: ~azure.core.exceptions.HttpResponseError
          """
          cls = kwargs.pop('cls', None)  # type: ClsType["_models.WorkerPoolResource"]
          error_map = {
              401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
          }
          error_map.update(kwargs.pop('error_map', {}))
          api_version = "2016-09-01"
          accept = "application/json"
  
          # Construct URL
          url = self.get_worker_pool.metadata['url']  # type: ignore
          path_format_arguments = {
              'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+[^\.]$'),
              'name': self._serialize.url("name", name, 'str'),
              'workerPoolName': self._serialize.url("worker_pool_name", worker_pool_name, 'str'),
              'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str'),
          }
          url = self._client.format_url(url, **path_format_arguments)
  
          # Construct parameters
          query_parameters = {}  # type: Dict[str, Any]
          query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str')
  
          # Construct headers
          header_parameters = {}  # type: Dict[str, Any]
          header_parameters['Accept'] = self._serialize.header("accept", accept, 'str')
  
          request = self._client.get(url, query_parameters, header_parameters)
          pipeline_response = self._client._pipeline.run(request, stream=False, **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)
  
          deserialized = self._deserialize('WorkerPoolResource', pipeline_response)
  
          if cls:
              return cls(pipeline_response, deserialized, {})
  
          return deserialized
      get_worker_pool.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/workerPools/{workerPoolName}'}  # type: ignore
  
      def _create_or_update_worker_pool_initial(
          self,
          resource_group_name,  # type: str
          name,  # type: str
          worker_pool_name,  # type: str
          worker_pool_envelope,  # type: "_models.WorkerPoolResource"
          **kwargs  # type: Any
      ):
          # type: (...) -> Optional["_models.WorkerPoolResource"]
          cls = kwargs.pop('cls', None)  # type: ClsType[Optional["_models.WorkerPoolResource"]]
          error_map = {
              401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
          }
          error_map.update(kwargs.pop('error_map', {}))
          api_version = "2016-09-01"
          content_type = kwargs.pop("content_type", "application/json")
          accept = "application/json"
  
          # Construct URL
          url = self._create_or_update_worker_pool_initial.metadata['url']  # type: ignore
          path_format_arguments = {
              'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+[^\.]$'),
              'name': self._serialize.url("name", name, 'str'),
              'workerPoolName': self._serialize.url("worker_pool_name", worker_pool_name, 'str'),
              'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str'),
          }
          url = self._client.format_url(url, **path_format_arguments)
  
          # Construct parameters
          query_parameters = {}  # type: Dict[str, Any]
          query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str')
  
          # Construct headers
          header_parameters = {}  # type: Dict[str, Any]
          header_parameters['Content-Type'] = self._serialize.header("content_type", content_type, 'str')
          header_parameters['Accept'] = self._serialize.header("accept", accept, 'str')
  
          body_content_kwargs = {}  # type: Dict[str, Any]
          body_content = self._serialize.body(worker_pool_envelope, 'WorkerPoolResource')
          body_content_kwargs['content'] = body_content
          request = self._client.put(url, query_parameters, header_parameters, **body_content_kwargs)
          pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs)
          response = pipeline_response.http_response
  
          if response.status_code not in [200, 202, 400, 404, 409]:
              map_error(status_code=response.status_code, response=response, error_map=error_map)
              raise HttpResponseError(response=response, error_format=ARMErrorFormat)
  
          deserialized = None
          if response.status_code == 200:
              deserialized = self._deserialize('WorkerPoolResource', pipeline_response)
  
          if response.status_code == 202:
              deserialized = self._deserialize('WorkerPoolResource', pipeline_response)
  
          if cls:
              return cls(pipeline_response, deserialized, {})
  
          return deserialized
      _create_or_update_worker_pool_initial.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/workerPools/{workerPoolName}'}  # type: ignore
  
      def begin_create_or_update_worker_pool(
          self,
          resource_group_name,  # type: str
          name,  # type: str
          worker_pool_name,  # type: str
          worker_pool_envelope,  # type: "_models.WorkerPoolResource"
          **kwargs  # type: Any
      ):
          # type: (...) -> LROPoller["_models.WorkerPoolResource"]
          """Create or update a worker pool.
  
          Create or update a worker pool.
  
          :param resource_group_name: Name of the resource group to which the resource belongs.
          :type resource_group_name: str
          :param name: Name of the App Service Environment.
          :type name: str
          :param worker_pool_name: Name of the worker pool.
          :type worker_pool_name: str
          :param worker_pool_envelope: Properties of the worker pool.
          :type worker_pool_envelope: ~azure.mgmt.web.v2016_09_01.models.WorkerPoolResource
          :keyword callable cls: A custom type or function that will be passed the direct response
          :keyword str continuation_token: A continuation token to restart a poller from a saved state.
          :keyword polling: True for ARMPolling, False for no polling, or a
           polling object for personal polling strategy
          :paramtype polling: bool or ~azure.core.polling.PollingMethod
          :keyword int polling_interval: Default waiting time between two polls for LRO operations if no Retry-After header is present.
          :return: An instance of LROPoller that returns either WorkerPoolResource or the result of cls(response)
          :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.web.v2016_09_01.models.WorkerPoolResource]
          :raises ~azure.core.exceptions.HttpResponseError:
          """
          polling = kwargs.pop('polling', True)  # type: Union[bool, PollingMethod]
          cls = kwargs.pop('cls', None)  # type: ClsType["_models.WorkerPoolResource"]
          lro_delay = kwargs.pop(
              'polling_interval',
              self._config.polling_interval
          )
          cont_token = kwargs.pop('continuation_token', None)  # type: Optional[str]
          if cont_token is None:
              raw_result = self._create_or_update_worker_pool_initial(
                  resource_group_name=resource_group_name,
                  name=name,
                  worker_pool_name=worker_pool_name,
                  worker_pool_envelope=worker_pool_envelope,
                  cls=lambda x,y,z: x,
                  **kwargs
              )
  
          kwargs.pop('error_map', None)
          kwargs.pop('content_type', None)
  
          def get_long_running_output(pipeline_response):
              deserialized = self._deserialize('WorkerPoolResource', pipeline_response)
  
              if cls:
                  return cls(pipeline_response, deserialized, {})
              return deserialized
  
          path_format_arguments = {
              'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+[^\.]$'),
              'name': self._serialize.url("name", name, 'str'),
              'workerPoolName': self._serialize.url("worker_pool_name", worker_pool_name, 'str'),
              'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str'),
          }
  
          if polling is True: polling_method = ARMPolling(lro_delay, path_format_arguments=path_format_arguments,  **kwargs)
          elif polling is False: polling_method = NoPolling()
          else: polling_method = polling
          if cont_token:
              return LROPoller.from_continuation_token(
                  polling_method=polling_method,
                  continuation_token=cont_token,
                  client=self._client,
                  deserialization_callback=get_long_running_output
              )
          else:
              return LROPoller(self._client, raw_result, get_long_running_output, polling_method)
      begin_create_or_update_worker_pool.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/workerPools/{workerPoolName}'}  # type: ignore
  
      def update_worker_pool(
          self,
          resource_group_name,  # type: str
          name,  # type: str
          worker_pool_name,  # type: str
          worker_pool_envelope,  # type: "_models.WorkerPoolResource"
          **kwargs  # type: Any
      ):
          # type: (...) -> Optional["_models.WorkerPoolResource"]
          """Create or update a worker pool.
  
          Create or update a worker pool.
  
          :param resource_group_name: Name of the resource group to which the resource belongs.
          :type resource_group_name: str
          :param name: Name of the App Service Environment.
          :type name: str
          :param worker_pool_name: Name of the worker pool.
          :type worker_pool_name: str
          :param worker_pool_envelope: Properties of the worker pool.
          :type worker_pool_envelope: ~azure.mgmt.web.v2016_09_01.models.WorkerPoolResource
          :keyword callable cls: A custom type or function that will be passed the direct response
          :return: WorkerPoolResource, or the result of cls(response)
          :rtype: ~azure.mgmt.web.v2016_09_01.models.WorkerPoolResource or None
          :raises: ~azure.core.exceptions.HttpResponseError
          """
          cls = kwargs.pop('cls', None)  # type: ClsType[Optional["_models.WorkerPoolResource"]]
          error_map = {
              401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
          }
          error_map.update(kwargs.pop('error_map', {}))
          api_version = "2016-09-01"
          content_type = kwargs.pop("content_type", "application/json")
          accept = "application/json"
  
          # Construct URL
          url = self.update_worker_pool.metadata['url']  # type: ignore
          path_format_arguments = {
              'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+[^\.]$'),
              'name': self._serialize.url("name", name, 'str'),
              'workerPoolName': self._serialize.url("worker_pool_name", worker_pool_name, 'str'),
              'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str'),
          }
          url = self._client.format_url(url, **path_format_arguments)
  
          # Construct parameters
          query_parameters = {}  # type: Dict[str, Any]
          query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str')
  
          # Construct headers
          header_parameters = {}  # type: Dict[str, Any]
          header_parameters['Content-Type'] = self._serialize.header("content_type", content_type, 'str')
          header_parameters['Accept'] = self._serialize.header("accept", accept, 'str')
  
          body_content_kwargs = {}  # type: Dict[str, Any]
          body_content = self._serialize.body(worker_pool_envelope, 'WorkerPoolResource')
          body_content_kwargs['content'] = body_content
          request = self._client.patch(url, query_parameters, header_parameters, **body_content_kwargs)
          pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs)
          response = pipeline_response.http_response
  
          if response.status_code not in [200, 202, 400, 404, 409]:
              map_error(status_code=response.status_code, response=response, error_map=error_map)
              raise HttpResponseError(response=response, error_format=ARMErrorFormat)
  
          deserialized = None
          if response.status_code == 200:
              deserialized = self._deserialize('WorkerPoolResource', pipeline_response)
  
          if response.status_code == 202:
              deserialized = self._deserialize('WorkerPoolResource', pipeline_response)
  
          if cls:
              return cls(pipeline_response, deserialized, {})
  
          return deserialized
      update_worker_pool.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/workerPools/{workerPoolName}'}  # type: ignore
  
      def list_worker_pool_instance_metric_definitions(
          self,
          resource_group_name,  # type: str
          name,  # type: str
          worker_pool_name,  # type: str
          instance,  # type: str
          **kwargs  # type: Any
      ):
          # type: (...) -> Iterable["_models.ResourceMetricDefinitionCollection"]
          """Get metric definitions for a specific instance of a worker pool of an App Service Environment.
  
          Get metric definitions for a specific instance of a worker pool of an App Service Environment.
  
          :param resource_group_name: Name of the resource group to which the resource belongs.
          :type resource_group_name: str
          :param name: Name of the App Service Environment.
          :type name: str
          :param worker_pool_name: Name of the worker pool.
          :type worker_pool_name: str
          :param instance: Name of the instance in the worker pool.
          :type instance: str
          :keyword callable cls: A custom type or function that will be passed the direct response
          :return: An iterator like instance of either ResourceMetricDefinitionCollection or the result of cls(response)
          :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.web.v2016_09_01.models.ResourceMetricDefinitionCollection]
          :raises: ~azure.core.exceptions.HttpResponseError
          """
          cls = kwargs.pop('cls', None)  # type: ClsType["_models.ResourceMetricDefinitionCollection"]
          error_map = {
              401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
          }
          error_map.update(kwargs.pop('error_map', {}))
          api_version = "2016-09-01"
          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.list_worker_pool_instance_metric_definitions.metadata['url']  # type: ignore
                  path_format_arguments = {
                      'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+[^\.]$'),
                      'name': self._serialize.url("name", name, 'str'),
                      'workerPoolName': self._serialize.url("worker_pool_name", worker_pool_name, 'str'),
                      'instance': self._serialize.url("instance", instance, 'str'),
                      'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str'),
                  }
                  url = self._client.format_url(url, **path_format_arguments)
                  # 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('ResourceMetricDefinitionCollection', 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]:
                  map_error(status_code=response.status_code, response=response, error_map=error_map)
                  raise HttpResponseError(response=response, error_format=ARMErrorFormat)
  
              return pipeline_response
  
          return ItemPaged(
              get_next, extract_data
          )
      list_worker_pool_instance_metric_definitions.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/workerPools/{workerPoolName}/instances/{instance}/metricdefinitions'}  # type: ignore
  
      def list_worker_pool_instance_metrics(
          self,
          resource_group_name,  # type: str
          name,  # type: str
          worker_pool_name,  # type: str
          instance,  # type: str
          details=None,  # type: Optional[bool]
          filter=None,  # type: Optional[str]
          **kwargs  # type: Any
      ):
          # type: (...) -> Iterable["_models.ResourceMetricCollection"]
          """Get metrics for a specific instance of a worker pool of an App Service Environment.
  
          Get metrics for a specific instance of a worker pool of an App Service Environment.
  
          :param resource_group_name: Name of the resource group to which the resource belongs.
          :type resource_group_name: str
          :param name: Name of the App Service Environment.
          :type name: str
          :param worker_pool_name: Name of the worker pool.
          :type worker_pool_name: str
          :param instance: Name of the instance in the worker pool.
          :type instance: str
          :param details: Specify :code:`<code>true</code>` to include instance details. The default is
           :code:`<code>false</code>`.
          :type details: bool
          :param filter: Return only usages/metrics specified in the filter. Filter conforms to odata
           syntax. Example: $filter=(name.value eq 'Metric1' or name.value eq 'Metric2') and startTime eq
           '2014-01-01T00:00:00Z' and endTime eq '2014-12-31T23:59:59Z' and timeGrain eq
           duration'[Hour|Minute|Day]'.
          :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 ResourceMetricCollection or the result of cls(response)
          :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.web.v2016_09_01.models.ResourceMetricCollection]
          :raises: ~azure.core.exceptions.HttpResponseError
          """
          cls = kwargs.pop('cls', None)  # type: ClsType["_models.ResourceMetricCollection"]
          error_map = {
              401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
          }
          error_map.update(kwargs.pop('error_map', {}))
          api_version = "2016-09-01"
          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.list_worker_pool_instance_metrics.metadata['url']  # type: ignore
                  path_format_arguments = {
                      'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+[^\.]$'),
                      'name': self._serialize.url("name", name, 'str'),
                      'workerPoolName': self._serialize.url("worker_pool_name", worker_pool_name, 'str'),
                      'instance': self._serialize.url("instance", instance, 'str'),
                      'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str'),
                  }
                  url = self._client.format_url(url, **path_format_arguments)
                  # Construct parameters
                  query_parameters = {}  # type: Dict[str, Any]
                  if details is not None:
                      query_parameters['details'] = self._serialize.query("details", details, 'bool')
                  if filter is not None:
                      query_parameters['$filter'] = self._serialize.query("filter", filter, 'str', skip_quote=True)
                  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('ResourceMetricCollection', 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]:
                  map_error(status_code=response.status_code, response=response, error_map=error_map)
                  raise HttpResponseError(response=response, error_format=ARMErrorFormat)
  
              return pipeline_response
  
          return ItemPaged(
              get_next, extract_data
          )
      list_worker_pool_instance_metrics.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/workerPools/{workerPoolName}/instances/{instance}/metrics'}  # type: ignore
  
      def list_web_worker_metric_definitions(
          self,
          resource_group_name,  # type: str
          name,  # type: str
          worker_pool_name,  # type: str
          **kwargs  # type: Any
      ):
          # type: (...) -> Iterable["_models.ResourceMetricDefinitionCollection"]
          """Get metric definitions for a worker pool of an App Service Environment.
  
          Get metric definitions for a worker pool of an App Service Environment.
  
          :param resource_group_name: Name of the resource group to which the resource belongs.
          :type resource_group_name: str
          :param name: Name of the App Service Environment.
          :type name: str
          :param worker_pool_name: Name of the worker pool.
          :type worker_pool_name: str
          :keyword callable cls: A custom type or function that will be passed the direct response
          :return: An iterator like instance of either ResourceMetricDefinitionCollection or the result of cls(response)
          :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.web.v2016_09_01.models.ResourceMetricDefinitionCollection]
          :raises: ~azure.core.exceptions.HttpResponseError
          """
          cls = kwargs.pop('cls', None)  # type: ClsType["_models.ResourceMetricDefinitionCollection"]
          error_map = {
              401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
          }
          error_map.update(kwargs.pop('error_map', {}))
          api_version = "2016-09-01"
          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.list_web_worker_metric_definitions.metadata['url']  # type: ignore
                  path_format_arguments = {
                      'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+[^\.]$'),
                      'name': self._serialize.url("name", name, 'str'),
                      'workerPoolName': self._serialize.url("worker_pool_name", worker_pool_name, 'str'),
                      'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str'),
                  }
                  url = self._client.format_url(url, **path_format_arguments)
                  # 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('ResourceMetricDefinitionCollection', 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]:
                  map_error(status_code=response.status_code, response=response, error_map=error_map)
                  raise HttpResponseError(response=response, error_format=ARMErrorFormat)
  
              return pipeline_response
  
          return ItemPaged(
              get_next, extract_data
          )
      list_web_worker_metric_definitions.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/workerPools/{workerPoolName}/metricdefinitions'}  # type: ignore
  
      def list_web_worker_metrics(
          self,
          resource_group_name,  # type: str
          name,  # type: str
          worker_pool_name,  # type: str
          details=None,  # type: Optional[bool]
          filter=None,  # type: Optional[str]
          **kwargs  # type: Any
      ):
          # type: (...) -> Iterable["_models.ResourceMetricCollection"]
          """Get metrics for a worker pool of a AppServiceEnvironment (App Service Environment).
  
          Get metrics for a worker pool of a AppServiceEnvironment (App Service Environment).
  
          :param resource_group_name: Name of the resource group to which the resource belongs.
          :type resource_group_name: str
          :param name: Name of the App Service Environment.
          :type name: str
          :param worker_pool_name: Name of worker pool.
          :type worker_pool_name: str
          :param details: Specify :code:`<code>true</code>` to include instance details. The default is
           :code:`<code>false</code>`.
          :type details: bool
          :param filter: Return only usages/metrics specified in the filter. Filter conforms to odata
           syntax. Example: $filter=(name.value eq 'Metric1' or name.value eq 'Metric2') and startTime eq
           '2014-01-01T00:00:00Z' and endTime eq '2014-12-31T23:59:59Z' and timeGrain eq
           duration'[Hour|Minute|Day]'.
          :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 ResourceMetricCollection or the result of cls(response)
          :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.web.v2016_09_01.models.ResourceMetricCollection]
          :raises: ~azure.core.exceptions.HttpResponseError
          """
          cls = kwargs.pop('cls', None)  # type: ClsType["_models.ResourceMetricCollection"]
          error_map = {
              401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
          }
          error_map.update(kwargs.pop('error_map', {}))
          api_version = "2016-09-01"
          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.list_web_worker_metrics.metadata['url']  # type: ignore
                  path_format_arguments = {
                      'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+[^\.]$'),
                      'name': self._serialize.url("name", name, 'str'),
                      'workerPoolName': self._serialize.url("worker_pool_name", worker_pool_name, 'str'),
                      'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str'),
                  }
                  url = self._client.format_url(url, **path_format_arguments)
                  # Construct parameters
                  query_parameters = {}  # type: Dict[str, Any]
                  if details is not None:
                      query_parameters['details'] = self._serialize.query("details", details, 'bool')
                  if filter is not None:
                      query_parameters['$filter'] = self._serialize.query("filter", filter, 'str', skip_quote=True)
                  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('ResourceMetricCollection', 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]:
                  map_error(status_code=response.status_code, response=response, error_map=error_map)
                  raise HttpResponseError(response=response, error_format=ARMErrorFormat)
  
              return pipeline_response
  
          return ItemPaged(
              get_next, extract_data
          )
      list_web_worker_metrics.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/workerPools/{workerPoolName}/metrics'}  # type: ignore
  
      def list_worker_pool_skus(
          self,
          resource_group_name,  # type: str
          name,  # type: str
          worker_pool_name,  # type: str
          **kwargs  # type: Any
      ):
          # type: (...) -> Iterable["_models.SkuInfoCollection"]
          """Get available SKUs for scaling a worker pool.
  
          Get available SKUs for scaling a worker pool.
  
          :param resource_group_name: Name of the resource group to which the resource belongs.
          :type resource_group_name: str
          :param name: Name of the App Service Environment.
          :type name: str
          :param worker_pool_name: Name of the worker pool.
          :type worker_pool_name: str
          :keyword callable cls: A custom type or function that will be passed the direct response
          :return: An iterator like instance of either SkuInfoCollection or the result of cls(response)
          :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.web.v2016_09_01.models.SkuInfoCollection]
          :raises: ~azure.core.exceptions.HttpResponseError
          """
          cls = kwargs.pop('cls', None)  # type: ClsType["_models.SkuInfoCollection"]
          error_map = {
              401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
          }
          error_map.update(kwargs.pop('error_map', {}))
          api_version = "2016-09-01"
          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.list_worker_pool_skus.metadata['url']  # type: ignore
                  path_format_arguments = {
                      'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+[^\.]$'),
                      'name': self._serialize.url("name", name, 'str'),
                      'workerPoolName': self._serialize.url("worker_pool_name", worker_pool_name, 'str'),
                      'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str'),
                  }
                  url = self._client.format_url(url, **path_format_arguments)
                  # 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('SkuInfoCollection', 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]:
                  map_error(status_code=response.status_code, response=response, error_map=error_map)
                  raise HttpResponseError(response=response, error_format=ARMErrorFormat)
  
              return pipeline_response
  
          return ItemPaged(
              get_next, extract_data
          )
      list_worker_pool_skus.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/workerPools/{workerPoolName}/skus'}  # type: ignore
  
      def list_web_worker_usages(
          self,
          resource_group_name,  # type: str
          name,  # type: str
          worker_pool_name,  # type: str
          **kwargs  # type: Any
      ):
          # type: (...) -> Iterable["_models.UsageCollection"]
          """Get usage metrics for a worker pool of an App Service Environment.
  
          Get usage metrics for a worker pool of an App Service Environment.
  
          :param resource_group_name: Name of the resource group to which the resource belongs.
          :type resource_group_name: str
          :param name: Name of the App Service Environment.
          :type name: str
          :param worker_pool_name: Name of the worker pool.
          :type worker_pool_name: str
          :keyword callable cls: A custom type or function that will be passed the direct response
          :return: An iterator like instance of either UsageCollection or the result of cls(response)
          :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.web.v2016_09_01.models.UsageCollection]
          :raises: ~azure.core.exceptions.HttpResponseError
          """
          cls = kwargs.pop('cls', None)  # type: ClsType["_models.UsageCollection"]
          error_map = {
              401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
          }
          error_map.update(kwargs.pop('error_map', {}))
          api_version = "2016-09-01"
          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.list_web_worker_usages.metadata['url']  # type: ignore
                  path_format_arguments = {
                      'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+[^\.]$'),
                      'name': self._serialize.url("name", name, 'str'),
                      'workerPoolName': self._serialize.url("worker_pool_name", worker_pool_name, 'str'),
                      'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str'),
                  }
                  url = self._client.format_url(url, **path_format_arguments)
                  # 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('UsageCollection', 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]:
                  map_error(status_code=response.status_code, response=response, error_map=error_map)
                  raise HttpResponseError(response=response, error_format=ARMErrorFormat)
  
              return pipeline_response
  
          return ItemPaged(
              get_next, extract_data
          )
      list_web_worker_usages.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/hostingEnvironments/{name}/workerPools/{workerPoolName}/usages'}  # type: ignore
  