async def METHOD_NAME(  # pylint: disable=inconsistent-return-statements
    self,
    resource_group_name: str,
    virtual_machine_name: str,
    extension_upgrade_parameters: "_models.MachineExtensionUpgrade",
    **kwargs: Any
) -> AsyncLROPoller[None]:
    """The operation to Upgrade Machine Extensions.
    :param resource_group_name: The Resource Group Name.
    :type resource_group_name: str
    :param virtual_machine_name: The name of the machine containing the extension.
    :type virtual_machine_name: str
    :param extension_upgrade_parameters: Parameters supplied to the Upgrade Extensions operation.
    :type extension_upgrade_parameters: ~azure.mgmt.connectedvmware.models.MachineExtensionUpgrade
    :keyword callable cls: A custom type or function that will be passed the direct response
    :keyword str continuation_token: A continuation token to restart a poller from a saved state.
    :keyword polling: By default, your polling method will be AsyncARMPolling. Pass in False for
     this operation to not poll, or pass in your own initialized polling object for a personal
     polling strategy.
    :paramtype polling: bool or ~azure.core.polling.AsyncPollingMethod
    :keyword int polling_interval: Default waiting time between two polls for LRO operations if no
     Retry-After header is present.
    :return: An instance of AsyncLROPoller that returns either None or the result of cls(response)
    :rtype: ~azure.core.polling.AsyncLROPoller[None]
    :raises: ~azure.core.exceptions.HttpResponseError
    """
    api_version = kwargs.pop('api_version', "2023-03-01-preview")  # type: str
    content_type = kwargs.pop('content_type', "application/json")  # type: Optional[str]
    polling = kwargs.pop('polling', True)  # type: Union[bool, AsyncPollingMethod]
    cls = kwargs.pop('cls', None)  # type: ClsType[None]
    lro_delay = kwargs.pop(
        'polling_interval',
        self._config.polling_interval
    )
    cont_token = kwargs.pop('continuation_token', None)  # type: Optional[str]
    if cont_token is None:
        raw_result = await self._upgrade_extensions_initial(
            resource_group_name=resource_group_name,
            virtual_machine_name=virtual_machine_name,
            extension_upgrade_parameters=extension_upgrade_parameters,
            api_version=api_version,
            content_type=content_type,
            cls=lambda x,y,z: x,
            **kwargs
        )
    kwargs.pop('error_map', None)
    def get_long_running_output(pipeline_response):
        if cls:
            return cls(pipeline_response, None, {})
    if polling is True: polling_method = AsyncARMPolling(lro_delay, lro_options={'final-state-via': 'location'}, **kwargs)
    elif polling is False: polling_method = AsyncNoPolling()
    else: polling_method = polling
    if cont_token:
        return AsyncLROPoller.from_continuation_token(
            polling_method=polling_method,
            continuation_token=cont_token,
            client=self._client,
            deserialization_callback=get_long_running_output
        )
    return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method)