text: # pylint: disable=too-many-lines
  # 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 Any, AsyncIterable, Callable, Dict, Optional, TypeVar, Union
  
  from azure.core.async_paging import AsyncItemPaged, AsyncList
  from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error
  from azure.core.pipeline import PipelineResponse
  from azure.core.pipeline.transport import AsyncHttpResponse
  from azure.core.polling import AsyncLROPoller, AsyncNoPolling, AsyncPollingMethod
  from azure.core.rest import HttpRequest
  from azure.core.tracing.decorator import distributed_trace
  from azure.core.tracing.decorator_async import distributed_trace_async
  from azure.mgmt.core.exceptions import ARMErrorFormat
  from azure.mgmt.core.polling.async_arm_polling import AsyncARMPolling
  
  from ... import models as _models
  from ..._vendor import _convert_request
  from ...operations._virtual_machines_operations import build_assess_patches_request_initial, build_capture_request_initial, build_convert_to_managed_disks_request_initial, build_create_or_update_request_initial, build_deallocate_request_initial, build_delete_request_initial, build_generalize_request, build_get_request, build_install_patches_request_initial, build_instance_view_request, build_list_all_request, build_list_available_sizes_request, build_list_by_location_request, build_list_request, build_perform_maintenance_request_initial, build_power_off_request_initial, build_reapply_request_initial, build_redeploy_request_initial, build_reimage_request_initial, build_restart_request_initial, build_retrieve_boot_diagnostics_data_request, build_run_command_request_initial, build_simulate_eviction_request, build_start_request_initial, build_update_request_initial
  T = TypeVar('T')
  ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]]
  
  class VirtualMachinesOperations:  # pylint: disable=too-many-public-methods
      """VirtualMachinesOperations async 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.compute.v2021_03_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) -> None:
          self._client = client
          self._serialize = serializer
          self._deserialize = deserializer
          self._config = config
  
      @distributed_trace
      def list_by_location(
          self,
          location: str,
          **kwargs: Any
      ) -> AsyncIterable["_models.VirtualMachineListResult"]:
          """Gets all the virtual machines under the specified subscription for the specified location.
  
          :param location: The location for which virtual machines under the subscription are queried.
          :type location: str
          :keyword callable cls: A custom type or function that will be passed the direct response
          :return: An iterator like instance of either VirtualMachineListResult or the result of
           cls(response)
          :rtype:
           ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.compute.v2021_03_01.models.VirtualMachineListResult]
          :raises: ~azure.core.exceptions.HttpResponseError
          """
          api_version = kwargs.pop('api_version', "2021-03-01")  # type: str
  
          cls = kwargs.pop('cls', None)  # type: ClsType["_models.VirtualMachineListResult"]
          error_map = {
              401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
          }
          error_map.update(kwargs.pop('error_map', {}))
          def prepare_request(next_link=None):
              if not next_link:
                  
                  request = build_list_by_location_request(
                      location=location,
                      subscription_id=self._config.subscription_id,
                      api_version=api_version,
                      template_url=self.list_by_location.metadata['url'],
                  )
                  request = _convert_request(request)
                  request.url = self._client.format_url(request.url)
  
              else:
                  
                  request = build_list_by_location_request(
                      location=location,
                      subscription_id=self._config.subscription_id,
                      api_version=api_version,
                      template_url=next_link,
                  )
                  request = _convert_request(request)
                  request.url = self._client.format_url(request.url)
                  request.method = "GET"
              return request
  
          async def extract_data(pipeline_response):
              deserialized = self._deserialize("VirtualMachineListResult", pipeline_response)
              list_of_elem = deserialized.value
              if cls:
                  list_of_elem = cls(list_of_elem)
              return deserialized.next_link or None, AsyncList(list_of_elem)
  
          async def get_next(next_link=None):
              request = prepare_request(next_link)
  
              pipeline_response = await self._client._pipeline.run(  # pylint: disable=protected-access
                  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 AsyncItemPaged(
              get_next, extract_data
          )
      list_by_location.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.Compute/locations/{location}/virtualMachines"}  # type: ignore
  
      async def _capture_initial(
          self,
          resource_group_name: str,
          vm_name: str,
          parameters: "_models.VirtualMachineCaptureParameters",
          **kwargs: Any
      ) -> Optional["_models.VirtualMachineCaptureResult"]:
          cls = kwargs.pop('cls', None)  # type: ClsType[Optional["_models.VirtualMachineCaptureResult"]]
          error_map = {
              401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
          }
          error_map.update(kwargs.pop('error_map', {}))
  
          api_version = kwargs.pop('api_version', "2021-03-01")  # type: str
          content_type = kwargs.pop('content_type', "application/json")  # type: Optional[str]
  
          _json = self._serialize.body(parameters, 'VirtualMachineCaptureParameters')
  
          request = build_capture_request_initial(
              resource_group_name=resource_group_name,
              vm_name=vm_name,
              subscription_id=self._config.subscription_id,
              api_version=api_version,
              content_type=content_type,
              json=_json,
              template_url=self._capture_initial.metadata['url'],
          )
          request = _convert_request(request)
          request.url = self._client.format_url(request.url)
  
          pipeline_response = await self._client._pipeline.run(  # pylint: disable=protected-access
              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)
  
          deserialized = None
          if response.status_code == 200:
              deserialized = self._deserialize('VirtualMachineCaptureResult', pipeline_response)
  
          if cls:
              return cls(pipeline_response, deserialized, {})
  
          return deserialized
  
      _capture_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/capture"}  # type: ignore
  
  
      @distributed_trace_async
      async def begin_capture(
          self,
          resource_group_name: str,
          vm_name: str,
          parameters: "_models.VirtualMachineCaptureParameters",
          **kwargs: Any
      ) -> AsyncLROPoller["_models.VirtualMachineCaptureResult"]:
          """Captures the VM by copying virtual hard disks of the VM and outputs a template that can be used
          to create similar VMs.
  
          :param resource_group_name: The name of the resource group.
          :type resource_group_name: str
          :param vm_name: The name of the virtual machine.
          :type vm_name: str
          :param parameters: Parameters supplied to the Capture Virtual Machine operation.
          :type parameters: ~azure.mgmt.compute.v2021_03_01.models.VirtualMachineCaptureParameters
          :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: By default, your polling method will be AsyncARMPolling. Pass in False for
           this operation to not poll, or pass in your own initialized polling object for a personal
           polling strategy.
          :paramtype polling: bool or ~azure.core.polling.AsyncPollingMethod
          :keyword int polling_interval: Default waiting time between two polls for LRO operations if no
           Retry-After header is present.
          :return: An instance of AsyncLROPoller that returns either VirtualMachineCaptureResult or the
           result of cls(response)
          :rtype:
           ~azure.core.polling.AsyncLROPoller[~azure.mgmt.compute.v2021_03_01.models.VirtualMachineCaptureResult]
          :raises: ~azure.core.exceptions.HttpResponseError
          """
          api_version = kwargs.pop('api_version', "2021-03-01")  # type: str
          content_type = kwargs.pop('content_type', "application/json")  # type: Optional[str]
          polling = kwargs.pop('polling', True)  # type: Union[bool, AsyncPollingMethod]
          cls = kwargs.pop('cls', None)  # type: ClsType["_models.VirtualMachineCaptureResult"]
          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 = await self._capture_initial(
                  resource_group_name=resource_group_name,
                  vm_name=vm_name,
                  parameters=parameters,
                  api_version=api_version,
                  content_type=content_type,
                  cls=lambda x,y,z: x,
                  **kwargs
              )
          kwargs.pop('error_map', None)
  
          def get_long_running_output(pipeline_response):
              response = pipeline_response.http_response
              deserialized = self._deserialize('VirtualMachineCaptureResult', pipeline_response)
              if cls:
                  return cls(pipeline_response, deserialized, {})
              return deserialized
  
  
          if polling is True: polling_method = AsyncARMPolling(lro_delay, lro_options={'final-state-via': 'location'}, **kwargs)
          elif polling is False: polling_method = AsyncNoPolling()
          else: polling_method = polling
          if cont_token:
              return AsyncLROPoller.from_continuation_token(
                  polling_method=polling_method,
                  continuation_token=cont_token,
                  client=self._client,
                  deserialization_callback=get_long_running_output
              )
          return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method)
  
      begin_capture.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/capture"}  # type: ignore
  
      async def _create_or_update_initial(
          self,
          resource_group_name: str,
          vm_name: str,
          parameters: "_models.VirtualMachine",
          **kwargs: Any
      ) -> "_models.VirtualMachine":
          cls = kwargs.pop('cls', None)  # type: ClsType["_models.VirtualMachine"]
          error_map = {
              401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
          }
          error_map.update(kwargs.pop('error_map', {}))
  
          api_version = kwargs.pop('api_version', "2021-03-01")  # type: str
          content_type = kwargs.pop('content_type', "application/json")  # type: Optional[str]
  
          _json = self._serialize.body(parameters, 'VirtualMachine')
  
          request = build_create_or_update_request_initial(
              resource_group_name=resource_group_name,
              vm_name=vm_name,
              subscription_id=self._config.subscription_id,
              api_version=api_version,
              content_type=content_type,
              json=_json,
              template_url=self._create_or_update_initial.metadata['url'],
          )
          request = _convert_request(request)
          request.url = self._client.format_url(request.url)
  
          pipeline_response = await self._client._pipeline.run(  # pylint: disable=protected-access
              request,
              stream=False,
              **kwargs
          )
          response = pipeline_response.http_response
  
          if response.status_code not in [200, 201]:
              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('VirtualMachine', pipeline_response)
  
          if response.status_code == 201:
              deserialized = self._deserialize('VirtualMachine', pipeline_response)
  
          if cls:
              return cls(pipeline_response, deserialized, {})
  
          return deserialized
  
      _create_or_update_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}"}  # type: ignore
  
  
      @distributed_trace_async
      async def begin_create_or_update(
          self,
          resource_group_name: str,
          vm_name: str,
          parameters: "_models.VirtualMachine",
          **kwargs: Any
      ) -> AsyncLROPoller["_models.VirtualMachine"]:
          """The operation to create or update a virtual machine. Please note some properties can be set
          only during virtual machine creation.
  
          :param resource_group_name: The name of the resource group.
          :type resource_group_name: str
          :param vm_name: The name of the virtual machine.
          :type vm_name: str
          :param parameters: Parameters supplied to the Create Virtual Machine operation.
          :type parameters: ~azure.mgmt.compute.v2021_03_01.models.VirtualMachine
          :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: By default, your polling method will be AsyncARMPolling. Pass in False for
           this operation to not poll, or pass in your own initialized polling object for a personal
           polling strategy.
          :paramtype polling: bool or ~azure.core.polling.AsyncPollingMethod
          :keyword int polling_interval: Default waiting time between two polls for LRO operations if no
           Retry-After header is present.
          :return: An instance of AsyncLROPoller that returns either VirtualMachine or the result of
           cls(response)
          :rtype:
           ~azure.core.polling.AsyncLROPoller[~azure.mgmt.compute.v2021_03_01.models.VirtualMachine]
          :raises: ~azure.core.exceptions.HttpResponseError
          """
          api_version = kwargs.pop('api_version', "2021-03-01")  # type: str
          content_type = kwargs.pop('content_type', "application/json")  # type: Optional[str]
          polling = kwargs.pop('polling', True)  # type: Union[bool, AsyncPollingMethod]
          cls = kwargs.pop('cls', None)  # type: ClsType["_models.VirtualMachine"]
          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 = await self._create_or_update_initial(
                  resource_group_name=resource_group_name,
                  vm_name=vm_name,
                  parameters=parameters,
                  api_version=api_version,
                  content_type=content_type,
                  cls=lambda x,y,z: x,
                  **kwargs
              )
          kwargs.pop('error_map', None)
  
          def get_long_running_output(pipeline_response):
              response = pipeline_response.http_response
              deserialized = self._deserialize('VirtualMachine', pipeline_response)
              if cls:
                  return cls(pipeline_response, deserialized, {})
              return deserialized
  
  
          if polling is True: polling_method = AsyncARMPolling(lro_delay, **kwargs)
          elif polling is False: polling_method = AsyncNoPolling()
          else: polling_method = polling
          if cont_token:
              return AsyncLROPoller.from_continuation_token(
                  polling_method=polling_method,
                  continuation_token=cont_token,
                  client=self._client,
                  deserialization_callback=get_long_running_output
              )
          return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method)
  
      begin_create_or_update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}"}  # type: ignore
  
      async def _update_initial(
          self,
          resource_group_name: str,
          vm_name: str,
          parameters: "_models.VirtualMachineUpdate",
          **kwargs: Any
      ) -> "_models.VirtualMachine":
          cls = kwargs.pop('cls', None)  # type: ClsType["_models.VirtualMachine"]
          error_map = {
              401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
          }
          error_map.update(kwargs.pop('error_map', {}))
  
          api_version = kwargs.pop('api_version', "2021-03-01")  # type: str
          content_type = kwargs.pop('content_type', "application/json")  # type: Optional[str]
  
          _json = self._serialize.body(parameters, 'VirtualMachineUpdate')
  
          request = build_update_request_initial(
              resource_group_name=resource_group_name,
              vm_name=vm_name,
              subscription_id=self._config.subscription_id,
              api_version=api_version,
              content_type=content_type,
              json=_json,
              template_url=self._update_initial.metadata['url'],
          )
          request = _convert_request(request)
          request.url = self._client.format_url(request.url)
  
          pipeline_response = await self._client._pipeline.run(  # pylint: disable=protected-access
              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('VirtualMachine', pipeline_response)
  
          if cls:
              return cls(pipeline_response, deserialized, {})
  
          return deserialized
  
      _update_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}"}  # type: ignore
  
  
      @distributed_trace_async
      async def begin_update(
          self,
          resource_group_name: str,
          vm_name: str,
          parameters: "_models.VirtualMachineUpdate",
          **kwargs: Any
      ) -> AsyncLROPoller["_models.VirtualMachine"]:
          """The operation to update a virtual machine.
  
          :param resource_group_name: The name of the resource group.
          :type resource_group_name: str
          :param vm_name: The name of the virtual machine.
          :type vm_name: str
          :param parameters: Parameters supplied to the Update Virtual Machine operation.
          :type parameters: ~azure.mgmt.compute.v2021_03_01.models.VirtualMachineUpdate
          :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: By default, your polling method will be AsyncARMPolling. Pass in False for
           this operation to not poll, or pass in your own initialized polling object for a personal
           polling strategy.
          :paramtype polling: bool or ~azure.core.polling.AsyncPollingMethod
          :keyword int polling_interval: Default waiting time between two polls for LRO operations if no
           Retry-After header is present.
          :return: An instance of AsyncLROPoller that returns either VirtualMachine or the result of
           cls(response)
          :rtype:
           ~azure.core.polling.AsyncLROPoller[~azure.mgmt.compute.v2021_03_01.models.VirtualMachine]
          :raises: ~azure.core.exceptions.HttpResponseError
          """
          api_version = kwargs.pop('api_version', "2021-03-01")  # type: str
          content_type = kwargs.pop('content_type', "application/json")  # type: Optional[str]
          polling = kwargs.pop('polling', True)  # type: Union[bool, AsyncPollingMethod]
          cls = kwargs.pop('cls', None)  # type: ClsType["_models.VirtualMachine"]
          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 = await self._update_initial(
                  resource_group_name=resource_group_name,
                  vm_name=vm_name,
                  parameters=parameters,
                  api_version=api_version,
                  content_type=content_type,
                  cls=lambda x,y,z: x,
                  **kwargs
              )
          kwargs.pop('error_map', None)
  
          def get_long_running_output(pipeline_response):
              response = pipeline_response.http_response
              deserialized = self._deserialize('VirtualMachine', pipeline_response)
              if cls:
                  return cls(pipeline_response, deserialized, {})
              return deserialized
  
  
          if polling is True: polling_method = AsyncARMPolling(lro_delay, **kwargs)
          elif polling is False: polling_method = AsyncNoPolling()
          else: polling_method = polling
          if cont_token:
              return AsyncLROPoller.from_continuation_token(
                  polling_method=polling_method,
                  continuation_token=cont_token,
                  client=self._client,
                  deserialization_callback=get_long_running_output
              )
          return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method)
  
      begin_update.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}"}  # type: ignore
  
      async def _delete_initial(  # pylint: disable=inconsistent-return-statements
          self,
          resource_group_name: str,
          vm_name: str,
          force_deletion: Optional[bool] = None,
          **kwargs: Any
      ) -> 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 = kwargs.pop('api_version', "2021-03-01")  # type: str
  
          
          request = build_delete_request_initial(
              resource_group_name=resource_group_name,
              vm_name=vm_name,
              subscription_id=self._config.subscription_id,
              api_version=api_version,
              force_deletion=force_deletion,
              template_url=self._delete_initial.metadata['url'],
          )
          request = _convert_request(request)
          request.url = self._client.format_url(request.url)
  
          pipeline_response = await self._client._pipeline.run(  # pylint: disable=protected-access
              request,
              stream=False,
              **kwargs
          )
          response = pipeline_response.http_response
  
          if response.status_code not in [200, 202, 204]:
              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.Compute/virtualMachines/{vmName}"}  # type: ignore
  
  
      @distributed_trace_async
      async def begin_delete(  # pylint: disable=inconsistent-return-statements
          self,
          resource_group_name: str,
          vm_name: str,
          force_deletion: Optional[bool] = None,
          **kwargs: Any
      ) -> AsyncLROPoller[None]:
          """The operation to delete a virtual machine.
  
          :param resource_group_name: The name of the resource group.
          :type resource_group_name: str
          :param vm_name: The name of the virtual machine.
          :type vm_name: str
          :param force_deletion: Optional parameter to force delete virtual machines. Default value is
           None.
          :type force_deletion: 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: By default, your polling method will be AsyncARMPolling. Pass in False for
           this operation to not poll, or pass in your own initialized polling object for a personal
           polling strategy.
          :paramtype polling: bool or ~azure.core.polling.AsyncPollingMethod
          :keyword int polling_interval: Default waiting time between two polls for LRO operations if no
           Retry-After header is present.
          :return: An instance of AsyncLROPoller that returns either None or the result of cls(response)
          :rtype: ~azure.core.polling.AsyncLROPoller[None]
          :raises: ~azure.core.exceptions.HttpResponseError
          """
          api_version = kwargs.pop('api_version', "2021-03-01")  # type: str
          polling = kwargs.pop('polling', True)  # type: Union[bool, AsyncPollingMethod]
          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 = await self._delete_initial(
                  resource_group_name=resource_group_name,
                  vm_name=vm_name,
                  force_deletion=force_deletion,
                  api_version=api_version,
                  cls=lambda x,y,z: x,
                  **kwargs
              )
          kwargs.pop('error_map', None)
  
          def get_long_running_output(pipeline_response):
              if cls:
                  return cls(pipeline_response, None, {})
  
  
          if polling is True: polling_method = AsyncARMPolling(lro_delay, **kwargs)
          elif polling is False: polling_method = AsyncNoPolling()
          else: polling_method = polling
          if cont_token:
              return AsyncLROPoller.from_continuation_token(
                  polling_method=polling_method,
                  continuation_token=cont_token,
                  client=self._client,
                  deserialization_callback=get_long_running_output
              )
          return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method)
  
      begin_delete.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}"}  # type: ignore
  
      @distributed_trace_async
      async def get(
          self,
          resource_group_name: str,
          vm_name: str,
          expand: Optional[Union[str, "_models.InstanceViewTypes"]] = None,
          **kwargs: Any
      ) -> "_models.VirtualMachine":
          """Retrieves information about the model view or the instance view of a virtual machine.
  
          :param resource_group_name: The name of the resource group.
          :type resource_group_name: str
          :param vm_name: The name of the virtual machine.
          :type vm_name: str
          :param expand: The expand expression to apply on the operation. 'InstanceView' retrieves a
           snapshot of the runtime properties of the virtual machine that is managed by the platform and
           can change outside of control plane operations. 'UserData' retrieves the UserData property as
           part of the VM model view that was provided by the user during the VM Create/Update operation.
           Default value is None.
          :type expand: str or ~azure.mgmt.compute.v2021_03_01.models.InstanceViewTypes
          :keyword callable cls: A custom type or function that will be passed the direct response
          :return: VirtualMachine, or the result of cls(response)
          :rtype: ~azure.mgmt.compute.v2021_03_01.models.VirtualMachine
          :raises: ~azure.core.exceptions.HttpResponseError
          """
          cls = kwargs.pop('cls', None)  # type: ClsType["_models.VirtualMachine"]
          error_map = {
              401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
          }
          error_map.update(kwargs.pop('error_map', {}))
  
          api_version = kwargs.pop('api_version', "2021-03-01")  # type: str
  
          
          request = build_get_request(
              resource_group_name=resource_group_name,
              vm_name=vm_name,
              subscription_id=self._config.subscription_id,
              api_version=api_version,
              expand=expand,
              template_url=self.get.metadata['url'],
          )
          request = _convert_request(request)
          request.url = self._client.format_url(request.url)
  
          pipeline_response = await self._client._pipeline.run(  # pylint: disable=protected-access
              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('VirtualMachine', pipeline_response)
  
          if cls:
              return cls(pipeline_response, deserialized, {})
  
          return deserialized
  
      get.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}"}  # type: ignore
  
  
      @distributed_trace_async
      async def instance_view(
          self,
          resource_group_name: str,
          vm_name: str,
          **kwargs: Any
      ) -> "_models.VirtualMachineInstanceView":
          """Retrieves information about the run-time state of a virtual machine.
  
          :param resource_group_name: The name of the resource group.
          :type resource_group_name: str
          :param vm_name: The name of the virtual machine.
          :type vm_name: str
          :keyword callable cls: A custom type or function that will be passed the direct response
          :return: VirtualMachineInstanceView, or the result of cls(response)
          :rtype: ~azure.mgmt.compute.v2021_03_01.models.VirtualMachineInstanceView
          :raises: ~azure.core.exceptions.HttpResponseError
          """
          cls = kwargs.pop('cls', None)  # type: ClsType["_models.VirtualMachineInstanceView"]
          error_map = {
              401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
          }
          error_map.update(kwargs.pop('error_map', {}))
  
          api_version = kwargs.pop('api_version', "2021-03-01")  # type: str
  
          
          request = build_instance_view_request(
              resource_group_name=resource_group_name,
              vm_name=vm_name,
              subscription_id=self._config.subscription_id,
              api_version=api_version,
              template_url=self.instance_view.metadata['url'],
          )
          request = _convert_request(request)
          request.url = self._client.format_url(request.url)
  
          pipeline_response = await self._client._pipeline.run(  # pylint: disable=protected-access
              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('VirtualMachineInstanceView', pipeline_response)
  
          if cls:
              return cls(pipeline_response, deserialized, {})
  
          return deserialized
  
      instance_view.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/instanceView"}  # type: ignore
  
  
      async def _convert_to_managed_disks_initial(  # pylint: disable=inconsistent-return-statements
          self,
          resource_group_name: str,
          vm_name: str,
          **kwargs: Any
      ) -> 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 = kwargs.pop('api_version', "2021-03-01")  # type: str
  
          
          request = build_convert_to_managed_disks_request_initial(
              resource_group_name=resource_group_name,
              vm_name=vm_name,
              subscription_id=self._config.subscription_id,
              api_version=api_version,
              template_url=self._convert_to_managed_disks_initial.metadata['url'],
          )
          request = _convert_request(request)
          request.url = self._client.format_url(request.url)
  
          pipeline_response = await self._client._pipeline.run(  # pylint: disable=protected-access
              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 cls:
              return cls(pipeline_response, None, {})
  
      _convert_to_managed_disks_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/convertToManagedDisks"}  # type: ignore
  
  
      @distributed_trace_async
      async def begin_convert_to_managed_disks(  # pylint: disable=inconsistent-return-statements
          self,
          resource_group_name: str,
          vm_name: str,
          **kwargs: Any
      ) -> AsyncLROPoller[None]:
          """Converts virtual machine disks from blob-based to managed disks. Virtual machine must be
          stop-deallocated before invoking this operation.
  
          :param resource_group_name: The name of the resource group.
          :type resource_group_name: str
          :param vm_name: The name of the virtual machine.
          :type vm_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: By default, your polling method will be AsyncARMPolling. Pass in False for
           this operation to not poll, or pass in your own initialized polling object for a personal
           polling strategy.
          :paramtype polling: bool or ~azure.core.polling.AsyncPollingMethod
          :keyword int polling_interval: Default waiting time between two polls for LRO operations if no
           Retry-After header is present.
          :return: An instance of AsyncLROPoller that returns either None or the result of cls(response)
          :rtype: ~azure.core.polling.AsyncLROPoller[None]
          :raises: ~azure.core.exceptions.HttpResponseError
          """
          api_version = kwargs.pop('api_version', "2021-03-01")  # type: str
          polling = kwargs.pop('polling', True)  # type: Union[bool, AsyncPollingMethod]
          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 = await self._convert_to_managed_disks_initial(
                  resource_group_name=resource_group_name,
                  vm_name=vm_name,
                  api_version=api_version,
                  cls=lambda x,y,z: x,
                  **kwargs
              )
          kwargs.pop('error_map', None)
  
          def get_long_running_output(pipeline_response):
              if cls:
                  return cls(pipeline_response, None, {})
  
  
          if polling is True: polling_method = AsyncARMPolling(lro_delay, **kwargs)
          elif polling is False: polling_method = AsyncNoPolling()
          else: polling_method = polling
          if cont_token:
              return AsyncLROPoller.from_continuation_token(
                  polling_method=polling_method,
                  continuation_token=cont_token,
                  client=self._client,
                  deserialization_callback=get_long_running_output
              )
          return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method)
  
      begin_convert_to_managed_disks.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/convertToManagedDisks"}  # type: ignore
  
      async def _deallocate_initial(  # pylint: disable=inconsistent-return-statements
          self,
          resource_group_name: str,
          vm_name: str,
          **kwargs: Any
      ) -> 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 = kwargs.pop('api_version', "2021-03-01")  # type: str
  
          
          request = build_deallocate_request_initial(
              resource_group_name=resource_group_name,
              vm_name=vm_name,
              subscription_id=self._config.subscription_id,
              api_version=api_version,
              template_url=self._deallocate_initial.metadata['url'],
          )
          request = _convert_request(request)
          request.url = self._client.format_url(request.url)
  
          pipeline_response = await self._client._pipeline.run(  # pylint: disable=protected-access
              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 cls:
              return cls(pipeline_response, None, {})
  
      _deallocate_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/deallocate"}  # type: ignore
  
  
      @distributed_trace_async
      async def begin_deallocate(  # pylint: disable=inconsistent-return-statements
          self,
          resource_group_name: str,
          vm_name: str,
          **kwargs: Any
      ) -> AsyncLROPoller[None]:
          """Shuts down the virtual machine and releases the compute resources. You are not billed for the
          compute resources that this virtual machine uses.
  
          :param resource_group_name: The name of the resource group.
          :type resource_group_name: str
          :param vm_name: The name of the virtual machine.
          :type vm_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: By default, your polling method will be AsyncARMPolling. Pass in False for
           this operation to not poll, or pass in your own initialized polling object for a personal
           polling strategy.
          :paramtype polling: bool or ~azure.core.polling.AsyncPollingMethod
          :keyword int polling_interval: Default waiting time between two polls for LRO operations if no
           Retry-After header is present.
          :return: An instance of AsyncLROPoller that returns either None or the result of cls(response)
          :rtype: ~azure.core.polling.AsyncLROPoller[None]
          :raises: ~azure.core.exceptions.HttpResponseError
          """
          api_version = kwargs.pop('api_version', "2021-03-01")  # type: str
          polling = kwargs.pop('polling', True)  # type: Union[bool, AsyncPollingMethod]
          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 = await self._deallocate_initial(
                  resource_group_name=resource_group_name,
                  vm_name=vm_name,
                  api_version=api_version,
                  cls=lambda x,y,z: x,
                  **kwargs
              )
          kwargs.pop('error_map', None)
  
          def get_long_running_output(pipeline_response):
              if cls:
                  return cls(pipeline_response, None, {})
  
  
          if polling is True: polling_method = AsyncARMPolling(lro_delay, **kwargs)
          elif polling is False: polling_method = AsyncNoPolling()
          else: polling_method = polling
          if cont_token:
              return AsyncLROPoller.from_continuation_token(
                  polling_method=polling_method,
                  continuation_token=cont_token,
                  client=self._client,
                  deserialization_callback=get_long_running_output
              )
          return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method)
  
      begin_deallocate.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/deallocate"}  # type: ignore
  
      @distributed_trace_async
      async def generalize(  # pylint: disable=inconsistent-return-statements
          self,
          resource_group_name: str,
          vm_name: str,
          **kwargs: Any
      ) -> None:
          """Sets the OS state of the virtual machine to generalized. It is recommended to sysprep the
          virtual machine before performing this operation. :code:`<br>`For Windows, please refer to
          `Create a managed image of a generalized VM in Azure
          <https://docs.microsoft.com/azure/virtual-machines/windows/capture-image-resource>`_.:code:`<br>`For
          Linux, please refer to `How to create an image of a virtual machine or VHD
          <https://docs.microsoft.com/azure/virtual-machines/linux/capture-image>`_.
  
          :param resource_group_name: The name of the resource group.
          :type resource_group_name: str
          :param vm_name: The name of the virtual machine.
          :type vm_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 = kwargs.pop('api_version', "2021-03-01")  # type: str
  
          
          request = build_generalize_request(
              resource_group_name=resource_group_name,
              vm_name=vm_name,
              subscription_id=self._config.subscription_id,
              api_version=api_version,
              template_url=self.generalize.metadata['url'],
          )
          request = _convert_request(request)
          request.url = self._client.format_url(request.url)
  
          pipeline_response = await self._client._pipeline.run(  # pylint: disable=protected-access
              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)
  
          if cls:
              return cls(pipeline_response, None, {})
  
      generalize.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/generalize"}  # type: ignore
  
  
      @distributed_trace
      def list(
          self,
          resource_group_name: str,
          **kwargs: Any
      ) -> AsyncIterable["_models.VirtualMachineListResult"]:
          """Lists all of the virtual machines in the specified resource group. Use the nextLink property in
          the response to get the next page of virtual machines.
  
          :param resource_group_name: The name of the resource group.
          :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 VirtualMachineListResult or the result of
           cls(response)
          :rtype:
           ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.compute.v2021_03_01.models.VirtualMachineListResult]
          :raises: ~azure.core.exceptions.HttpResponseError
          """
          api_version = kwargs.pop('api_version', "2021-03-01")  # type: str
  
          cls = kwargs.pop('cls', None)  # type: ClsType["_models.VirtualMachineListResult"]
          error_map = {
              401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
          }
          error_map.update(kwargs.pop('error_map', {}))
          def prepare_request(next_link=None):
              if not next_link:
                  
                  request = build_list_request(
                      resource_group_name=resource_group_name,
                      subscription_id=self._config.subscription_id,
                      api_version=api_version,
                      template_url=self.list.metadata['url'],
                  )
                  request = _convert_request(request)
                  request.url = self._client.format_url(request.url)
  
              else:
                  
                  request = build_list_request(
                      resource_group_name=resource_group_name,
                      subscription_id=self._config.subscription_id,
                      api_version=api_version,
                      template_url=next_link,
                  )
                  request = _convert_request(request)
                  request.url = self._client.format_url(request.url)
                  request.method = "GET"
              return request
  
          async def extract_data(pipeline_response):
              deserialized = self._deserialize("VirtualMachineListResult", pipeline_response)
              list_of_elem = deserialized.value
              if cls:
                  list_of_elem = cls(list_of_elem)
              return deserialized.next_link or None, AsyncList(list_of_elem)
  
          async def get_next(next_link=None):
              request = prepare_request(next_link)
  
              pipeline_response = await self._client._pipeline.run(  # pylint: disable=protected-access
                  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 AsyncItemPaged(
              get_next, extract_data
          )
      list.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines"}  # type: ignore
  
      @distributed_trace
      def list_all(
          self,
          status_only: Optional[str] = None,
          **kwargs: Any
      ) -> AsyncIterable["_models.VirtualMachineListResult"]:
          """Lists all of the virtual machines in the specified subscription. Use the nextLink property in
          the response to get the next page of virtual machines.
  
          :param status_only: statusOnly=true enables fetching run time status of all Virtual Machines in
           the subscription. Default value is None.
          :type status_only: str
          :keyword callable cls: A custom type or function that will be passed the direct response
          :return: An iterator like instance of either VirtualMachineListResult or the result of
           cls(response)
          :rtype:
           ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.compute.v2021_03_01.models.VirtualMachineListResult]
          :raises: ~azure.core.exceptions.HttpResponseError
          """
          api_version = kwargs.pop('api_version', "2021-03-01")  # type: str
  
          cls = kwargs.pop('cls', None)  # type: ClsType["_models.VirtualMachineListResult"]
          error_map = {
              401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
          }
          error_map.update(kwargs.pop('error_map', {}))
          def prepare_request(next_link=None):
              if not next_link:
                  
                  request = build_list_all_request(
                      subscription_id=self._config.subscription_id,
                      api_version=api_version,
                      status_only=status_only,
                      template_url=self.list_all.metadata['url'],
                  )
                  request = _convert_request(request)
                  request.url = self._client.format_url(request.url)
  
              else:
                  
                  request = build_list_all_request(
                      subscription_id=self._config.subscription_id,
                      api_version=api_version,
                      status_only=status_only,
                      template_url=next_link,
                  )
                  request = _convert_request(request)
                  request.url = self._client.format_url(request.url)
                  request.method = "GET"
              return request
  
          async def extract_data(pipeline_response):
              deserialized = self._deserialize("VirtualMachineListResult", pipeline_response)
              list_of_elem = deserialized.value
              if cls:
                  list_of_elem = cls(list_of_elem)
              return deserialized.next_link or None, AsyncList(list_of_elem)
  
          async def get_next(next_link=None):
              request = prepare_request(next_link)
  
              pipeline_response = await self._client._pipeline.run(  # pylint: disable=protected-access
                  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 AsyncItemPaged(
              get_next, extract_data
          )
      list_all.metadata = {'url': "/subscriptions/{subscriptionId}/providers/Microsoft.Compute/virtualMachines"}  # type: ignore
  
      @distributed_trace
      def list_available_sizes(
          self,
          resource_group_name: str,
          vm_name: str,
          **kwargs: Any
      ) -> AsyncIterable["_models.VirtualMachineSizeListResult"]:
          """Lists all available virtual machine sizes to which the specified virtual machine can be
          resized.
  
          :param resource_group_name: The name of the resource group.
          :type resource_group_name: str
          :param vm_name: The name of the virtual machine.
          :type vm_name: str
          :keyword callable cls: A custom type or function that will be passed the direct response
          :return: An iterator like instance of either VirtualMachineSizeListResult or the result of
           cls(response)
          :rtype:
           ~azure.core.async_paging.AsyncItemPaged[~azure.mgmt.compute.v2021_03_01.models.VirtualMachineSizeListResult]
          :raises: ~azure.core.exceptions.HttpResponseError
          """
          api_version = kwargs.pop('api_version', "2021-03-01")  # type: str
  
          cls = kwargs.pop('cls', None)  # type: ClsType["_models.VirtualMachineSizeListResult"]
          error_map = {
              401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
          }
          error_map.update(kwargs.pop('error_map', {}))
          def prepare_request(next_link=None):
              if not next_link:
                  
                  request = build_list_available_sizes_request(
                      resource_group_name=resource_group_name,
                      vm_name=vm_name,
                      subscription_id=self._config.subscription_id,
                      api_version=api_version,
                      template_url=self.list_available_sizes.metadata['url'],
                  )
                  request = _convert_request(request)
                  request.url = self._client.format_url(request.url)
  
              else:
                  
                  request = build_list_available_sizes_request(
                      resource_group_name=resource_group_name,
                      vm_name=vm_name,
                      subscription_id=self._config.subscription_id,
                      api_version=api_version,
                      template_url=next_link,
                  )
                  request = _convert_request(request)
                  request.url = self._client.format_url(request.url)
                  request.method = "GET"
              return request
  
          async def extract_data(pipeline_response):
              deserialized = self._deserialize("VirtualMachineSizeListResult", pipeline_response)
              list_of_elem = deserialized.value
              if cls:
                  list_of_elem = cls(list_of_elem)
              return None, AsyncList(list_of_elem)
  
          async def get_next(next_link=None):
              request = prepare_request(next_link)
  
              pipeline_response = await self._client._pipeline.run(  # pylint: disable=protected-access
                  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 AsyncItemPaged(
              get_next, extract_data
          )
      list_available_sizes.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/vmSizes"}  # type: ignore
  
      async def _power_off_initial(  # pylint: disable=inconsistent-return-statements
          self,
          resource_group_name: str,
          vm_name: str,
          skip_shutdown: Optional[bool] = False,
          **kwargs: Any
      ) -> 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 = kwargs.pop('api_version', "2021-03-01")  # type: str
  
          
          request = build_power_off_request_initial(
              resource_group_name=resource_group_name,
              vm_name=vm_name,
              subscription_id=self._config.subscription_id,
              api_version=api_version,
              skip_shutdown=skip_shutdown,
              template_url=self._power_off_initial.metadata['url'],
          )
          request = _convert_request(request)
          request.url = self._client.format_url(request.url)
  
          pipeline_response = await self._client._pipeline.run(  # pylint: disable=protected-access
              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 cls:
              return cls(pipeline_response, None, {})
  
      _power_off_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/powerOff"}  # type: ignore
  
  
      @distributed_trace_async
      async def begin_power_off(  # pylint: disable=inconsistent-return-statements
          self,
          resource_group_name: str,
          vm_name: str,
          skip_shutdown: Optional[bool] = False,
          **kwargs: Any
      ) -> AsyncLROPoller[None]:
          """The operation to power off (stop) a virtual machine. The virtual machine can be restarted with
          the same provisioned resources. You are still charged for this virtual machine.
  
          :param resource_group_name: The name of the resource group.
          :type resource_group_name: str
          :param vm_name: The name of the virtual machine.
          :type vm_name: str
          :param skip_shutdown: The parameter to request non-graceful VM shutdown. True value for this
           flag indicates non-graceful shutdown whereas false indicates otherwise. Default value for this
           flag is false if not specified. Default value is False.
          :type skip_shutdown: 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: By default, your polling method will be AsyncARMPolling. Pass in False for
           this operation to not poll, or pass in your own initialized polling object for a personal
           polling strategy.
          :paramtype polling: bool or ~azure.core.polling.AsyncPollingMethod
          :keyword int polling_interval: Default waiting time between two polls for LRO operations if no
           Retry-After header is present.
          :return: An instance of AsyncLROPoller that returns either None or the result of cls(response)
          :rtype: ~azure.core.polling.AsyncLROPoller[None]
          :raises: ~azure.core.exceptions.HttpResponseError
          """
          api_version = kwargs.pop('api_version', "2021-03-01")  # type: str
          polling = kwargs.pop('polling', True)  # type: Union[bool, AsyncPollingMethod]
          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 = await self._power_off_initial(
                  resource_group_name=resource_group_name,
                  vm_name=vm_name,
                  skip_shutdown=skip_shutdown,
                  api_version=api_version,
                  cls=lambda x,y,z: x,
                  **kwargs
              )
          kwargs.pop('error_map', None)
  
          def get_long_running_output(pipeline_response):
              if cls:
                  return cls(pipeline_response, None, {})
  
  
          if polling is True: polling_method = AsyncARMPolling(lro_delay, **kwargs)
          elif polling is False: polling_method = AsyncNoPolling()
          else: polling_method = polling
          if cont_token:
              return AsyncLROPoller.from_continuation_token(
                  polling_method=polling_method,
                  continuation_token=cont_token,
                  client=self._client,
                  deserialization_callback=get_long_running_output
              )
          return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method)
  
      begin_power_off.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/powerOff"}  # type: ignore
  
      async def _reapply_initial(  # pylint: disable=inconsistent-return-statements
          self,
          resource_group_name: str,
          vm_name: str,
          **kwargs: Any
      ) -> 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 = kwargs.pop('api_version', "2021-03-01")  # type: str
  
          
          request = build_reapply_request_initial(
              resource_group_name=resource_group_name,
              vm_name=vm_name,
              subscription_id=self._config.subscription_id,
              api_version=api_version,
              template_url=self._reapply_initial.metadata['url'],
          )
          request = _convert_request(request)
          request.url = self._client.format_url(request.url)
  
          pipeline_response = await self._client._pipeline.run(  # pylint: disable=protected-access
              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 cls:
              return cls(pipeline_response, None, {})
  
      _reapply_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/reapply"}  # type: ignore
  
  
      @distributed_trace_async
      async def begin_reapply(  # pylint: disable=inconsistent-return-statements
          self,
          resource_group_name: str,
          vm_name: str,
          **kwargs: Any
      ) -> AsyncLROPoller[None]:
          """The operation to reapply a virtual machine's state.
  
          :param resource_group_name: The name of the resource group.
          :type resource_group_name: str
          :param vm_name: The name of the virtual machine.
          :type vm_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: By default, your polling method will be AsyncARMPolling. Pass in False for
           this operation to not poll, or pass in your own initialized polling object for a personal
           polling strategy.
          :paramtype polling: bool or ~azure.core.polling.AsyncPollingMethod
          :keyword int polling_interval: Default waiting time between two polls for LRO operations if no
           Retry-After header is present.
          :return: An instance of AsyncLROPoller that returns either None or the result of cls(response)
          :rtype: ~azure.core.polling.AsyncLROPoller[None]
          :raises: ~azure.core.exceptions.HttpResponseError
          """
          api_version = kwargs.pop('api_version', "2021-03-01")  # type: str
          polling = kwargs.pop('polling', True)  # type: Union[bool, AsyncPollingMethod]
          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 = await self._reapply_initial(
                  resource_group_name=resource_group_name,
                  vm_name=vm_name,
                  api_version=api_version,
                  cls=lambda x,y,z: x,
                  **kwargs
              )
          kwargs.pop('error_map', None)
  
          def get_long_running_output(pipeline_response):
              if cls:
                  return cls(pipeline_response, None, {})
  
  
          if polling is True: polling_method = AsyncARMPolling(lro_delay, **kwargs)
          elif polling is False: polling_method = AsyncNoPolling()
          else: polling_method = polling
          if cont_token:
              return AsyncLROPoller.from_continuation_token(
                  polling_method=polling_method,
                  continuation_token=cont_token,
                  client=self._client,
                  deserialization_callback=get_long_running_output
              )
          return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method)
  
      begin_reapply.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/reapply"}  # type: ignore
  
      async def _restart_initial(  # pylint: disable=inconsistent-return-statements
          self,
          resource_group_name: str,
          vm_name: str,
          **kwargs: Any
      ) -> 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 = kwargs.pop('api_version', "2021-03-01")  # type: str
  
          
          request = build_restart_request_initial(
              resource_group_name=resource_group_name,
              vm_name=vm_name,
              subscription_id=self._config.subscription_id,
              api_version=api_version,
              template_url=self._restart_initial.metadata['url'],
          )
          request = _convert_request(request)
          request.url = self._client.format_url(request.url)
  
          pipeline_response = await self._client._pipeline.run(  # pylint: disable=protected-access
              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 cls:
              return cls(pipeline_response, None, {})
  
      _restart_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/restart"}  # type: ignore
  
  
      @distributed_trace_async
      async def begin_restart(  # pylint: disable=inconsistent-return-statements
          self,
          resource_group_name: str,
          vm_name: str,
          **kwargs: Any
      ) -> AsyncLROPoller[None]:
          """The operation to restart a virtual machine.
  
          :param resource_group_name: The name of the resource group.
          :type resource_group_name: str
          :param vm_name: The name of the virtual machine.
          :type vm_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: By default, your polling method will be AsyncARMPolling. Pass in False for
           this operation to not poll, or pass in your own initialized polling object for a personal
           polling strategy.
          :paramtype polling: bool or ~azure.core.polling.AsyncPollingMethod
          :keyword int polling_interval: Default waiting time between two polls for LRO operations if no
           Retry-After header is present.
          :return: An instance of AsyncLROPoller that returns either None or the result of cls(response)
          :rtype: ~azure.core.polling.AsyncLROPoller[None]
          :raises: ~azure.core.exceptions.HttpResponseError
          """
          api_version = kwargs.pop('api_version', "2021-03-01")  # type: str
          polling = kwargs.pop('polling', True)  # type: Union[bool, AsyncPollingMethod]
          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 = await self._restart_initial(
                  resource_group_name=resource_group_name,
                  vm_name=vm_name,
                  api_version=api_version,
                  cls=lambda x,y,z: x,
                  **kwargs
              )
          kwargs.pop('error_map', None)
  
          def get_long_running_output(pipeline_response):
              if cls:
                  return cls(pipeline_response, None, {})
  
  
          if polling is True: polling_method = AsyncARMPolling(lro_delay, **kwargs)
          elif polling is False: polling_method = AsyncNoPolling()
          else: polling_method = polling
          if cont_token:
              return AsyncLROPoller.from_continuation_token(
                  polling_method=polling_method,
                  continuation_token=cont_token,
                  client=self._client,
                  deserialization_callback=get_long_running_output
              )
          return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method)
  
      begin_restart.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/restart"}  # type: ignore
  
      async def _start_initial(  # pylint: disable=inconsistent-return-statements
          self,
          resource_group_name: str,
          vm_name: str,
          **kwargs: Any
      ) -> 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 = kwargs.pop('api_version', "2021-03-01")  # type: str
  
          
          request = build_start_request_initial(
              resource_group_name=resource_group_name,
              vm_name=vm_name,
              subscription_id=self._config.subscription_id,
              api_version=api_version,
              template_url=self._start_initial.metadata['url'],
          )
          request = _convert_request(request)
          request.url = self._client.format_url(request.url)
  
          pipeline_response = await self._client._pipeline.run(  # pylint: disable=protected-access
              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 cls:
              return cls(pipeline_response, None, {})
  
      _start_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/start"}  # type: ignore
  
  
      @distributed_trace_async
      async def begin_start(  # pylint: disable=inconsistent-return-statements
          self,
          resource_group_name: str,
          vm_name: str,
          **kwargs: Any
      ) -> AsyncLROPoller[None]:
          """The operation to start a virtual machine.
  
          :param resource_group_name: The name of the resource group.
          :type resource_group_name: str
          :param vm_name: The name of the virtual machine.
          :type vm_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: By default, your polling method will be AsyncARMPolling. Pass in False for
           this operation to not poll, or pass in your own initialized polling object for a personal
           polling strategy.
          :paramtype polling: bool or ~azure.core.polling.AsyncPollingMethod
          :keyword int polling_interval: Default waiting time between two polls for LRO operations if no
           Retry-After header is present.
          :return: An instance of AsyncLROPoller that returns either None or the result of cls(response)
          :rtype: ~azure.core.polling.AsyncLROPoller[None]
          :raises: ~azure.core.exceptions.HttpResponseError
          """
          api_version = kwargs.pop('api_version', "2021-03-01")  # type: str
          polling = kwargs.pop('polling', True)  # type: Union[bool, AsyncPollingMethod]
          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 = await self._start_initial(
                  resource_group_name=resource_group_name,
                  vm_name=vm_name,
                  api_version=api_version,
                  cls=lambda x,y,z: x,
                  **kwargs
              )
          kwargs.pop('error_map', None)
  
          def get_long_running_output(pipeline_response):
              if cls:
                  return cls(pipeline_response, None, {})
  
  
          if polling is True: polling_method = AsyncARMPolling(lro_delay, **kwargs)
          elif polling is False: polling_method = AsyncNoPolling()
          else: polling_method = polling
          if cont_token:
              return AsyncLROPoller.from_continuation_token(
                  polling_method=polling_method,
                  continuation_token=cont_token,
                  client=self._client,
                  deserialization_callback=get_long_running_output
              )
          return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method)
  
      begin_start.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/start"}  # type: ignore
  
      async def _redeploy_initial(  # pylint: disable=inconsistent-return-statements
          self,
          resource_group_name: str,
          vm_name: str,
          **kwargs: Any
      ) -> 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 = kwargs.pop('api_version', "2021-03-01")  # type: str
  
          
          request = build_redeploy_request_initial(
              resource_group_name=resource_group_name,
              vm_name=vm_name,
              subscription_id=self._config.subscription_id,
              api_version=api_version,
              template_url=self._redeploy_initial.metadata['url'],
          )
          request = _convert_request(request)
          request.url = self._client.format_url(request.url)
  
          pipeline_response = await self._client._pipeline.run(  # pylint: disable=protected-access
              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 cls:
              return cls(pipeline_response, None, {})
  
      _redeploy_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/redeploy"}  # type: ignore
  
  
      @distributed_trace_async
      async def begin_redeploy(  # pylint: disable=inconsistent-return-statements
          self,
          resource_group_name: str,
          vm_name: str,
          **kwargs: Any
      ) -> AsyncLROPoller[None]:
          """Shuts down the virtual machine, moves it to a new node, and powers it back on.
  
          :param resource_group_name: The name of the resource group.
          :type resource_group_name: str
          :param vm_name: The name of the virtual machine.
          :type vm_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: By default, your polling method will be AsyncARMPolling. Pass in False for
           this operation to not poll, or pass in your own initialized polling object for a personal
           polling strategy.
          :paramtype polling: bool or ~azure.core.polling.AsyncPollingMethod
          :keyword int polling_interval: Default waiting time between two polls for LRO operations if no
           Retry-After header is present.
          :return: An instance of AsyncLROPoller that returns either None or the result of cls(response)
          :rtype: ~azure.core.polling.AsyncLROPoller[None]
          :raises: ~azure.core.exceptions.HttpResponseError
          """
          api_version = kwargs.pop('api_version', "2021-03-01")  # type: str
          polling = kwargs.pop('polling', True)  # type: Union[bool, AsyncPollingMethod]
          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 = await self._redeploy_initial(
                  resource_group_name=resource_group_name,
                  vm_name=vm_name,
                  api_version=api_version,
                  cls=lambda x,y,z: x,
                  **kwargs
              )
          kwargs.pop('error_map', None)
  
          def get_long_running_output(pipeline_response):
              if cls:
                  return cls(pipeline_response, None, {})
  
  
          if polling is True: polling_method = AsyncARMPolling(lro_delay, **kwargs)
          elif polling is False: polling_method = AsyncNoPolling()
          else: polling_method = polling
          if cont_token:
              return AsyncLROPoller.from_continuation_token(
                  polling_method=polling_method,
                  continuation_token=cont_token,
                  client=self._client,
                  deserialization_callback=get_long_running_output
              )
          return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method)
  
      begin_redeploy.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/redeploy"}  # type: ignore
  
      async def _reimage_initial(  # pylint: disable=inconsistent-return-statements
          self,
          resource_group_name: str,
          vm_name: str,
          parameters: Optional["_models.VirtualMachineReimageParameters"] = None,
          **kwargs: Any
      ) -> 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 = kwargs.pop('api_version', "2021-03-01")  # type: str
          content_type = kwargs.pop('content_type', "application/json")  # type: Optional[str]
  
          if parameters is not None:
              _json = self._serialize.body(parameters, 'VirtualMachineReimageParameters')
          else:
              _json = None
  
          request = build_reimage_request_initial(
              resource_group_name=resource_group_name,
              vm_name=vm_name,
              subscription_id=self._config.subscription_id,
              api_version=api_version,
              content_type=content_type,
              json=_json,
              template_url=self._reimage_initial.metadata['url'],
          )
          request = _convert_request(request)
          request.url = self._client.format_url(request.url)
  
          pipeline_response = await self._client._pipeline.run(  # pylint: disable=protected-access
              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 cls:
              return cls(pipeline_response, None, {})
  
      _reimage_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/reimage"}  # type: ignore
  
  
      @distributed_trace_async
      async def begin_reimage(  # pylint: disable=inconsistent-return-statements
          self,
          resource_group_name: str,
          vm_name: str,
          parameters: Optional["_models.VirtualMachineReimageParameters"] = None,
          **kwargs: Any
      ) -> AsyncLROPoller[None]:
          """Reimages the virtual machine which has an ephemeral OS disk back to its initial state.
  
          :param resource_group_name: The name of the resource group.
          :type resource_group_name: str
          :param vm_name: The name of the virtual machine.
          :type vm_name: str
          :param parameters: Parameters supplied to the Reimage Virtual Machine operation. Default value
           is None.
          :type parameters: ~azure.mgmt.compute.v2021_03_01.models.VirtualMachineReimageParameters
          :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: By default, your polling method will be AsyncARMPolling. Pass in False for
           this operation to not poll, or pass in your own initialized polling object for a personal
           polling strategy.
          :paramtype polling: bool or ~azure.core.polling.AsyncPollingMethod
          :keyword int polling_interval: Default waiting time between two polls for LRO operations if no
           Retry-After header is present.
          :return: An instance of AsyncLROPoller that returns either None or the result of cls(response)
          :rtype: ~azure.core.polling.AsyncLROPoller[None]
          :raises: ~azure.core.exceptions.HttpResponseError
          """
          api_version = kwargs.pop('api_version', "2021-03-01")  # type: str
          content_type = kwargs.pop('content_type', "application/json")  # type: Optional[str]
          polling = kwargs.pop('polling', True)  # type: Union[bool, AsyncPollingMethod]
          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 = await self._reimage_initial(
                  resource_group_name=resource_group_name,
                  vm_name=vm_name,
                  parameters=parameters,
                  api_version=api_version,
                  content_type=content_type,
                  cls=lambda x,y,z: x,
                  **kwargs
              )
          kwargs.pop('error_map', None)
  
          def get_long_running_output(pipeline_response):
              if cls:
                  return cls(pipeline_response, None, {})
  
  
          if polling is True: polling_method = AsyncARMPolling(lro_delay, **kwargs)
          elif polling is False: polling_method = AsyncNoPolling()
          else: polling_method = polling
          if cont_token:
              return AsyncLROPoller.from_continuation_token(
                  polling_method=polling_method,
                  continuation_token=cont_token,
                  client=self._client,
                  deserialization_callback=get_long_running_output
              )
          return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method)
  
      begin_reimage.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/reimage"}  # type: ignore
  
      @distributed_trace_async
      async def retrieve_boot_diagnostics_data(
          self,
          resource_group_name: str,
          vm_name: str,
          sas_uri_expiration_time_in_minutes: Optional[int] = None,
          **kwargs: Any
      ) -> "_models.RetrieveBootDiagnosticsDataResult":
          """The operation to retrieve SAS URIs for a virtual machine's boot diagnostic logs.
  
          :param resource_group_name: The name of the resource group.
          :type resource_group_name: str
          :param vm_name: The name of the virtual machine.
          :type vm_name: str
          :param sas_uri_expiration_time_in_minutes: Expiration duration in minutes for the SAS URIs with
           a value between 1 to 1440 minutes. :code:`<br>`:code:`<br>`NOTE: If not specified, SAS URIs
           will be generated with a default expiration duration of 120 minutes. Default value is None.
          :type sas_uri_expiration_time_in_minutes: int
          :keyword callable cls: A custom type or function that will be passed the direct response
          :return: RetrieveBootDiagnosticsDataResult, or the result of cls(response)
          :rtype: ~azure.mgmt.compute.v2021_03_01.models.RetrieveBootDiagnosticsDataResult
          :raises: ~azure.core.exceptions.HttpResponseError
          """
          cls = kwargs.pop('cls', None)  # type: ClsType["_models.RetrieveBootDiagnosticsDataResult"]
          error_map = {
              401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
          }
          error_map.update(kwargs.pop('error_map', {}))
  
          api_version = kwargs.pop('api_version', "2021-03-01")  # type: str
  
          
          request = build_retrieve_boot_diagnostics_data_request(
              resource_group_name=resource_group_name,
              vm_name=vm_name,
              subscription_id=self._config.subscription_id,
              api_version=api_version,
              sas_uri_expiration_time_in_minutes=sas_uri_expiration_time_in_minutes,
              template_url=self.retrieve_boot_diagnostics_data.metadata['url'],
          )
          request = _convert_request(request)
          request.url = self._client.format_url(request.url)
  
          pipeline_response = await self._client._pipeline.run(  # pylint: disable=protected-access
              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)
              error = self._deserialize.failsafe_deserialize(_models.CloudErrorAutoGenerated, pipeline_response)
              raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
  
          deserialized = self._deserialize('RetrieveBootDiagnosticsDataResult', pipeline_response)
  
          if cls:
              return cls(pipeline_response, deserialized, {})
  
          return deserialized
  
      retrieve_boot_diagnostics_data.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/retrieveBootDiagnosticsData"}  # type: ignore
  
  
      async def _perform_maintenance_initial(  # pylint: disable=inconsistent-return-statements
          self,
          resource_group_name: str,
          vm_name: str,
          **kwargs: Any
      ) -> 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 = kwargs.pop('api_version', "2021-03-01")  # type: str
  
          
          request = build_perform_maintenance_request_initial(
              resource_group_name=resource_group_name,
              vm_name=vm_name,
              subscription_id=self._config.subscription_id,
              api_version=api_version,
              template_url=self._perform_maintenance_initial.metadata['url'],
          )
          request = _convert_request(request)
          request.url = self._client.format_url(request.url)
  
          pipeline_response = await self._client._pipeline.run(  # pylint: disable=protected-access
              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 cls:
              return cls(pipeline_response, None, {})
  
      _perform_maintenance_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/performMaintenance"}  # type: ignore
  
  
      @distributed_trace_async
      async def begin_perform_maintenance(  # pylint: disable=inconsistent-return-statements
          self,
          resource_group_name: str,
          vm_name: str,
          **kwargs: Any
      ) -> AsyncLROPoller[None]:
          """The operation to perform maintenance on a virtual machine.
  
          :param resource_group_name: The name of the resource group.
          :type resource_group_name: str
          :param vm_name: The name of the virtual machine.
          :type vm_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: By default, your polling method will be AsyncARMPolling. Pass in False for
           this operation to not poll, or pass in your own initialized polling object for a personal
           polling strategy.
          :paramtype polling: bool or ~azure.core.polling.AsyncPollingMethod
          :keyword int polling_interval: Default waiting time between two polls for LRO operations if no
           Retry-After header is present.
          :return: An instance of AsyncLROPoller that returns either None or the result of cls(response)
          :rtype: ~azure.core.polling.AsyncLROPoller[None]
          :raises: ~azure.core.exceptions.HttpResponseError
          """
          api_version = kwargs.pop('api_version', "2021-03-01")  # type: str
          polling = kwargs.pop('polling', True)  # type: Union[bool, AsyncPollingMethod]
          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 = await self._perform_maintenance_initial(
                  resource_group_name=resource_group_name,
                  vm_name=vm_name,
                  api_version=api_version,
                  cls=lambda x,y,z: x,
                  **kwargs
              )
          kwargs.pop('error_map', None)
  
          def get_long_running_output(pipeline_response):
              if cls:
                  return cls(pipeline_response, None, {})
  
  
          if polling is True: polling_method = AsyncARMPolling(lro_delay, **kwargs)
          elif polling is False: polling_method = AsyncNoPolling()
          else: polling_method = polling
          if cont_token:
              return AsyncLROPoller.from_continuation_token(
                  polling_method=polling_method,
                  continuation_token=cont_token,
                  client=self._client,
                  deserialization_callback=get_long_running_output
              )
          return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method)
  
      begin_perform_maintenance.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/performMaintenance"}  # type: ignore
  
      @distributed_trace_async
      async def simulate_eviction(  # pylint: disable=inconsistent-return-statements
          self,
          resource_group_name: str,
          vm_name: str,
          **kwargs: Any
      ) -> None:
          """The operation to simulate the eviction of spot virtual machine.
  
          :param resource_group_name: The name of the resource group.
          :type resource_group_name: str
          :param vm_name: The name of the virtual machine.
          :type vm_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 = kwargs.pop('api_version', "2021-03-01")  # type: str
  
          
          request = build_simulate_eviction_request(
              resource_group_name=resource_group_name,
              vm_name=vm_name,
              subscription_id=self._config.subscription_id,
              api_version=api_version,
              template_url=self.simulate_eviction.metadata['url'],
          )
          request = _convert_request(request)
          request.url = self._client.format_url(request.url)
  
          pipeline_response = await self._client._pipeline.run(  # pylint: disable=protected-access
              request,
              stream=False,
              **kwargs
          )
          response = pipeline_response.http_response
  
          if response.status_code not in [204]:
              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, {})
  
      simulate_eviction.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/simulateEviction"}  # type: ignore
  
  
      async def _assess_patches_initial(
          self,
          resource_group_name: str,
          vm_name: str,
          **kwargs: Any
      ) -> Optional["_models.VirtualMachineAssessPatchesResult"]:
          cls = kwargs.pop('cls', None)  # type: ClsType[Optional["_models.VirtualMachineAssessPatchesResult"]]
          error_map = {
              401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
          }
          error_map.update(kwargs.pop('error_map', {}))
  
          api_version = kwargs.pop('api_version', "2021-03-01")  # type: str
  
          
          request = build_assess_patches_request_initial(
              resource_group_name=resource_group_name,
              vm_name=vm_name,
              subscription_id=self._config.subscription_id,
              api_version=api_version,
              template_url=self._assess_patches_initial.metadata['url'],
          )
          request = _convert_request(request)
          request.url = self._client.format_url(request.url)
  
          pipeline_response = await self._client._pipeline.run(  # pylint: disable=protected-access
              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)
  
          deserialized = None
          if response.status_code == 200:
              deserialized = self._deserialize('VirtualMachineAssessPatchesResult', pipeline_response)
  
          if cls:
              return cls(pipeline_response, deserialized, {})
  
          return deserialized
  
      _assess_patches_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/assessPatches"}  # type: ignore
  
  
      @distributed_trace_async
      async def begin_assess_patches(
          self,
          resource_group_name: str,
          vm_name: str,
          **kwargs: Any
      ) -> AsyncLROPoller["_models.VirtualMachineAssessPatchesResult"]:
          """Assess patches on the VM.
  
          :param resource_group_name: The name of the resource group.
          :type resource_group_name: str
          :param vm_name: The name of the virtual machine.
          :type vm_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: By default, your polling method will be AsyncARMPolling. Pass in False for
           this operation to not poll, or pass in your own initialized polling object for a personal
           polling strategy.
          :paramtype polling: bool or ~azure.core.polling.AsyncPollingMethod
          :keyword int polling_interval: Default waiting time between two polls for LRO operations if no
           Retry-After header is present.
          :return: An instance of AsyncLROPoller that returns either VirtualMachineAssessPatchesResult or
           the result of cls(response)
          :rtype:
           ~azure.core.polling.AsyncLROPoller[~azure.mgmt.compute.v2021_03_01.models.VirtualMachineAssessPatchesResult]
          :raises: ~azure.core.exceptions.HttpResponseError
          """
          api_version = kwargs.pop('api_version', "2021-03-01")  # type: str
          polling = kwargs.pop('polling', True)  # type: Union[bool, AsyncPollingMethod]
          cls = kwargs.pop('cls', None)  # type: ClsType["_models.VirtualMachineAssessPatchesResult"]
          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 = await self._assess_patches_initial(
                  resource_group_name=resource_group_name,
                  vm_name=vm_name,
                  api_version=api_version,
                  cls=lambda x,y,z: x,
                  **kwargs
              )
          kwargs.pop('error_map', None)
  
          def get_long_running_output(pipeline_response):
              response = pipeline_response.http_response
              deserialized = self._deserialize('VirtualMachineAssessPatchesResult', pipeline_response)
              if cls:
                  return cls(pipeline_response, deserialized, {})
              return deserialized
  
  
          if polling is True: polling_method = AsyncARMPolling(lro_delay, lro_options={'final-state-via': 'location'}, **kwargs)
          elif polling is False: polling_method = AsyncNoPolling()
          else: polling_method = polling
          if cont_token:
              return AsyncLROPoller.from_continuation_token(
                  polling_method=polling_method,
                  continuation_token=cont_token,
                  client=self._client,
                  deserialization_callback=get_long_running_output
              )
          return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method)
  
      begin_assess_patches.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/assessPatches"}  # type: ignore
  
      async def _install_patches_initial(
          self,
          resource_group_name: str,
          vm_name: str,
          install_patches_input: "_models.VirtualMachineInstallPatchesParameters",
          **kwargs: Any
      ) -> Optional["_models.VirtualMachineInstallPatchesResult"]:
          cls = kwargs.pop('cls', None)  # type: ClsType[Optional["_models.VirtualMachineInstallPatchesResult"]]
          error_map = {
              401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
          }
          error_map.update(kwargs.pop('error_map', {}))
  
          api_version = kwargs.pop('api_version', "2021-03-01")  # type: str
          content_type = kwargs.pop('content_type', "application/json")  # type: Optional[str]
  
          _json = self._serialize.body(install_patches_input, 'VirtualMachineInstallPatchesParameters')
  
          request = build_install_patches_request_initial(
              resource_group_name=resource_group_name,
              vm_name=vm_name,
              subscription_id=self._config.subscription_id,
              api_version=api_version,
              content_type=content_type,
              json=_json,
              template_url=self._install_patches_initial.metadata['url'],
          )
          request = _convert_request(request)
          request.url = self._client.format_url(request.url)
  
          pipeline_response = await self._client._pipeline.run(  # pylint: disable=protected-access
              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)
  
          deserialized = None
          if response.status_code == 200:
              deserialized = self._deserialize('VirtualMachineInstallPatchesResult', pipeline_response)
  
          if cls:
              return cls(pipeline_response, deserialized, {})
  
          return deserialized
  
      _install_patches_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/installPatches"}  # type: ignore
  
  
      @distributed_trace_async
      async def begin_install_patches(
          self,
          resource_group_name: str,
          vm_name: str,
          install_patches_input: "_models.VirtualMachineInstallPatchesParameters",
          **kwargs: Any
      ) -> AsyncLROPoller["_models.VirtualMachineInstallPatchesResult"]:
          """Installs patches on the VM.
  
          :param resource_group_name: The name of the resource group.
          :type resource_group_name: str
          :param vm_name: The name of the virtual machine.
          :type vm_name: str
          :param install_patches_input: Input for InstallPatches as directly received by the API.
          :type install_patches_input:
           ~azure.mgmt.compute.v2021_03_01.models.VirtualMachineInstallPatchesParameters
          :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: By default, your polling method will be AsyncARMPolling. Pass in False for
           this operation to not poll, or pass in your own initialized polling object for a personal
           polling strategy.
          :paramtype polling: bool or ~azure.core.polling.AsyncPollingMethod
          :keyword int polling_interval: Default waiting time between two polls for LRO operations if no
           Retry-After header is present.
          :return: An instance of AsyncLROPoller that returns either VirtualMachineInstallPatchesResult
           or the result of cls(response)
          :rtype:
           ~azure.core.polling.AsyncLROPoller[~azure.mgmt.compute.v2021_03_01.models.VirtualMachineInstallPatchesResult]
          :raises: ~azure.core.exceptions.HttpResponseError
          """
          api_version = kwargs.pop('api_version', "2021-03-01")  # type: str
          content_type = kwargs.pop('content_type', "application/json")  # type: Optional[str]
          polling = kwargs.pop('polling', True)  # type: Union[bool, AsyncPollingMethod]
          cls = kwargs.pop('cls', None)  # type: ClsType["_models.VirtualMachineInstallPatchesResult"]
          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 = await self._install_patches_initial(
                  resource_group_name=resource_group_name,
                  vm_name=vm_name,
                  install_patches_input=install_patches_input,
                  api_version=api_version,
                  content_type=content_type,
                  cls=lambda x,y,z: x,
                  **kwargs
              )
          kwargs.pop('error_map', None)
  
          def get_long_running_output(pipeline_response):
              response = pipeline_response.http_response
              deserialized = self._deserialize('VirtualMachineInstallPatchesResult', pipeline_response)
              if cls:
                  return cls(pipeline_response, deserialized, {})
              return deserialized
  
  
          if polling is True: polling_method = AsyncARMPolling(lro_delay, lro_options={'final-state-via': 'location'}, **kwargs)
          elif polling is False: polling_method = AsyncNoPolling()
          else: polling_method = polling
          if cont_token:
              return AsyncLROPoller.from_continuation_token(
                  polling_method=polling_method,
                  continuation_token=cont_token,
                  client=self._client,
                  deserialization_callback=get_long_running_output
              )
          return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method)
  
      begin_install_patches.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/installPatches"}  # type: ignore
  
      async def _run_command_initial(
          self,
          resource_group_name: str,
          vm_name: str,
          parameters: "_models.RunCommandInput",
          *,
          content_type: Optional[str] = "application/json",
          **kwargs: Any
      ) -> Optional["_models.RunCommandResult"]:
          cls = kwargs.pop('cls', None)  # type: ClsType[Optional["_models.RunCommandResult"]]
          error_map = {
              401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
          }
          error_map.update(kwargs.pop('error_map', {}))
  
          api_version = kwargs.pop('api_version', "2021-03-01")  # type: str
  
          _json = self._serialize.body(parameters, 'RunCommandInput')
  
          request = build_run_command_request_initial(
              resource_group_name=resource_group_name,
              vm_name=vm_name,
              subscription_id=self._config.subscription_id,
              api_version=api_version,
              content_type=content_type,
              json=_json,
              template_url=self._run_command_initial.metadata['url'],
          )
          request = _convert_request(request)
          request.url = self._client.format_url(request.url)
  
          pipeline_response = await self._client._pipeline.run(  # pylint: disable=protected-access
              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)
  
          deserialized = None
          if response.status_code == 200:
              deserialized = self._deserialize('RunCommandResult', pipeline_response)
  
          if cls:
              return cls(pipeline_response, deserialized, {})
  
          return deserialized
  
      _run_command_initial.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/runCommand"}  # type: ignore
  
  
      @distributed_trace_async
      async def begin_run_command(
          self,
          resource_group_name: str,
          vm_name: str,
          parameters: "_models.RunCommandInput",
          *,
          content_type: Optional[str] = "application/json",
          **kwargs: Any
      ) -> AsyncLROPoller["_models.RunCommandResult"]:
          """Run command on the VM.
  
          :param resource_group_name: The name of the resource group.
          :type resource_group_name: str
          :param vm_name: The name of the virtual machine.
          :type vm_name: str
          :param parameters: Parameters supplied to the Run command operation.
          :type parameters: ~azure.mgmt.compute.v2021_03_01.models.RunCommandInput
          :keyword content_type: Media type of the body sent to the API. Possible values are:
           "application/json" or "text/json". Default value is "application/json".
          :paramtype content_type: 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: By default, your polling method will be AsyncARMPolling. Pass in False for
           this operation to not poll, or pass in your own initialized polling object for a personal
           polling strategy.
          :paramtype polling: bool or ~azure.core.polling.AsyncPollingMethod
          :keyword int polling_interval: Default waiting time between two polls for LRO operations if no
           Retry-After header is present.
          :return: An instance of AsyncLROPoller that returns either RunCommandResult or the result of
           cls(response)
          :rtype:
           ~azure.core.polling.AsyncLROPoller[~azure.mgmt.compute.v2021_03_01.models.RunCommandResult]
          :raises: ~azure.core.exceptions.HttpResponseError
          """
          api_version = kwargs.pop('api_version', "2021-03-01")  # type: str
          polling = kwargs.pop('polling', True)  # type: Union[bool, AsyncPollingMethod]
          cls = kwargs.pop('cls', None)  # type: ClsType["_models.RunCommandResult"]
          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 = await self._run_command_initial(
                  resource_group_name=resource_group_name,
                  vm_name=vm_name,
                  parameters=parameters,
                  content_type=content_type,
                  api_version=api_version,
                  cls=lambda x,y,z: x,
                  **kwargs
              )
          kwargs.pop('error_map', None)
  
          def get_long_running_output(pipeline_response):
              response = pipeline_response.http_response
              deserialized = self._deserialize('RunCommandResult', pipeline_response)
              if cls:
                  return cls(pipeline_response, deserialized, {})
              return deserialized
  
  
          if polling is True: polling_method = AsyncARMPolling(lro_delay, lro_options={'final-state-via': 'location'}, **kwargs)
          elif polling is False: polling_method = AsyncNoPolling()
          else: polling_method = polling
          if cont_token:
              return AsyncLROPoller.from_continuation_token(
                  polling_method=polling_method,
                  continuation_token=cont_token,
                  client=self._client,
                  deserialization_callback=get_long_running_output
              )
          return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method)
  
      begin_run_command.metadata = {'url': "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/runCommand"}  # type: ignore
  