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 DeploymentsOperations(object):
      """DeploymentsOperations 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.
      :ivar api_version: The API version to use for this operation. Constant value: "2016-09-01".
      """
  
      models = models
  
      def __init__(self, client, config, serializer, deserializer):
  
          self._client = client
          self._serialize = serializer
          self._deserialize = deserializer
          self.api_version = "2016-09-01"
  
          self.config = config
  
  
      def _delete_initial(
              self, resource_group_name, deployment_name, custom_headers=None, raw=False, **operation_config):
          # Construct URL
          url = self.delete.metadata['url']
          path_format_arguments = {
              'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+$'),
              'deploymentName': self._serialize.url("deployment_name", deployment_name, 'str', max_length=64, min_length=1, pattern=r'^[-\w\._\(\)]+$'),
              'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str')
          }
          url = self._client.format_url(url, **path_format_arguments)
  
          # Construct parameters
          query_parameters = {}
          query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str')
  
          # Construct headers
          header_parameters = {}
          if self.config.generate_client_request_id:
              header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
          if custom_headers:
              header_parameters.update(custom_headers)
          if self.config.accept_language is not None:
              header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str')
  
          # Construct and send request
          request = self._client.delete(url, query_parameters, header_parameters)
          response = self._client.send(request, stream=False, **operation_config)
  
          if response.status_code not in [202, 204]:
              exp = CloudError(response)
              exp.request_id = response.headers.get('x-ms-request-id')
              raise exp
  
          if raw:
              client_raw_response = ClientRawResponse(None, response)
              return client_raw_response
  
      def delete(
              self, resource_group_name, deployment_name, custom_headers=None, raw=False, polling=True, **operation_config):
          """Deletes a deployment from the deployment history.
  
          A template deployment that is currently running cannot be deleted.
          Deleting a template deployment removes the associated deployment
          operations. Deleting a template deployment does not affect the state of
          the resource group. This is an asynchronous operation that returns a
          status of 202 until the template deployment is successfully deleted.
          The Location response header contains the URI that is used to obtain
          the status of the process. While the process is running, a call to the
          URI in the Location header returns a status of 202. When the process
          finishes, the URI in the Location header returns a status of 204 on
          success. If the asynchronous request failed, the URI in the Location
          header returns an error-level status code.
  
          :param resource_group_name: The name of the resource group with the
           deployment to delete. The name is case insensitive.
          :type resource_group_name: str
          :param deployment_name: The name of the deployment to delete.
          :type deployment_name: str
          :param dict custom_headers: headers that will be added to the request
          :param bool raw: The poller return type is ClientRawResponse, the
           direct response alongside the deserialized response
          :param polling: True for ARMPolling, False for no polling, or a
           polling object for personal polling strategy
          :return: An instance of LROPoller that returns None or
           ClientRawResponse<None> if raw==True
          :rtype: ~msrestazure.azure_operation.AzureOperationPoller[None] or
           ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[None]]
          :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
          """
          raw_result = self._delete_initial(
              resource_group_name=resource_group_name,
              deployment_name=deployment_name,
              custom_headers=custom_headers,
              raw=True,
              **operation_config
          )
  
          def get_long_running_output(response):
              if raw:
                  client_raw_response = ClientRawResponse(None, response)
                  return client_raw_response
  
          lro_delay = operation_config.get(
              'long_running_operation_timeout',
              self.config.long_running_operation_timeout)
          if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)
          elif polling is False: polling_method = NoPolling()
          else: polling_method = polling
          return LROPoller(self._client, raw_result, get_long_running_output, polling_method)
      delete.metadata = {'url': '/subscriptions/{subscriptionId}/resourcegroups/{resourceGroupName}/providers/Microsoft.Resources/deployments/{deploymentName}'}
  
      def check_existence(
              self, resource_group_name, deployment_name, custom_headers=None, raw=False, **operation_config):
          """Checks whether the deployment exists.
  
          :param resource_group_name: The name of the resource group with the
           deployment to check. The name is case insensitive.
          :type resource_group_name: str
          :param deployment_name: The name of the deployment to check.
          :type deployment_name: str
          :param dict custom_headers: headers that will be added to the request
          :param bool raw: returns the direct response alongside the
           deserialized response
          :param operation_config: :ref:`Operation configuration
           overrides<msrest:optionsforoperations>`.
          :return: bool or ClientRawResponse if raw=true
          :rtype: bool or ~msrest.pipeline.ClientRawResponse
          :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
          """
          # Construct URL
          url = self.check_existence.metadata['url']
          path_format_arguments = {
              'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+$'),
              'deploymentName': self._serialize.url("deployment_name", deployment_name, 'str', max_length=64, min_length=1, pattern=r'^[-\w\._\(\)]+$'),
              'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str')
          }
          url = self._client.format_url(url, **path_format_arguments)
  
          # Construct parameters
          query_parameters = {}
          query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str')
  
          # Construct headers
          header_parameters = {}
          if self.config.generate_client_request_id:
              header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
          if custom_headers:
              header_parameters.update(custom_headers)
          if self.config.accept_language is not None:
              header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str')
  
          # Construct and send request
          request = self._client.head(url, query_parameters, header_parameters)
          response = self._client.send(request, stream=False, **operation_config)
  
          if response.status_code not in [204, 404]:
              exp = CloudError(response)
              exp.request_id = response.headers.get('x-ms-request-id')
              raise exp
  
          deserialized = (response.status_code == 204)
          if raw:
              client_raw_response = ClientRawResponse(deserialized, response)
              return client_raw_response
          return deserialized
      check_existence.metadata = {'url': '/subscriptions/{subscriptionId}/resourcegroups/{resourceGroupName}/providers/Microsoft.Resources/deployments/{deploymentName}'}
  
  
      def _create_or_update_initial(
              self, resource_group_name, deployment_name, properties, custom_headers=None, raw=False, **operation_config):
          parameters = models.Deployment(properties=properties)
  
          # Construct URL
          url = self.create_or_update.metadata['url']
          path_format_arguments = {
              'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+$'),
              'deploymentName': self._serialize.url("deployment_name", deployment_name, 'str', max_length=64, min_length=1, pattern=r'^[-\w\._\(\)]+$'),
              'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str')
          }
          url = self._client.format_url(url, **path_format_arguments)
  
          # Construct parameters
          query_parameters = {}
          query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str')
  
          # Construct headers
          header_parameters = {}
          header_parameters['Accept'] = 'application/json'
          header_parameters['Content-Type'] = 'application/json; charset=utf-8'
          if self.config.generate_client_request_id:
              header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
          if custom_headers:
              header_parameters.update(custom_headers)
          if self.config.accept_language is not None:
              header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str')
  
          # Construct body
          body_content = self._serialize.body(parameters, 'Deployment')
  
          # 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('DeploymentExtended', response)
          if response.status_code == 201:
              deserialized = self._deserialize('DeploymentExtended', response)
  
          if raw:
              client_raw_response = ClientRawResponse(deserialized, response)
              return client_raw_response
  
          return deserialized
  
      def create_or_update(
              self, resource_group_name, deployment_name, properties, custom_headers=None, raw=False, polling=True, **operation_config):
          """Deploys resources to a resource group.
  
          You can provide the template and parameters directly in the request or
          link to JSON files.
  
          :param resource_group_name: The name of the resource group to deploy
           the resources to. The name is case insensitive. The resource group
           must already exist.
          :type resource_group_name: str
          :param deployment_name: The name of the deployment.
          :type deployment_name: str
          :param properties: The deployment properties.
          :type properties:
           ~azure.mgmt.resource.resources.v2016_09_01.models.DeploymentProperties
          :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 DeploymentExtended or
           ClientRawResponse<DeploymentExtended> if raw==True
          :rtype:
           ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.resource.resources.v2016_09_01.models.DeploymentExtended]
           or
           ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.resource.resources.v2016_09_01.models.DeploymentExtended]]
          :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
          """
          raw_result = self._create_or_update_initial(
              resource_group_name=resource_group_name,
              deployment_name=deployment_name,
              properties=properties,
              custom_headers=custom_headers,
              raw=True,
              **operation_config
          )
  
          def get_long_running_output(response):
              deserialized = self._deserialize('DeploymentExtended', response)
  
              if raw:
                  client_raw_response = ClientRawResponse(deserialized, response)
                  return client_raw_response
  
              return deserialized
  
          lro_delay = operation_config.get(
              'long_running_operation_timeout',
              self.config.long_running_operation_timeout)
          if polling is True: polling_method = ARMPolling(lro_delay, **operation_config)
          elif polling is False: polling_method = NoPolling()
          else: polling_method = polling
          return LROPoller(self._client, raw_result, get_long_running_output, polling_method)
      create_or_update.metadata = {'url': '/subscriptions/{subscriptionId}/resourcegroups/{resourceGroupName}/providers/Microsoft.Resources/deployments/{deploymentName}'}
  
      def get(
              self, resource_group_name, deployment_name, custom_headers=None, raw=False, **operation_config):
          """Gets a deployment.
  
          :param resource_group_name: The name of the resource group. The name
           is case insensitive.
          :type resource_group_name: str
          :param deployment_name: The name of the deployment to get.
          :type deployment_name: str
          :param dict custom_headers: headers that will be added to the request
          :param bool raw: returns the direct response alongside the
           deserialized response
          :param operation_config: :ref:`Operation configuration
           overrides<msrest:optionsforoperations>`.
          :return: DeploymentExtended or ClientRawResponse if raw=true
          :rtype:
           ~azure.mgmt.resource.resources.v2016_09_01.models.DeploymentExtended
           or ~msrest.pipeline.ClientRawResponse
          :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
          """
          # Construct URL
          url = self.get.metadata['url']
          path_format_arguments = {
              'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+$'),
              'deploymentName': self._serialize.url("deployment_name", deployment_name, 'str', max_length=64, min_length=1, pattern=r'^[-\w\._\(\)]+$'),
              'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str')
          }
          url = self._client.format_url(url, **path_format_arguments)
  
          # Construct parameters
          query_parameters = {}
          query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str')
  
          # Construct headers
          header_parameters = {}
          header_parameters['Accept'] = 'application/json'
          if self.config.generate_client_request_id:
              header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
          if custom_headers:
              header_parameters.update(custom_headers)
          if self.config.accept_language is not None:
              header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str')
  
          # Construct and send request
          request = self._client.get(url, query_parameters, header_parameters)
          response = self._client.send(request, stream=False, **operation_config)
  
          if response.status_code not in [200]:
              exp = CloudError(response)
              exp.request_id = response.headers.get('x-ms-request-id')
              raise exp
  
          deserialized = None
  
          if response.status_code == 200:
              deserialized = self._deserialize('DeploymentExtended', response)
  
          if raw:
              client_raw_response = ClientRawResponse(deserialized, response)
              return client_raw_response
  
          return deserialized
      get.metadata = {'url': '/subscriptions/{subscriptionId}/resourcegroups/{resourceGroupName}/providers/Microsoft.Resources/deployments/{deploymentName}'}
  
      def cancel(
              self, resource_group_name, deployment_name, custom_headers=None, raw=False, **operation_config):
          """Cancels a currently running template deployment.
  
          You can cancel a deployment only if the provisioningState is Accepted
          or Running. After the deployment is canceled, the provisioningState is
          set to Canceled. Canceling a template deployment stops the currently
          running template deployment and leaves the resource group partially
          deployed.
  
          :param resource_group_name: The name of the resource group. The name
           is case insensitive.
          :type resource_group_name: str
          :param deployment_name: The name of the deployment to cancel.
          :type deployment_name: str
          :param dict custom_headers: headers that will be added to the request
          :param bool raw: returns the direct response alongside the
           deserialized response
          :param operation_config: :ref:`Operation configuration
           overrides<msrest:optionsforoperations>`.
          :return: None or ClientRawResponse if raw=true
          :rtype: None or ~msrest.pipeline.ClientRawResponse
          :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
          """
          # Construct URL
          url = self.cancel.metadata['url']
          path_format_arguments = {
              'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+$'),
              'deploymentName': self._serialize.url("deployment_name", deployment_name, 'str', max_length=64, min_length=1, pattern=r'^[-\w\._\(\)]+$'),
              'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str')
          }
          url = self._client.format_url(url, **path_format_arguments)
  
          # Construct parameters
          query_parameters = {}
          query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str')
  
          # Construct headers
          header_parameters = {}
          if self.config.generate_client_request_id:
              header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
          if custom_headers:
              header_parameters.update(custom_headers)
          if self.config.accept_language is not None:
              header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str')
  
          # Construct and send request
          request = self._client.post(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
      cancel.metadata = {'url': '/subscriptions/{subscriptionId}/resourcegroups/{resourceGroupName}/providers/Microsoft.Resources/deployments/{deploymentName}/cancel'}
  
      def validate(
              self, resource_group_name, deployment_name, properties, custom_headers=None, raw=False, **operation_config):
          """Validates whether the specified template is syntactically correct and
          will be accepted by Azure Resource Manager..
  
          :param resource_group_name: The name of the resource group the
           template will be deployed to. The name is case insensitive.
          :type resource_group_name: str
          :param deployment_name: The name of the deployment.
          :type deployment_name: str
          :param properties: The deployment properties.
          :type properties:
           ~azure.mgmt.resource.resources.v2016_09_01.models.DeploymentProperties
          :param dict custom_headers: headers that will be added to the request
          :param bool raw: returns the direct response alongside the
           deserialized response
          :param operation_config: :ref:`Operation configuration
           overrides<msrest:optionsforoperations>`.
          :return: DeploymentValidateResult or ClientRawResponse if raw=true
          :rtype:
           ~azure.mgmt.resource.resources.v2016_09_01.models.DeploymentValidateResult
           or ~msrest.pipeline.ClientRawResponse
          :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
          """
          parameters = models.Deployment(properties=properties)
  
          # Construct URL
          url = self.validate.metadata['url']
          path_format_arguments = {
              'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+$'),
              'deploymentName': self._serialize.url("deployment_name", deployment_name, 'str', max_length=64, min_length=1, pattern=r'^[-\w\._\(\)]+$'),
              'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str')
          }
          url = self._client.format_url(url, **path_format_arguments)
  
          # Construct parameters
          query_parameters = {}
          query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str')
  
          # Construct headers
          header_parameters = {}
          header_parameters['Accept'] = 'application/json'
          header_parameters['Content-Type'] = 'application/json; charset=utf-8'
          if self.config.generate_client_request_id:
              header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
          if custom_headers:
              header_parameters.update(custom_headers)
          if self.config.accept_language is not None:
              header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str')
  
          # Construct body
          body_content = self._serialize.body(parameters, 'Deployment')
  
          # 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, 400]:
              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('DeploymentValidateResult', response)
          if response.status_code == 400:
              deserialized = self._deserialize('DeploymentValidateResult', response)
  
          if raw:
              client_raw_response = ClientRawResponse(deserialized, response)
              return client_raw_response
  
          return deserialized
      validate.metadata = {'url': '/subscriptions/{subscriptionId}/resourcegroups/{resourceGroupName}/providers/Microsoft.Resources/deployments/{deploymentName}/validate'}
  
      def export_template(
              self, resource_group_name, deployment_name, custom_headers=None, raw=False, **operation_config):
          """Exports the template used for specified deployment.
  
          :param resource_group_name: The name of the resource group. The name
           is case insensitive.
          :type resource_group_name: str
          :param deployment_name: The name of the deployment from which to get
           the template.
          :type deployment_name: str
          :param dict custom_headers: headers that will be added to the request
          :param bool raw: returns the direct response alongside the
           deserialized response
          :param operation_config: :ref:`Operation configuration
           overrides<msrest:optionsforoperations>`.
          :return: DeploymentExportResult or ClientRawResponse if raw=true
          :rtype:
           ~azure.mgmt.resource.resources.v2016_09_01.models.DeploymentExportResult
           or ~msrest.pipeline.ClientRawResponse
          :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
          """
          # Construct URL
          url = self.export_template.metadata['url']
          path_format_arguments = {
              'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+$'),
              'deploymentName': self._serialize.url("deployment_name", deployment_name, 'str', max_length=64, min_length=1, pattern=r'^[-\w\._\(\)]+$'),
              'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str')
          }
          url = self._client.format_url(url, **path_format_arguments)
  
          # Construct parameters
          query_parameters = {}
          query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str')
  
          # Construct headers
          header_parameters = {}
          header_parameters['Accept'] = 'application/json'
          if self.config.generate_client_request_id:
              header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
          if custom_headers:
              header_parameters.update(custom_headers)
          if self.config.accept_language is not None:
              header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str')
  
          # Construct and send request
          request = self._client.post(url, query_parameters, header_parameters)
          response = self._client.send(request, stream=False, **operation_config)
  
          if response.status_code not in [200]:
              exp = CloudError(response)
              exp.request_id = response.headers.get('x-ms-request-id')
              raise exp
  
          deserialized = None
  
          if response.status_code == 200:
              deserialized = self._deserialize('DeploymentExportResult', response)
  
          if raw:
              client_raw_response = ClientRawResponse(deserialized, response)
              return client_raw_response
  
          return deserialized
      export_template.metadata = {'url': '/subscriptions/{subscriptionId}/resourcegroups/{resourceGroupName}/providers/Microsoft.Resources/deployments/{deploymentName}/exportTemplate'}
  
      def list(
              self, resource_group_name, filter=None, top=None, custom_headers=None, raw=False, **operation_config):
          """Get all the deployments for a resource group.
  
          :param resource_group_name: The name of the resource group with the
           deployments to get. The name is case insensitive.
          :type resource_group_name: str
          :param filter: The filter to apply on the operation. For example, you
           can use $filter=provisioningState eq '{state}'.
          :type filter: str
          :param top: The number of results to get. If null is passed, returns
           all deployments.
          :type top: int
          :param dict custom_headers: headers that will be added to the request
          :param bool raw: returns the direct response alongside the
           deserialized response
          :param operation_config: :ref:`Operation configuration
           overrides<msrest:optionsforoperations>`.
          :return: An iterator like instance of DeploymentExtended
          :rtype:
           ~azure.mgmt.resource.resources.v2016_09_01.models.DeploymentExtendedPaged[~azure.mgmt.resource.resources.v2016_09_01.models.DeploymentExtended]
          :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
          """
          def internal_paging(next_link=None, raw=False):
  
              if not next_link:
                  # Construct URL
                  url = self.list.metadata['url']
                  path_format_arguments = {
                      'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+$'),
                      'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str')
                  }
                  url = self._client.format_url(url, **path_format_arguments)
  
                  # Construct parameters
                  query_parameters = {}
                  if filter is not None:
                      query_parameters['$filter'] = self._serialize.query("filter", filter, 'str')
                  if top is not None:
                      query_parameters['$top'] = self._serialize.query("top", top, 'int')
                  query_parameters['api-version'] = self._serialize.query("self.api_version", self.api_version, 'str')
  
              else:
                  url = next_link
                  query_parameters = {}
  
              # Construct headers
              header_parameters = {}
              header_parameters['Accept'] = 'application/json'
              if self.config.generate_client_request_id:
                  header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
              if custom_headers:
                  header_parameters.update(custom_headers)
              if self.config.accept_language is not None:
                  header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str')
  
              # Construct and send request
              request = self._client.get(url, query_parameters, header_parameters)
              response = self._client.send(request, stream=False, **operation_config)
  
              if response.status_code not in [200]:
                  exp = CloudError(response)
                  exp.request_id = response.headers.get('x-ms-request-id')
                  raise exp
  
              return response
  
          # Deserialize response
          deserialized = models.DeploymentExtendedPaged(internal_paging, self._deserialize.dependencies)
  
          if raw:
              header_dict = {}
              client_raw_response = models.DeploymentExtendedPaged(internal_paging, self._deserialize.dependencies, header_dict)
              return client_raw_response
  
          return deserialized
      list.metadata = {'url': '/subscriptions/{subscriptionId}/resourcegroups/{resourceGroupName}/providers/Microsoft.Resources/deployments/'}
  