# Source code for azure.mgmt.resource.resources.v2018_05_01.operations._deployments_operations

    # coding=utf-8
    # --------------------------------------------------------------------------
    # Copyright (c) Microsoft Corporation. All rights reserved.
    # Licensed under the MIT License. See License.txt in the project root for
    # license information.
    #
    # Code generated by Microsoft (R) AutoRest Code Generator.
    # Changes may cause incorrect behavior and will be lost if the code is
    # regenerated.
    # --------------------------------------------------------------------------

    import uuid
    from msrest.pipeline import ClientRawResponse
    from msrestazure.azure_exceptions import CloudError
    from msrest.polling import LROPoller, NoPolling
    from msrestazure.polling.arm_polling import ARMPolling

    from .. import models

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

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

        :param client: Client for service requests.
        :param config: Configuration of service client.
        :param serializer: An object model serializer.
        :param deserializer: An object model deserializer.
        :ivar api_version: The API version to use for this operation. Constant value: "2018-05-01".
        """

        models = models

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

            self._client = client
            self._serialize = serializer
            self._deserialize = deserializer
            self.api_version = "2018-05-01"

            self.config = config

        def _delete_at_subscription_scope_initial(
                self, deployment_name, custom_headers=None, raw=False, **operation_config):
            # Construct URL
            url = self.delete_at_subscription_scope.metadata['url']
            path_format_arguments = {
                '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_at_subscription_scope(
                self, 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. 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 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_at_subscription_scope_initial(
                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_at_subscription_scope.metadata = {'url': '/subscriptions/{subscriptionId}/providers/Microsoft.Resources/deployments/{deploymentName}'}

        def check_existence_at_subscription_scope(
                self, deployment_name, custom_headers=None, raw=False, **operation_config):
            """Checks whether the deployment exists.

            :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_at_subscription_scope.metadata['url']
            path_format_arguments = {
                '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_at_subscription_scope.metadata = {'url': '/subscriptions/{subscriptionId}/providers/Microsoft.Resources/deployments/{deploymentName}'}

        def _create_or_update_at_subscription_scope_initial(
                self, deployment_name, properties, location=None, custom_headers=None, raw=False, **operation_config):
            parameters = models.Deployment(location=location, properties=properties)

            # Construct URL
            url = self.create_or_update_at_subscription_scope.metadata['url']
            path_format_arguments = {
                '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_at_subscription_scope(
                self, deployment_name, properties, location=None, custom_headers=None, raw=False, polling=True, **operation_config):
            """Deploys resources at subscription scope.

            You can provide the template and parameters directly in the request or
            link to JSON files.

            :param deployment_name: The name of the deployment.
            :type deployment_name: str
            :param properties: The deployment properties.
            :type properties:
             ~azure.mgmt.resource.resources.v2018_05_01.models.DeploymentProperties
            :param location: The location to store the deployment data.
            :type location: 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 DeploymentExtended or
             ClientRawResponse<DeploymentExtended> if raw==True
            :rtype:
             ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.resource.resources.v2018_05_01.models.DeploymentExtended]
             or
             ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.resource.resources.v2018_05_01.models.DeploymentExtended]]
            :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
            """
            raw_result = self._create_or_update_at_subscription_scope_initial(
                deployment_name=deployment_name,
                properties=properties,
                location=location,
                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_at_subscription_scope.metadata = {'url': '/subscriptions/{subscriptionId}/providers/Microsoft.Resources/deployments/{deploymentName}'}

        def get_at_subscription_scope(
                self, deployment_name, custom_headers=None, raw=False, **operation_config):
            """Gets a deployment.

            :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.v2018_05_01.models.DeploymentExtended
             or ~msrest.pipeline.ClientRawResponse
            :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
            """
            # Construct URL
            url = self.get_at_subscription_scope.metadata['url']
            path_format_arguments = {
                '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_at_subscription_scope.metadata = {'url': '/subscriptions/{subscriptionId}/providers/Microsoft.Resources/deployments/{deploymentName}'}

        def cancel_at_subscription_scope(
                self, 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 resources partially
            deployed.

            :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_at_subscription_scope.metadata['url']
            path_format_arguments = {
                '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_at_subscription_scope.metadata = {'url': '/subscriptions/{subscriptionId}/providers/Microsoft.Resources/deployments/{deploymentName}/cancel'}

        def validate_at_subscription_scope(
                self, deployment_name, properties, location=None, custom_headers=None, raw=False, **operation_config):
            """Validates whether the specified template is syntactically correct and
            will be accepted by Azure Resource Manager..

            :param deployment_name: The name of the deployment.
            :type deployment_name: str
            :param properties: The deployment properties.
            :type properties:
             ~azure.mgmt.resource.resources.v2018_05_01.models.DeploymentProperties
            :param location: The location to store the deployment data.
            :type location: 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: DeploymentValidateResult or ClientRawResponse if raw=true
            :rtype:
             ~azure.mgmt.resource.resources.v2018_05_01.models.DeploymentValidateResult
             or ~msrest.pipeline.ClientRawResponse
            :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
            """
            parameters = models.Deployment(location=location, properties=properties)

            # Construct URL
            url = self.validate_at_subscription_scope.metadata['url']
            path_format_arguments = {
                '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_at_subscription_scope.metadata = {'url': '/subscriptions/{subscriptionId}/providers/Microsoft.Resources/deployments/{deploymentName}/validate'}

        def export_template_at_subscription_scope(
                self, deployment_name, custom_headers=None, raw=False, **operation_config):
            """Exports the template used for specified deployment.

            :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.v2018_05_01.models.DeploymentExportResult
             or ~msrest.pipeline.ClientRawResponse
            :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
            """
            # Construct URL
            url = self.export_template_at_subscription_scope.metadata['url']
            path_format_arguments = {
                '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_at_subscription_scope.metadata = {'url': '/subscriptions/{subscriptionId}/providers/Microsoft.Resources/deployments/{deploymentName}/exportTemplate'}

        def list_at_subscription_scope(
                self, filter=None, top=None, custom_headers=None, raw=False, **operation_config):
            """Get all the deployments for a subscription.

            :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.v2018_05_01.models.DeploymentExtendedPaged[~azure.mgmt.resource.resources.v2018_05_01.models.DeploymentExtended]
            :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
            """
            def prepare_request(next_link=None):
                if not next_link:
                    # Construct URL
                    url = self.list_at_subscription_scope.metadata['url']
                    path_format_arguments = {
                        'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str')
                    }
                    url = self._client.format_url(url, **path_format_arguments)

                    # Construct parameters
                    query_parameters = {}
                    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)
                return request

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

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

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

                return response

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

            return deserialized
        list_at_subscription_scope.metadata = {'url': '/subscriptions/{subscriptionId}/providers/Microsoft.Resources/deployments/'}

        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, location=None, custom_headers=None, raw=False, **operation_config):
            parameters = models.Deployment(location=location, 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, location=None, 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.v2018_05_01.models.DeploymentProperties
            :param location: The location to store the deployment data.
            :type location: 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 DeploymentExtended or
             ClientRawResponse<DeploymentExtended> if raw==True
            :rtype:
             ~msrestazure.azure_operation.AzureOperationPoller[~azure.mgmt.resource.resources.v2018_05_01.models.DeploymentExtended]
             or
             ~msrestazure.azure_operation.AzureOperationPoller[~msrest.pipeline.ClientRawResponse[~azure.mgmt.resource.resources.v2018_05_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,
                location=location,
                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.v2018_05_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, location=None, 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.v2018_05_01.models.DeploymentProperties
            :param location: The location to store the deployment data.
            :type location: 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: DeploymentValidateResult or ClientRawResponse if raw=true
            :rtype:
             ~azure.mgmt.resource.resources.v2018_05_01.models.DeploymentValidateResult
             or ~msrest.pipeline.ClientRawResponse
            :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
            """
            parameters = models.Deployment(location=location, 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.v2018_05_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_by_resource_group(
                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.v2018_05_01.models.DeploymentExtendedPaged[~azure.mgmt.resource.resources.v2018_05_01.models.DeploymentExtended]
            :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
            """
            def prepare_request(next_link=None):
                if not next_link:
                    # Construct URL
                    url = self.list_by_resource_group.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)
                return request

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

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

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

                return response

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

            return deserialized
        list_by_resource_group.metadata = {'url': '/subscriptions/{subscriptionId}/resourcegroups/{resourceGroupName}/providers/Microsoft.Resources/deployments/'}

        def calculate_template_hash(
                self, template, custom_headers=None, raw=False, **operation_config):
            """Calculate the hash of the given template.

            :param template: The template provided to calculate hash.
            :type template: object
            :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: TemplateHashResult or ClientRawResponse if raw=true
            :rtype:
             ~azure.mgmt.resource.resources.v2018_05_01.models.TemplateHashResult
             or ~msrest.pipeline.ClientRawResponse
            :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
            """
            # Construct URL
            url = self.calculate_template_hash.metadata['url']

            # 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(template, 'object')

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

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

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

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

            return deserialized
        calculate_template_hash.metadata = {'url': '/providers/Microsoft.Resources/calculateTemplateHash'}