'Lists all of the applications available in the specified account.
This operation returns only applications and versions that are
available for use on compute nodes; that is, that can be used in an
application package reference. For administrator information about
applications and versions that are not yet available to compute nodes,
use the Azure portal or the Azure Resource Manager API.
:param application_list_options: Additional parameters for the
operation
:type application_list_options: :class:`ApplicationListOptions
<azure.batch.models.ApplicationListOptions>`
: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: :class:`ApplicationSummaryPaged
<azure.batch.models.ApplicationSummaryPaged>`
:raises:
:class:`BatchErrorException<azure.batch.models.BatchErrorException>`'

def list(self, application_list_options=None, custom_headers=None, raw=False, **operation_config):

    max_results = None
    if (application_list_options is not None):
        max_results = application_list_options.max_results
    timeout = None
    if (application_list_options is not None):
        timeout = application_list_options.timeout
    client_request_id = None
    if (application_list_options is not None):
        client_request_id = application_list_options.client_request_id
    return_client_request_id = None
    if (application_list_options is not None):
        return_client_request_id = application_list_options.return_client_request_id
    ocp_date = None
    if (application_list_options is not None):
        ocp_date = application_list_options.ocp_date
    def internal_paging(next_link=None, raw=False):
        if (not next_link):
            url = '/applications'
            query_parameters = {}
            query_parameters['api-version'] = self._serialize.query('self.api_version', self.api_version, 'str')
            if (max_results is not None):
                query_parameters['maxresults'] = self._serialize.query('max_results', max_results, 'int', maximum=1000, minimum=1)
            if (timeout is not None):
                query_parameters['timeout'] = self._serialize.query('timeout', timeout, 'int')
        else:
            url = next_link
            query_parameters = {}
        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')
        request = self._client.get(url, query_parameters)
        response = self._client.send(request, header_parameters, **operation_config)
        if (response.status_code not in [200]):
            raise models.BatchErrorException(self._deserialize, response)
        return response
    deserialized = models.ApplicationSummaryPaged(internal_paging, self._deserialize.dependencies)
    if raw:
        header_dict = {}
        client_raw_response = models.ApplicationSummaryPaged(internal_paging, self._deserialize.dependencies, header_dict)
        return client_raw_response
    return deserialized
