'Disables the specified job, preventing new tasks from running.
The Batch Service immediately moves the job to the disabling state.
Batch then uses the disableTasks parameter to determine what to do with
the currently running tasks of the job. The job remains in the
disabling state until the disable operation is completed and all tasks
have been dealt with according to the disableTasks option; the job then
moves to the disabled state. No new tasks are started under the job
until it moves back to active state. If you try to disable a job that
is in any state other than active, disabling, or disabled, the request
fails with status code 409.
:param job_id: The ID of the job to disable.
:type job_id: str
:param disable_tasks: What to do with active tasks associated with the
job. requeue - Terminate running tasks and requeue them. The tasks
will run again when the job is enabled. terminate - Terminate running
tasks. The tasks will not run again. wait - Allow currently running
tasks to complete. Possible values include: \'requeue\', \'terminate\',
\'wait\'
:type disable_tasks: str or :class:`DisableJobOption
<azure.batch.models.DisableJobOption>`
:param job_disable_options: Additional parameters for the operation
:type job_disable_options: :class:`JobDisableOptions
<azure.batch.models.JobDisableOptions>`
: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 disable(self, job_id, disable_tasks, job_disable_options=None, custom_headers=None, raw=False, **operation_config):

    timeout = None
    if (job_disable_options is not None):
        timeout = job_disable_options.timeout
    client_request_id = None
    if (job_disable_options is not None):
        client_request_id = job_disable_options.client_request_id
    return_client_request_id = None
    if (job_disable_options is not None):
        return_client_request_id = job_disable_options.return_client_request_id
    ocp_date = None
    if (job_disable_options is not None):
        ocp_date = job_disable_options.ocp_date
    if_match = None
    if (job_disable_options is not None):
        if_match = job_disable_options.if_match
    if_none_match = None
    if (job_disable_options is not None):
        if_none_match = job_disable_options.if_none_match
    if_modified_since = None
    if (job_disable_options is not None):
        if_modified_since = job_disable_options.if_modified_since
    if_unmodified_since = None
    if (job_disable_options is not None):
        if_unmodified_since = job_disable_options.if_unmodified_since
    job_disable_parameter = models.JobDisableParameter(disable_tasks=disable_tasks)
    url = '/jobs/{jobId}/disable'
    path_format_arguments = {'jobId': self._serialize.url('job_id', job_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')
    body_content = self._serialize.body(job_disable_parameter, 'JobDisableParameter')
    request = self._client.post(url, query_parameters)
    response = self._client.send(request, header_parameters, body_content, **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', 'ETag': 'str', 'Last-Modified': 'rfc-1123', 'DataServiceId': 'str'})
        return client_raw_response
