'Gets the list of application types in the Service Fabric cluster
matching exactly the specified name.
Returns the information about the application types that are
provisioned or in the process of being provisioned in the Service
Fabric cluster. These results are of application types whose name
match exactly the one specified as the parameter, and which comply
with the given query parameters. All versions of the application type
matching the application type name are returned, with each version
returned as one application type. The response includes the name,
version, status and other details about the application type. This is
a paged query, meaning that if not all of the application types fit
in a page, one page of results is returned as well as a continuation
token which can be used to get the next page. For example, if there
are 10 application types but a page only fits the first 3 application
types, or if max results is set to 3, then 3 is returned. To access
the rest of the results, retrieve subsequent pages by using the
returned continuation token in the next query. An empty continuation
token is returned if there are no subsequent pages.
:param application_type_name: The name of the application type.
:type application_type_name: str
:param exclude_application_parameters: The flag that specifies
whether application parameters will be excluded from the result.
:type exclude_application_parameters: bool
:param continuation_token: The continuation token parameter is used
to obtain next set of results. A continuation token with a non empty
value is included in the response of the API when the results from
the system do not fit in a single response. When this value is
passed to the next API call, the API returns next set of results. If
there are no further results then the continuation token does not
contain a value. The value of this parameter should not be URL
encoded.
:type continuation_token: str
:param max_results: The maximum number of results to be returned as
part of the paged queries. This parameter defines the upper bound on
the number of results returned. The results returned can be less
than the specified maximum results if they do not fit in the message
as per the max message size restrictions defined in the
configuration. If this parameter is zero or not specified, the paged
queries includes as much results as possible that fit in the return
message.
:type max_results: long
:param timeout: The server timeout for performing the operation in
seconds. This specifies the time duration that the client is willing
to wait for the requested operation to complete. The default value
for this parameter is 60 seconds.
:type timeout: long
: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:`PagedApplicationTypeInfoList
<azure.servicefabric.models.PagedApplicationTypeInfoList>`
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
:raises:
:class:`FabricErrorException<azure.servicefabric.models.FabricErrorException>`'

def get_application_type_info_list_by_name(self, application_type_name, exclude_application_parameters=False, continuation_token=None, max_results=0, timeout=60, custom_headers=None, raw=False, **operation_config):

    api_version = '4.0'
    url = '/ApplicationTypes/{applicationTypeName}'
    path_format_arguments = {'applicationTypeName': self._serialize.url('application_type_name', application_type_name, 'str')}
    url = self._client.format_url(url, **path_format_arguments)
    query_parameters = {}
    query_parameters['api-version'] = self._serialize.query('api_version', api_version, 'str')
    if (exclude_application_parameters is not None):
        query_parameters['ExcludeApplicationParameters'] = self._serialize.query('exclude_application_parameters', exclude_application_parameters, 'bool')
    if (continuation_token is not None):
        query_parameters['ContinuationToken'] = self._serialize.query('continuation_token', continuation_token, 'str', skip_quote=True)
    if (max_results is not None):
        query_parameters['MaxResults'] = self._serialize.query('max_results', max_results, 'long', minimum=0)
    if (timeout is not None):
        query_parameters['timeout'] = self._serialize.query('timeout', timeout, 'long', maximum=4294967295, minimum=1)
    header_parameters = {}
    header_parameters['Content-Type'] = 'application/json;    charset=utf-8'
    if custom_headers:
        header_parameters.update(custom_headers)
    request = self._client.get(url, query_parameters)
    response = self._client.send(request, header_parameters, **operation_config)
    if (response.status_code not in [200, 204]):
        raise models.FabricErrorException(self._deserialize, response)
    deserialized = None
    if (response.status_code == 200):
        deserialized = self._deserialize('PagedApplicationTypeInfoList', response)
    if raw:
        client_raw_response = ClientRawResponse(deserialized, response)
        return client_raw_response
    return deserialized
