text: # coding=utf-8
  # --------------------------------------------------------------------------
  # Copyright (c) Microsoft Corporation. All rights reserved.
  # Licensed under the MIT License. See License.txt in the project root for license information.
  # Code generated by Microsoft (R) AutoRest Code Generator.
  # Changes may cause incorrect behavior and will be lost if the code is regenerated.
  # --------------------------------------------------------------------------
  import functools
  from typing import Any, Callable, Dict, Generic, Iterable, Optional, TypeVar, Union
  import warnings
  
  from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error
  from azure.core.paging import ItemPaged
  from azure.core.pipeline import PipelineResponse
  from azure.core.pipeline.transport import HttpResponse
  from azure.core.polling import LROPoller, NoPolling, PollingMethod
  from azure.core.rest import HttpRequest
  from azure.core.tracing.decorator import distributed_trace
  from azure.mgmt.core.exceptions import ARMErrorFormat
  from azure.mgmt.core.polling.arm_polling import ARMPolling
  from msrest import Serializer
  
  from .. import models as _models
  from .._vendor import _convert_request, _format_url_section
  T = TypeVar('T')
  JSONType = Any
  ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]]
  
  _SERIALIZER = Serializer()
  _SERIALIZER.client_side_validation = False
  
  def build_list_by_location_request(
      location: str,
      subscription_id: str,
      **kwargs: Any
  ) -> HttpRequest:
      api_version = "2021-03-01"
      accept = "application/json"
      # Construct URL
      url = kwargs.pop("template_url", '/subscriptions/{subscriptionId}/providers/Microsoft.Compute/locations/{location}/virtualMachines')
      path_format_arguments = {
          "location": _SERIALIZER.url("location", location, 'str', pattern=r'^[-\w\._]+$'),
          "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'),
      }
  
      url = _format_url_section(url, **path_format_arguments)
  
      # Construct parameters
      query_parameters = kwargs.pop("params", {})  # type: Dict[str, Any]
      query_parameters['api-version'] = _SERIALIZER.query("api_version", api_version, 'str')
  
      # Construct headers
      header_parameters = kwargs.pop("headers", {})  # type: Dict[str, Any]
      header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str')
  
      return HttpRequest(
          method="GET",
          url=url,
          params=query_parameters,
          headers=header_parameters,
          **kwargs
      )
  
  
  def build_capture_request_initial(
      resource_group_name: str,
      vm_name: str,
      subscription_id: str,
      *,
      json: JSONType = None,
      content: Any = None,
      **kwargs: Any
  ) -> HttpRequest:
      content_type = kwargs.pop('content_type', None)  # type: Optional[str]
  
      api_version = "2021-03-01"
      accept = "application/json"
      # Construct URL
      url = kwargs.pop("template_url", '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/capture')
      path_format_arguments = {
          "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str'),
          "vmName": _SERIALIZER.url("vm_name", vm_name, 'str'),
          "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'),
      }
  
      url = _format_url_section(url, **path_format_arguments)
  
      # Construct parameters
      query_parameters = kwargs.pop("params", {})  # type: Dict[str, Any]
      query_parameters['api-version'] = _SERIALIZER.query("api_version", api_version, 'str')
  
      # Construct headers
      header_parameters = kwargs.pop("headers", {})  # type: Dict[str, Any]
      if content_type is not None:
          header_parameters['Content-Type'] = _SERIALIZER.header("content_type", content_type, 'str')
      header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str')
  
      return HttpRequest(
          method="POST",
          url=url,
          params=query_parameters,
          headers=header_parameters,
          json=json,
          content=content,
          **kwargs
      )
  
  
  def build_create_or_update_request_initial(
      resource_group_name: str,
      vm_name: str,
      subscription_id: str,
      *,
      json: JSONType = None,
      content: Any = None,
      **kwargs: Any
  ) -> HttpRequest:
      content_type = kwargs.pop('content_type', None)  # type: Optional[str]
  
      api_version = "2021-03-01"
      accept = "application/json"
      # Construct URL
      url = kwargs.pop("template_url", '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}')
      path_format_arguments = {
          "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str'),
          "vmName": _SERIALIZER.url("vm_name", vm_name, 'str'),
          "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'),
      }
  
      url = _format_url_section(url, **path_format_arguments)
  
      # Construct parameters
      query_parameters = kwargs.pop("params", {})  # type: Dict[str, Any]
      query_parameters['api-version'] = _SERIALIZER.query("api_version", api_version, 'str')
  
      # Construct headers
      header_parameters = kwargs.pop("headers", {})  # type: Dict[str, Any]
      if content_type is not None:
          header_parameters['Content-Type'] = _SERIALIZER.header("content_type", content_type, 'str')
      header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str')
  
      return HttpRequest(
          method="PUT",
          url=url,
          params=query_parameters,
          headers=header_parameters,
          json=json,
          content=content,
          **kwargs
      )
  
  
  def build_update_request_initial(
      resource_group_name: str,
      vm_name: str,
      subscription_id: str,
      *,
      json: JSONType = None,
      content: Any = None,
      **kwargs: Any
  ) -> HttpRequest:
      content_type = kwargs.pop('content_type', None)  # type: Optional[str]
  
      api_version = "2021-03-01"
      accept = "application/json"
      # Construct URL
      url = kwargs.pop("template_url", '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}')
      path_format_arguments = {
          "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str'),
          "vmName": _SERIALIZER.url("vm_name", vm_name, 'str'),
          "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'),
      }
  
      url = _format_url_section(url, **path_format_arguments)
  
      # Construct parameters
      query_parameters = kwargs.pop("params", {})  # type: Dict[str, Any]
      query_parameters['api-version'] = _SERIALIZER.query("api_version", api_version, 'str')
  
      # Construct headers
      header_parameters = kwargs.pop("headers", {})  # type: Dict[str, Any]
      if content_type is not None:
          header_parameters['Content-Type'] = _SERIALIZER.header("content_type", content_type, 'str')
      header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str')
  
      return HttpRequest(
          method="PATCH",
          url=url,
          params=query_parameters,
          headers=header_parameters,
          json=json,
          content=content,
          **kwargs
      )
  
  
  def build_delete_request_initial(
      resource_group_name: str,
      vm_name: str,
      subscription_id: str,
      *,
      force_deletion: Optional[bool] = None,
      **kwargs: Any
  ) -> HttpRequest:
      api_version = "2021-03-01"
      # Construct URL
      url = kwargs.pop("template_url", '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}')
      path_format_arguments = {
          "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str'),
          "vmName": _SERIALIZER.url("vm_name", vm_name, 'str'),
          "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'),
      }
  
      url = _format_url_section(url, **path_format_arguments)
  
      # Construct parameters
      query_parameters = kwargs.pop("params", {})  # type: Dict[str, Any]
      if force_deletion is not None:
          query_parameters['forceDeletion'] = _SERIALIZER.query("force_deletion", force_deletion, 'bool')
      query_parameters['api-version'] = _SERIALIZER.query("api_version", api_version, 'str')
  
      return HttpRequest(
          method="DELETE",
          url=url,
          params=query_parameters,
          **kwargs
      )
  
  
  def build_get_request(
      resource_group_name: str,
      vm_name: str,
      subscription_id: str,
      *,
      expand: Optional[Union[str, "_models.InstanceViewTypes"]] = None,
      **kwargs: Any
  ) -> HttpRequest:
      api_version = "2021-03-01"
      accept = "application/json"
      # Construct URL
      url = kwargs.pop("template_url", '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}')
      path_format_arguments = {
          "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str'),
          "vmName": _SERIALIZER.url("vm_name", vm_name, 'str'),
          "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'),
      }
  
      url = _format_url_section(url, **path_format_arguments)
  
      # Construct parameters
      query_parameters = kwargs.pop("params", {})  # type: Dict[str, Any]
      if expand is not None:
          query_parameters['$expand'] = _SERIALIZER.query("expand", expand, 'str')
      query_parameters['api-version'] = _SERIALIZER.query("api_version", api_version, 'str')
  
      # Construct headers
      header_parameters = kwargs.pop("headers", {})  # type: Dict[str, Any]
      header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str')
  
      return HttpRequest(
          method="GET",
          url=url,
          params=query_parameters,
          headers=header_parameters,
          **kwargs
      )
  
  
  def build_instance_view_request(
      resource_group_name: str,
      vm_name: str,
      subscription_id: str,
      **kwargs: Any
  ) -> HttpRequest:
      api_version = "2021-03-01"
      accept = "application/json"
      # Construct URL
      url = kwargs.pop("template_url", '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/instanceView')
      path_format_arguments = {
          "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str'),
          "vmName": _SERIALIZER.url("vm_name", vm_name, 'str'),
          "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'),
      }
  
      url = _format_url_section(url, **path_format_arguments)
  
      # Construct parameters
      query_parameters = kwargs.pop("params", {})  # type: Dict[str, Any]
      query_parameters['api-version'] = _SERIALIZER.query("api_version", api_version, 'str')
  
      # Construct headers
      header_parameters = kwargs.pop("headers", {})  # type: Dict[str, Any]
      header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str')
  
      return HttpRequest(
          method="GET",
          url=url,
          params=query_parameters,
          headers=header_parameters,
          **kwargs
      )
  
  
  def build_convert_to_managed_disks_request_initial(
      resource_group_name: str,
      vm_name: str,
      subscription_id: str,
      **kwargs: Any
  ) -> HttpRequest:
      api_version = "2021-03-01"
      # Construct URL
      url = kwargs.pop("template_url", '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/convertToManagedDisks')
      path_format_arguments = {
          "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str'),
          "vmName": _SERIALIZER.url("vm_name", vm_name, 'str'),
          "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'),
      }
  
      url = _format_url_section(url, **path_format_arguments)
  
      # Construct parameters
      query_parameters = kwargs.pop("params", {})  # type: Dict[str, Any]
      query_parameters['api-version'] = _SERIALIZER.query("api_version", api_version, 'str')
  
      return HttpRequest(
          method="POST",
          url=url,
          params=query_parameters,
          **kwargs
      )
  
  
  def build_deallocate_request_initial(
      resource_group_name: str,
      vm_name: str,
      subscription_id: str,
      **kwargs: Any
  ) -> HttpRequest:
      api_version = "2021-03-01"
      # Construct URL
      url = kwargs.pop("template_url", '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/deallocate')
      path_format_arguments = {
          "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str'),
          "vmName": _SERIALIZER.url("vm_name", vm_name, 'str'),
          "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'),
      }
  
      url = _format_url_section(url, **path_format_arguments)
  
      # Construct parameters
      query_parameters = kwargs.pop("params", {})  # type: Dict[str, Any]
      query_parameters['api-version'] = _SERIALIZER.query("api_version", api_version, 'str')
  
      return HttpRequest(
          method="POST",
          url=url,
          params=query_parameters,
          **kwargs
      )
  
  
  def build_generalize_request(
      resource_group_name: str,
      vm_name: str,
      subscription_id: str,
      **kwargs: Any
  ) -> HttpRequest:
      api_version = "2021-03-01"
      # Construct URL
      url = kwargs.pop("template_url", '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/generalize')
      path_format_arguments = {
          "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str'),
          "vmName": _SERIALIZER.url("vm_name", vm_name, 'str'),
          "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'),
      }
  
      url = _format_url_section(url, **path_format_arguments)
  
      # Construct parameters
      query_parameters = kwargs.pop("params", {})  # type: Dict[str, Any]
      query_parameters['api-version'] = _SERIALIZER.query("api_version", api_version, 'str')
  
      return HttpRequest(
          method="POST",
          url=url,
          params=query_parameters,
          **kwargs
      )
  
  
  def build_list_request(
      resource_group_name: str,
      subscription_id: str,
      **kwargs: Any
  ) -> HttpRequest:
      api_version = "2021-03-01"
      accept = "application/json"
      # Construct URL
      url = kwargs.pop("template_url", '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines')
      path_format_arguments = {
          "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str'),
          "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'),
      }
  
      url = _format_url_section(url, **path_format_arguments)
  
      # Construct parameters
      query_parameters = kwargs.pop("params", {})  # type: Dict[str, Any]
      query_parameters['api-version'] = _SERIALIZER.query("api_version", api_version, 'str')
  
      # Construct headers
      header_parameters = kwargs.pop("headers", {})  # type: Dict[str, Any]
      header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str')
  
      return HttpRequest(
          method="GET",
          url=url,
          params=query_parameters,
          headers=header_parameters,
          **kwargs
      )
  
  
  def build_list_all_request(
      subscription_id: str,
      *,
      status_only: Optional[str] = None,
      **kwargs: Any
  ) -> HttpRequest:
      api_version = "2021-03-01"
      accept = "application/json"
      # Construct URL
      url = kwargs.pop("template_url", '/subscriptions/{subscriptionId}/providers/Microsoft.Compute/virtualMachines')
      path_format_arguments = {
          "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'),
      }
  
      url = _format_url_section(url, **path_format_arguments)
  
      # Construct parameters
      query_parameters = kwargs.pop("params", {})  # type: Dict[str, Any]
      query_parameters['api-version'] = _SERIALIZER.query("api_version", api_version, 'str')
      if status_only is not None:
          query_parameters['statusOnly'] = _SERIALIZER.query("status_only", status_only, 'str')
  
      # Construct headers
      header_parameters = kwargs.pop("headers", {})  # type: Dict[str, Any]
      header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str')
  
      return HttpRequest(
          method="GET",
          url=url,
          params=query_parameters,
          headers=header_parameters,
          **kwargs
      )
  
  
  def build_list_available_sizes_request(
      resource_group_name: str,
      vm_name: str,
      subscription_id: str,
      **kwargs: Any
  ) -> HttpRequest:
      api_version = "2021-03-01"
      accept = "application/json"
      # Construct URL
      url = kwargs.pop("template_url", '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/vmSizes')
      path_format_arguments = {
          "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str'),
          "vmName": _SERIALIZER.url("vm_name", vm_name, 'str'),
          "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'),
      }
  
      url = _format_url_section(url, **path_format_arguments)
  
      # Construct parameters
      query_parameters = kwargs.pop("params", {})  # type: Dict[str, Any]
      query_parameters['api-version'] = _SERIALIZER.query("api_version", api_version, 'str')
  
      # Construct headers
      header_parameters = kwargs.pop("headers", {})  # type: Dict[str, Any]
      header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str')
  
      return HttpRequest(
          method="GET",
          url=url,
          params=query_parameters,
          headers=header_parameters,
          **kwargs
      )
  
  
  def build_power_off_request_initial(
      resource_group_name: str,
      vm_name: str,
      subscription_id: str,
      *,
      skip_shutdown: Optional[bool] = False,
      **kwargs: Any
  ) -> HttpRequest:
      api_version = "2021-03-01"
      # Construct URL
      url = kwargs.pop("template_url", '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/powerOff')
      path_format_arguments = {
          "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str'),
          "vmName": _SERIALIZER.url("vm_name", vm_name, 'str'),
          "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'),
      }
  
      url = _format_url_section(url, **path_format_arguments)
  
      # Construct parameters
      query_parameters = kwargs.pop("params", {})  # type: Dict[str, Any]
      if skip_shutdown is not None:
          query_parameters['skipShutdown'] = _SERIALIZER.query("skip_shutdown", skip_shutdown, 'bool')
      query_parameters['api-version'] = _SERIALIZER.query("api_version", api_version, 'str')
  
      return HttpRequest(
          method="POST",
          url=url,
          params=query_parameters,
          **kwargs
      )
  
  
  def build_reapply_request_initial(
      resource_group_name: str,
      vm_name: str,
      subscription_id: str,
      **kwargs: Any
  ) -> HttpRequest:
      api_version = "2021-03-01"
      accept = "application/json"
      # Construct URL
      url = kwargs.pop("template_url", '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/reapply')
      path_format_arguments = {
          "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str'),
          "vmName": _SERIALIZER.url("vm_name", vm_name, 'str'),
          "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'),
      }
  
      url = _format_url_section(url, **path_format_arguments)
  
      # Construct parameters
      query_parameters = kwargs.pop("params", {})  # type: Dict[str, Any]
      query_parameters['api-version'] = _SERIALIZER.query("api_version", api_version, 'str')
  
      # Construct headers
      header_parameters = kwargs.pop("headers", {})  # type: Dict[str, Any]
      header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str')
  
      return HttpRequest(
          method="POST",
          url=url,
          params=query_parameters,
          headers=header_parameters,
          **kwargs
      )
  
  
  def build_restart_request_initial(
      resource_group_name: str,
      vm_name: str,
      subscription_id: str,
      **kwargs: Any
  ) -> HttpRequest:
      api_version = "2021-03-01"
      # Construct URL
      url = kwargs.pop("template_url", '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/restart')
      path_format_arguments = {
          "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str'),
          "vmName": _SERIALIZER.url("vm_name", vm_name, 'str'),
          "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'),
      }
  
      url = _format_url_section(url, **path_format_arguments)
  
      # Construct parameters
      query_parameters = kwargs.pop("params", {})  # type: Dict[str, Any]
      query_parameters['api-version'] = _SERIALIZER.query("api_version", api_version, 'str')
  
      return HttpRequest(
          method="POST",
          url=url,
          params=query_parameters,
          **kwargs
      )
  
  
  def build_start_request_initial(
      resource_group_name: str,
      vm_name: str,
      subscription_id: str,
      **kwargs: Any
  ) -> HttpRequest:
      api_version = "2021-03-01"
      # Construct URL
      url = kwargs.pop("template_url", '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/start')
      path_format_arguments = {
          "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str'),
          "vmName": _SERIALIZER.url("vm_name", vm_name, 'str'),
          "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'),
      }
  
      url = _format_url_section(url, **path_format_arguments)
  
      # Construct parameters
      query_parameters = kwargs.pop("params", {})  # type: Dict[str, Any]
      query_parameters['api-version'] = _SERIALIZER.query("api_version", api_version, 'str')
  
      return HttpRequest(
          method="POST",
          url=url,
          params=query_parameters,
          **kwargs
      )
  
  
  def build_redeploy_request_initial(
      resource_group_name: str,
      vm_name: str,
      subscription_id: str,
      **kwargs: Any
  ) -> HttpRequest:
      api_version = "2021-03-01"
      # Construct URL
      url = kwargs.pop("template_url", '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/redeploy')
      path_format_arguments = {
          "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str'),
          "vmName": _SERIALIZER.url("vm_name", vm_name, 'str'),
          "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'),
      }
  
      url = _format_url_section(url, **path_format_arguments)
  
      # Construct parameters
      query_parameters = kwargs.pop("params", {})  # type: Dict[str, Any]
      query_parameters['api-version'] = _SERIALIZER.query("api_version", api_version, 'str')
  
      return HttpRequest(
          method="POST",
          url=url,
          params=query_parameters,
          **kwargs
      )
  
  
  def build_reimage_request_initial(
      resource_group_name: str,
      vm_name: str,
      subscription_id: str,
      *,
      json: JSONType = None,
      content: Any = None,
      **kwargs: Any
  ) -> HttpRequest:
      content_type = kwargs.pop('content_type', None)  # type: Optional[str]
  
      api_version = "2021-03-01"
      # Construct URL
      url = kwargs.pop("template_url", '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/reimage')
      path_format_arguments = {
          "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str'),
          "vmName": _SERIALIZER.url("vm_name", vm_name, 'str'),
          "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'),
      }
  
      url = _format_url_section(url, **path_format_arguments)
  
      # Construct parameters
      query_parameters = kwargs.pop("params", {})  # type: Dict[str, Any]
      query_parameters['api-version'] = _SERIALIZER.query("api_version", api_version, 'str')
  
      # Construct headers
      header_parameters = kwargs.pop("headers", {})  # type: Dict[str, Any]
      if content_type is not None:
          header_parameters['Content-Type'] = _SERIALIZER.header("content_type", content_type, 'str')
  
      return HttpRequest(
          method="POST",
          url=url,
          params=query_parameters,
          headers=header_parameters,
          json=json,
          content=content,
          **kwargs
      )
  
  
  def build_retrieve_boot_diagnostics_data_request(
      resource_group_name: str,
      vm_name: str,
      subscription_id: str,
      *,
      sas_uri_expiration_time_in_minutes: Optional[int] = None,
      **kwargs: Any
  ) -> HttpRequest:
      api_version = "2021-03-01"
      accept = "application/json"
      # Construct URL
      url = kwargs.pop("template_url", '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/retrieveBootDiagnosticsData')
      path_format_arguments = {
          "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str'),
          "vmName": _SERIALIZER.url("vm_name", vm_name, 'str'),
          "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'),
      }
  
      url = _format_url_section(url, **path_format_arguments)
  
      # Construct parameters
      query_parameters = kwargs.pop("params", {})  # type: Dict[str, Any]
      if sas_uri_expiration_time_in_minutes is not None:
          query_parameters['sasUriExpirationTimeInMinutes'] = _SERIALIZER.query("sas_uri_expiration_time_in_minutes", sas_uri_expiration_time_in_minutes, 'int')
      query_parameters['api-version'] = _SERIALIZER.query("api_version", api_version, 'str')
  
      # Construct headers
      header_parameters = kwargs.pop("headers", {})  # type: Dict[str, Any]
      header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str')
  
      return HttpRequest(
          method="POST",
          url=url,
          params=query_parameters,
          headers=header_parameters,
          **kwargs
      )
  
  
  def build_perform_maintenance_request_initial(
      resource_group_name: str,
      vm_name: str,
      subscription_id: str,
      **kwargs: Any
  ) -> HttpRequest:
      api_version = "2021-03-01"
      # Construct URL
      url = kwargs.pop("template_url", '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/performMaintenance')
      path_format_arguments = {
          "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str'),
          "vmName": _SERIALIZER.url("vm_name", vm_name, 'str'),
          "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'),
      }
  
      url = _format_url_section(url, **path_format_arguments)
  
      # Construct parameters
      query_parameters = kwargs.pop("params", {})  # type: Dict[str, Any]
      query_parameters['api-version'] = _SERIALIZER.query("api_version", api_version, 'str')
  
      return HttpRequest(
          method="POST",
          url=url,
          params=query_parameters,
          **kwargs
      )
  
  
  def build_simulate_eviction_request(
      resource_group_name: str,
      vm_name: str,
      subscription_id: str,
      **kwargs: Any
  ) -> HttpRequest:
      api_version = "2021-03-01"
      # Construct URL
      url = kwargs.pop("template_url", '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/simulateEviction')
      path_format_arguments = {
          "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str'),
          "vmName": _SERIALIZER.url("vm_name", vm_name, 'str'),
          "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'),
      }
  
      url = _format_url_section(url, **path_format_arguments)
  
      # Construct parameters
      query_parameters = kwargs.pop("params", {})  # type: Dict[str, Any]
      query_parameters['api-version'] = _SERIALIZER.query("api_version", api_version, 'str')
  
      return HttpRequest(
          method="POST",
          url=url,
          params=query_parameters,
          **kwargs
      )
  
  
  def build_assess_patches_request_initial(
      resource_group_name: str,
      vm_name: str,
      subscription_id: str,
      **kwargs: Any
  ) -> HttpRequest:
      api_version = "2021-03-01"
      accept = "application/json"
      # Construct URL
      url = kwargs.pop("template_url", '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/assessPatches')
      path_format_arguments = {
          "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str'),
          "vmName": _SERIALIZER.url("vm_name", vm_name, 'str'),
          "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'),
      }
  
      url = _format_url_section(url, **path_format_arguments)
  
      # Construct parameters
      query_parameters = kwargs.pop("params", {})  # type: Dict[str, Any]
      query_parameters['api-version'] = _SERIALIZER.query("api_version", api_version, 'str')
  
      # Construct headers
      header_parameters = kwargs.pop("headers", {})  # type: Dict[str, Any]
      header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str')
  
      return HttpRequest(
          method="POST",
          url=url,
          params=query_parameters,
          headers=header_parameters,
          **kwargs
      )
  
  
  def build_install_patches_request_initial(
      resource_group_name: str,
      vm_name: str,
      subscription_id: str,
      *,
      json: JSONType = None,
      content: Any = None,
      **kwargs: Any
  ) -> HttpRequest:
      content_type = kwargs.pop('content_type', None)  # type: Optional[str]
  
      api_version = "2021-03-01"
      accept = "application/json"
      # Construct URL
      url = kwargs.pop("template_url", '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/installPatches')
      path_format_arguments = {
          "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str'),
          "vmName": _SERIALIZER.url("vm_name", vm_name, 'str'),
          "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'),
      }
  
      url = _format_url_section(url, **path_format_arguments)
  
      # Construct parameters
      query_parameters = kwargs.pop("params", {})  # type: Dict[str, Any]
      query_parameters['api-version'] = _SERIALIZER.query("api_version", api_version, 'str')
  
      # Construct headers
      header_parameters = kwargs.pop("headers", {})  # type: Dict[str, Any]
      if content_type is not None:
          header_parameters['Content-Type'] = _SERIALIZER.header("content_type", content_type, 'str')
      header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str')
  
      return HttpRequest(
          method="POST",
          url=url,
          params=query_parameters,
          headers=header_parameters,
          json=json,
          content=content,
          **kwargs
      )
  
  
  def build_run_command_request_initial(
      resource_group_name: str,
      vm_name: str,
      subscription_id: str,
      *,
      json: JSONType = None,
      content: Any = None,
      **kwargs: Any
  ) -> HttpRequest:
      content_type = kwargs.pop('content_type', None)  # type: Optional[str]
  
      api_version = "2021-03-01"
      accept = "application/json, text/json"
      # Construct URL
      url = kwargs.pop("template_url", '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/runCommand')
      path_format_arguments = {
          "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str'),
          "vmName": _SERIALIZER.url("vm_name", vm_name, 'str'),
          "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'),
      }
  
      url = _format_url_section(url, **path_format_arguments)
  
      # Construct parameters
      query_parameters = kwargs.pop("params", {})  # type: Dict[str, Any]
      query_parameters['api-version'] = _SERIALIZER.query("api_version", api_version, 'str')
  
      # Construct headers
      header_parameters = kwargs.pop("headers", {})  # type: Dict[str, Any]
      if content_type is not None:
          header_parameters['Content-Type'] = _SERIALIZER.header("content_type", content_type, 'str')
      header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str')
  
      return HttpRequest(
          method="POST",
          url=url,
          params=query_parameters,
          headers=header_parameters,
          json=json,
          content=content,
          **kwargs
      )
  
  class VirtualMachinesOperations(object):
      """VirtualMachinesOperations 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):
          self._client = client
          self._serialize = serializer
          self._deserialize = deserializer
          self._config = config
  
      @distributed_trace
      def list_by_location(
          self,
          location: str,
          **kwargs: Any
      ) -> Iterable["_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.paging.ItemPaged[~azure.mgmt.compute.v2021_03_01.models.VirtualMachineListResult]
          :raises: ~azure.core.exceptions.HttpResponseError
          """
          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,
                      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,
                      template_url=next_link,
                  )
                  request = _convert_request(request)
                  request.url = self._client.format_url(request.url)
                  request.method = "GET"
              return request
  
          def extract_data(pipeline_response):
              deserialized = self._deserialize("VirtualMachineListResult", pipeline_response)
              list_of_elem = deserialized.value
              if cls:
                  list_of_elem = cls(list_of_elem)
              return deserialized.next_link or None, iter(list_of_elem)
  
          def get_next(next_link=None):
              request = prepare_request(next_link)
  
              pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs)
              response = pipeline_response.http_response
  
              if response.status_code not in [200]:
                  map_error(status_code=response.status_code, response=response, error_map=error_map)
                  raise HttpResponseError(response=response, error_format=ARMErrorFormat)
  
              return pipeline_response
  
  
          return ItemPaged(
              get_next, extract_data
          )
      list_by_location.metadata = {'url': '/subscriptions/{subscriptionId}/providers/Microsoft.Compute/locations/{location}/virtualMachines'}  # type: ignore
  
      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', {}))
  
          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,
              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 = self._client._pipeline.run(request, stream=False, **kwargs)
          response = pipeline_response.http_response
  
          if response.status_code not in [200, 202]:
              map_error(status_code=response.status_code, response=response, error_map=error_map)
              raise HttpResponseError(response=response, error_format=ARMErrorFormat)
  
          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
      def begin_capture(
          self,
          resource_group_name: str,
          vm_name: str,
          parameters: "_models.VirtualMachineCaptureParameters",
          **kwargs: Any
      ) -> LROPoller["_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 ARMPolling. 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.PollingMethod
          :keyword int polling_interval: Default waiting time between two polls for LRO operations if no
           Retry-After header is present.
          :return: An instance of LROPoller that returns either VirtualMachineCaptureResult or the result
           of cls(response)
          :rtype:
           ~azure.core.polling.LROPoller[~azure.mgmt.compute.v2021_03_01.models.VirtualMachineCaptureResult]
          :raises: ~azure.core.exceptions.HttpResponseError
          """
          content_type = kwargs.pop('content_type', "application/json")  # type: Optional[str]
          polling = kwargs.pop('polling', True)  # type: Union[bool, azure.core.polling.PollingMethod]
          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 = self._capture_initial(
                  resource_group_name=resource_group_name,
                  vm_name=vm_name,
                  parameters=parameters,
                  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 = ARMPolling(lro_delay, lro_options={'final-state-via': 'location'}, **kwargs)
          elif polling is False: polling_method = NoPolling()
          else: polling_method = polling
          if cont_token:
              return LROPoller.from_continuation_token(
                  polling_method=polling_method,
                  continuation_token=cont_token,
                  client=self._client,
                  deserialization_callback=get_long_running_output
              )
          else:
              return LROPoller(self._client, raw_result, get_long_running_output, polling_method)
  
      begin_capture.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/capture'}  # type: ignore
  
      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', {}))
  
          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,
              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 = self._client._pipeline.run(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
      def begin_create_or_update(
          self,
          resource_group_name: str,
          vm_name: str,
          parameters: "_models.VirtualMachine",
          **kwargs: Any
      ) -> LROPoller["_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 ARMPolling. 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.PollingMethod
          :keyword int polling_interval: Default waiting time between two polls for LRO operations if no
           Retry-After header is present.
          :return: An instance of LROPoller that returns either VirtualMachine or the result of
           cls(response)
          :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.compute.v2021_03_01.models.VirtualMachine]
          :raises: ~azure.core.exceptions.HttpResponseError
          """
          content_type = kwargs.pop('content_type', "application/json")  # type: Optional[str]
          polling = kwargs.pop('polling', True)  # type: Union[bool, azure.core.polling.PollingMethod]
          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 = self._create_or_update_initial(
                  resource_group_name=resource_group_name,
                  vm_name=vm_name,
                  parameters=parameters,
                  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 = ARMPolling(lro_delay, **kwargs)
          elif polling is False: polling_method = NoPolling()
          else: polling_method = polling
          if cont_token:
              return LROPoller.from_continuation_token(
                  polling_method=polling_method,
                  continuation_token=cont_token,
                  client=self._client,
                  deserialization_callback=get_long_running_output
              )
          else:
              return LROPoller(self._client, raw_result, get_long_running_output, polling_method)
  
      begin_create_or_update.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}'}  # type: ignore
  
      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', {}))
  
          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,
              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 = self._client._pipeline.run(request, stream=False, **kwargs)
          response = pipeline_response.http_response
  
          if response.status_code not in [200]:
              map_error(status_code=response.status_code, response=response, error_map=error_map)
              raise HttpResponseError(response=response, error_format=ARMErrorFormat)
  
          deserialized = self._deserialize('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
      def begin_update(
          self,
          resource_group_name: str,
          vm_name: str,
          parameters: "_models.VirtualMachineUpdate",
          **kwargs: Any
      ) -> LROPoller["_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 ARMPolling. 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.PollingMethod
          :keyword int polling_interval: Default waiting time between two polls for LRO operations if no
           Retry-After header is present.
          :return: An instance of LROPoller that returns either VirtualMachine or the result of
           cls(response)
          :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.compute.v2021_03_01.models.VirtualMachine]
          :raises: ~azure.core.exceptions.HttpResponseError
          """
          content_type = kwargs.pop('content_type', "application/json")  # type: Optional[str]
          polling = kwargs.pop('polling', True)  # type: Union[bool, azure.core.polling.PollingMethod]
          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 = self._update_initial(
                  resource_group_name=resource_group_name,
                  vm_name=vm_name,
                  parameters=parameters,
                  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 = ARMPolling(lro_delay, **kwargs)
          elif polling is False: polling_method = NoPolling()
          else: polling_method = polling
          if cont_token:
              return LROPoller.from_continuation_token(
                  polling_method=polling_method,
                  continuation_token=cont_token,
                  client=self._client,
                  deserialization_callback=get_long_running_output
              )
          else:
              return LROPoller(self._client, raw_result, get_long_running_output, polling_method)
  
      begin_update.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}'}  # type: ignore
  
      def _delete_initial(
          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', {}))
  
          
          request = build_delete_request_initial(
              resource_group_name=resource_group_name,
              vm_name=vm_name,
              subscription_id=self._config.subscription_id,
              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 = self._client._pipeline.run(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
      def begin_delete(
          self,
          resource_group_name: str,
          vm_name: str,
          force_deletion: Optional[bool] = None,
          **kwargs: Any
      ) -> LROPoller[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.
          :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 ARMPolling. 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.PollingMethod
          :keyword int polling_interval: Default waiting time between two polls for LRO operations if no
           Retry-After header is present.
          :return: An instance of LROPoller that returns either None or the result of cls(response)
          :rtype: ~azure.core.polling.LROPoller[None]
          :raises: ~azure.core.exceptions.HttpResponseError
          """
          polling = kwargs.pop('polling', True)  # type: Union[bool, azure.core.polling.PollingMethod]
          cls = kwargs.pop('cls', None)  # type: ClsType[None]
          lro_delay = kwargs.pop(
              'polling_interval',
              self._config.polling_interval
          )
          cont_token = kwargs.pop('continuation_token', None)  # type: Optional[str]
          if cont_token is None:
              raw_result = self._delete_initial(
                  resource_group_name=resource_group_name,
                  vm_name=vm_name,
                  force_deletion=force_deletion,
                  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 = ARMPolling(lro_delay, **kwargs)
          elif polling is False: polling_method = NoPolling()
          else: polling_method = polling
          if cont_token:
              return LROPoller.from_continuation_token(
                  polling_method=polling_method,
                  continuation_token=cont_token,
                  client=self._client,
                  deserialization_callback=get_long_running_output
              )
          else:
              return LROPoller(self._client, raw_result, get_long_running_output, polling_method)
  
      begin_delete.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}'}  # type: ignore
  
      @distributed_trace
      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.
          :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', {}))
  
          
          request = build_get_request(
              resource_group_name=resource_group_name,
              vm_name=vm_name,
              subscription_id=self._config.subscription_id,
              expand=expand,
              template_url=self.get.metadata['url'],
          )
          request = _convert_request(request)
          request.url = self._client.format_url(request.url)
  
          pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs)
          response = pipeline_response.http_response
  
          if response.status_code not in [200]:
              map_error(status_code=response.status_code, response=response, error_map=error_map)
              raise HttpResponseError(response=response, error_format=ARMErrorFormat)
  
          deserialized = self._deserialize('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
      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', {}))
  
          
          request = build_instance_view_request(
              resource_group_name=resource_group_name,
              vm_name=vm_name,
              subscription_id=self._config.subscription_id,
              template_url=self.instance_view.metadata['url'],
          )
          request = _convert_request(request)
          request.url = self._client.format_url(request.url)
  
          pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs)
          response = pipeline_response.http_response
  
          if response.status_code not in [200]:
              map_error(status_code=response.status_code, response=response, error_map=error_map)
              raise HttpResponseError(response=response, error_format=ARMErrorFormat)
  
          deserialized = self._deserialize('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
  
  
      def _convert_to_managed_disks_initial(
          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', {}))
  
          
          request = build_convert_to_managed_disks_request_initial(
              resource_group_name=resource_group_name,
              vm_name=vm_name,
              subscription_id=self._config.subscription_id,
              template_url=self._convert_to_managed_disks_initial.metadata['url'],
          )
          request = _convert_request(request)
          request.url = self._client.format_url(request.url)
  
          pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs)
          response = pipeline_response.http_response
  
          if response.status_code not in [200, 202]:
              map_error(status_code=response.status_code, response=response, error_map=error_map)
              raise HttpResponseError(response=response, error_format=ARMErrorFormat)
  
          if 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
      def begin_convert_to_managed_disks(
          self,
          resource_group_name: str,
          vm_name: str,
          **kwargs: Any
      ) -> LROPoller[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 ARMPolling. 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.PollingMethod
          :keyword int polling_interval: Default waiting time between two polls for LRO operations if no
           Retry-After header is present.
          :return: An instance of LROPoller that returns either None or the result of cls(response)
          :rtype: ~azure.core.polling.LROPoller[None]
          :raises: ~azure.core.exceptions.HttpResponseError
          """
          polling = kwargs.pop('polling', True)  # type: Union[bool, azure.core.polling.PollingMethod]
          cls = kwargs.pop('cls', None)  # type: ClsType[None]
          lro_delay = kwargs.pop(
              'polling_interval',
              self._config.polling_interval
          )
          cont_token = kwargs.pop('continuation_token', None)  # type: Optional[str]
          if cont_token is None:
              raw_result = self._convert_to_managed_disks_initial(
                  resource_group_name=resource_group_name,
                  vm_name=vm_name,
                  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 = ARMPolling(lro_delay, **kwargs)
          elif polling is False: polling_method = NoPolling()
          else: polling_method = polling
          if cont_token:
              return LROPoller.from_continuation_token(
                  polling_method=polling_method,
                  continuation_token=cont_token,
                  client=self._client,
                  deserialization_callback=get_long_running_output
              )
          else:
              return LROPoller(self._client, raw_result, get_long_running_output, polling_method)
  
      begin_convert_to_managed_disks.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/convertToManagedDisks'}  # type: ignore
  
      def _deallocate_initial(
          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', {}))
  
          
          request = build_deallocate_request_initial(
              resource_group_name=resource_group_name,
              vm_name=vm_name,
              subscription_id=self._config.subscription_id,
              template_url=self._deallocate_initial.metadata['url'],
          )
          request = _convert_request(request)
          request.url = self._client.format_url(request.url)
  
          pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs)
          response = pipeline_response.http_response
  
          if response.status_code not in [200, 202]:
              map_error(status_code=response.status_code, response=response, error_map=error_map)
              raise HttpResponseError(response=response, error_format=ARMErrorFormat)
  
          if cls:
              return cls(pipeline_response, None, {})
  
      _deallocate_initial.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/deallocate'}  # type: ignore
  
  
      @distributed_trace
      def begin_deallocate(
          self,
          resource_group_name: str,
          vm_name: str,
          **kwargs: Any
      ) -> LROPoller[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 ARMPolling. 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.PollingMethod
          :keyword int polling_interval: Default waiting time between two polls for LRO operations if no
           Retry-After header is present.
          :return: An instance of LROPoller that returns either None or the result of cls(response)
          :rtype: ~azure.core.polling.LROPoller[None]
          :raises: ~azure.core.exceptions.HttpResponseError
          """
          polling = kwargs.pop('polling', True)  # type: Union[bool, azure.core.polling.PollingMethod]
          cls = kwargs.pop('cls', None)  # type: ClsType[None]
          lro_delay = kwargs.pop(
              'polling_interval',
              self._config.polling_interval
          )
          cont_token = kwargs.pop('continuation_token', None)  # type: Optional[str]
          if cont_token is None:
              raw_result = self._deallocate_initial(
                  resource_group_name=resource_group_name,
                  vm_name=vm_name,
                  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 = ARMPolling(lro_delay, **kwargs)
          elif polling is False: polling_method = NoPolling()
          else: polling_method = polling
          if cont_token:
              return LROPoller.from_continuation_token(
                  polling_method=polling_method,
                  continuation_token=cont_token,
                  client=self._client,
                  deserialization_callback=get_long_running_output
              )
          else:
              return LROPoller(self._client, raw_result, get_long_running_output, polling_method)
  
      begin_deallocate.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/deallocate'}  # type: ignore
  
      @distributed_trace
      def generalize(
          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', {}))
  
          
          request = build_generalize_request(
              resource_group_name=resource_group_name,
              vm_name=vm_name,
              subscription_id=self._config.subscription_id,
              template_url=self.generalize.metadata['url'],
          )
          request = _convert_request(request)
          request.url = self._client.format_url(request.url)
  
          pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs)
          response = pipeline_response.http_response
  
          if response.status_code not in [200]:
              map_error(status_code=response.status_code, response=response, error_map=error_map)
              raise HttpResponseError(response=response, error_format=ARMErrorFormat)
  
          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
      ) -> Iterable["_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.paging.ItemPaged[~azure.mgmt.compute.v2021_03_01.models.VirtualMachineListResult]
          :raises: ~azure.core.exceptions.HttpResponseError
          """
          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,
                      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,
                      template_url=next_link,
                  )
                  request = _convert_request(request)
                  request.url = self._client.format_url(request.url)
                  request.method = "GET"
              return request
  
          def extract_data(pipeline_response):
              deserialized = self._deserialize("VirtualMachineListResult", pipeline_response)
              list_of_elem = deserialized.value
              if cls:
                  list_of_elem = cls(list_of_elem)
              return deserialized.next_link or None, iter(list_of_elem)
  
          def get_next(next_link=None):
              request = prepare_request(next_link)
  
              pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs)
              response = pipeline_response.http_response
  
              if response.status_code not in [200]:
                  map_error(status_code=response.status_code, response=response, error_map=error_map)
                  raise HttpResponseError(response=response, error_format=ARMErrorFormat)
  
              return pipeline_response
  
  
          return ItemPaged(
              get_next, extract_data
          )
      list.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines'}  # type: ignore
  
      @distributed_trace
      def list_all(
          self,
          status_only: Optional[str] = None,
          **kwargs: Any
      ) -> Iterable["_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.
          :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.paging.ItemPaged[~azure.mgmt.compute.v2021_03_01.models.VirtualMachineListResult]
          :raises: ~azure.core.exceptions.HttpResponseError
          """
          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,
                      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,
                      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
  
          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, iter(list_of_elem)
  
          def get_next(next_link=None):
              request = prepare_request(next_link)
  
              pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs)
              response = pipeline_response.http_response
  
              if response.status_code not in [200]:
                  map_error(status_code=response.status_code, response=response, error_map=error_map)
                  raise HttpResponseError(response=response, error_format=ARMErrorFormat)
  
              return pipeline_response
  
  
          return ItemPaged(
              get_next, extract_data
          )
      list_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
      ) -> Iterable["_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.paging.ItemPaged[~azure.mgmt.compute.v2021_03_01.models.VirtualMachineSizeListResult]
          :raises: ~azure.core.exceptions.HttpResponseError
          """
          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,
                      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,
                      template_url=next_link,
                  )
                  request = _convert_request(request)
                  request.url = self._client.format_url(request.url)
                  request.method = "GET"
              return request
  
          def extract_data(pipeline_response):
              deserialized = self._deserialize("VirtualMachineSizeListResult", pipeline_response)
              list_of_elem = deserialized.value
              if cls:
                  list_of_elem = cls(list_of_elem)
              return None, iter(list_of_elem)
  
          def get_next(next_link=None):
              request = prepare_request(next_link)
  
              pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs)
              response = pipeline_response.http_response
  
              if response.status_code not in [200]:
                  map_error(status_code=response.status_code, response=response, error_map=error_map)
                  raise HttpResponseError(response=response, error_format=ARMErrorFormat)
  
              return pipeline_response
  
  
          return ItemPaged(
              get_next, extract_data
          )
      list_available_sizes.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/vmSizes'}  # type: ignore
  
      def _power_off_initial(
          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', {}))
  
          
          request = build_power_off_request_initial(
              resource_group_name=resource_group_name,
              vm_name=vm_name,
              subscription_id=self._config.subscription_id,
              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 = self._client._pipeline.run(request, stream=False, **kwargs)
          response = pipeline_response.http_response
  
          if response.status_code not in [200, 202]:
              map_error(status_code=response.status_code, response=response, error_map=error_map)
              raise HttpResponseError(response=response, error_format=ARMErrorFormat)
  
          if 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
      def begin_power_off(
          self,
          resource_group_name: str,
          vm_name: str,
          skip_shutdown: Optional[bool] = False,
          **kwargs: Any
      ) -> LROPoller[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.
          :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 ARMPolling. 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.PollingMethod
          :keyword int polling_interval: Default waiting time between two polls for LRO operations if no
           Retry-After header is present.
          :return: An instance of LROPoller that returns either None or the result of cls(response)
          :rtype: ~azure.core.polling.LROPoller[None]
          :raises: ~azure.core.exceptions.HttpResponseError
          """
          polling = kwargs.pop('polling', True)  # type: Union[bool, azure.core.polling.PollingMethod]
          cls = kwargs.pop('cls', None)  # type: ClsType[None]
          lro_delay = kwargs.pop(
              'polling_interval',
              self._config.polling_interval
          )
          cont_token = kwargs.pop('continuation_token', None)  # type: Optional[str]
          if cont_token is None:
              raw_result = self._power_off_initial(
                  resource_group_name=resource_group_name,
                  vm_name=vm_name,
                  skip_shutdown=skip_shutdown,
                  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 = ARMPolling(lro_delay, **kwargs)
          elif polling is False: polling_method = NoPolling()
          else: polling_method = polling
          if cont_token:
              return LROPoller.from_continuation_token(
                  polling_method=polling_method,
                  continuation_token=cont_token,
                  client=self._client,
                  deserialization_callback=get_long_running_output
              )
          else:
              return LROPoller(self._client, raw_result, get_long_running_output, polling_method)
  
      begin_power_off.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/powerOff'}  # type: ignore
  
      def _reapply_initial(
          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', {}))
  
          
          request = build_reapply_request_initial(
              resource_group_name=resource_group_name,
              vm_name=vm_name,
              subscription_id=self._config.subscription_id,
              template_url=self._reapply_initial.metadata['url'],
          )
          request = _convert_request(request)
          request.url = self._client.format_url(request.url)
  
          pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs)
          response = pipeline_response.http_response
  
          if response.status_code not in [200, 202]:
              map_error(status_code=response.status_code, response=response, error_map=error_map)
              raise HttpResponseError(response=response, error_format=ARMErrorFormat)
  
          if cls:
              return cls(pipeline_response, None, {})
  
      _reapply_initial.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/reapply'}  # type: ignore
  
  
      @distributed_trace
      def begin_reapply(
          self,
          resource_group_name: str,
          vm_name: str,
          **kwargs: Any
      ) -> LROPoller[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 ARMPolling. 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.PollingMethod
          :keyword int polling_interval: Default waiting time between two polls for LRO operations if no
           Retry-After header is present.
          :return: An instance of LROPoller that returns either None or the result of cls(response)
          :rtype: ~azure.core.polling.LROPoller[None]
          :raises: ~azure.core.exceptions.HttpResponseError
          """
          polling = kwargs.pop('polling', True)  # type: Union[bool, azure.core.polling.PollingMethod]
          cls = kwargs.pop('cls', None)  # type: ClsType[None]
          lro_delay = kwargs.pop(
              'polling_interval',
              self._config.polling_interval
          )
          cont_token = kwargs.pop('continuation_token', None)  # type: Optional[str]
          if cont_token is None:
              raw_result = self._reapply_initial(
                  resource_group_name=resource_group_name,
                  vm_name=vm_name,
                  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 = ARMPolling(lro_delay, **kwargs)
          elif polling is False: polling_method = NoPolling()
          else: polling_method = polling
          if cont_token:
              return LROPoller.from_continuation_token(
                  polling_method=polling_method,
                  continuation_token=cont_token,
                  client=self._client,
                  deserialization_callback=get_long_running_output
              )
          else:
              return LROPoller(self._client, raw_result, get_long_running_output, polling_method)
  
      begin_reapply.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/reapply'}  # type: ignore
  
      def _restart_initial(
          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', {}))
  
          
          request = build_restart_request_initial(
              resource_group_name=resource_group_name,
              vm_name=vm_name,
              subscription_id=self._config.subscription_id,
              template_url=self._restart_initial.metadata['url'],
          )
          request = _convert_request(request)
          request.url = self._client.format_url(request.url)
  
          pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs)
          response = pipeline_response.http_response
  
          if response.status_code not in [200, 202]:
              map_error(status_code=response.status_code, response=response, error_map=error_map)
              raise HttpResponseError(response=response, error_format=ARMErrorFormat)
  
          if cls:
              return cls(pipeline_response, None, {})
  
      _restart_initial.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/restart'}  # type: ignore
  
  
      @distributed_trace
      def begin_restart(
          self,
          resource_group_name: str,
          vm_name: str,
          **kwargs: Any
      ) -> LROPoller[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 ARMPolling. 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.PollingMethod
          :keyword int polling_interval: Default waiting time between two polls for LRO operations if no
           Retry-After header is present.
          :return: An instance of LROPoller that returns either None or the result of cls(response)
          :rtype: ~azure.core.polling.LROPoller[None]
          :raises: ~azure.core.exceptions.HttpResponseError
          """
          polling = kwargs.pop('polling', True)  # type: Union[bool, azure.core.polling.PollingMethod]
          cls = kwargs.pop('cls', None)  # type: ClsType[None]
          lro_delay = kwargs.pop(
              'polling_interval',
              self._config.polling_interval
          )
          cont_token = kwargs.pop('continuation_token', None)  # type: Optional[str]
          if cont_token is None:
              raw_result = self._restart_initial(
                  resource_group_name=resource_group_name,
                  vm_name=vm_name,
                  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 = ARMPolling(lro_delay, **kwargs)
          elif polling is False: polling_method = NoPolling()
          else: polling_method = polling
          if cont_token:
              return LROPoller.from_continuation_token(
                  polling_method=polling_method,
                  continuation_token=cont_token,
                  client=self._client,
                  deserialization_callback=get_long_running_output
              )
          else:
              return LROPoller(self._client, raw_result, get_long_running_output, polling_method)
  
      begin_restart.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/restart'}  # type: ignore
  
      def _start_initial(
          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', {}))
  
          
          request = build_start_request_initial(
              resource_group_name=resource_group_name,
              vm_name=vm_name,
              subscription_id=self._config.subscription_id,
              template_url=self._start_initial.metadata['url'],
          )
          request = _convert_request(request)
          request.url = self._client.format_url(request.url)
  
          pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs)
          response = pipeline_response.http_response
  
          if response.status_code not in [200, 202]:
              map_error(status_code=response.status_code, response=response, error_map=error_map)
              raise HttpResponseError(response=response, error_format=ARMErrorFormat)
  
          if cls:
              return cls(pipeline_response, None, {})
  
      _start_initial.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/start'}  # type: ignore
  
  
      @distributed_trace
      def begin_start(
          self,
          resource_group_name: str,
          vm_name: str,
          **kwargs: Any
      ) -> LROPoller[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 ARMPolling. 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.PollingMethod
          :keyword int polling_interval: Default waiting time between two polls for LRO operations if no
           Retry-After header is present.
          :return: An instance of LROPoller that returns either None or the result of cls(response)
          :rtype: ~azure.core.polling.LROPoller[None]
          :raises: ~azure.core.exceptions.HttpResponseError
          """
          polling = kwargs.pop('polling', True)  # type: Union[bool, azure.core.polling.PollingMethod]
          cls = kwargs.pop('cls', None)  # type: ClsType[None]
          lro_delay = kwargs.pop(
              'polling_interval',
              self._config.polling_interval
          )
          cont_token = kwargs.pop('continuation_token', None)  # type: Optional[str]
          if cont_token is None:
              raw_result = self._start_initial(
                  resource_group_name=resource_group_name,
                  vm_name=vm_name,
                  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 = ARMPolling(lro_delay, **kwargs)
          elif polling is False: polling_method = NoPolling()
          else: polling_method = polling
          if cont_token:
              return LROPoller.from_continuation_token(
                  polling_method=polling_method,
                  continuation_token=cont_token,
                  client=self._client,
                  deserialization_callback=get_long_running_output
              )
          else:
              return LROPoller(self._client, raw_result, get_long_running_output, polling_method)
  
      begin_start.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/start'}  # type: ignore
  
      def _redeploy_initial(
          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', {}))
  
          
          request = build_redeploy_request_initial(
              resource_group_name=resource_group_name,
              vm_name=vm_name,
              subscription_id=self._config.subscription_id,
              template_url=self._redeploy_initial.metadata['url'],
          )
          request = _convert_request(request)
          request.url = self._client.format_url(request.url)
  
          pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs)
          response = pipeline_response.http_response
  
          if response.status_code not in [200, 202]:
              map_error(status_code=response.status_code, response=response, error_map=error_map)
              raise HttpResponseError(response=response, error_format=ARMErrorFormat)
  
          if cls:
              return cls(pipeline_response, None, {})
  
      _redeploy_initial.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/redeploy'}  # type: ignore
  
  
      @distributed_trace
      def begin_redeploy(
          self,
          resource_group_name: str,
          vm_name: str,
          **kwargs: Any
      ) -> LROPoller[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 ARMPolling. 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.PollingMethod
          :keyword int polling_interval: Default waiting time between two polls for LRO operations if no
           Retry-After header is present.
          :return: An instance of LROPoller that returns either None or the result of cls(response)
          :rtype: ~azure.core.polling.LROPoller[None]
          :raises: ~azure.core.exceptions.HttpResponseError
          """
          polling = kwargs.pop('polling', True)  # type: Union[bool, azure.core.polling.PollingMethod]
          cls = kwargs.pop('cls', None)  # type: ClsType[None]
          lro_delay = kwargs.pop(
              'polling_interval',
              self._config.polling_interval
          )
          cont_token = kwargs.pop('continuation_token', None)  # type: Optional[str]
          if cont_token is None:
              raw_result = self._redeploy_initial(
                  resource_group_name=resource_group_name,
                  vm_name=vm_name,
                  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 = ARMPolling(lro_delay, **kwargs)
          elif polling is False: polling_method = NoPolling()
          else: polling_method = polling
          if cont_token:
              return LROPoller.from_continuation_token(
                  polling_method=polling_method,
                  continuation_token=cont_token,
                  client=self._client,
                  deserialization_callback=get_long_running_output
              )
          else:
              return LROPoller(self._client, raw_result, get_long_running_output, polling_method)
  
      begin_redeploy.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/redeploy'}  # type: ignore
  
      def _reimage_initial(
          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', {}))
  
          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,
              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 = self._client._pipeline.run(request, stream=False, **kwargs)
          response = pipeline_response.http_response
  
          if response.status_code not in [200, 202]:
              map_error(status_code=response.status_code, response=response, error_map=error_map)
              raise HttpResponseError(response=response, error_format=ARMErrorFormat)
  
          if cls:
              return cls(pipeline_response, None, {})
  
      _reimage_initial.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/reimage'}  # type: ignore
  
  
      @distributed_trace
      def begin_reimage(
          self,
          resource_group_name: str,
          vm_name: str,
          parameters: Optional["_models.VirtualMachineReimageParameters"] = None,
          **kwargs: Any
      ) -> LROPoller[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.
          :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 ARMPolling. 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.PollingMethod
          :keyword int polling_interval: Default waiting time between two polls for LRO operations if no
           Retry-After header is present.
          :return: An instance of LROPoller that returns either None or the result of cls(response)
          :rtype: ~azure.core.polling.LROPoller[None]
          :raises: ~azure.core.exceptions.HttpResponseError
          """
          content_type = kwargs.pop('content_type', "application/json")  # type: Optional[str]
          polling = kwargs.pop('polling', True)  # type: Union[bool, azure.core.polling.PollingMethod]
          cls = kwargs.pop('cls', None)  # type: ClsType[None]
          lro_delay = kwargs.pop(
              'polling_interval',
              self._config.polling_interval
          )
          cont_token = kwargs.pop('continuation_token', None)  # type: Optional[str]
          if cont_token is None:
              raw_result = self._reimage_initial(
                  resource_group_name=resource_group_name,
                  vm_name=vm_name,
                  parameters=parameters,
                  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 = ARMPolling(lro_delay, **kwargs)
          elif polling is False: polling_method = NoPolling()
          else: polling_method = polling
          if cont_token:
              return LROPoller.from_continuation_token(
                  polling_method=polling_method,
                  continuation_token=cont_token,
                  client=self._client,
                  deserialization_callback=get_long_running_output
              )
          else:
              return LROPoller(self._client, raw_result, get_long_running_output, polling_method)
  
      begin_reimage.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/reimage'}  # type: ignore
  
      @distributed_trace
      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.
          :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', {}))
  
          
          request = build_retrieve_boot_diagnostics_data_request(
              resource_group_name=resource_group_name,
              vm_name=vm_name,
              subscription_id=self._config.subscription_id,
              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 = self._client._pipeline.run(request, stream=False, **kwargs)
          response = pipeline_response.http_response
  
          if response.status_code not in [200]:
              map_error(status_code=response.status_code, response=response, error_map=error_map)
              raise HttpResponseError(response=response, error_format=ARMErrorFormat)
  
          deserialized = self._deserialize('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
  
  
      def _perform_maintenance_initial(
          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', {}))
  
          
          request = build_perform_maintenance_request_initial(
              resource_group_name=resource_group_name,
              vm_name=vm_name,
              subscription_id=self._config.subscription_id,
              template_url=self._perform_maintenance_initial.metadata['url'],
          )
          request = _convert_request(request)
          request.url = self._client.format_url(request.url)
  
          pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs)
          response = pipeline_response.http_response
  
          if response.status_code not in [200, 202]:
              map_error(status_code=response.status_code, response=response, error_map=error_map)
              raise HttpResponseError(response=response, error_format=ARMErrorFormat)
  
          if 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
      def begin_perform_maintenance(
          self,
          resource_group_name: str,
          vm_name: str,
          **kwargs: Any
      ) -> LROPoller[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 ARMPolling. 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.PollingMethod
          :keyword int polling_interval: Default waiting time between two polls for LRO operations if no
           Retry-After header is present.
          :return: An instance of LROPoller that returns either None or the result of cls(response)
          :rtype: ~azure.core.polling.LROPoller[None]
          :raises: ~azure.core.exceptions.HttpResponseError
          """
          polling = kwargs.pop('polling', True)  # type: Union[bool, azure.core.polling.PollingMethod]
          cls = kwargs.pop('cls', None)  # type: ClsType[None]
          lro_delay = kwargs.pop(
              'polling_interval',
              self._config.polling_interval
          )
          cont_token = kwargs.pop('continuation_token', None)  # type: Optional[str]
          if cont_token is None:
              raw_result = self._perform_maintenance_initial(
                  resource_group_name=resource_group_name,
                  vm_name=vm_name,
                  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 = ARMPolling(lro_delay, **kwargs)
          elif polling is False: polling_method = NoPolling()
          else: polling_method = polling
          if cont_token:
              return LROPoller.from_continuation_token(
                  polling_method=polling_method,
                  continuation_token=cont_token,
                  client=self._client,
                  deserialization_callback=get_long_running_output
              )
          else:
              return LROPoller(self._client, raw_result, get_long_running_output, polling_method)
  
      begin_perform_maintenance.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/performMaintenance'}  # type: ignore
  
      @distributed_trace
      def simulate_eviction(
          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', {}))
  
          
          request = build_simulate_eviction_request(
              resource_group_name=resource_group_name,
              vm_name=vm_name,
              subscription_id=self._config.subscription_id,
              template_url=self.simulate_eviction.metadata['url'],
          )
          request = _convert_request(request)
          request.url = self._client.format_url(request.url)
  
          pipeline_response = self._client._pipeline.run(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
  
  
      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', {}))
  
          
          request = build_assess_patches_request_initial(
              resource_group_name=resource_group_name,
              vm_name=vm_name,
              subscription_id=self._config.subscription_id,
              template_url=self._assess_patches_initial.metadata['url'],
          )
          request = _convert_request(request)
          request.url = self._client.format_url(request.url)
  
          pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs)
          response = pipeline_response.http_response
  
          if response.status_code not in [200, 202]:
              map_error(status_code=response.status_code, response=response, error_map=error_map)
              raise HttpResponseError(response=response, error_format=ARMErrorFormat)
  
          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
      def begin_assess_patches(
          self,
          resource_group_name: str,
          vm_name: str,
          **kwargs: Any
      ) -> LROPoller["_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 ARMPolling. 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.PollingMethod
          :keyword int polling_interval: Default waiting time between two polls for LRO operations if no
           Retry-After header is present.
          :return: An instance of LROPoller that returns either VirtualMachineAssessPatchesResult or the
           result of cls(response)
          :rtype:
           ~azure.core.polling.LROPoller[~azure.mgmt.compute.v2021_03_01.models.VirtualMachineAssessPatchesResult]
          :raises: ~azure.core.exceptions.HttpResponseError
          """
          polling = kwargs.pop('polling', True)  # type: Union[bool, azure.core.polling.PollingMethod]
          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 = self._assess_patches_initial(
                  resource_group_name=resource_group_name,
                  vm_name=vm_name,
                  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 = ARMPolling(lro_delay, lro_options={'final-state-via': 'location'}, **kwargs)
          elif polling is False: polling_method = NoPolling()
          else: polling_method = polling
          if cont_token:
              return LROPoller.from_continuation_token(
                  polling_method=polling_method,
                  continuation_token=cont_token,
                  client=self._client,
                  deserialization_callback=get_long_running_output
              )
          else:
              return LROPoller(self._client, raw_result, get_long_running_output, polling_method)
  
      begin_assess_patches.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/assessPatches'}  # type: ignore
  
      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', {}))
  
          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,
              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 = self._client._pipeline.run(request, stream=False, **kwargs)
          response = pipeline_response.http_response
  
          if response.status_code not in [200, 202]:
              map_error(status_code=response.status_code, response=response, error_map=error_map)
              raise HttpResponseError(response=response, error_format=ARMErrorFormat)
  
          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
      def begin_install_patches(
          self,
          resource_group_name: str,
          vm_name: str,
          install_patches_input: "_models.VirtualMachineInstallPatchesParameters",
          **kwargs: Any
      ) -> LROPoller["_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 ARMPolling. 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.PollingMethod
          :keyword int polling_interval: Default waiting time between two polls for LRO operations if no
           Retry-After header is present.
          :return: An instance of LROPoller that returns either VirtualMachineInstallPatchesResult or the
           result of cls(response)
          :rtype:
           ~azure.core.polling.LROPoller[~azure.mgmt.compute.v2021_03_01.models.VirtualMachineInstallPatchesResult]
          :raises: ~azure.core.exceptions.HttpResponseError
          """
          content_type = kwargs.pop('content_type', "application/json")  # type: Optional[str]
          polling = kwargs.pop('polling', True)  # type: Union[bool, azure.core.polling.PollingMethod]
          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 = self._install_patches_initial(
                  resource_group_name=resource_group_name,
                  vm_name=vm_name,
                  install_patches_input=install_patches_input,
                  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 = ARMPolling(lro_delay, lro_options={'final-state-via': 'location'}, **kwargs)
          elif polling is False: polling_method = NoPolling()
          else: polling_method = polling
          if cont_token:
              return LROPoller.from_continuation_token(
                  polling_method=polling_method,
                  continuation_token=cont_token,
                  client=self._client,
                  deserialization_callback=get_long_running_output
              )
          else:
              return LROPoller(self._client, raw_result, get_long_running_output, polling_method)
  
      begin_install_patches.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/installPatches'}  # type: ignore
  
      def _run_command_initial(
          self,
          resource_group_name: str,
          vm_name: str,
          parameters: "_models.RunCommandInput",
          **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', {}))
  
          content_type = kwargs.pop('content_type', "application/json")  # type: Optional[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,
              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 = self._client._pipeline.run(request, stream=False, **kwargs)
          response = pipeline_response.http_response
  
          if response.status_code not in [200, 202]:
              map_error(status_code=response.status_code, response=response, error_map=error_map)
              raise HttpResponseError(response=response, error_format=ARMErrorFormat)
  
          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
      def begin_run_command(
          self,
          resource_group_name: str,
          vm_name: str,
          parameters: "_models.RunCommandInput",
          **kwargs: Any
      ) -> LROPoller["_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 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 ARMPolling. 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.PollingMethod
          :keyword int polling_interval: Default waiting time between two polls for LRO operations if no
           Retry-After header is present.
          :return: An instance of LROPoller that returns either RunCommandResult or the result of
           cls(response)
          :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.compute.v2021_03_01.models.RunCommandResult]
          :raises: ~azure.core.exceptions.HttpResponseError
          """
          content_type = kwargs.pop('content_type', "application/json")  # type: Optional[str]
          polling = kwargs.pop('polling', True)  # type: Union[bool, azure.core.polling.PollingMethod]
          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 = self._run_command_initial(
                  resource_group_name=resource_group_name,
                  vm_name=vm_name,
                  parameters=parameters,
                  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('RunCommandResult', pipeline_response)
              if cls:
                  return cls(pipeline_response, deserialized, {})
              return deserialized
  
  
          if polling is True: polling_method = ARMPolling(lro_delay, lro_options={'final-state-via': 'location'}, **kwargs)
          elif polling is False: polling_method = NoPolling()
          else: polling_method = polling
          if cont_token:
              return LROPoller.from_continuation_token(
                  polling_method=polling_method,
                  continuation_token=cont_token,
                  client=self._client,
                  deserialization_callback=get_long_running_output
              )
          else:
              return LROPoller(self._client, raw_result, get_long_running_output, polling_method)
  
      begin_run_command.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/runCommand'}  # type: ignore
  