text: # coding=utf-8
  # --------------------------------------------------------------------------
  # Copyright (c) Microsoft Corporation. All rights reserved.
  # Licensed under the MIT License. See License.txt in the project root for
  # license information.
  #
  # Code generated by Microsoft (R) AutoRest Code Generator.
  # Changes may cause incorrect behavior and will be lost if the code is
  # regenerated.
  # --------------------------------------------------------------------------
  
  import 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 LROsOperations(object):
      """LROsOperations operations.
  
      :param client: Client for service requests.
      :param config: Configuration of service client.
      :param serializer: An object model serializer.
      :param deserializer: An object model deserializer.
      """
  
      models = models
  
      def __init__(self, client, config, serializer, deserializer):
  
          self._client = client
          self._serialize = serializer
          self._deserialize = deserializer
  
          self.config = config
  
  
      def _put200_succeeded_initial(
              self, product=None, custom_headers=None, raw=False, **operation_config):
          # Construct URL
          url = self.put200_succeeded.metadata['url']
  
          # Construct parameters
          query_parameters = {}
  
          # 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
          if product is not None:
              body_content = self._serialize.body(product, 'Product')
          else:
              body_content = None
  
          # 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, 204]:
              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('Product', response)
  
          if raw:
              client_raw_response = ClientRawResponse(deserialized, response)
              return client_raw_response
  
          return deserialized
  
      def put200_succeeded(
              self, product=None, custom_headers=None, raw=False, polling=True, **operation_config):
          """Long running put request, service returns a 200 to the initial request,
          with an entity that contains ProvisioningState=’Succeeded’.
  
          :param product: Product to put
          :type product: ~lro.models.Product
          :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 Product or
           ClientRawResponse<Product> if raw==True
          :rtype:
           ~msrestazure.azure_operation.AzureOperationPoller[~lro.models.Product]
           or
           ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~lro.models.Product]]
          :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
          """
          raw_result = self._put200_succeeded_initial(
              product=product,
              custom_headers=custom_headers,
              raw=True,
              **operation_config
          )
  
          def get_long_running_output(response):
              deserialized = self._deserialize('Product', 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)
      put200_succeeded.metadata = {'url': '/lro/put/200/succeeded'}
  
  
      def _put200_succeeded_no_state_initial(
              self, product=None, custom_headers=None, raw=False, **operation_config):
          # Construct URL
          url = self.put200_succeeded_no_state.metadata['url']
  
          # Construct parameters
          query_parameters = {}
  
          # 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
          if product is not None:
              body_content = self._serialize.body(product, 'Product')
          else:
              body_content = None
  
          # 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]:
              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('Product', response)
  
          if raw:
              client_raw_response = ClientRawResponse(deserialized, response)
              return client_raw_response
  
          return deserialized
  
      def put200_succeeded_no_state(
              self, product=None, custom_headers=None, raw=False, polling=True, **operation_config):
          """Long running put request, service returns a 200 to the initial request,
          with an entity that does not contain ProvisioningState=’Succeeded’.
  
          :param product: Product to put
          :type product: ~lro.models.Product
          :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 Product or
           ClientRawResponse<Product> if raw==True
          :rtype:
           ~msrestazure.azure_operation.AzureOperationPoller[~lro.models.Product]
           or
           ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~lro.models.Product]]
          :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
          """
          raw_result = self._put200_succeeded_no_state_initial(
              product=product,
              custom_headers=custom_headers,
              raw=True,
              **operation_config
          )
  
          def get_long_running_output(response):
              deserialized = self._deserialize('Product', 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)
      put200_succeeded_no_state.metadata = {'url': '/lro/put/200/succeeded/nostate'}
  
  
      def _put202_retry200_initial(
              self, product=None, custom_headers=None, raw=False, **operation_config):
          # Construct URL
          url = self.put202_retry200.metadata['url']
  
          # Construct parameters
          query_parameters = {}
  
          # 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
          if product is not None:
              body_content = self._serialize.body(product, 'Product')
          else:
              body_content = None
  
          # 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 [202]:
              exp = CloudError(response)
              exp.request_id = response.headers.get('x-ms-request-id')
              raise exp
  
          deserialized = None
  
          if response.status_code == 202:
              deserialized = self._deserialize('Product', response)
  
          if raw:
              client_raw_response = ClientRawResponse(deserialized, response)
              return client_raw_response
  
          return deserialized
  
      def put202_retry200(
              self, product=None, custom_headers=None, raw=False, polling=True, **operation_config):
          """Long running put request, service returns a 202 to the initial request,
          with a location header that points to a polling URL that returns a 200
          and an entity that doesn't contains ProvisioningState.
  
          :param product: Product to put
          :type product: ~lro.models.Product
          :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 Product or
           ClientRawResponse<Product> if raw==True
          :rtype:
           ~msrestazure.azure_operation.AzureOperationPoller[~lro.models.Product]
           or
           ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~lro.models.Product]]
          :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
          """
          raw_result = self._put202_retry200_initial(
              product=product,
              custom_headers=custom_headers,
              raw=True,
              **operation_config
          )
  
          def get_long_running_output(response):
              deserialized = self._deserialize('Product', 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)
      put202_retry200.metadata = {'url': '/lro/put/202/retry/200'}
  
  
      def _put201_creating_succeeded200_initial(
              self, product=None, custom_headers=None, raw=False, **operation_config):
          # Construct URL
          url = self.put201_creating_succeeded200.metadata['url']
  
          # Construct parameters
          query_parameters = {}
  
          # 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
          if product is not None:
              body_content = self._serialize.body(product, 'Product')
          else:
              body_content = None
  
          # 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('Product', response)
          if response.status_code == 201:
              deserialized = self._deserialize('Product', response)
  
          if raw:
              client_raw_response = ClientRawResponse(deserialized, response)
              return client_raw_response
  
          return deserialized
  
      def put201_creating_succeeded200(
              self, product=None, custom_headers=None, raw=False, polling=True, **operation_config):
          """Long running put request, service returns a 201 to the initial request,
          with an entity that contains ProvisioningState=’Creating’.  Polls
          return this value until the last poll returns a ‘200’ with
          ProvisioningState=’Succeeded’.
  
          :param product: Product to put
          :type product: ~lro.models.Product
          :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 Product or
           ClientRawResponse<Product> if raw==True
          :rtype:
           ~msrestazure.azure_operation.AzureOperationPoller[~lro.models.Product]
           or
           ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~lro.models.Product]]
          :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
          """
          raw_result = self._put201_creating_succeeded200_initial(
              product=product,
              custom_headers=custom_headers,
              raw=True,
              **operation_config
          )
  
          def get_long_running_output(response):
              deserialized = self._deserialize('Product', 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)
      put201_creating_succeeded200.metadata = {'url': '/lro/put/201/creating/succeeded/200'}
  
  
      def _put200_updating_succeeded204_initial(
              self, product=None, custom_headers=None, raw=False, **operation_config):
          # Construct URL
          url = self.put200_updating_succeeded204.metadata['url']
  
          # Construct parameters
          query_parameters = {}
  
          # 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
          if product is not None:
              body_content = self._serialize.body(product, 'Product')
          else:
              body_content = None
  
          # 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]:
              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('Product', response)
  
          if raw:
              client_raw_response = ClientRawResponse(deserialized, response)
              return client_raw_response
  
          return deserialized
  
      def put200_updating_succeeded204(
              self, product=None, custom_headers=None, raw=False, polling=True, **operation_config):
          """Long running put request, service returns a 201 to the initial request,
          with an entity that contains ProvisioningState=’Updating’.  Polls
          return this value until the last poll returns a ‘200’ with
          ProvisioningState=’Succeeded’.
  
          :param product: Product to put
          :type product: ~lro.models.Product
          :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 Product or
           ClientRawResponse<Product> if raw==True
          :rtype:
           ~msrestazure.azure_operation.AzureOperationPoller[~lro.models.Product]
           or
           ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~lro.models.Product]]
          :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
          """
          raw_result = self._put200_updating_succeeded204_initial(
              product=product,
              custom_headers=custom_headers,
              raw=True,
              **operation_config
          )
  
          def get_long_running_output(response):
              deserialized = self._deserialize('Product', 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)
      put200_updating_succeeded204.metadata = {'url': '/lro/put/200/updating/succeeded/200'}
  
  
      def _put201_creating_failed200_initial(
              self, product=None, custom_headers=None, raw=False, **operation_config):
          # Construct URL
          url = self.put201_creating_failed200.metadata['url']
  
          # Construct parameters
          query_parameters = {}
  
          # 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
          if product is not None:
              body_content = self._serialize.body(product, 'Product')
          else:
              body_content = None
  
          # 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('Product', response)
          if response.status_code == 201:
              deserialized = self._deserialize('Product', response)
  
          if raw:
              client_raw_response = ClientRawResponse(deserialized, response)
              return client_raw_response
  
          return deserialized
  
      def put201_creating_failed200(
              self, product=None, custom_headers=None, raw=False, polling=True, **operation_config):
          """Long running put request, service returns a 201 to the initial request,
          with an entity that contains ProvisioningState=’Created’.  Polls return
          this value until the last poll returns a ‘200’ with
          ProvisioningState=’Failed’.
  
          :param product: Product to put
          :type product: ~lro.models.Product
          :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 Product or
           ClientRawResponse<Product> if raw==True
          :rtype:
           ~msrestazure.azure_operation.AzureOperationPoller[~lro.models.Product]
           or
           ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~lro.models.Product]]
          :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
          """
          raw_result = self._put201_creating_failed200_initial(
              product=product,
              custom_headers=custom_headers,
              raw=True,
              **operation_config
          )
  
          def get_long_running_output(response):
              deserialized = self._deserialize('Product', 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)
      put201_creating_failed200.metadata = {'url': '/lro/put/201/created/failed/200'}
  
  
      def _put200_acceptedcanceled200_initial(
              self, product=None, custom_headers=None, raw=False, **operation_config):
          # Construct URL
          url = self.put200_acceptedcanceled200.metadata['url']
  
          # Construct parameters
          query_parameters = {}
  
          # 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
          if product is not None:
              body_content = self._serialize.body(product, 'Product')
          else:
              body_content = None
  
          # 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]:
              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('Product', response)
  
          if raw:
              client_raw_response = ClientRawResponse(deserialized, response)
              return client_raw_response
  
          return deserialized
  
      def put200_acceptedcanceled200(
              self, product=None, custom_headers=None, raw=False, polling=True, **operation_config):
          """Long running put request, service returns a 201 to the initial request,
          with an entity that contains ProvisioningState=’Creating’.  Polls
          return this value until the last poll returns a ‘200’ with
          ProvisioningState=’Canceled’.
  
          :param product: Product to put
          :type product: ~lro.models.Product
          :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 Product or
           ClientRawResponse<Product> if raw==True
          :rtype:
           ~msrestazure.azure_operation.AzureOperationPoller[~lro.models.Product]
           or
           ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~lro.models.Product]]
          :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
          """
          raw_result = self._put200_acceptedcanceled200_initial(
              product=product,
              custom_headers=custom_headers,
              raw=True,
              **operation_config
          )
  
          def get_long_running_output(response):
              deserialized = self._deserialize('Product', 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)
      put200_acceptedcanceled200.metadata = {'url': '/lro/put/200/accepted/canceled/200'}
  
  
      def _put_no_header_in_retry_initial(
              self, product=None, custom_headers=None, raw=False, **operation_config):
          # Construct URL
          url = self.put_no_header_in_retry.metadata['url']
  
          # Construct parameters
          query_parameters = {}
  
          # 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
          if product is not None:
              body_content = self._serialize.body(product, 'Product')
          else:
              body_content = None
  
          # 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 [202]:
              exp = CloudError(response)
              exp.request_id = response.headers.get('x-ms-request-id')
              raise exp
  
          deserialized = None
          header_dict = {}
  
          if response.status_code == 202:
              deserialized = self._deserialize('Product', response)
              header_dict = {
                  'location': 'str',
              }
  
          if raw:
              client_raw_response = ClientRawResponse(deserialized, response)
              client_raw_response.add_headers(header_dict)
              return client_raw_response
  
          return deserialized
  
      def put_no_header_in_retry(
              self, product=None, custom_headers=None, raw=False, polling=True, **operation_config):
          """Long running put request, service returns a 202 to the initial request
          with location header. Subsequent calls to operation status do not
          contain location header.
  
          :param product: Product to put
          :type product: ~lro.models.Product
          :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 Product or
           ClientRawResponse<Product> if raw==True
          :rtype:
           ~msrestazure.azure_operation.AzureOperationPoller[~lro.models.Product]
           or
           ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~lro.models.Product]]
          :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
          """
          raw_result = self._put_no_header_in_retry_initial(
              product=product,
              custom_headers=custom_headers,
              raw=True,
              **operation_config
          )
  
          def get_long_running_output(response):
              header_dict = {
                  'location': 'str',
              }
              deserialized = self._deserialize('Product', response)
  
              if raw:
                  client_raw_response = ClientRawResponse(deserialized, response)
                  client_raw_response.add_headers(header_dict)
                  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)
      put_no_header_in_retry.metadata = {'url': '/lro/put/noheader/202/200'}
  
  
      def _put_async_retry_succeeded_initial(
              self, product=None, custom_headers=None, raw=False, **operation_config):
          # Construct URL
          url = self.put_async_retry_succeeded.metadata['url']
  
          # Construct parameters
          query_parameters = {}
  
          # 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
          if product is not None:
              body_content = self._serialize.body(product, 'Product')
          else:
              body_content = None
  
          # 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]:
              exp = CloudError(response)
              exp.request_id = response.headers.get('x-ms-request-id')
              raise exp
  
          deserialized = None
          header_dict = {}
  
          if response.status_code == 200:
              deserialized = self._deserialize('Product', response)
              header_dict = {
                  'Azure-AsyncOperation': 'str',
                  'Location': 'str',
                  'Retry-After': 'int',
              }
  
          if raw:
              client_raw_response = ClientRawResponse(deserialized, response)
              client_raw_response.add_headers(header_dict)
              return client_raw_response
  
          return deserialized
  
      def put_async_retry_succeeded(
              self, product=None, custom_headers=None, raw=False, polling=True, **operation_config):
          """Long running put request, service returns a 200 to the initial request,
          with an entity that contains ProvisioningState=’Creating’. Poll the
          endpoint indicated in the Azure-AsyncOperation header for operation
          status.
  
          :param product: Product to put
          :type product: ~lro.models.Product
          :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 Product or
           ClientRawResponse<Product> if raw==True
          :rtype:
           ~msrestazure.azure_operation.AzureOperationPoller[~lro.models.Product]
           or
           ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~lro.models.Product]]
          :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
          """
          raw_result = self._put_async_retry_succeeded_initial(
              product=product,
              custom_headers=custom_headers,
              raw=True,
              **operation_config
          )
  
          def get_long_running_output(response):
              header_dict = {
                  'Azure-AsyncOperation': 'str',
                  'Location': 'str',
                  'Retry-After': 'int',
              }
              deserialized = self._deserialize('Product', response)
  
              if raw:
                  client_raw_response = ClientRawResponse(deserialized, response)
                  client_raw_response.add_headers(header_dict)
                  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)
      put_async_retry_succeeded.metadata = {'url': '/lro/putasync/retry/succeeded'}
  
  
      def _put_async_no_retry_succeeded_initial(
              self, product=None, custom_headers=None, raw=False, **operation_config):
          # Construct URL
          url = self.put_async_no_retry_succeeded.metadata['url']
  
          # Construct parameters
          query_parameters = {}
  
          # 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
          if product is not None:
              body_content = self._serialize.body(product, 'Product')
          else:
              body_content = None
  
          # 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]:
              exp = CloudError(response)
              exp.request_id = response.headers.get('x-ms-request-id')
              raise exp
  
          deserialized = None
          header_dict = {}
  
          if response.status_code == 200:
              deserialized = self._deserialize('Product', response)
              header_dict = {
                  'Azure-AsyncOperation': 'str',
                  'Location': 'str',
              }
  
          if raw:
              client_raw_response = ClientRawResponse(deserialized, response)
              client_raw_response.add_headers(header_dict)
              return client_raw_response
  
          return deserialized
  
      def put_async_no_retry_succeeded(
              self, product=None, custom_headers=None, raw=False, polling=True, **operation_config):
          """Long running put request, service returns a 200 to the initial request,
          with an entity that contains ProvisioningState=’Creating’. Poll the
          endpoint indicated in the Azure-AsyncOperation header for operation
          status.
  
          :param product: Product to put
          :type product: ~lro.models.Product
          :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 Product or
           ClientRawResponse<Product> if raw==True
          :rtype:
           ~msrestazure.azure_operation.AzureOperationPoller[~lro.models.Product]
           or
           ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~lro.models.Product]]
          :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
          """
          raw_result = self._put_async_no_retry_succeeded_initial(
              product=product,
              custom_headers=custom_headers,
              raw=True,
              **operation_config
          )
  
          def get_long_running_output(response):
              header_dict = {
                  'Azure-AsyncOperation': 'str',
                  'Location': 'str',
              }
              deserialized = self._deserialize('Product', response)
  
              if raw:
                  client_raw_response = ClientRawResponse(deserialized, response)
                  client_raw_response.add_headers(header_dict)
                  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)
      put_async_no_retry_succeeded.metadata = {'url': '/lro/putasync/noretry/succeeded'}
  
  
      def _put_async_retry_failed_initial(
              self, product=None, custom_headers=None, raw=False, **operation_config):
          # Construct URL
          url = self.put_async_retry_failed.metadata['url']
  
          # Construct parameters
          query_parameters = {}
  
          # 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
          if product is not None:
              body_content = self._serialize.body(product, 'Product')
          else:
              body_content = None
  
          # 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]:
              exp = CloudError(response)
              exp.request_id = response.headers.get('x-ms-request-id')
              raise exp
  
          deserialized = None
          header_dict = {}
  
          if response.status_code == 200:
              deserialized = self._deserialize('Product', response)
              header_dict = {
                  'Azure-AsyncOperation': 'str',
                  'Location': 'str',
                  'Retry-After': 'int',
              }
  
          if raw:
              client_raw_response = ClientRawResponse(deserialized, response)
              client_raw_response.add_headers(header_dict)
              return client_raw_response
  
          return deserialized
  
      def put_async_retry_failed(
              self, product=None, custom_headers=None, raw=False, polling=True, **operation_config):
          """Long running put request, service returns a 200 to the initial request,
          with an entity that contains ProvisioningState=’Creating’. Poll the
          endpoint indicated in the Azure-AsyncOperation header for operation
          status.
  
          :param product: Product to put
          :type product: ~lro.models.Product
          :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 Product or
           ClientRawResponse<Product> if raw==True
          :rtype:
           ~msrestazure.azure_operation.AzureOperationPoller[~lro.models.Product]
           or
           ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~lro.models.Product]]
          :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
          """
          raw_result = self._put_async_retry_failed_initial(
              product=product,
              custom_headers=custom_headers,
              raw=True,
              **operation_config
          )
  
          def get_long_running_output(response):
              header_dict = {
                  'Azure-AsyncOperation': 'str',
                  'Location': 'str',
                  'Retry-After': 'int',
              }
              deserialized = self._deserialize('Product', response)
  
              if raw:
                  client_raw_response = ClientRawResponse(deserialized, response)
                  client_raw_response.add_headers(header_dict)
                  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)
      put_async_retry_failed.metadata = {'url': '/lro/putasync/retry/failed'}
  
  
      def _put_async_no_retrycanceled_initial(
              self, product=None, custom_headers=None, raw=False, **operation_config):
          # Construct URL
          url = self.put_async_no_retrycanceled.metadata['url']
  
          # Construct parameters
          query_parameters = {}
  
          # 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
          if product is not None:
              body_content = self._serialize.body(product, 'Product')
          else:
              body_content = None
  
          # 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]:
              exp = CloudError(response)
              exp.request_id = response.headers.get('x-ms-request-id')
              raise exp
  
          deserialized = None
          header_dict = {}
  
          if response.status_code == 200:
              deserialized = self._deserialize('Product', response)
              header_dict = {
                  'Azure-AsyncOperation': 'str',
                  'Location': 'str',
              }
  
          if raw:
              client_raw_response = ClientRawResponse(deserialized, response)
              client_raw_response.add_headers(header_dict)
              return client_raw_response
  
          return deserialized
  
      def put_async_no_retrycanceled(
              self, product=None, custom_headers=None, raw=False, polling=True, **operation_config):
          """Long running put request, service returns a 200 to the initial request,
          with an entity that contains ProvisioningState=’Creating’. Poll the
          endpoint indicated in the Azure-AsyncOperation header for operation
          status.
  
          :param product: Product to put
          :type product: ~lro.models.Product
          :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 Product or
           ClientRawResponse<Product> if raw==True
          :rtype:
           ~msrestazure.azure_operation.AzureOperationPoller[~lro.models.Product]
           or
           ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~lro.models.Product]]
          :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
          """
          raw_result = self._put_async_no_retrycanceled_initial(
              product=product,
              custom_headers=custom_headers,
              raw=True,
              **operation_config
          )
  
          def get_long_running_output(response):
              header_dict = {
                  'Azure-AsyncOperation': 'str',
                  'Location': 'str',
              }
              deserialized = self._deserialize('Product', response)
  
              if raw:
                  client_raw_response = ClientRawResponse(deserialized, response)
                  client_raw_response.add_headers(header_dict)
                  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)
      put_async_no_retrycanceled.metadata = {'url': '/lro/putasync/noretry/canceled'}
  
  
      def _put_async_no_header_in_retry_initial(
              self, product=None, custom_headers=None, raw=False, **operation_config):
          # Construct URL
          url = self.put_async_no_header_in_retry.metadata['url']
  
          # Construct parameters
          query_parameters = {}
  
          # 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
          if product is not None:
              body_content = self._serialize.body(product, 'Product')
          else:
              body_content = None
  
          # 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 [201]:
              exp = CloudError(response)
              exp.request_id = response.headers.get('x-ms-request-id')
              raise exp
  
          deserialized = None
          header_dict = {}
  
          if response.status_code == 201:
              deserialized = self._deserialize('Product', response)
              header_dict = {
                  'Azure-AsyncOperation': 'str',
              }
  
          if raw:
              client_raw_response = ClientRawResponse(deserialized, response)
              client_raw_response.add_headers(header_dict)
              return client_raw_response
  
          return deserialized
  
      def put_async_no_header_in_retry(
              self, product=None, custom_headers=None, raw=False, polling=True, **operation_config):
          """Long running put request, service returns a 202 to the initial request
          with Azure-AsyncOperation header. Subsequent calls to operation status
          do not contain Azure-AsyncOperation header.
  
          :param product: Product to put
          :type product: ~lro.models.Product
          :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 Product or
           ClientRawResponse<Product> if raw==True
          :rtype:
           ~msrestazure.azure_operation.AzureOperationPoller[~lro.models.Product]
           or
           ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~lro.models.Product]]
          :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
          """
          raw_result = self._put_async_no_header_in_retry_initial(
              product=product,
              custom_headers=custom_headers,
              raw=True,
              **operation_config
          )
  
          def get_long_running_output(response):
              header_dict = {
                  'Azure-AsyncOperation': 'str',
              }
              deserialized = self._deserialize('Product', response)
  
              if raw:
                  client_raw_response = ClientRawResponse(deserialized, response)
                  client_raw_response.add_headers(header_dict)
                  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)
      put_async_no_header_in_retry.metadata = {'url': '/lro/putasync/noheader/201/200'}
  
  
      def _put_non_resource_initial(
              self, sku=None, custom_headers=None, raw=False, **operation_config):
          # Construct URL
          url = self.put_non_resource.metadata['url']
  
          # Construct parameters
          query_parameters = {}
  
          # 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
          if sku is not None:
              body_content = self._serialize.body(sku, 'Sku')
          else:
              body_content = None
  
          # 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 [202]:
              exp = CloudError(response)
              exp.request_id = response.headers.get('x-ms-request-id')
              raise exp
  
          deserialized = None
  
          if response.status_code == 202:
              deserialized = self._deserialize('Sku', response)
  
          if raw:
              client_raw_response = ClientRawResponse(deserialized, response)
              return client_raw_response
  
          return deserialized
  
      def put_non_resource(
              self, sku=None, custom_headers=None, raw=False, polling=True, **operation_config):
          """Long running put request with non resource.
  
          :param sku: sku to put
          :type sku: ~lro.models.Sku
          :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 Sku or
           ClientRawResponse<Sku> if raw==True
          :rtype:
           ~msrestazure.azure_operation.AzureOperationPoller[~lro.models.Sku] or
           ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~lro.models.Sku]]
          :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
          """
          raw_result = self._put_non_resource_initial(
              sku=sku,
              custom_headers=custom_headers,
              raw=True,
              **operation_config
          )
  
          def get_long_running_output(response):
              deserialized = self._deserialize('Sku', 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)
      put_non_resource.metadata = {'url': '/lro/putnonresource/202/200'}
  
  
      def _put_async_non_resource_initial(
              self, sku=None, custom_headers=None, raw=False, **operation_config):
          # Construct URL
          url = self.put_async_non_resource.metadata['url']
  
          # Construct parameters
          query_parameters = {}
  
          # 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
          if sku is not None:
              body_content = self._serialize.body(sku, 'Sku')
          else:
              body_content = None
  
          # 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 [202]:
              exp = CloudError(response)
              exp.request_id = response.headers.get('x-ms-request-id')
              raise exp
  
          deserialized = None
  
          if response.status_code == 202:
              deserialized = self._deserialize('Sku', response)
  
          if raw:
              client_raw_response = ClientRawResponse(deserialized, response)
              return client_raw_response
  
          return deserialized
  
      def put_async_non_resource(
              self, sku=None, custom_headers=None, raw=False, polling=True, **operation_config):
          """Long running put request with non resource.
  
          :param sku: Sku to put
          :type sku: ~lro.models.Sku
          :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 Sku or
           ClientRawResponse<Sku> if raw==True
          :rtype:
           ~msrestazure.azure_operation.AzureOperationPoller[~lro.models.Sku] or
           ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~lro.models.Sku]]
          :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
          """
          raw_result = self._put_async_non_resource_initial(
              sku=sku,
              custom_headers=custom_headers,
              raw=True,
              **operation_config
          )
  
          def get_long_running_output(response):
              deserialized = self._deserialize('Sku', 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)
      put_async_non_resource.metadata = {'url': '/lro/putnonresourceasync/202/200'}
  
  
      def _put_sub_resource_initial(
              self, provisioning_state=None, custom_headers=None, raw=False, **operation_config):
          product = None
          if provisioning_state is not None:
              product = models.SubProduct(provisioning_state=provisioning_state)
  
          # Construct URL
          url = self.put_sub_resource.metadata['url']
  
          # Construct parameters
          query_parameters = {}
  
          # 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
          if product is not None:
              body_content = self._serialize.body(product, 'SubProduct')
          else:
              body_content = None
  
          # 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 [202]:
              exp = CloudError(response)
              exp.request_id = response.headers.get('x-ms-request-id')
              raise exp
  
          deserialized = None
  
          if response.status_code == 202:
              deserialized = self._deserialize('SubProduct', response)
  
          if raw:
              client_raw_response = ClientRawResponse(deserialized, response)
              return client_raw_response
  
          return deserialized
  
      def put_sub_resource(
              self, provisioning_state=None, custom_headers=None, raw=False, polling=True, **operation_config):
          """Long running put request with sub resource.
  
          :param provisioning_state:
          :type provisioning_state: 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 SubProduct or
           ClientRawResponse<SubProduct> if raw==True
          :rtype:
           ~msrestazure.azure_operation.AzureOperationPoller[~lro.models.SubProduct]
           or
           ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~lro.models.SubProduct]]
          :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
          """
          raw_result = self._put_sub_resource_initial(
              provisioning_state=provisioning_state,
              custom_headers=custom_headers,
              raw=True,
              **operation_config
          )
  
          def get_long_running_output(response):
              deserialized = self._deserialize('SubProduct', 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)
      put_sub_resource.metadata = {'url': '/lro/putsubresource/202/200'}
  
  
      def _put_async_sub_resource_initial(
              self, provisioning_state=None, custom_headers=None, raw=False, **operation_config):
          product = None
          if provisioning_state is not None:
              product = models.SubProduct(provisioning_state=provisioning_state)
  
          # Construct URL
          url = self.put_async_sub_resource.metadata['url']
  
          # Construct parameters
          query_parameters = {}
  
          # 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
          if product is not None:
              body_content = self._serialize.body(product, 'SubProduct')
          else:
              body_content = None
  
          # 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 [202]:
              exp = CloudError(response)
              exp.request_id = response.headers.get('x-ms-request-id')
              raise exp
  
          deserialized = None
  
          if response.status_code == 202:
              deserialized = self._deserialize('SubProduct', response)
  
          if raw:
              client_raw_response = ClientRawResponse(deserialized, response)
              return client_raw_response
  
          return deserialized
  
      def put_async_sub_resource(
              self, provisioning_state=None, custom_headers=None, raw=False, polling=True, **operation_config):
          """Long running put request with sub resource.
  
          :param provisioning_state:
          :type provisioning_state: 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 SubProduct or
           ClientRawResponse<SubProduct> if raw==True
          :rtype:
           ~msrestazure.azure_operation.AzureOperationPoller[~lro.models.SubProduct]
           or
           ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~lro.models.SubProduct]]
          :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
          """
          raw_result = self._put_async_sub_resource_initial(
              provisioning_state=provisioning_state,
              custom_headers=custom_headers,
              raw=True,
              **operation_config
          )
  
          def get_long_running_output(response):
              deserialized = self._deserialize('SubProduct', 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)
      put_async_sub_resource.metadata = {'url': '/lro/putsubresourceasync/202/200'}
  
  
      def _delete_provisioning202_accepted200_succeeded_initial(
              self, custom_headers=None, raw=False, **operation_config):
          # Construct URL
          url = self.delete_provisioning202_accepted200_succeeded.metadata['url']
  
          # Construct parameters
          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.delete(url, query_parameters, header_parameters)
          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
  
          deserialized = None
          header_dict = {}
  
          if response.status_code == 200:
              deserialized = self._deserialize('Product', response)
              header_dict = {
                  'Location': 'str',
                  'Retry-After': 'int',
              }
          if response.status_code == 202:
              deserialized = self._deserialize('Product', response)
              header_dict = {
                  'Location': 'str',
                  'Retry-After': 'int',
              }
  
          if raw:
              client_raw_response = ClientRawResponse(deserialized, response)
              client_raw_response.add_headers(header_dict)
              return client_raw_response
  
          return deserialized
  
      def delete_provisioning202_accepted200_succeeded(
              self, custom_headers=None, raw=False, polling=True, **operation_config):
          """Long running delete request, service returns a 202 to the initial
          request, with an entity that contains ProvisioningState=’Accepted’.
          Polls return this value until the last poll returns a ‘200’ with
          ProvisioningState=’Succeeded’.
  
          :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 Product or
           ClientRawResponse<Product> if raw==True
          :rtype:
           ~msrestazure.azure_operation.AzureOperationPoller[~lro.models.Product]
           or
           ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~lro.models.Product]]
          :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
          """
          raw_result = self._delete_provisioning202_accepted200_succeeded_initial(
              custom_headers=custom_headers,
              raw=True,
              **operation_config
          )
  
          def get_long_running_output(response):
              header_dict = {
                  'Location': 'str',
                  'Retry-After': 'int',
              }
              deserialized = self._deserialize('Product', response)
  
              if raw:
                  client_raw_response = ClientRawResponse(deserialized, response)
                  client_raw_response.add_headers(header_dict)
                  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)
      delete_provisioning202_accepted200_succeeded.metadata = {'url': '/lro/delete/provisioning/202/accepted/200/succeeded'}
  
  
      def _delete_provisioning202_deleting_failed200_initial(
              self, custom_headers=None, raw=False, **operation_config):
          # Construct URL
          url = self.delete_provisioning202_deleting_failed200.metadata['url']
  
          # Construct parameters
          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.delete(url, query_parameters, header_parameters)
          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
  
          deserialized = None
          header_dict = {}
  
          if response.status_code == 200:
              deserialized = self._deserialize('Product', response)
              header_dict = {
                  'Location': 'str',
                  'Retry-After': 'int',
              }
          if response.status_code == 202:
              deserialized = self._deserialize('Product', response)
              header_dict = {
                  'Location': 'str',
                  'Retry-After': 'int',
              }
  
          if raw:
              client_raw_response = ClientRawResponse(deserialized, response)
              client_raw_response.add_headers(header_dict)
              return client_raw_response
  
          return deserialized
  
      def delete_provisioning202_deleting_failed200(
              self, custom_headers=None, raw=False, polling=True, **operation_config):
          """Long running delete request, service returns a 202 to the initial
          request, with an entity that contains ProvisioningState=’Creating’.
          Polls return this value until the last poll returns a ‘200’ with
          ProvisioningState=’Failed’.
  
          :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 Product or
           ClientRawResponse<Product> if raw==True
          :rtype:
           ~msrestazure.azure_operation.AzureOperationPoller[~lro.models.Product]
           or
           ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~lro.models.Product]]
          :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
          """
          raw_result = self._delete_provisioning202_deleting_failed200_initial(
              custom_headers=custom_headers,
              raw=True,
              **operation_config
          )
  
          def get_long_running_output(response):
              header_dict = {
                  'Location': 'str',
                  'Retry-After': 'int',
              }
              deserialized = self._deserialize('Product', response)
  
              if raw:
                  client_raw_response = ClientRawResponse(deserialized, response)
                  client_raw_response.add_headers(header_dict)
                  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)
      delete_provisioning202_deleting_failed200.metadata = {'url': '/lro/delete/provisioning/202/deleting/200/failed'}
  
  
      def _delete_provisioning202_deletingcanceled200_initial(
              self, custom_headers=None, raw=False, **operation_config):
          # Construct URL
          url = self.delete_provisioning202_deletingcanceled200.metadata['url']
  
          # Construct parameters
          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.delete(url, query_parameters, header_parameters)
          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
  
          deserialized = None
          header_dict = {}
  
          if response.status_code == 200:
              deserialized = self._deserialize('Product', response)
              header_dict = {
                  'Location': 'str',
                  'Retry-After': 'int',
              }
          if response.status_code == 202:
              deserialized = self._deserialize('Product', response)
              header_dict = {
                  'Location': 'str',
                  'Retry-After': 'int',
              }
  
          if raw:
              client_raw_response = ClientRawResponse(deserialized, response)
              client_raw_response.add_headers(header_dict)
              return client_raw_response
  
          return deserialized
  
      def delete_provisioning202_deletingcanceled200(
              self, custom_headers=None, raw=False, polling=True, **operation_config):
          """Long running delete request, service returns a 202 to the initial
          request, with an entity that contains ProvisioningState=’Creating’.
          Polls return this value until the last poll returns a ‘200’ with
          ProvisioningState=’Canceled’.
  
          :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 Product or
           ClientRawResponse<Product> if raw==True
          :rtype:
           ~msrestazure.azure_operation.AzureOperationPoller[~lro.models.Product]
           or
           ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~lro.models.Product]]
          :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
          """
          raw_result = self._delete_provisioning202_deletingcanceled200_initial(
              custom_headers=custom_headers,
              raw=True,
              **operation_config
          )
  
          def get_long_running_output(response):
              header_dict = {
                  'Location': 'str',
                  'Retry-After': 'int',
              }
              deserialized = self._deserialize('Product', response)
  
              if raw:
                  client_raw_response = ClientRawResponse(deserialized, response)
                  client_raw_response.add_headers(header_dict)
                  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)
      delete_provisioning202_deletingcanceled200.metadata = {'url': '/lro/delete/provisioning/202/deleting/200/canceled'}
  
  
      def _delete204_succeeded_initial(
              self, custom_headers=None, raw=False, **operation_config):
          # Construct URL
          url = self.delete204_succeeded.metadata['url']
  
          # Construct parameters
          query_parameters = {}
  
          # 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 [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 delete204_succeeded(
              self, custom_headers=None, raw=False, polling=True, **operation_config):
          """Long running delete succeeds and returns right away.
  
          :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._delete204_succeeded_initial(
              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)
      delete204_succeeded.metadata = {'url': '/lro/delete/204/succeeded'}
  
  
      def _delete202_retry200_initial(
              self, custom_headers=None, raw=False, **operation_config):
          # Construct URL
          url = self.delete202_retry200.metadata['url']
  
          # Construct parameters
          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.delete(url, query_parameters, header_parameters)
          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
  
          deserialized = None
          header_dict = {}
  
          if response.status_code == 200:
              deserialized = self._deserialize('Product', response)
              header_dict = {
                  'Location': 'str',
                  'Retry-After': 'int',
              }
  
          if raw:
              client_raw_response = ClientRawResponse(deserialized, response)
              client_raw_response.add_headers(header_dict)
              return client_raw_response
  
          return deserialized
  
      def delete202_retry200(
              self, custom_headers=None, raw=False, polling=True, **operation_config):
          """Long running delete request, service returns a 202 to the initial
          request. Polls return this value until the last poll returns a ‘200’
          with ProvisioningState=’Succeeded’.
  
          :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 Product or
           ClientRawResponse<Product> if raw==True
          :rtype:
           ~msrestazure.azure_operation.AzureOperationPoller[~lro.models.Product]
           or
           ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~lro.models.Product]]
          :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
          """
          raw_result = self._delete202_retry200_initial(
              custom_headers=custom_headers,
              raw=True,
              **operation_config
          )
  
          def get_long_running_output(response):
              header_dict = {
                  'Location': 'str',
                  'Retry-After': 'int',
              }
              deserialized = self._deserialize('Product', response)
  
              if raw:
                  client_raw_response = ClientRawResponse(deserialized, response)
                  client_raw_response.add_headers(header_dict)
                  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)
      delete202_retry200.metadata = {'url': '/lro/delete/202/retry/200'}
  
  
      def _delete202_no_retry204_initial(
              self, custom_headers=None, raw=False, **operation_config):
          # Construct URL
          url = self.delete202_no_retry204.metadata['url']
  
          # Construct parameters
          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.delete(url, query_parameters, header_parameters)
          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
  
          deserialized = None
          header_dict = {}
  
          if response.status_code == 200:
              deserialized = self._deserialize('Product', response)
              header_dict = {
                  'Location': 'str',
                  'Retry-After': 'int',
              }
  
          if raw:
              client_raw_response = ClientRawResponse(deserialized, response)
              client_raw_response.add_headers(header_dict)
              return client_raw_response
  
          return deserialized
  
      def delete202_no_retry204(
              self, custom_headers=None, raw=False, polling=True, **operation_config):
          """Long running delete request, service returns a 202 to the initial
          request. Polls return this value until the last poll returns a ‘200’
          with ProvisioningState=’Succeeded’.
  
          :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 Product or
           ClientRawResponse<Product> if raw==True
          :rtype:
           ~msrestazure.azure_operation.AzureOperationPoller[~lro.models.Product]
           or
           ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~lro.models.Product]]
          :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
          """
          raw_result = self._delete202_no_retry204_initial(
              custom_headers=custom_headers,
              raw=True,
              **operation_config
          )
  
          def get_long_running_output(response):
              header_dict = {
                  'Location': 'str',
                  'Retry-After': 'int',
              }
              deserialized = self._deserialize('Product', response)
  
              if raw:
                  client_raw_response = ClientRawResponse(deserialized, response)
                  client_raw_response.add_headers(header_dict)
                  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)
      delete202_no_retry204.metadata = {'url': '/lro/delete/202/noretry/204'}
  
  
      def _delete_no_header_in_retry_initial(
              self, custom_headers=None, raw=False, **operation_config):
          # Construct URL
          url = self.delete_no_header_in_retry.metadata['url']
  
          # Construct parameters
          query_parameters = {}
  
          # 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 [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)
              header_dict = {
                  'Location': 'str',
              }
              client_raw_response.add_headers(header_dict)
              return client_raw_response
  
      def delete_no_header_in_retry(
              self, custom_headers=None, raw=False, polling=True, **operation_config):
          """Long running delete request, service returns a location header in the
          initial request. Subsequent calls to operation status do not contain
          location header.
  
          :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_no_header_in_retry_initial(
              custom_headers=custom_headers,
              raw=True,
              **operation_config
          )
  
          def get_long_running_output(response):
              if raw:
                  client_raw_response = ClientRawResponse(None, response)
                  client_raw_response.add_headers({
                      'Location': 'str',
                  })
                  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_no_header_in_retry.metadata = {'url': '/lro/delete/noheader'}
  
  
      def _delete_async_no_header_in_retry_initial(
              self, custom_headers=None, raw=False, **operation_config):
          # Construct URL
          url = self.delete_async_no_header_in_retry.metadata['url']
  
          # Construct parameters
          query_parameters = {}
  
          # 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 [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)
              header_dict = {
                  'Location': 'str',
              }
              client_raw_response.add_headers(header_dict)
              return client_raw_response
  
      def delete_async_no_header_in_retry(
              self, custom_headers=None, raw=False, polling=True, **operation_config):
          """Long running delete request, service returns an Azure-AsyncOperation
          header in the initial request. Subsequent calls to operation status do
          not contain Azure-AsyncOperation header.
  
          :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_async_no_header_in_retry_initial(
              custom_headers=custom_headers,
              raw=True,
              **operation_config
          )
  
          def get_long_running_output(response):
              if raw:
                  client_raw_response = ClientRawResponse(None, response)
                  client_raw_response.add_headers({
                      'Location': 'str',
                  })
                  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_async_no_header_in_retry.metadata = {'url': '/lro/deleteasync/noheader/202/204'}
  
  
      def _delete_async_retry_succeeded_initial(
              self, custom_headers=None, raw=False, **operation_config):
          # Construct URL
          url = self.delete_async_retry_succeeded.metadata['url']
  
          # Construct parameters
          query_parameters = {}
  
          # 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 [202]:
              exp = CloudError(response)
              exp.request_id = response.headers.get('x-ms-request-id')
              raise exp
  
          if raw:
              client_raw_response = ClientRawResponse(None, response)
              header_dict = {
                  'Azure-AsyncOperation': 'str',
                  'Location': 'str',
                  'Retry-After': 'int',
              }
              client_raw_response.add_headers(header_dict)
              return client_raw_response
  
      def delete_async_retry_succeeded(
              self, custom_headers=None, raw=False, polling=True, **operation_config):
          """Long running delete request, service returns a 202 to the initial
          request. Poll the endpoint indicated in the Azure-AsyncOperation header
          for operation status.
  
          :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_async_retry_succeeded_initial(
              custom_headers=custom_headers,
              raw=True,
              **operation_config
          )
  
          def get_long_running_output(response):
              if raw:
                  client_raw_response = ClientRawResponse(None, response)
                  client_raw_response.add_headers({
                      'Azure-AsyncOperation': 'str',
                      'Location': 'str',
                      'Retry-After': 'int',
                  })
                  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_async_retry_succeeded.metadata = {'url': '/lro/deleteasync/retry/succeeded'}
  
  
      def _delete_async_no_retry_succeeded_initial(
              self, custom_headers=None, raw=False, **operation_config):
          # Construct URL
          url = self.delete_async_no_retry_succeeded.metadata['url']
  
          # Construct parameters
          query_parameters = {}
  
          # 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 [202]:
              exp = CloudError(response)
              exp.request_id = response.headers.get('x-ms-request-id')
              raise exp
  
          if raw:
              client_raw_response = ClientRawResponse(None, response)
              header_dict = {
                  'Azure-AsyncOperation': 'str',
                  'Location': 'str',
                  'Retry-After': 'int',
              }
              client_raw_response.add_headers(header_dict)
              return client_raw_response
  
      def delete_async_no_retry_succeeded(
              self, custom_headers=None, raw=False, polling=True, **operation_config):
          """Long running delete request, service returns a 202 to the initial
          request. Poll the endpoint indicated in the Azure-AsyncOperation header
          for operation status.
  
          :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_async_no_retry_succeeded_initial(
              custom_headers=custom_headers,
              raw=True,
              **operation_config
          )
  
          def get_long_running_output(response):
              if raw:
                  client_raw_response = ClientRawResponse(None, response)
                  client_raw_response.add_headers({
                      'Azure-AsyncOperation': 'str',
                      'Location': 'str',
                      'Retry-After': 'int',
                  })
                  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_async_no_retry_succeeded.metadata = {'url': '/lro/deleteasync/noretry/succeeded'}
  
  
      def _delete_async_retry_failed_initial(
              self, custom_headers=None, raw=False, **operation_config):
          # Construct URL
          url = self.delete_async_retry_failed.metadata['url']
  
          # Construct parameters
          query_parameters = {}
  
          # 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 [202]:
              exp = CloudError(response)
              exp.request_id = response.headers.get('x-ms-request-id')
              raise exp
  
          if raw:
              client_raw_response = ClientRawResponse(None, response)
              header_dict = {
                  'Azure-AsyncOperation': 'str',
                  'Location': 'str',
                  'Retry-After': 'int',
              }
              client_raw_response.add_headers(header_dict)
              return client_raw_response
  
      def delete_async_retry_failed(
              self, custom_headers=None, raw=False, polling=True, **operation_config):
          """Long running delete request, service returns a 202 to the initial
          request. Poll the endpoint indicated in the Azure-AsyncOperation header
          for operation status.
  
          :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_async_retry_failed_initial(
              custom_headers=custom_headers,
              raw=True,
              **operation_config
          )
  
          def get_long_running_output(response):
              if raw:
                  client_raw_response = ClientRawResponse(None, response)
                  client_raw_response.add_headers({
                      'Azure-AsyncOperation': 'str',
                      'Location': 'str',
                      'Retry-After': 'int',
                  })
                  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_async_retry_failed.metadata = {'url': '/lro/deleteasync/retry/failed'}
  
  
      def _delete_async_retrycanceled_initial(
              self, custom_headers=None, raw=False, **operation_config):
          # Construct URL
          url = self.delete_async_retrycanceled.metadata['url']
  
          # Construct parameters
          query_parameters = {}
  
          # 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 [202]:
              exp = CloudError(response)
              exp.request_id = response.headers.get('x-ms-request-id')
              raise exp
  
          if raw:
              client_raw_response = ClientRawResponse(None, response)
              header_dict = {
                  'Azure-AsyncOperation': 'str',
                  'Location': 'str',
                  'Retry-After': 'int',
              }
              client_raw_response.add_headers(header_dict)
              return client_raw_response
  
      def delete_async_retrycanceled(
              self, custom_headers=None, raw=False, polling=True, **operation_config):
          """Long running delete request, service returns a 202 to the initial
          request. Poll the endpoint indicated in the Azure-AsyncOperation header
          for operation status.
  
          :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_async_retrycanceled_initial(
              custom_headers=custom_headers,
              raw=True,
              **operation_config
          )
  
          def get_long_running_output(response):
              if raw:
                  client_raw_response = ClientRawResponse(None, response)
                  client_raw_response.add_headers({
                      'Azure-AsyncOperation': 'str',
                      'Location': 'str',
                      'Retry-After': 'int',
                  })
                  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_async_retrycanceled.metadata = {'url': '/lro/deleteasync/retry/canceled'}
  
  
      def _post200_with_payload_initial(
              self, custom_headers=None, raw=False, **operation_config):
          # Construct URL
          url = self.post200_with_payload.metadata['url']
  
          # Construct parameters
          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.post(url, query_parameters, header_parameters)
          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
  
          deserialized = None
  
          if response.status_code == 200:
              deserialized = self._deserialize('Sku', response)
          if response.status_code == 202:
              deserialized = self._deserialize('Sku', response)
  
          if raw:
              client_raw_response = ClientRawResponse(deserialized, response)
              return client_raw_response
  
          return deserialized
  
      def post200_with_payload(
              self, custom_headers=None, raw=False, polling=True, **operation_config):
          """Long running post request, service returns a 202 to the initial
          request, with 'Location' header. Poll returns a 200 with a response
          body after success.
  
          :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 Sku or
           ClientRawResponse<Sku> if raw==True
          :rtype:
           ~msrestazure.azure_operation.AzureOperationPoller[~lro.models.Sku] or
           ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~lro.models.Sku]]
          :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
          """
          raw_result = self._post200_with_payload_initial(
              custom_headers=custom_headers,
              raw=True,
              **operation_config
          )
  
          def get_long_running_output(response):
              deserialized = self._deserialize('Sku', 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)
      post200_with_payload.metadata = {'url': '/lro/post/payload/200'}
  
  
      def _post202_retry200_initial(
              self, product=None, custom_headers=None, raw=False, **operation_config):
          # Construct URL
          url = self.post202_retry200.metadata['url']
  
          # 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
          if product is not None:
              body_content = self._serialize.body(product, 'Product')
          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 [202]:
              exp = CloudError(response)
              exp.request_id = response.headers.get('x-ms-request-id')
              raise exp
  
          if raw:
              client_raw_response = ClientRawResponse(None, response)
              header_dict = {
                  'Location': 'str',
                  'Retry-After': 'int',
              }
              client_raw_response.add_headers(header_dict)
              return client_raw_response
  
      def post202_retry200(
              self, product=None, custom_headers=None, raw=False, polling=True, **operation_config):
          """Long running post request, service returns a 202 to the initial
          request, with 'Location' and 'Retry-After' headers, Polls return a 200
          with a response body after success.
  
          :param product: Product to put
          :type product: ~lro.models.Product
          :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._post202_retry200_initial(
              product=product,
              custom_headers=custom_headers,
              raw=True,
              **operation_config
          )
  
          def get_long_running_output(response):
              if raw:
                  client_raw_response = ClientRawResponse(None, response)
                  client_raw_response.add_headers({
                      'Location': 'str',
                      'Retry-After': 'int',
                  })
                  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)
      post202_retry200.metadata = {'url': '/lro/post/202/retry/200'}
  
  
      def _post202_no_retry204_initial(
              self, product=None, custom_headers=None, raw=False, **operation_config):
          # Construct URL
          url = self.post202_no_retry204.metadata['url']
  
          # Construct parameters
          query_parameters = {}
  
          # 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
          if product is not None:
              body_content = self._serialize.body(product, 'Product')
          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 [202]:
              exp = CloudError(response)
              exp.request_id = response.headers.get('x-ms-request-id')
              raise exp
  
          deserialized = None
          header_dict = {}
  
          if response.status_code == 202:
              deserialized = self._deserialize('Product', response)
              header_dict = {
                  'Location': 'str',
                  'Retry-After': 'int',
              }
  
          if raw:
              client_raw_response = ClientRawResponse(deserialized, response)
              client_raw_response.add_headers(header_dict)
              return client_raw_response
  
          return deserialized
  
      def post202_no_retry204(
              self, product=None, custom_headers=None, raw=False, polling=True, **operation_config):
          """Long running post request, service returns a 202 to the initial
          request, with 'Location' header, 204 with noresponse body after
          success.
  
          :param product: Product to put
          :type product: ~lro.models.Product
          :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 Product or
           ClientRawResponse<Product> if raw==True
          :rtype:
           ~msrestazure.azure_operation.AzureOperationPoller[~lro.models.Product]
           or
           ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~lro.models.Product]]
          :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
          """
          raw_result = self._post202_no_retry204_initial(
              product=product,
              custom_headers=custom_headers,
              raw=True,
              **operation_config
          )
  
          def get_long_running_output(response):
              header_dict = {
                  'Location': 'str',
                  'Retry-After': 'int',
              }
              deserialized = self._deserialize('Product', response)
  
              if raw:
                  client_raw_response = ClientRawResponse(deserialized, response)
                  client_raw_response.add_headers(header_dict)
                  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)
      post202_no_retry204.metadata = {'url': '/lro/post/202/noretry/204'}
  
  
      def _post_double_headers_final_location_get_initial(
              self, custom_headers=None, raw=False, **operation_config):
          # Construct URL
          url = self.post_double_headers_final_location_get.metadata['url']
  
          # Construct parameters
          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.post(url, query_parameters, header_parameters)
          response = self._client.send(request, stream=False, **operation_config)
  
          if response.status_code not in [202]:
              exp = CloudError(response)
              exp.request_id = response.headers.get('x-ms-request-id')
              raise exp
  
          deserialized = None
  
          if response.status_code == 202:
              deserialized = self._deserialize('Product', response)
  
          if raw:
              client_raw_response = ClientRawResponse(deserialized, response)
              return client_raw_response
  
          return deserialized
  
      def post_double_headers_final_location_get(
              self, custom_headers=None, raw=False, polling=True, **operation_config):
          """Long running post request, service returns a 202 to the initial request
          with both Location and Azure-Async header. Poll Azure-Async and it's
          success. Should poll Location to get the final object.
  
          :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 Product or
           ClientRawResponse<Product> if raw==True
          :rtype:
           ~msrestazure.azure_operation.AzureOperationPoller[~lro.models.Product]
           or
           ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~lro.models.Product]]
          :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
          """
          raw_result = self._post_double_headers_final_location_get_initial(
              custom_headers=custom_headers,
              raw=True,
              **operation_config
          )
  
          def get_long_running_output(response):
              deserialized = self._deserialize('Product', 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, lro_options={'final-state-via': 'location'}, **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)
      post_double_headers_final_location_get.metadata = {'url': '/lro/LROPostDoubleHeadersFinalLocationGet'}
  
  
      def _post_double_headers_final_azure_header_get_initial(
              self, custom_headers=None, raw=False, **operation_config):
          # Construct URL
          url = self.post_double_headers_final_azure_header_get.metadata['url']
  
          # Construct parameters
          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.post(url, query_parameters, header_parameters)
          response = self._client.send(request, stream=False, **operation_config)
  
          if response.status_code not in [202]:
              exp = CloudError(response)
              exp.request_id = response.headers.get('x-ms-request-id')
              raise exp
  
          deserialized = None
  
          if response.status_code == 202:
              deserialized = self._deserialize('Product', response)
  
          if raw:
              client_raw_response = ClientRawResponse(deserialized, response)
              return client_raw_response
  
          return deserialized
  
      def post_double_headers_final_azure_header_get(
              self, custom_headers=None, raw=False, polling=True, **operation_config):
          """Long running post request, service returns a 202 to the initial request
          with both Location and Azure-Async header. Poll Azure-Async and it's
          success. Should NOT poll Location to get the final object.
  
          :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 Product or
           ClientRawResponse<Product> if raw==True
          :rtype:
           ~msrestazure.azure_operation.AzureOperationPoller[~lro.models.Product]
           or
           ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~lro.models.Product]]
          :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
          """
          raw_result = self._post_double_headers_final_azure_header_get_initial(
              custom_headers=custom_headers,
              raw=True,
              **operation_config
          )
  
          def get_long_running_output(response):
              deserialized = self._deserialize('Product', 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, lro_options={'final-state-via': 'azure-async-operation'}, **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)
      post_double_headers_final_azure_header_get.metadata = {'url': '/lro/LROPostDoubleHeadersFinalAzureHeaderGet'}
  
  
      def _post_double_headers_final_azure_header_get_default_initial(
              self, custom_headers=None, raw=False, **operation_config):
          # Construct URL
          url = self.post_double_headers_final_azure_header_get_default.metadata['url']
  
          # Construct parameters
          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.post(url, query_parameters, header_parameters)
          response = self._client.send(request, stream=False, **operation_config)
  
          if response.status_code not in [202]:
              exp = CloudError(response)
              exp.request_id = response.headers.get('x-ms-request-id')
              raise exp
  
          deserialized = None
  
          if response.status_code == 202:
              deserialized = self._deserialize('Product', response)
  
          if raw:
              client_raw_response = ClientRawResponse(deserialized, response)
              return client_raw_response
  
          return deserialized
  
      def post_double_headers_final_azure_header_get_default(
              self, custom_headers=None, raw=False, polling=True, **operation_config):
          """Long running post request, service returns a 202 to the initial request
          with both Location and Azure-Async header. Poll Azure-Async and it's
          success. Should NOT poll Location to get the final object if you
          support initial Autorest behavior.
  
          :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 Product or
           ClientRawResponse<Product> if raw==True
          :rtype:
           ~msrestazure.azure_operation.AzureOperationPoller[~lro.models.Product]
           or
           ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~lro.models.Product]]
          :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
          """
          raw_result = self._post_double_headers_final_azure_header_get_default_initial(
              custom_headers=custom_headers,
              raw=True,
              **operation_config
          )
  
          def get_long_running_output(response):
              deserialized = self._deserialize('Product', 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)
      post_double_headers_final_azure_header_get_default.metadata = {'url': '/lro/LROPostDoubleHeadersFinalAzureHeaderGetDefault'}
  
  
      def _post_async_retry_succeeded_initial(
              self, product=None, custom_headers=None, raw=False, **operation_config):
          # Construct URL
          url = self.post_async_retry_succeeded.metadata['url']
  
          # Construct parameters
          query_parameters = {}
  
          # 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
          if product is not None:
              body_content = self._serialize.body(product, 'Product')
          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
  
          deserialized = None
          header_dict = {}
  
          if response.status_code == 200:
              deserialized = self._deserialize('Product', response)
              header_dict = {
                  'Azure-AsyncOperation': 'str',
                  'Location': 'str',
                  'Retry-After': 'int',
              }
  
          if raw:
              client_raw_response = ClientRawResponse(deserialized, response)
              client_raw_response.add_headers(header_dict)
              return client_raw_response
  
          return deserialized
  
      def post_async_retry_succeeded(
              self, product=None, custom_headers=None, raw=False, polling=True, **operation_config):
          """Long running post request, service returns a 202 to the initial
          request, with an entity that contains ProvisioningState=’Creating’.
          Poll the endpoint indicated in the Azure-AsyncOperation header for
          operation status.
  
          :param product: Product to put
          :type product: ~lro.models.Product
          :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 Product or
           ClientRawResponse<Product> if raw==True
          :rtype:
           ~msrestazure.azure_operation.AzureOperationPoller[~lro.models.Product]
           or
           ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~lro.models.Product]]
          :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
          """
          raw_result = self._post_async_retry_succeeded_initial(
              product=product,
              custom_headers=custom_headers,
              raw=True,
              **operation_config
          )
  
          def get_long_running_output(response):
              header_dict = {
                  'Azure-AsyncOperation': 'str',
                  'Location': 'str',
                  'Retry-After': 'int',
              }
              deserialized = self._deserialize('Product', response)
  
              if raw:
                  client_raw_response = ClientRawResponse(deserialized, response)
                  client_raw_response.add_headers(header_dict)
                  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)
      post_async_retry_succeeded.metadata = {'url': '/lro/postasync/retry/succeeded'}
  
  
      def _post_async_no_retry_succeeded_initial(
              self, product=None, custom_headers=None, raw=False, **operation_config):
          # Construct URL
          url = self.post_async_no_retry_succeeded.metadata['url']
  
          # Construct parameters
          query_parameters = {}
  
          # 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
          if product is not None:
              body_content = self._serialize.body(product, 'Product')
          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
  
          deserialized = None
          header_dict = {}
  
          if response.status_code == 200:
              deserialized = self._deserialize('Product', response)
              header_dict = {
                  'Azure-AsyncOperation': 'str',
                  'Location': 'str',
                  'Retry-After': 'int',
              }
  
          if raw:
              client_raw_response = ClientRawResponse(deserialized, response)
              client_raw_response.add_headers(header_dict)
              return client_raw_response
  
          return deserialized
  
      def post_async_no_retry_succeeded(
              self, product=None, custom_headers=None, raw=False, polling=True, **operation_config):
          """Long running post request, service returns a 202 to the initial
          request, with an entity that contains ProvisioningState=’Creating’.
          Poll the endpoint indicated in the Azure-AsyncOperation header for
          operation status.
  
          :param product: Product to put
          :type product: ~lro.models.Product
          :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 Product or
           ClientRawResponse<Product> if raw==True
          :rtype:
           ~msrestazure.azure_operation.AzureOperationPoller[~lro.models.Product]
           or
           ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~lro.models.Product]]
          :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
          """
          raw_result = self._post_async_no_retry_succeeded_initial(
              product=product,
              custom_headers=custom_headers,
              raw=True,
              **operation_config
          )
  
          def get_long_running_output(response):
              header_dict = {
                  'Azure-AsyncOperation': 'str',
                  'Location': 'str',
                  'Retry-After': 'int',
              }
              deserialized = self._deserialize('Product', response)
  
              if raw:
                  client_raw_response = ClientRawResponse(deserialized, response)
                  client_raw_response.add_headers(header_dict)
                  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)
      post_async_no_retry_succeeded.metadata = {'url': '/lro/postasync/noretry/succeeded'}
  
  
      def _post_async_retry_failed_initial(
              self, product=None, custom_headers=None, raw=False, **operation_config):
          # Construct URL
          url = self.post_async_retry_failed.metadata['url']
  
          # 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
          if product is not None:
              body_content = self._serialize.body(product, 'Product')
          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 [202]:
              exp = CloudError(response)
              exp.request_id = response.headers.get('x-ms-request-id')
              raise exp
  
          if raw:
              client_raw_response = ClientRawResponse(None, response)
              header_dict = {
                  'Azure-AsyncOperation': 'str',
                  'Location': 'str',
                  'Retry-After': 'int',
              }
              client_raw_response.add_headers(header_dict)
              return client_raw_response
  
      def post_async_retry_failed(
              self, product=None, custom_headers=None, raw=False, polling=True, **operation_config):
          """Long running post request, service returns a 202 to the initial
          request, with an entity that contains ProvisioningState=’Creating’.
          Poll the endpoint indicated in the Azure-AsyncOperation header for
          operation status.
  
          :param product: Product to put
          :type product: ~lro.models.Product
          :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._post_async_retry_failed_initial(
              product=product,
              custom_headers=custom_headers,
              raw=True,
              **operation_config
          )
  
          def get_long_running_output(response):
              if raw:
                  client_raw_response = ClientRawResponse(None, response)
                  client_raw_response.add_headers({
                      'Azure-AsyncOperation': 'str',
                      'Location': 'str',
                      'Retry-After': 'int',
                  })
                  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)
      post_async_retry_failed.metadata = {'url': '/lro/postasync/retry/failed'}
  
  
      def _post_async_retrycanceled_initial(
              self, product=None, custom_headers=None, raw=False, **operation_config):
          # Construct URL
          url = self.post_async_retrycanceled.metadata['url']
  
          # 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
          if product is not None:
              body_content = self._serialize.body(product, 'Product')
          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 [202]:
              exp = CloudError(response)
              exp.request_id = response.headers.get('x-ms-request-id')
              raise exp
  
          if raw:
              client_raw_response = ClientRawResponse(None, response)
              header_dict = {
                  'Azure-AsyncOperation': 'str',
                  'Location': 'str',
                  'Retry-After': 'int',
              }
              client_raw_response.add_headers(header_dict)
              return client_raw_response
  
      def post_async_retrycanceled(
              self, product=None, custom_headers=None, raw=False, polling=True, **operation_config):
          """Long running post request, service returns a 202 to the initial
          request, with an entity that contains ProvisioningState=’Creating’.
          Poll the endpoint indicated in the Azure-AsyncOperation header for
          operation status.
  
          :param product: Product to put
          :type product: ~lro.models.Product
          :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._post_async_retrycanceled_initial(
              product=product,
              custom_headers=custom_headers,
              raw=True,
              **operation_config
          )
  
          def get_long_running_output(response):
              if raw:
                  client_raw_response = ClientRawResponse(None, response)
                  client_raw_response.add_headers({
                      'Azure-AsyncOperation': 'str',
                      'Location': 'str',
                      'Retry-After': 'int',
                  })
                  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)
      post_async_retrycanceled.metadata = {'url': '/lro/postasync/retry/canceled'}
  