# Source code for azure.mgmt.compute.v2019_03_01.operations._virtual_machine_scale_sets_operations

    # 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 uuid
    from msrest.pipeline import ClientRawResponse
    from msrestazure.azure_exceptions import CloudError
    from msrest.polling import LROPoller, NoPolling
    from msrestazure.polling.arm_polling import ARMPolling

    from .. import models

    class VirtualMachineScaleSetsOperations(object):
        """VirtualMachineScaleSetsOperations operations.

        You should not instantiate directly this class, but create a Client instance that will create it for you and attach it as attribute.

        :param client: Client for service requests.
        :param config: Configuration of service client.
        :param serializer: An object model serializer.
        :param deserializer: An object model deserializer.
        :ivar api_version: Client Api Version. Constant value: "2019-03-01".
        """

        models = models

        def __init__(self, client, config, serializer, deserializer):

            self._client = client
            self._serialize = serializer
            self._deserialize = deserializer
            self.api_version = "2019-03-01"

            self.config = config

        def _create_or_update_initial(
                self, resource_group_name, vm_scale_set_name, parameters, custom_headers=None, raw=False, **operation_config):
            # Construct URL
            url = self.create_or_update.metadata['url']
            path_format_arguments = {
                'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str'),
                'vmScaleSetName': self._serialize.url("vm_scale_set_name", vm_scale_set_name, 'str'),
                'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str')
            }
            url = self._client.format_url(url, **path_format_arguments)

            # Construct parameters
            query_parameters = {}
            query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str')

            # Construct headers
            header_parameters = {}
            header_parameters['Accept'] = 'application/json'
            header_parameters['Content-Type'] = 'application/json; charset=utf-8'
            if self.config.generate_client_request_id:
                header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
            if custom_headers:
                header_parameters.update(custom_headers)
            if self.config.accept_language is not None:
                header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str')

            # Construct body
            body_content = self._serialize.body(parameters, 'VirtualMachineScaleSet')

            # Construct and send request
            request = self._client.put(url, query_parameters, header_parameters, body_content)
            response = self._client.send(request, stream=False, **operation_config)

            if response.status_code not in [200, 201]:
                exp = CloudError(response)
                exp.request_id = response.headers.get('x-ms-request-id')
                raise exp

            deserialized = None

            if response.status_code == 200:
                deserialized = self._deserialize('VirtualMachineScaleSet', response)
            if response.status_code == 201:
                deserialized = self._deserialize('VirtualMachineScaleSet', response)

            if raw:
                client_raw_response = ClientRawResponse(deserialized, response)
                return client_raw_response

            return deserialized

        def create_or_update(
                self, resource_group_name, vm_scale_set_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):
            """Create or update a VM scale set.

            :param resource_group_name: The name of the resource group.
            :type resource_group_name: str
            :param vm_scale_set_name: The name of the VM scale set to create or
             update.
            :type vm_scale_set_name: str
            :param parameters: The scale set object.
            :type parameters:
             ~azure.mgmt.compute.v2019_03_01.models.VirtualMachineScaleSet
            :param dict custom_headers: headers that will be added to the request
            :param bool raw: The poller return type is ClientRawResponse, the
             direct response alongside the deserialized response
            :param polling: True for ARMPolling, False for no polling, or a
             polling object for personal polling strategy
            :return: An instance of LROPoller that returns VirtualMachineScaleSet
             or ClientRawResponse<VirtualMachineScaleSet> if raw==True
            :rtype:
             ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.compute.v2019_03_01.models.VirtualMachineScaleSet]
             or
             ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.compute.v2019_03_01.models.VirtualMachineScaleSet]]
            :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
            """
            raw_result = self._create_or_update_initial(
                resource_group_name=resource_group_name,
                vm_scale_set_name=vm_scale_set_name,
                parameters=parameters,
                custom_headers=custom_headers,
                raw=True,
                **operation_config
            )

            def get_long_running_output(response):
                deserialized = self._deserialize('VirtualMachineScaleSet', response)

                if raw:
                    client_raw_response = ClientRawResponse(deserialized, response)
                    return client_raw_response

                return deserialized

            lro_delay = operation_config.get(
                'long_running_operation_timeout',
                self.config.long_running_operation_timeout)
            if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)
            elif polling is False: polling_method = NoPolling()
            else: polling_method = polling
            return LROPoller(self._client, raw_result, get_long_running_output, polling_method)
        create_or_update.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}'}

        def _update_initial(
                self, resource_group_name, vm_scale_set_name, parameters, custom_headers=None, raw=False, **operation_config):
            # Construct URL
            url = self.update.metadata['url']
            path_format_arguments = {
                'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str'),
                'vmScaleSetName': self._serialize.url("vm_scale_set_name", vm_scale_set_name, 'str'),
                'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str')
            }
            url = self._client.format_url(url, **path_format_arguments)

            # Construct parameters
            query_parameters = {}
            query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str')

            # Construct headers
            header_parameters = {}
            header_parameters['Accept'] = 'application/json'
            header_parameters['Content-Type'] = 'application/json; charset=utf-8'
            if self.config.generate_client_request_id:
                header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
            if custom_headers:
                header_parameters.update(custom_headers)
            if self.config.accept_language is not None:
                header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str')

            # Construct body
            body_content = self._serialize.body(parameters, 'VirtualMachineScaleSetUpdate')

            # Construct and send request
            request = self._client.patch(url, query_parameters, header_parameters, body_content)
            response = self._client.send(request, stream=False, **operation_config)

            if response.status_code not in [200]:
                exp = CloudError(response)
                exp.request_id = response.headers.get('x-ms-request-id')
                raise exp

            deserialized = None

            if response.status_code == 200:
                deserialized = self._deserialize('VirtualMachineScaleSet', response)

            if raw:
                client_raw_response = ClientRawResponse(deserialized, response)
                return client_raw_response

            return deserialized

        def update(
                self, resource_group_name, vm_scale_set_name, parameters, custom_headers=None, raw=False, polling=True, **operation_config):
            """Update a VM scale set.

            :param resource_group_name: The name of the resource group.
            :type resource_group_name: str
            :param vm_scale_set_name: The name of the VM scale set to create or
             update.
            :type vm_scale_set_name: str
            :param parameters: The scale set object.
            :type parameters:
             ~azure.mgmt.compute.v2019_03_01.models.VirtualMachineScaleSetUpdate
            :param dict custom_headers: headers that will be added to the request
            :param bool raw: The poller return type is ClientRawResponse, the
             direct response alongside the deserialized response
            :param polling: True for ARMPolling, False for no polling, or a
             polling object for personal polling strategy
            :return: An instance of LROPoller that returns VirtualMachineScaleSet
             or ClientRawResponse<VirtualMachineScaleSet> if raw==True
            :rtype:
             ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.compute.v2019_03_01.models.VirtualMachineScaleSet]
             or
             ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.compute.v2019_03_01.models.VirtualMachineScaleSet]]
            :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
            """
            raw_result = self._update_initial(
                resource_group_name=resource_group_name,
                vm_scale_set_name=vm_scale_set_name,
                parameters=parameters,
                custom_headers=custom_headers,
                raw=True,
                **operation_config
            )

            def get_long_running_output(response):
                deserialized = self._deserialize('VirtualMachineScaleSet', response)

                if raw:
                    client_raw_response = ClientRawResponse(deserialized, response)
                    return client_raw_response

                return deserialized

            lro_delay = operation_config.get(
                'long_running_operation_timeout',
                self.config.long_running_operation_timeout)
            if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)
            elif polling is False: polling_method = NoPolling()
            else: polling_method = polling
            return LROPoller(self._client, raw_result, get_long_running_output, polling_method)
        update.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}'}

        def _delete_initial(
                self, resource_group_name, vm_scale_set_name, custom_headers=None, raw=False, **operation_config):
            # Construct URL
            url = self.delete.metadata['url']
            path_format_arguments = {
                'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str'),
                'vmScaleSetName': self._serialize.url("vm_scale_set_name", vm_scale_set_name, 'str'),
                'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str')
            }
            url = self._client.format_url(url, **path_format_arguments)

            # Construct parameters
            query_parameters = {}
            query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str')

            # Construct headers
            header_parameters = {}
            if self.config.generate_client_request_id:
                header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
            if custom_headers:
                header_parameters.update(custom_headers)
            if self.config.accept_language is not None:
                header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str')

            # Construct and send request
            request = self._client.delete(url, query_parameters, header_parameters)
            response = self._client.send(request, stream=False, **operation_config)

            if response.status_code not in [200, 202, 204]:
                exp = CloudError(response)
                exp.request_id = response.headers.get('x-ms-request-id')
                raise exp

            if raw:
                client_raw_response = ClientRawResponse(None, response)
                return client_raw_response

        def delete(
                self, resource_group_name, vm_scale_set_name, custom_headers=None, raw=False, polling=True, **operation_config):
            """Deletes a VM scale set.

            :param resource_group_name: The name of the resource group.
            :type resource_group_name: str
            :param vm_scale_set_name: The name of the VM scale set.
            :type vm_scale_set_name: str
            :param dict custom_headers: headers that will be added to the request
            :param bool raw: The poller return type is ClientRawResponse, the
             direct response alongside the deserialized response
            :param polling: True for ARMPolling, False for no polling, or a
             polling object for personal polling strategy
            :return: An instance of LROPoller that returns None or
             ClientRawResponse<None> if raw==True
            :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or
             ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]
            :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
            """
            raw_result = self._delete_initial(
                resource_group_name=resource_group_name,
                vm_scale_set_name=vm_scale_set_name,
                custom_headers=custom_headers,
                raw=True,
                **operation_config
            )

            def get_long_running_output(response):
                if raw:
                    client_raw_response = ClientRawResponse(None, response)
                    return client_raw_response

            lro_delay = operation_config.get(
                'long_running_operation_timeout',
                self.config.long_running_operation_timeout)
            if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)
            elif polling is False: polling_method = NoPolling()
            else: polling_method = polling
            return LROPoller(self._client, raw_result, get_long_running_output, polling_method)
        delete.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}'}

        def get(
                self, resource_group_name, vm_scale_set_name, custom_headers=None, raw=False, **operation_config):
            """Display information about a virtual machine scale set.

            :param resource_group_name: The name of the resource group.
            :type resource_group_name: str
            :param vm_scale_set_name: The name of the VM scale set.
            :type vm_scale_set_name: str
            :param dict custom_headers: headers that will be added to the request
            :param bool raw: returns the direct response alongside the
             deserialized response
            :param operation_config: :ref:`Operation configuration
             overrides<msrest:optionsforoperations>`.
            :return: VirtualMachineScaleSet or ClientRawResponse if raw=true
            :rtype: ~azure.mgmt.compute.v2019_03_01.models.VirtualMachineScaleSet
             or ~msrest.pipeline.ClientRawResponse
            :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
            """
            # Construct URL
            url = self.get.metadata['url']
            path_format_arguments = {
                'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str'),
                'vmScaleSetName': self._serialize.url("vm_scale_set_name", vm_scale_set_name, 'str'),
                'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str')
            }
            url = self._client.format_url(url, **path_format_arguments)

            # Construct parameters
            query_parameters = {}
            query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str')

            # Construct headers
            header_parameters = {}
            header_parameters['Accept'] = 'application/json'
            if self.config.generate_client_request_id:
                header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
            if custom_headers:
                header_parameters.update(custom_headers)
            if self.config.accept_language is not None:
                header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str')

            # Construct and send request
            request = self._client.get(url, query_parameters, header_parameters)
            response = self._client.send(request, stream=False, **operation_config)

            if response.status_code not in [200]:
                exp = CloudError(response)
                exp.request_id = response.headers.get('x-ms-request-id')
                raise exp

            deserialized = None
            if response.status_code == 200:
                deserialized = self._deserialize('VirtualMachineScaleSet', response)

            if raw:
                client_raw_response = ClientRawResponse(deserialized, response)
                return client_raw_response

            return deserialized
        get.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}'}

        def _deallocate_initial(
                self, resource_group_name, vm_scale_set_name, instance_ids=None, custom_headers=None, raw=False, **operation_config):
            vm_instance_ids = None
            if instance_ids is not None:
                vm_instance_ids = models.VirtualMachineScaleSetVMInstanceIDs(instance_ids=instance_ids)

            # Construct URL
            url = self.deallocate.metadata['url']
            path_format_arguments = {
                'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str'),
                'vmScaleSetName': self._serialize.url("vm_scale_set_name", vm_scale_set_name, 'str'),
                'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str')
            }
            url = self._client.format_url(url, **path_format_arguments)

            # Construct parameters
            query_parameters = {}
            query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str')

            # Construct headers
            header_parameters = {}
            header_parameters['Content-Type'] = 'application/json; charset=utf-8'
            if self.config.generate_client_request_id:
                header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
            if custom_headers:
                header_parameters.update(custom_headers)
            if self.config.accept_language is not None:
                header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str')

            # Construct body
            if vm_instance_ids is not None:
                body_content = self._serialize.body(vm_instance_ids, 'VirtualMachineScaleSetVMInstanceIDs')
            else:
                body_content = None

            # Construct and send request
            request = self._client.post(url, query_parameters, header_parameters, body_content)
            response = self._client.send(request, stream=False, **operation_config)

            if response.status_code not in [200, 202]:
                exp = CloudError(response)
                exp.request_id = response.headers.get('x-ms-request-id')
                raise exp

            if raw:
                client_raw_response = ClientRawResponse(None, response)
                return client_raw_response

        def deallocate(
                self, resource_group_name, vm_scale_set_name, instance_ids=None, custom_headers=None, raw=False, polling=True, **operation_config):
            """Deallocates specific virtual machines in a VM scale set. Shuts down the
            virtual machines and releases the compute resources. You are not billed
            for the compute resources that this virtual machine scale set
            deallocates.

            :param resource_group_name: The name of the resource group.
            :type resource_group_name: str
            :param vm_scale_set_name: The name of the VM scale set.
            :type vm_scale_set_name: str
            :param instance_ids: The virtual machine scale set instance ids.
             Omitting the virtual machine scale set instance ids will result in the
             operation being performed on all virtual machines in the virtual
             machine scale set.
            :type instance_ids: list[str]
            :param dict custom_headers: headers that will be added to the request
            :param bool raw: The poller return type is ClientRawResponse, the
             direct response alongside the deserialized response
            :param polling: True for ARMPolling, False for no polling, or a
             polling object for personal polling strategy
            :return: An instance of LROPoller that returns None or
             ClientRawResponse<None> if raw==True
            :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or
             ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]
            :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
            """
            raw_result = self._deallocate_initial(
                resource_group_name=resource_group_name,
                vm_scale_set_name=vm_scale_set_name,
                instance_ids=instance_ids,
                custom_headers=custom_headers,
                raw=True,
                **operation_config
            )

            def get_long_running_output(response):
                if raw:
                    client_raw_response = ClientRawResponse(None, response)
                    return client_raw_response

            lro_delay = operation_config.get(
                'long_running_operation_timeout',
                self.config.long_running_operation_timeout)
            if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)
            elif polling is False: polling_method = NoPolling()
            else: polling_method = polling
            return LROPoller(self._client, raw_result, get_long_running_output, polling_method)
        deallocate.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}/deallocate'}

        def _delete_instances_initial(
                self, resource_group_name, vm_scale_set_name, instance_ids, custom_headers=None, raw=False, **operation_config):
            vm_instance_ids = models.VirtualMachineScaleSetVMInstanceRequiredIDs(instance_ids=instance_ids)

            # Construct URL
            url = self.delete_instances.metadata['url']
            path_format_arguments = {
                'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str'),
                'vmScaleSetName': self._serialize.url("vm_scale_set_name", vm_scale_set_name, 'str'),
                'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str')
            }
            url = self._client.format_url(url, **path_format_arguments)

            # Construct parameters
            query_parameters = {}
            query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str')

            # Construct headers
            header_parameters = {}
            header_parameters['Content-Type'] = 'application/json; charset=utf-8'
            if self.config.generate_client_request_id:
                header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
            if custom_headers:
                header_parameters.update(custom_headers)
            if self.config.accept_language is not None:
                header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str')

            # Construct body
            body_content = self._serialize.body(vm_instance_ids, 'VirtualMachineScaleSetVMInstanceRequiredIDs')

            # Construct and send request
            request = self._client.post(url, query_parameters, header_parameters, body_content)
            response = self._client.send(request, stream=False, **operation_config)

            if response.status_code not in [200, 202]:
                exp = CloudError(response)
                exp.request_id = response.headers.get('x-ms-request-id')
                raise exp

            if raw:
                client_raw_response = ClientRawResponse(None, response)
                return client_raw_response

        def delete_instances(
                self, resource_group_name, vm_scale_set_name, instance_ids, custom_headers=None, raw=False, polling=True, **operation_config):
            """Deletes virtual machines in a VM scale set.

            :param resource_group_name: The name of the resource group.
            :type resource_group_name: str
            :param vm_scale_set_name: The name of the VM scale set.
            :type vm_scale_set_name: str
            :param instance_ids: The virtual machine scale set instance ids.
            :type instance_ids: list[str]
            :param dict custom_headers: headers that will be added to the request
            :param bool raw: The poller return type is ClientRawResponse, the
             direct response alongside the deserialized response
            :param polling: True for ARMPolling, False for no polling, or a
             polling object for personal polling strategy
            :return: An instance of LROPoller that returns None or
             ClientRawResponse<None> if raw==True
            :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or
             ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]
            :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
            """
            raw_result = self._delete_instances_initial(
                resource_group_name=resource_group_name,
                vm_scale_set_name=vm_scale_set_name,
                instance_ids=instance_ids,
                custom_headers=custom_headers,
                raw=True,
                **operation_config
            )

            def get_long_running_output(response):
                if raw:
                    client_raw_response = ClientRawResponse(None, response)
                    return client_raw_response

            lro_delay = operation_config.get(
                'long_running_operation_timeout',
                self.config.long_running_operation_timeout)
            if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)
            elif polling is False: polling_method = NoPolling()
            else: polling_method = polling
            return LROPoller(self._client, raw_result, get_long_running_output, polling_method)
        delete_instances.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}/delete'}

        def get_instance_view(
                self, resource_group_name, vm_scale_set_name, custom_headers=None, raw=False, **operation_config):
            """Gets the status of a VM scale set instance.

            :param resource_group_name: The name of the resource group.
            :type resource_group_name: str
            :param vm_scale_set_name: The name of the VM scale set.
            :type vm_scale_set_name: str
            :param dict custom_headers: headers that will be added to the request
            :param bool raw: returns the direct response alongside the
             deserialized response
            :param operation_config: :ref:`Operation configuration
             overrides<msrest:optionsforoperations>`.
            :return: VirtualMachineScaleSetInstanceView or ClientRawResponse if
             raw=true
            :rtype:
             ~azure.mgmt.compute.v2019_03_01.models.VirtualMachineScaleSetInstanceView
             or ~msrest.pipeline.ClientRawResponse
            :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
            """
            # Construct URL
            url = self.get_instance_view.metadata['url']
            path_format_arguments = {
                'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str'),
                'vmScaleSetName': self._serialize.url("vm_scale_set_name", vm_scale_set_name, 'str'),
                'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str')
            }
            url = self._client.format_url(url, **path_format_arguments)

            # Construct parameters
            query_parameters = {}
            query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str')

            # Construct headers
            header_parameters = {}
            header_parameters['Accept'] = 'application/json'
            if self.config.generate_client_request_id:
                header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
            if custom_headers:
                header_parameters.update(custom_headers)
            if self.config.accept_language is not None:
                header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str')

            # Construct and send request
            request = self._client.get(url, query_parameters, header_parameters)
            response = self._client.send(request, stream=False, **operation_config)

            if response.status_code not in [200]:
                exp = CloudError(response)
                exp.request_id = response.headers.get('x-ms-request-id')
                raise exp

            deserialized = None
            if response.status_code == 200:
                deserialized = self._deserialize('VirtualMachineScaleSetInstanceView', response)

            if raw:
                client_raw_response = ClientRawResponse(deserialized, response)
                return client_raw_response

            return deserialized
        get_instance_view.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}/instanceView'}

        def list(
                self, resource_group_name, custom_headers=None, raw=False, **operation_config):
            """Gets a list of all VM scale sets under a resource group.

            :param resource_group_name: The name of the resource group.
            :type resource_group_name: str
            :param dict custom_headers: headers that will be added to the request
            :param bool raw: returns the direct response alongside the
             deserialized response
            :param operation_config: :ref:`Operation configuration
             overrides<msrest:optionsforoperations>`.
            :return: An iterator like instance of VirtualMachineScaleSet
            :rtype:
             ~azure.mgmt.compute.v2019_03_01.models.VirtualMachineScaleSetPaged[~azure.mgmt.compute.v2019_03_01.models.VirtualMachineScaleSet]
            :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
            """
            def prepare_request(next_link=None):
                if not next_link:
                    # Construct URL
                    url = self.list.metadata['url']
                    path_format_arguments = {
                        'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str'),
                        'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str')
                    }
                    url = self._client.format_url(url, **path_format_arguments)

                    # Construct parameters
                    query_parameters = {}
                    query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str')

                else:
                    url = next_link
                    query_parameters = {}

                # Construct headers
                header_parameters = {}
                header_parameters['Accept'] = 'application/json'
                if self.config.generate_client_request_id:
                    header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
                if custom_headers:
                    header_parameters.update(custom_headers)
                if self.config.accept_language is not None:
                    header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str')

                # Construct and send request
                request = self._client.get(url, query_parameters, header_parameters)
                return request

            def internal_paging(next_link=None):
                request = prepare_request(next_link)

                response = self._client.send(request, stream=False, **operation_config)

                if response.status_code not in [200]:
                    exp = CloudError(response)
                    exp.request_id = response.headers.get('x-ms-request-id')
                    raise exp

                return response

            # Deserialize response
            header_dict = None
            if raw:
                header_dict = {}
            deserialized = models.VirtualMachineScaleSetPaged(internal_paging, self._deserialize.dependencies, header_dict)

            return deserialized
        list.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets'}

        def list_all(
                self, custom_headers=None, raw=False, **operation_config):
            """Gets a list of all VM Scale Sets in the subscription, regardless of the
            associated resource group. Use nextLink property in the response to get
            the next page of VM Scale Sets. Do this till nextLink is null to fetch
            all the VM Scale Sets.

            :param dict custom_headers: headers that will be added to the request
            :param bool raw: returns the direct response alongside the
             deserialized response
            :param operation_config: :ref:`Operation configuration
             overrides<msrest:optionsforoperations>`.
            :return: An iterator like instance of VirtualMachineScaleSet
            :rtype:
             ~azure.mgmt.compute.v2019_03_01.models.VirtualMachineScaleSetPaged[~azure.mgmt.compute.v2019_03_01.models.VirtualMachineScaleSet]
            :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
            """
            def prepare_request(next_link=None):
                if not next_link:
                    # Construct URL
                    url = self.list_all.metadata['url']
                    path_format_arguments = {
                        'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str')
                    }
                    url = self._client.format_url(url, **path_format_arguments)

                    # Construct parameters
                    query_parameters = {}
                    query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str')

                else:
                    url = next_link
                    query_parameters = {}

                # Construct headers
                header_parameters = {}
                header_parameters['Accept'] = 'application/json'
                if self.config.generate_client_request_id:
                    header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
                if custom_headers:
                    header_parameters.update(custom_headers)
                if self.config.accept_language is not None:
                    header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str')

                # Construct and send request
                request = self._client.get(url, query_parameters, header_parameters)
                return request

            def internal_paging(next_link=None):
                request = prepare_request(next_link)

                response = self._client.send(request, stream=False, **operation_config)

                if response.status_code not in [200]:
                    exp = CloudError(response)
                    exp.request_id = response.headers.get('x-ms-request-id')
                    raise exp

                return response

            # Deserialize response
            header_dict = None
            if raw:
                header_dict = {}
            deserialized = models.VirtualMachineScaleSetPaged(internal_paging, self._deserialize.dependencies, header_dict)

            return deserialized
        list_all.metadata = {'url': '/subscriptions/{subscriptionId}/providers/Microsoft.Compute/virtualMachineScaleSets'}

        def list_skus(
                self, resource_group_name, vm_scale_set_name, custom_headers=None, raw=False, **operation_config):
            """Gets a list of SKUs available for your VM scale set, including the
            minimum and maximum VM instances allowed for each SKU.

            :param resource_group_name: The name of the resource group.
            :type resource_group_name: str
            :param vm_scale_set_name: The name of the VM scale set.
            :type vm_scale_set_name: str
            :param dict custom_headers: headers that will be added to the request
            :param bool raw: returns the direct response alongside the
             deserialized response
            :param operation_config: :ref:`Operation configuration
             overrides<msrest:optionsforoperations>`.
            :return: An iterator like instance of VirtualMachineScaleSetSku
            :rtype:
             ~azure.mgmt.compute.v2019_03_01.models.VirtualMachineScaleSetSkuPaged[~azure.mgmt.compute.v2019_03_01.models.VirtualMachineScaleSetSku]
            :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
            """
            def prepare_request(next_link=None):
                if not next_link:
                    # Construct URL
                    url = self.list_skus.metadata['url']
                    path_format_arguments = {
                        'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str'),
                        'vmScaleSetName': self._serialize.url("vm_scale_set_name", vm_scale_set_name, 'str'),
                        'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str')
                    }
                    url = self._client.format_url(url, **path_format_arguments)

                    # Construct parameters
                    query_parameters = {}
                    query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str')

                else:
                    url = next_link
                    query_parameters = {}

                # Construct headers
                header_parameters = {}
                header_parameters['Accept'] = 'application/json'
                if self.config.generate_client_request_id:
                    header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
                if custom_headers:
                    header_parameters.update(custom_headers)
                if self.config.accept_language is not None:
                    header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str')

                # Construct and send request
                request = self._client.get(url, query_parameters, header_parameters)
                return request

            def internal_paging(next_link=None):
                request = prepare_request(next_link)

                response = self._client.send(request, stream=False, **operation_config)

                if response.status_code not in [200]:
                    exp = CloudError(response)
                    exp.request_id = response.headers.get('x-ms-request-id')
                    raise exp

                return response

            # Deserialize response
            header_dict = None
            if raw:
                header_dict = {}
            deserialized = models.VirtualMachineScaleSetSkuPaged(internal_paging, self._deserialize.dependencies, header_dict)

            return deserialized
        list_skus.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}/skus'}

        def get_os_upgrade_history(
                self, resource_group_name, vm_scale_set_name, custom_headers=None, raw=False, **operation_config):
            """Gets list of OS upgrades on a VM scale set instance.

            :param resource_group_name: The name of the resource group.
            :type resource_group_name: str
            :param vm_scale_set_name: The name of the VM scale set.
            :type vm_scale_set_name: str
            :param dict custom_headers: headers that will be added to the request
            :param bool raw: returns the direct response alongside the
             deserialized response
            :param operation_config: :ref:`Operation configuration
             overrides<msrest:optionsforoperations>`.
            :return: An iterator like instance of
             UpgradeOperationHistoricalStatusInfo
            :rtype:
             ~azure.mgmt.compute.v2019_03_01.models.UpgradeOperationHistoricalStatusInfoPaged[~azure.mgmt.compute.v2019_03_01.models.UpgradeOperationHistoricalStatusInfo]
            :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
            """
            def prepare_request(next_link=None):
                if not next_link:
                    # Construct URL
                    url = self.get_os_upgrade_history.metadata['url']
                    path_format_arguments = {
                        'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str'),
                        'vmScaleSetName': self._serialize.url("vm_scale_set_name", vm_scale_set_name, 'str'),
                        'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str')
                    }
                    url = self._client.format_url(url, **path_format_arguments)

                    # Construct parameters
                    query_parameters = {}
                    query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str')

                else:
                    url = next_link
                    query_parameters = {}

                # Construct headers
                header_parameters = {}
                header_parameters['Accept'] = 'application/json'
                if self.config.generate_client_request_id:
                    header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
                if custom_headers:
                    header_parameters.update(custom_headers)
                if self.config.accept_language is not None:
                    header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str')

                # Construct and send request
                request = self._client.get(url, query_parameters, header_parameters)
                return request

            def internal_paging(next_link=None):
                request = prepare_request(next_link)

                response = self._client.send(request, stream=False, **operation_config)

                if response.status_code not in [200]:
                    exp = CloudError(response)
                    exp.request_id = response.headers.get('x-ms-request-id')
                    raise exp

                return response

            # Deserialize response
            header_dict = None
            if raw:
                header_dict = {}
            deserialized = models.UpgradeOperationHistoricalStatusInfoPaged(internal_paging, self._deserialize.dependencies, header_dict)

            return deserialized
        get_os_upgrade_history.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}/osUpgradeHistory'}

        def _power_off_initial(
                self, resource_group_name, vm_scale_set_name, skip_shutdown=False, instance_ids=None, custom_headers=None, raw=False, **operation_config):
            vm_instance_ids = None
            if instance_ids is not None:
                vm_instance_ids = models.VirtualMachineScaleSetVMInstanceIDs(instance_ids=instance_ids)

            # Construct URL
            url = self.power_off.metadata['url']
            path_format_arguments = {
                'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str'),
                'vmScaleSetName': self._serialize.url("vm_scale_set_name", vm_scale_set_name, 'str'),
                'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str')
            }
            url = self._client.format_url(url, **path_format_arguments)

            # Construct parameters
            query_parameters = {}
            if skip_shutdown is not None:
                query_parameters['skipShutdown'] = self._serialize.query("skip_shutdown", skip_shutdown, 'bool')
            query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str')

            # Construct headers
            header_parameters = {}
            header_parameters['Content-Type'] = 'application/json; charset=utf-8'
            if self.config.generate_client_request_id:
                header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
            if custom_headers:
                header_parameters.update(custom_headers)
            if self.config.accept_language is not None:
                header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str')

            # Construct body
            if vm_instance_ids is not None:
                body_content = self._serialize.body(vm_instance_ids, 'VirtualMachineScaleSetVMInstanceIDs')
            else:
                body_content = None

            # Construct and send request
            request = self._client.post(url, query_parameters, header_parameters, body_content)
            response = self._client.send(request, stream=False, **operation_config)

            if response.status_code not in [200, 202]:
                exp = CloudError(response)
                exp.request_id = response.headers.get('x-ms-request-id')
                raise exp

            if raw:
                client_raw_response = ClientRawResponse(None, response)
                return client_raw_response

        def power_off(
                self, resource_group_name, vm_scale_set_name, skip_shutdown=False, instance_ids=None, custom_headers=None, raw=False, polling=True, **operation_config):
            """Power off (stop) one or more virtual machines in a VM scale set. Note
            that resources are still attached and you are getting charged for the
            resources. Instead, use deallocate to release resources and avoid
            charges.

            :param resource_group_name: The name of the resource group.
            :type resource_group_name: str
            :param vm_scale_set_name: The name of the VM scale set.
            :type vm_scale_set_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
            :param instance_ids: The virtual machine scale set instance ids.
             Omitting the virtual machine scale set instance ids will result in the
             operation being performed on all virtual machines in the virtual
             machine scale set.
            :type instance_ids: list[str]
            :param dict custom_headers: headers that will be added to the request
            :param bool raw: The poller return type is ClientRawResponse, the
             direct response alongside the deserialized response
            :param polling: True for ARMPolling, False for no polling, or a
             polling object for personal polling strategy
            :return: An instance of LROPoller that returns None or
             ClientRawResponse<None> if raw==True
            :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or
             ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]
            :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
            """
            raw_result = self._power_off_initial(
                resource_group_name=resource_group_name,
                vm_scale_set_name=vm_scale_set_name,
                skip_shutdown=skip_shutdown,
                instance_ids=instance_ids,
                custom_headers=custom_headers,
                raw=True,
                **operation_config
            )

            def get_long_running_output(response):
                if raw:
                    client_raw_response = ClientRawResponse(None, response)
                    return client_raw_response

            lro_delay = operation_config.get(
                'long_running_operation_timeout',
                self.config.long_running_operation_timeout)
            if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)
            elif polling is False: polling_method = NoPolling()
            else: polling_method = polling
            return LROPoller(self._client, raw_result, get_long_running_output, polling_method)
        power_off.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}/poweroff'}

        def _restart_initial(
                self, resource_group_name, vm_scale_set_name, instance_ids=None, custom_headers=None, raw=False, **operation_config):
            vm_instance_ids = None
            if instance_ids is not None:
                vm_instance_ids = models.VirtualMachineScaleSetVMInstanceIDs(instance_ids=instance_ids)

            # Construct URL
            url = self.restart.metadata['url']
            path_format_arguments = {
                'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str'),
                'vmScaleSetName': self._serialize.url("vm_scale_set_name", vm_scale_set_name, 'str'),
                'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str')
            }
            url = self._client.format_url(url, **path_format_arguments)

            # Construct parameters
            query_parameters = {}
            query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str')

            # Construct headers
            header_parameters = {}
            header_parameters['Content-Type'] = 'application/json; charset=utf-8'
            if self.config.generate_client_request_id:
                header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
            if custom_headers:
                header_parameters.update(custom_headers)
            if self.config.accept_language is not None:
                header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str')

            # Construct body
            if vm_instance_ids is not None:
                body_content = self._serialize.body(vm_instance_ids, 'VirtualMachineScaleSetVMInstanceIDs')
            else:
                body_content = None

            # Construct and send request
            request = self._client.post(url, query_parameters, header_parameters, body_content)
            response = self._client.send(request, stream=False, **operation_config)

            if response.status_code not in [200, 202]:
                exp = CloudError(response)
                exp.request_id = response.headers.get('x-ms-request-id')
                raise exp

            if raw:
                client_raw_response = ClientRawResponse(None, response)
                return client_raw_response

        def restart(
                self, resource_group_name, vm_scale_set_name, instance_ids=None, custom_headers=None, raw=False, polling=True, **operation_config):
            """Restarts one or more virtual machines in a VM scale set.

            :param resource_group_name: The name of the resource group.
            :type resource_group_name: str
            :param vm_scale_set_name: The name of the VM scale set.
            :type vm_scale_set_name: str
            :param instance_ids: The virtual machine scale set instance ids.
             Omitting the virtual machine scale set instance ids will result in the
             operation being performed on all virtual machines in the virtual
             machine scale set.
            :type instance_ids: list[str]
            :param dict custom_headers: headers that will be added to the request
            :param bool raw: The poller return type is ClientRawResponse, the
             direct response alongside the deserialized response
            :param polling: True for ARMPolling, False for no polling, or a
             polling object for personal polling strategy
            :return: An instance of LROPoller that returns None or
             ClientRawResponse<None> if raw==True
            :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or
             ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]
            :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
            """
            raw_result = self._restart_initial(
                resource_group_name=resource_group_name,
                vm_scale_set_name=vm_scale_set_name,
                instance_ids=instance_ids,
                custom_headers=custom_headers,
                raw=True,
                **operation_config
            )

            def get_long_running_output(response):
                if raw:
                    client_raw_response = ClientRawResponse(None, response)
                    return client_raw_response

            lro_delay = operation_config.get(
                'long_running_operation_timeout',
                self.config.long_running_operation_timeout)
            if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)
            elif polling is False: polling_method = NoPolling()
            else: polling_method = polling
            return LROPoller(self._client, raw_result, get_long_running_output, polling_method)
        restart.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}/restart'}

        def _start_initial(
                self, resource_group_name, vm_scale_set_name, instance_ids=None, custom_headers=None, raw=False, **operation_config):
            vm_instance_ids = None
            if instance_ids is not None:
                vm_instance_ids = models.VirtualMachineScaleSetVMInstanceIDs(instance_ids=instance_ids)

            # Construct URL
            url = self.start.metadata['url']
            path_format_arguments = {
                'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str'),
                'vmScaleSetName': self._serialize.url("vm_scale_set_name", vm_scale_set_name, 'str'),
                'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str')
            }
            url = self._client.format_url(url, **path_format_arguments)

            # Construct parameters
            query_parameters = {}
            query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str')

            # Construct headers
            header_parameters = {}
            header_parameters['Content-Type'] = 'application/json; charset=utf-8'
            if self.config.generate_client_request_id:
                header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
            if custom_headers:
                header_parameters.update(custom_headers)
            if self.config.accept_language is not None:
                header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str')

            # Construct body
            if vm_instance_ids is not None:
                body_content = self._serialize.body(vm_instance_ids, 'VirtualMachineScaleSetVMInstanceIDs')
            else:
                body_content = None

            # Construct and send request
            request = self._client.post(url, query_parameters, header_parameters, body_content)
            response = self._client.send(request, stream=False, **operation_config)

            if response.status_code not in [200, 202]:
                exp = CloudError(response)
                exp.request_id = response.headers.get('x-ms-request-id')
                raise exp

            if raw:
                client_raw_response = ClientRawResponse(None, response)
                return client_raw_response

        def start(
                self, resource_group_name, vm_scale_set_name, instance_ids=None, custom_headers=None, raw=False, polling=True, **operation_config):
            """Starts one or more virtual machines in a VM scale set.

            :param resource_group_name: The name of the resource group.
            :type resource_group_name: str
            :param vm_scale_set_name: The name of the VM scale set.
            :type vm_scale_set_name: str
            :param instance_ids: The virtual machine scale set instance ids.
             Omitting the virtual machine scale set instance ids will result in the
             operation being performed on all virtual machines in the virtual
             machine scale set.
            :type instance_ids: list[str]
            :param dict custom_headers: headers that will be added to the request
            :param bool raw: The poller return type is ClientRawResponse, the
             direct response alongside the deserialized response
            :param polling: True for ARMPolling, False for no polling, or a
             polling object for personal polling strategy
            :return: An instance of LROPoller that returns None or
             ClientRawResponse<None> if raw==True
            :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or
             ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]
            :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
            """
            raw_result = self._start_initial(
                resource_group_name=resource_group_name,
                vm_scale_set_name=vm_scale_set_name,
                instance_ids=instance_ids,
                custom_headers=custom_headers,
                raw=True,
                **operation_config
            )

            def get_long_running_output(response):
                if raw:
                    client_raw_response = ClientRawResponse(None, response)
                    return client_raw_response

            lro_delay = operation_config.get(
                'long_running_operation_timeout',
                self.config.long_running_operation_timeout)
            if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)
            elif polling is False: polling_method = NoPolling()
            else: polling_method = polling
            return LROPoller(self._client, raw_result, get_long_running_output, polling_method)
        start.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}/start'}

        def _redeploy_initial(
                self, resource_group_name, vm_scale_set_name, instance_ids=None, custom_headers=None, raw=False, **operation_config):
            vm_instance_ids = None
            if instance_ids is not None:
                vm_instance_ids = models.VirtualMachineScaleSetVMInstanceIDs(instance_ids=instance_ids)

            # Construct URL
            url = self.redeploy.metadata['url']
            path_format_arguments = {
                'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str'),
                'vmScaleSetName': self._serialize.url("vm_scale_set_name", vm_scale_set_name, 'str'),
                'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str')
            }
            url = self._client.format_url(url, **path_format_arguments)

            # Construct parameters
            query_parameters = {}
            query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str')

            # Construct headers
            header_parameters = {}
            header_parameters['Content-Type'] = 'application/json; charset=utf-8'
            if self.config.generate_client_request_id:
                header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
            if custom_headers:
                header_parameters.update(custom_headers)
            if self.config.accept_language is not None:
                header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str')

            # Construct body
            if vm_instance_ids is not None:
                body_content = self._serialize.body(vm_instance_ids, 'VirtualMachineScaleSetVMInstanceIDs')
            else:
                body_content = None

            # Construct and send request
            request = self._client.post(url, query_parameters, header_parameters, body_content)
            response = self._client.send(request, stream=False, **operation_config)

            if response.status_code not in [200, 202]:
                exp = CloudError(response)
                exp.request_id = response.headers.get('x-ms-request-id')
                raise exp

            if raw:
                client_raw_response = ClientRawResponse(None, response)
                return client_raw_response

        def redeploy(
                self, resource_group_name, vm_scale_set_name, instance_ids=None, custom_headers=None, raw=False, polling=True, **operation_config):
            """Shuts down all the virtual machines in the virtual machine scale set,
            moves them to a new node, and powers them back on.

            :param resource_group_name: The name of the resource group.
            :type resource_group_name: str
            :param vm_scale_set_name: The name of the VM scale set.
            :type vm_scale_set_name: str
            :param instance_ids: The virtual machine scale set instance ids.
             Omitting the virtual machine scale set instance ids will result in the
             operation being performed on all virtual machines in the virtual
             machine scale set.
            :type instance_ids: list[str]
            :param dict custom_headers: headers that will be added to the request
            :param bool raw: The poller return type is ClientRawResponse, the
             direct response alongside the deserialized response
            :param polling: True for ARMPolling, False for no polling, or a
             polling object for personal polling strategy
            :return: An instance of LROPoller that returns None or
             ClientRawResponse<None> if raw==True
            :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or
             ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]
            :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
            """
            raw_result = self._redeploy_initial(
                resource_group_name=resource_group_name,
                vm_scale_set_name=vm_scale_set_name,
                instance_ids=instance_ids,
                custom_headers=custom_headers,
                raw=True,
                **operation_config
            )

            def get_long_running_output(response):
                if raw:
                    client_raw_response = ClientRawResponse(None, response)
                    return client_raw_response

            lro_delay = operation_config.get(
                'long_running_operation_timeout',
                self.config.long_running_operation_timeout)
            if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)
            elif polling is False: polling_method = NoPolling()
            else: polling_method = polling
            return LROPoller(self._client, raw_result, get_long_running_output, polling_method)
        redeploy.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}/redeploy'}

        def _perform_maintenance_initial(
                self, resource_group_name, vm_scale_set_name, instance_ids=None, custom_headers=None, raw=False, **operation_config):
            vm_instance_ids = None
            if instance_ids is not None:
                vm_instance_ids = models.VirtualMachineScaleSetVMInstanceIDs(instance_ids=instance_ids)

            # Construct URL
            url = self.perform_maintenance.metadata['url']
            path_format_arguments = {
                'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str'),
                'vmScaleSetName': self._serialize.url("vm_scale_set_name", vm_scale_set_name, 'str'),
                'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str')
            }
            url = self._client.format_url(url, **path_format_arguments)

            # Construct parameters
            query_parameters = {}
            query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str')

            # Construct headers
            header_parameters = {}
            header_parameters['Content-Type'] = 'application/json; charset=utf-8'
            if self.config.generate_client_request_id:
                header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
            if custom_headers:
                header_parameters.update(custom_headers)
            if self.config.accept_language is not None:
                header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str')

            # Construct body
            if vm_instance_ids is not None:
                body_content = self._serialize.body(vm_instance_ids, 'VirtualMachineScaleSetVMInstanceIDs')
            else:
                body_content = None

            # Construct and send request
            request = self._client.post(url, query_parameters, header_parameters, body_content)
            response = self._client.send(request, stream=False, **operation_config)

            if response.status_code not in [200, 202]:
                exp = CloudError(response)
                exp.request_id = response.headers.get('x-ms-request-id')
                raise exp

            if raw:
                client_raw_response = ClientRawResponse(None, response)
                return client_raw_response

        def perform_maintenance(
                self, resource_group_name, vm_scale_set_name, instance_ids=None, custom_headers=None, raw=False, polling=True, **operation_config):
            """Perform maintenance on one or more virtual machines in a VM scale set.
            Operation on instances which are not eligible for perform maintenance
            will be failed. Please refer to best practices for more details:
            https://docs.microsoft.com/en-us/azure/virtual-machine-scale-sets/virtual-machine-scale-sets-maintenance-notifications.

            :param resource_group_name: The name of the resource group.
            :type resource_group_name: str
            :param vm_scale_set_name: The name of the VM scale set.
            :type vm_scale_set_name: str
            :param instance_ids: The virtual machine scale set instance ids.
             Omitting the virtual machine scale set instance ids will result in the
             operation being performed on all virtual machines in the virtual
             machine scale set.
            :type instance_ids: list[str]
            :param dict custom_headers: headers that will be added to the request
            :param bool raw: The poller return type is ClientRawResponse, the
             direct response alongside the deserialized response
            :param polling: True for ARMPolling, False for no polling, or a
             polling object for personal polling strategy
            :return: An instance of LROPoller that returns None or
             ClientRawResponse<None> if raw==True
            :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or
             ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]
            :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
            """
            raw_result = self._perform_maintenance_initial(
                resource_group_name=resource_group_name,
                vm_scale_set_name=vm_scale_set_name,
                instance_ids=instance_ids,
                custom_headers=custom_headers,
                raw=True,
                **operation_config
            )

            def get_long_running_output(response):
                if raw:
                    client_raw_response = ClientRawResponse(None, response)
                    return client_raw_response

            lro_delay = operation_config.get(
                'long_running_operation_timeout',
                self.config.long_running_operation_timeout)
            if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)
            elif polling is False: polling_method = NoPolling()
            else: polling_method = polling
            return LROPoller(self._client, raw_result, get_long_running_output, polling_method)
        perform_maintenance.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}/performMaintenance'}

        def _update_instances_initial(
                self, resource_group_name, vm_scale_set_name, instance_ids, custom_headers=None, raw=False, **operation_config):
            vm_instance_ids = models.VirtualMachineScaleSetVMInstanceRequiredIDs(instance_ids=instance_ids)

            # Construct URL
            url = self.update_instances.metadata['url']
            path_format_arguments = {
                'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str'),
                'vmScaleSetName': self._serialize.url("vm_scale_set_name", vm_scale_set_name, 'str'),
                'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str')
            }
            url = self._client.format_url(url, **path_format_arguments)

            # Construct parameters
            query_parameters = {}
            query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str')

            # Construct headers
            header_parameters = {}
            header_parameters['Content-Type'] = 'application/json; charset=utf-8'
            if self.config.generate_client_request_id:
                header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
            if custom_headers:
                header_parameters.update(custom_headers)
            if self.config.accept_language is not None:
                header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str')

            # Construct body
            body_content = self._serialize.body(vm_instance_ids, 'VirtualMachineScaleSetVMInstanceRequiredIDs')

            # Construct and send request
            request = self._client.post(url, query_parameters, header_parameters, body_content)
            response = self._client.send(request, stream=False, **operation_config)

            if response.status_code not in [200, 202]:
                exp = CloudError(response)
                exp.request_id = response.headers.get('x-ms-request-id')
                raise exp

            if raw:
                client_raw_response = ClientRawResponse(None, response)
                return client_raw_response

        def update_instances(
                self, resource_group_name, vm_scale_set_name, instance_ids, custom_headers=None, raw=False, polling=True, **operation_config):
            """Upgrades one or more virtual machines to the latest SKU set in the VM
            scale set model.

            :param resource_group_name: The name of the resource group.
            :type resource_group_name: str
            :param vm_scale_set_name: The name of the VM scale set.
            :type vm_scale_set_name: str
            :param instance_ids: The virtual machine scale set instance ids.
            :type instance_ids: list[str]
            :param dict custom_headers: headers that will be added to the request
            :param bool raw: The poller return type is ClientRawResponse, the
             direct response alongside the deserialized response
            :param polling: True for ARMPolling, False for no polling, or a
             polling object for personal polling strategy
            :return: An instance of LROPoller that returns None or
             ClientRawResponse<None> if raw==True
            :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or
             ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]
            :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
            """
            raw_result = self._update_instances_initial(
                resource_group_name=resource_group_name,
                vm_scale_set_name=vm_scale_set_name,
                instance_ids=instance_ids,
                custom_headers=custom_headers,
                raw=True,
                **operation_config
            )

            def get_long_running_output(response):
                if raw:
                    client_raw_response = ClientRawResponse(None, response)
                    return client_raw_response

            lro_delay = operation_config.get(
                'long_running_operation_timeout',
                self.config.long_running_operation_timeout)
            if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)
            elif polling is False: polling_method = NoPolling()
            else: polling_method = polling
            return LROPoller(self._client, raw_result, get_long_running_output, polling_method)
        update_instances.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}/manualupgrade'}

        def _reimage_initial(
                self, resource_group_name, vm_scale_set_name, temp_disk=None, instance_ids=None, custom_headers=None, raw=False, **operation_config):
            vm_scale_set_reimage_input = None
            if temp_disk is not None or instance_ids is not None:
                vm_scale_set_reimage_input = models.VirtualMachineScaleSetReimageParameters(temp_disk=temp_disk, instance_ids=instance_ids)

            # Construct URL
            url = self.reimage.metadata['url']
            path_format_arguments = {
                'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str'),
                'vmScaleSetName': self._serialize.url("vm_scale_set_name", vm_scale_set_name, 'str'),
                'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str')
            }
            url = self._client.format_url(url, **path_format_arguments)

            # Construct parameters
            query_parameters = {}
            query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str')

            # Construct headers
            header_parameters = {}
            header_parameters['Content-Type'] = 'application/json; charset=utf-8'
            if self.config.generate_client_request_id:
                header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
            if custom_headers:
                header_parameters.update(custom_headers)
            if self.config.accept_language is not None:
                header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str')

            # Construct body
            if vm_scale_set_reimage_input is not None:
                body_content = self._serialize.body(vm_scale_set_reimage_input, 'VirtualMachineScaleSetReimageParameters')
            else:
                body_content = None

            # Construct and send request
            request = self._client.post(url, query_parameters, header_parameters, body_content)
            response = self._client.send(request, stream=False, **operation_config)

            if response.status_code not in [200, 202]:
                exp = CloudError(response)
                exp.request_id = response.headers.get('x-ms-request-id')
                raise exp

            if raw:
                client_raw_response = ClientRawResponse(None, response)
                return client_raw_response

        def reimage(
                self, resource_group_name, vm_scale_set_name, temp_disk=None, instance_ids=None, custom_headers=None, raw=False, polling=True, **operation_config):
            """Reimages (upgrade the operating system) one or more virtual machines in
            a VM scale set which don't have a ephemeral OS disk, for virtual
            machines who have a ephemeral OS disk the virtual machine is reset to
            initial state.

            :param resource_group_name: The name of the resource group.
            :type resource_group_name: str
            :param vm_scale_set_name: The name of the VM scale set.
            :type vm_scale_set_name: str
            :param temp_disk: Specifies whether to reimage temp disk. Default
             value: false. Note: This temp disk reimage parameter is only supported
             for VM/VMSS with Ephemeral OS disk.
            :type temp_disk: bool
            :param instance_ids: The virtual machine scale set instance ids.
             Omitting the virtual machine scale set instance ids will result in the
             operation being performed on all virtual machines in the virtual
             machine scale set.
            :type instance_ids: list[str]
            :param dict custom_headers: headers that will be added to the request
            :param bool raw: The poller return type is ClientRawResponse, the
             direct response alongside the deserialized response
            :param polling: True for ARMPolling, False for no polling, or a
             polling object for personal polling strategy
            :return: An instance of LROPoller that returns None or
             ClientRawResponse<None> if raw==True
            :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or
             ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]
            :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
            """
            raw_result = self._reimage_initial(
                resource_group_name=resource_group_name,
                vm_scale_set_name=vm_scale_set_name,
                temp_disk=temp_disk,
                instance_ids=instance_ids,
                custom_headers=custom_headers,
                raw=True,
                **operation_config
            )

            def get_long_running_output(response):
                if raw:
                    client_raw_response = ClientRawResponse(None, response)
                    return client_raw_response

            lro_delay = operation_config.get(
                'long_running_operation_timeout',
                self.config.long_running_operation_timeout)
            if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)
            elif polling is False: polling_method = NoPolling()
            else: polling_method = polling
            return LROPoller(self._client, raw_result, get_long_running_output, polling_method)
        reimage.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}/reimage'}

        def _reimage_all_initial(
                self, resource_group_name, vm_scale_set_name, instance_ids=None, custom_headers=None, raw=False, **operation_config):
            vm_instance_ids = None
            if instance_ids is not None:
                vm_instance_ids = models.VirtualMachineScaleSetVMInstanceIDs(instance_ids=instance_ids)

            # Construct URL
            url = self.reimage_all.metadata['url']
            path_format_arguments = {
                'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str'),
                'vmScaleSetName': self._serialize.url("vm_scale_set_name", vm_scale_set_name, 'str'),
                'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str')
            }
            url = self._client.format_url(url, **path_format_arguments)

            # Construct parameters
            query_parameters = {}
            query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str')

            # Construct headers
            header_parameters = {}
            header_parameters['Content-Type'] = 'application/json; charset=utf-8'
            if self.config.generate_client_request_id:
                header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
            if custom_headers:
                header_parameters.update(custom_headers)
            if self.config.accept_language is not None:
                header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str')

            # Construct body
            if vm_instance_ids is not None:
                body_content = self._serialize.body(vm_instance_ids, 'VirtualMachineScaleSetVMInstanceIDs')
            else:
                body_content = None

            # Construct and send request
            request = self._client.post(url, query_parameters, header_parameters, body_content)
            response = self._client.send(request, stream=False, **operation_config)

            if response.status_code not in [200, 202]:
                exp = CloudError(response)
                exp.request_id = response.headers.get('x-ms-request-id')
                raise exp

            if raw:
                client_raw_response = ClientRawResponse(None, response)
                return client_raw_response

        def reimage_all(
                self, resource_group_name, vm_scale_set_name, instance_ids=None, custom_headers=None, raw=False, polling=True, **operation_config):
            """Reimages all the disks ( including data disks ) in the virtual machines
            in a VM scale set. This operation is only supported for managed disks.

            :param resource_group_name: The name of the resource group.
            :type resource_group_name: str
            :param vm_scale_set_name: The name of the VM scale set.
            :type vm_scale_set_name: str
            :param instance_ids: The virtual machine scale set instance ids.
             Omitting the virtual machine scale set instance ids will result in the
             operation being performed on all virtual machines in the virtual
             machine scale set.
            :type instance_ids: list[str]
            :param dict custom_headers: headers that will be added to the request
            :param bool raw: The poller return type is ClientRawResponse, the
             direct response alongside the deserialized response
            :param polling: True for ARMPolling, False for no polling, or a
             polling object for personal polling strategy
            :return: An instance of LROPoller that returns None or
             ClientRawResponse<None> if raw==True
            :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or
             ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]
            :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
            """
            raw_result = self._reimage_all_initial(
                resource_group_name=resource_group_name,
                vm_scale_set_name=vm_scale_set_name,
                instance_ids=instance_ids,
                custom_headers=custom_headers,
                raw=True,
                **operation_config
            )

            def get_long_running_output(response):
                if raw:
                    client_raw_response = ClientRawResponse(None, response)
                    return client_raw_response

            lro_delay = operation_config.get(
                'long_running_operation_timeout',
                self.config.long_running_operation_timeout)
            if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)
            elif polling is False: polling_method = NoPolling()
            else: polling_method = polling
            return LROPoller(self._client, raw_result, get_long_running_output, polling_method)
        reimage_all.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}/reimageall'}

        def force_recovery_service_fabric_platform_update_domain_walk(
                self, resource_group_name, vm_scale_set_name, platform_update_domain, custom_headers=None, raw=False, **operation_config):
            """Manual platform update domain walk to update virtual machines in a
            service fabric virtual machine scale set.

            :param resource_group_name: The name of the resource group.
            :type resource_group_name: str
            :param vm_scale_set_name: The name of the VM scale set.
            :type vm_scale_set_name: str
            :param platform_update_domain: The platform update domain for which a
             manual recovery walk is requested
            :type platform_update_domain: int
            :param dict custom_headers: headers that will be added to the request
            :param bool raw: returns the direct response alongside the
             deserialized response
            :param operation_config: :ref:`Operation configuration
             overrides<msrest:optionsforoperations>`.
            :return: RecoveryWalkResponse or ClientRawResponse if raw=true
            :rtype: ~azure.mgmt.compute.v2019_03_01.models.RecoveryWalkResponse or
             ~msrest.pipeline.ClientRawResponse
            :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
            """
            # Construct URL
            url = self.force_recovery_service_fabric_platform_update_domain_walk.metadata['url']
            path_format_arguments = {
                'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str'),
                'vmScaleSetName': self._serialize.url("vm_scale_set_name", vm_scale_set_name, 'str'),
                'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str')
            }
            url = self._client.format_url(url, **path_format_arguments)

            # Construct parameters
            query_parameters = {}
            query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str')
            query_parameters['platformUpdateDomain'] = self._serialize.query("platform_update_domain", platform_update_domain, 'int')

            # Construct headers
            header_parameters = {}
            header_parameters['Accept'] = 'application/json'
            if self.config.generate_client_request_id:
                header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
            if custom_headers:
                header_parameters.update(custom_headers)
            if self.config.accept_language is not None:
                header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str')

            # Construct and send request
            request = self._client.post(url, query_parameters, header_parameters)
            response = self._client.send(request, stream=False, **operation_config)

            if response.status_code not in [200]:
                exp = CloudError(response)
                exp.request_id = response.headers.get('x-ms-request-id')
                raise exp

            deserialized = None
            if response.status_code == 200:
                deserialized = self._deserialize('RecoveryWalkResponse', response)

            if raw:
                client_raw_response = ClientRawResponse(deserialized, response)
                return client_raw_response

            return deserialized
        force_recovery_service_fabric_platform_update_domain_walk.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}/forceRecoveryServiceFabricPlatformUpdateDomainWalk'}

        def convert_to_single_placement_group(
                self, resource_group_name, vm_scale_set_name, active_placement_group_id=None, custom_headers=None, raw=False, **operation_config):
            """Converts SinglePlacementGroup property to false for a existing virtual
            machine scale set.

            :param resource_group_name: The name of the resource group.
            :type resource_group_name: str
            :param vm_scale_set_name: The name of the virtual machine scale set to
             create or update.
            :type vm_scale_set_name: str
            :param active_placement_group_id: Id of the placement group in which
             you want future virtual machine instances to be placed. To query
             placement group Id, please use Virtual Machine Scale Set VMs - Get
             API. If not provided, the platform will choose one with maximum number
             of virtual machine instances.
            :type active_placement_group_id: str
            :param dict custom_headers: headers that will be added to the request
            :param bool raw: returns the direct response alongside the
             deserialized response
            :param operation_config: :ref:`Operation configuration
             overrides<msrest:optionsforoperations>`.
            :return: None or ClientRawResponse if raw=true
            :rtype: None or ~msrest.pipeline.ClientRawResponse
            :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
            """
            parameters = models.VMScaleSetConvertToSinglePlacementGroupInput(active_placement_group_id=active_placement_group_id)

            # Construct URL
            url = self.convert_to_single_placement_group.metadata['url']
            path_format_arguments = {
                'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str'),
                'vmScaleSetName': self._serialize.url("vm_scale_set_name", vm_scale_set_name, 'str'),
                'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str')
            }
            url = self._client.format_url(url, **path_format_arguments)

            # Construct parameters
            query_parameters = {}

            # Construct headers
            header_parameters = {}
            header_parameters['Content-Type'] = 'application/json; charset=utf-8'
            if self.config.generate_client_request_id:
                header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
            if custom_headers:
                header_parameters.update(custom_headers)
            if self.config.accept_language is not None:
                header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str')

            # Construct body
            body_content = self._serialize.body(parameters, 'VMScaleSetConvertToSinglePlacementGroupInput')

            # Construct and send request
            request = self._client.post(url, query_parameters, header_parameters, body_content)
            response = self._client.send(request, stream=False, **operation_config)

            if response.status_code not in [200]:
                exp = CloudError(response)
                exp.request_id = response.headers.get('x-ms-request-id')
                raise exp

            if raw:
                client_raw_response = ClientRawResponse(None, response)
                return client_raw_response
        convert_to_single_placement_group.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmScaleSetName}/convertToSinglePlacementGroup'}