'Deletes a pool from the specified account.
When you request that a pool be deleted, the following actions occur:
the pool state is set to deleting; any ongoing resize operation on the
pool are stopped; the Batch service starts resizing the pool to zero
nodes; any tasks running on existing nodes are terminated and requeued
(as if a resize pool operation had been requested with the default
requeue option); finally, the pool is removed from the system. Because
running tasks are requeued, the user can rerun these tasks by updating
their job to target a different pool. The tasks can then run on the new
pool. If you want to override the requeue behavior, then you should
call resize pool explicitly to shrink the pool to zero size before
deleting the pool. If you call an Update, Patch or Delete API on a pool
in the deleting state, it will fail with HTTP status code 409 with
error code PoolBeingDeleted.
:param pool_id: The ID of the pool to delete.
:type pool_id: str
:param pool_delete_options: Additional parameters for the operation
:type pool_delete_options: :class:`PoolDeleteOptions
<azure.batch.models.PoolDeleteOptions>`
: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>`.
:rtype: None
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
:raises:
:class:`BatchErrorException<azure.batch.models.BatchErrorException>`'

def delete(self, pool_id, pool_delete_options=None, custom_headers=None, raw=False, **operation_config):

    timeout = None
    if (pool_delete_options is not None):
        timeout = pool_delete_options.timeout
    client_request_id = None
    if (pool_delete_options is not None):
        client_request_id = pool_delete_options.client_request_id
    return_client_request_id = None
    if (pool_delete_options is not None):
        return_client_request_id = pool_delete_options.return_client_request_id
    ocp_date = None
    if (pool_delete_options is not None):
        ocp_date = pool_delete_options.ocp_date
    if_match = None
    if (pool_delete_options is not None):
        if_match = pool_delete_options.if_match
    if_none_match = None
    if (pool_delete_options is not None):
        if_none_match = pool_delete_options.if_none_match
    if_modified_since = None
    if (pool_delete_options is not None):
        if_modified_since = pool_delete_options.if_modified_since
    if_unmodified_since = None
    if (pool_delete_options is not None):
        if_unmodified_since = pool_delete_options.if_unmodified_since
    url = '/pools/{poolId}'
    path_format_arguments = {'poolId': self._serialize.url('pool_id', pool_id, 'str')}
    url = self._client.format_url(url, **path_format_arguments)
    query_parameters = {}
    query_parameters['api-version'] = self._serialize.query('self.api_version', self.api_version, 'str')
    if (timeout is not None):
        query_parameters['timeout'] = self._serialize.query('timeout', timeout, 'int')
    header_parameters = {}
    header_parameters['Content-Type'] = 'application/json;    odata=minimalmetadata;    charset=utf-8'
    if self.config.generate_client_request_id:
        header_parameters['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')
    if (client_request_id is not None):
        header_parameters['client-request-id'] = self._serialize.header('client_request_id', client_request_id, 'str')
    if (return_client_request_id is not None):
        header_parameters['return-client-request-id'] = self._serialize.header('return_client_request_id', return_client_request_id, 'bool')
    if (ocp_date is not None):
        header_parameters['ocp-date'] = self._serialize.header('ocp_date', ocp_date, 'rfc-1123')
    if (if_match is not None):
        header_parameters['If-Match'] = self._serialize.header('if_match', if_match, 'str')
    if (if_none_match is not None):
        header_parameters['If-None-Match'] = self._serialize.header('if_none_match', if_none_match, 'str')
    if (if_modified_since is not None):
        header_parameters['If-Modified-Since'] = self._serialize.header('if_modified_since', if_modified_since, 'rfc-1123')
    if (if_unmodified_since is not None):
        header_parameters['If-Unmodified-Since'] = self._serialize.header('if_unmodified_since', if_unmodified_since, 'rfc-1123')
    request = self._client.delete(url, query_parameters)
    response = self._client.send(request, header_parameters, **operation_config)
    if (response.status_code not in [202]):
        raise models.BatchErrorException(self._deserialize, response)
    if raw:
        client_raw_response = ClientRawResponse(None, response)
        client_raw_response.add_headers({'client-request-id': 'str', 'request-id': 'str'})
        return client_raw_response
