:numbered!:
[appendix]
[[common-application-properties]]
== Common application properties
Various properties can be specified inside your `application.properties`/`application.yml`
file or as command line switches. This section provides a list common Spring Boot
properties and references to the underlying classes that consume them.

NOTE: Property contributions can come from additional jar files on your classpath so
you should not consider this an exhaustive list. It is also perfectly legit to define
your own properties.

WARNING: This sample file is meant as a guide only. Do **not** copy/paste the entire
content into your application; rather pick only the properties that you need.


[source,properties,indent=0,subs="verbatim,attributes,macros"]
----
	# ===================================================================
	# COMMON SPRING BOOT PROPERTIES
	#
	# This sample file is provided as a guideline. Do NOT copy it in its
	# entirety to your own application.               ^^^
	# ===================================================================

	# ----------------------------------------
	# CORE PROPERTIES
	# ----------------------------------------

    # BANNER
    banner.charset=UTF-8 # banner file encoding
    banner.location=classpath:banner.txt # banner file location

	# SPRING CONFIG ({sc-spring-boot}/context/config/ConfigFileApplicationListener.{sc-ext}[ConfigFileApplicationListener])
	spring.config.name= # config file name (default to 'application')
	spring.config.location= # location of config file

	# PROFILES
	spring.profiles.active= # comma list of <<howto-set-active-spring-profiles,active profiles>>
	spring.profiles.include= # unconditionally activate the specified comma separated profiles

	# APPLICATION SETTINGS ({sc-spring-boot}/SpringApplication.{sc-ext}[SpringApplication])
	spring.main.sources= # sources (class name, package name or XML resource location) to include
	spring.main.web-environment= # detect by default
	spring.main.show-banner=true
	spring.main.banner-mode=console # mode used to display the banner when the application runs (console, off, or log)
	spring.main....= # see class for all properties

	# AUTO-CONFIGURATION
	spring.autoconfigure.exclude= # comma-separated list of auto-configuration classes to exclude

	# ADMIN ({sc-spring-boot-autoconfigure}/admin/SpringApplicationAdminJmxAutoConfiguration.{sc-ext}[SpringApplicationAdminJmxAutoConfiguration])
	spring.application.admin.enabled=false # enable admin features for the application
	spring.application.admin.jmx-name=org.springframework.boot:type=Admin,name=SpringApplication # JMX name of the application admin MBean

	# OUTPUT
	spring.output.ansi.enabled=detect # Configure the ANSI output ("detect", "always", "never")

	# LOGGING
	logging.config= # location of config file (default classpath:logback.xml for logback)
	logging.exception-conversion-word=%rEx # conversion word used when logging exceptions
	logging.file=myapp.log
	logging.level.*= # levels for loggers, e.g. "logging.level.org.springframework=DEBUG" (TRACE, DEBUG, INFO, WARN, ERROR, FATAL, OFF)
	logging.path=/var/log
	logging.pattern.console= # appender pattern for output to the console (only supported with the default logback setup)
	logging.pattern.file= # appender pattern for output to the file (only supported with the default logback setup)
	logging.pattern.level= # appender pattern for the log level (default %5p, only supported with the default logback setup)
	logging.register-shutdown-hook=false # register a shutdown hook for the logging system when it is initialized

	# IDENTITY ({sc-spring-boot}/context/ContextIdApplicationContextInitializer.{sc-ext}[ContextIdApplicationContextInitializer])
	spring.application.name=
	spring.application.index=

	# EMBEDDED SERVER CONFIGURATION ({sc-spring-boot-autoconfigure}/web/ServerProperties.{sc-ext}[ServerProperties])
	server.port=8080
	server.address= # bind to a specific NIC
	server.compression.enabled=false # if response compression is enabled
	server.compression.excluded-user-agents= # list of user-agents to exclude from compression
	server.compression.mime-types=text/html,text/xml,text/plain,text/css # comma-separated list of MIME types that should be compressed
	server.compression.min-response-size=2048 # minimum response size that is required for compression to be performed
	server.context-parameters.*= # Servlet context init parameters, e.g. server.context-parameters.a=alpha
	server.context-path= # the context path, defaults to '/'
	server.jsp-servlet.class-name=org.apache.jasper.servlet.JspServlet # The class name of the JSP servlet
	server.jsp-servlet.init-parameters.*= # Init parameters used to configure the JSP servlet
	server.jsp-servlet.registered=true # Whether or not the JSP servlet is registered
	server.servlet-path= # the servlet path, defaults to '/'
	server.display-name= # the display name of the application
	server.use-forward-headers= # if X-Forwarded-* headers should be used (default is off unless running in a known cloud)
	server.session.persistent=false # true if session should be saved across restarts
	server.session.timeout= # session timeout in seconds
	server.session.tracking-modes= # tracking modes (one or more of "cookie" ,"url", "ssl")
	server.session.cookie.name= # session cookie name
	server.session.cookie.domain= # domain for the session cookie
	server.session.cookie.path= # path of the session cookie
	server.session.cookie.comment= # comment for the session cookie
	server.session.cookie.http-only= # "HttpOnly" flag for the session cookie
	server.session.cookie.secure= # "Secure" flag for the session cookie
	server.session.cookie.max-age= # maximum age of the session cookie in seconds
	server.ssl.enabled=true # if SSL support is enabled
	server.ssl.client-auth= # want or need
	server.ssl.key-alias=
	server.ssl.ciphers= # supported SSL ciphers
	server.ssl.key-password=
	server.ssl.key-store=
	server.ssl.key-store-password=
	server.ssl.key-store-provider=
	server.ssl.key-store-type=
	server.ssl.protocol=TLS
	server.ssl.trust-store=
	server.ssl.trust-store-password=
	server.ssl.trust-store-provider=
	server.ssl.trust-store-type=
	server.tomcat.accesslog.directory=logs # directory in which log files are created
	server.tomcat.accesslog.enabled=false # is access logging enabled
	server.tomcat.accesslog.pattern= # log pattern of the access log
	server.tomcat.accesslog.prefix=access_log # log file name prefix
	server.tomcat.accesslog.suffix=.log # log file name suffix
	server.tomcat.internal-proxies=10\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}|\\
			192\\.168\\.\\d{1,3}\\.\\d{1,3}|\\
			169\\.254\\.\\d{1,3}\\.\\d{1,3}|\\
			127\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}|\\
			172\\.1[6-9]{1}\\.\\d{1,3}\\.\\d{1,3}|\\
			172\\.2[0-9]{1}\\.\\d{1,3}\\.\\d{1,3}|\\
			172\\.3[0-1]{1}\\.\\d{1,3}\\.\\d{1,3} # regular expression matching trusted IP addresses
	server.tomcat.protocol-header=x-forwarded-proto # front end proxy forward header
	server.tomcat.protocol-header-https-value=https # value of the protocol header that indicates that the incoming request uses SSL
	server.tomcat.port-header= # front end proxy port header
	server.tomcat.remote-ip-header=x-forwarded-for
	server.tomcat.basedir=/tmp # base dir (usually not needed, defaults to tmp)
	server.tomcat.background-processor-delay=30; # in seconds
	server.tomcat.max-http-header-size= # maximum size in bytes of the HTTP message header
	server.tomcat.max-threads = 0 # number of threads in protocol handler
	server.tomcat.uri-encoding = UTF-8 # character encoding to use for URL decoding
	server.undertow.accesslog.enabled=false # if access logging is enabled
	server.undertow.accesslog.pattern=common # log pattern of the access log
	server.undertow.accesslog.dir=logs # access logs directory
	server.undertow.buffer-size= # size of each buffer in bytes
    server.undertow.buffers-per-region= # number of buffer per region
    server.undertow.direct-buffers=false # allocate buffers outside the Java heap
    server.undertow.io-threads= # number of I/O threads to create for the worker
    server.undertow.worker-threads= # number of worker threads

	# ERROR HANDLING ({sc-spring-boot-autoconfigure}/web/ErrorProperties.{sc-ext}[ErrorProperties])
	server.error.path=/error # the error path
	server.error.include-stacktrace=never # when to include a stacktrace attribute (never/alway/on-trace-param)
	server.error.whitelabel.enabled=true # enable the default error page displayed in browsers in case of a server error

	# SPRING MVC ({sc-spring-boot-autoconfigure}/web/WebMvcProperties.{sc-ext}[WebMvcProperties])
	spring.mvc.locale= # set fixed locale, e.g. en_UK
	spring.mvc.date-format= # set fixed date format, e.g. dd/MM/yyyy
	spring.mvc.favicon.enabled=true
	spring.mvc.message-codes-resolver-format= # PREFIX_ERROR_CODE / POSTFIX_ERROR_CODE
	spring.mvc.ignore-default-model-on-redirect=true # if the content of the "default" model should be ignored redirects
	spring.mvc.throw-exception-if-no-handler-found=false # if a "NoHandlerFoundException" should be thrown if no Handler was found to process a request
	spring.mvc.async.request-timeout= # async request timeout in milliseconds
	spring.mvc.view.prefix= # MVC view prefix
	spring.mvc.view.suffix= # ... and suffix

	# SPRING RESOURCES HANDLING ({sc-spring-boot-autoconfigure}/web/ResourceProperties.{sc-ext}[ResourceProperties])
	spring.resources.cache-period= # cache timeouts in headers sent to browser
	spring.resources.add-mappings=true # if default mappings should be added
	spring.resources.static-locations= # comma-separated list of the locations that serve static content (e.g. 'classpath:/resources/')
	spring.resources.chain.enabled=false # enable the Spring Resource Handling chain (enabled automatically if at least a strategy is enabled)
	spring.resources.chain.cache=false # enable in-memory caching of resource resolution
	spring.resources.chain.html-application-cache=false # enable HTML5 appcache manifest rewriting
	spring.resources.chain.strategy.content.enabled=false # enable a content version strategy
	spring.resources.chain.strategy.content.paths= # comma-separated list of regular expression patterns to apply the version strategy to
	spring.resources.chain.strategy.fixed.enabled=false # enable a fixed version strategy
	spring.resources.chain.strategy.fixed.paths= # comma-separated list of regular expression patterns to apply the version strategy to
	spring.resources.chain.strategy.fixed.version= # version string to use for this version strategy

	# MULTIPART ({sc-spring-boot-autoconfigure}/web/MultipartProperties.{sc-ext}[MultipartProperties])
	multipart.enabled=true
	multipart.file-size-threshold=0 # Threshold after which files will be written to disk.
	multipart.location= # Intermediate location of uploaded files.
	multipart.max-file-size=1Mb # Max file size.
	multipart.max-request-size=10Mb # Max request size.

	# H2 Web Console ({sc-spring-boot-autoconfigure}/h2/H2ConsoleProperties.{sc-ext}[H2ConsoleProperties])
	spring.h2.console.enabled=false # Enable the console
	spring.h2.console.path=/h2-console # Path at which the console can be accessed

	# SPRING HATEOAS ({sc-spring-boot-autoconfigure}/hateoas/HateoasProperties.{sc-ext}[HateoasProperties])
	spring.hateoas.use-hal-as-default-json-media-type=true # if application/hal+json responses should be sent in response to requests for application/json

	# HTTP encoding ({sc-spring-boot-autoconfigure}/web/HttpEncodingProperties.{sc-ext}[HttpEncodingProperties])
	spring.http.encoding.charset=UTF-8 # the encoding of HTTP requests/responses
	spring.http.encoding.enabled=true # enable http encoding support
	spring.http.encoding.force=true # force the configured encoding

	# HTTP message conversion
	spring.http.converters.preferred-json-mapper= # the preferred JSON mapper to use for HTTP message conversion. Set to "gson" to force the use of Gson when both it and Jackson are on the classpath.

	# JACKSON ({sc-spring-boot-autoconfigure}/jackson/JacksonProperties.{sc-ext}[JacksonProperties])
	spring.jackson.date-format= # Date format string (e.g. yyyy-MM-dd HH:mm:ss), or a fully-qualified date format class name (e.g. com.fasterxml.jackson.databind.util.ISO8601DateFormat)
	spring.jackson.property-naming-strategy= # One of the constants on Jackson's PropertyNamingStrategy (e.g. CAMEL_CASE_TO_LOWER_CASE_WITH_UNDERSCORES) or the fully-qualified class name of a PropertyNamingStrategy subclass
	spring.jackson.deserialization.*= # see Jackson's DeserializationFeature
	spring.jackson.generator.*= # see Jackson's JsonGenerator.Feature
	spring.jackson.joda-date-time-format= # Joda date time format string
	spring.jackson.locale= # locale used for formatting
	spring.jackson.mapper.*= # see Jackson's MapperFeature
	spring.jackson.parser.*= # see Jackson's JsonParser.Feature
	spring.jackson.serialization.*= # see Jackson's SerializationFeature
	spring.jackson.serialization-inclusion= # Controls the inclusion of properties during serialization (see Jackson's JsonInclude.Include)
	spring.jackson.time-zone= # Time zone used when formatting dates. Configured using any recognized time zone identifier, for example "America/Los_Angeles" or "GMT+10"

	# THYMELEAF ({sc-spring-boot-autoconfigure}/thymeleaf/ThymeleafAutoConfiguration.{sc-ext}[ThymeleafAutoConfiguration])
	spring.thymeleaf.check-template-location=true
	spring.thymeleaf.prefix=classpath:/templates/
	spring.thymeleaf.excluded-view-names= # comma-separated list of view names that should be excluded from resolution
	spring.thymeleaf.view-names= # comma-separated list of view names that can be resolved
	spring.thymeleaf.suffix=.html
	spring.thymeleaf.mode=HTML5
	spring.thymeleaf.enabled=true # enable MVC view resolution
	spring.thymeleaf.encoding=UTF-8
	spring.thymeleaf.content-type=text/html # ;charset=<encoding> is added
	spring.thymeleaf.cache=true # set to false for hot refresh
	spring.thymeleaf.template-resolver-order= #  order of the template resolver in the chain

	# FREEMARKER ({sc-spring-boot-autoconfigure}/freemarker/FreeMarkerAutoConfiguration.{sc-ext}[FreeMarkerAutoConfiguration])
	spring.freemarker.allow-request-override=false
	spring.freemarker.allow-session-override=false
	spring.freemarker.cache=true
	spring.freemarker.check-template-location=true
	spring.freemarker.charset=UTF-8
	spring.freemarker.content-type=text/html
	spring.freemarker.enabled=true # enable MVC view resolution
	spring.freemarker.expose-request-attributes=false
	spring.freemarker.expose-session-attributes=false
	spring.freemarker.expose-spring-macro-helpers=false
	spring.freemarker.prefix=
	spring.freemarker.prefer-file-system-access=true # prefer file system access for template loading
	spring.freemarker.request-context-attribute=
	spring.freemarker.settings.*=
	spring.freemarker.suffix=.ftl
	spring.freemarker.template-loader-path=classpath:/templates/ # comma-separated list
	spring.freemarker.view-names= # whitelist of view names that can be resolved

	# GROOVY TEMPLATES ({sc-spring-boot-autoconfigure}/groovy/template/GroovyTemplateAutoConfiguration.{sc-ext}[GroovyTemplateAutoConfiguration])
	spring.groovy.template.cache=true
	spring.groovy.template.charset=UTF-8
	spring.groovy.template.check-template-location=true # check that the templates location exists
	spring.groovy.template.configuration.*= # See GroovyMarkupConfigurer
	spring.groovy.template.content-type=text/html
	spring.groovy.template.enabled=true # enable MVC view resolution
	spring.groovy.template.prefix=
	spring.groovy.template.resource-loader-path=classpath:/templates/
    spring.groovy.template.suffix=.tpl
	spring.groovy.template.view-names= # whitelist of view names that can be resolved

	# VELOCITY TEMPLATES ({sc-spring-boot-autoconfigure}/velocity/VelocityAutoConfiguration.{sc-ext}[VelocityAutoConfiguration])
	spring.velocity.allow-request-override=false
	spring.velocity.allow-session-override=false
	spring.velocity.cache=true
	spring.velocity.check-template-location=true
	spring.velocity.charset=UTF-8 # charset for input and output encoding
	spring.velocity.content-type=text/html
	spring.velocity.date-tool-attribute=
	spring.velocity.enabled=true # enable MVC view resolution
	spring.velocity.expose-request-attributes=false
	spring.velocity.expose-session-attributes=false
	spring.velocity.expose-spring-macro-helpers=false
	spring.velocity.number-tool-attribute=
	spring.velocity.prefer-file-system-access=true # prefer file system access for template loading
	spring.velocity.prefix=
	spring.velocity.properties.*=
	spring.velocity.request-context-attribute=
	spring.velocity.resource-loader-path=classpath:/templates/
	spring.velocity.suffix=.vm
	spring.velocity.toolbox-config-location= # velocity Toolbox config location, for example "/WEB-INF/toolbox.xml"
	spring.velocity.view-names= # whitelist of view names that can be resolved

	# MUSTACHE TEMPLATES ({sc-spring-boot-autoconfigure}/mustache/MustacheAutoConfiguration.{sc-ext}[MustacheAutoConfiguration])
	spring.mustache.cache=true
	spring.mustache.charset=UTF-8
	spring.mustache.check-template-location=true
	spring.mustache.content-type=UTF-8
	spring.mustache.enabled=true # enable MVC view resolution
	spring.mustache.prefix=
	spring.mustache.suffix=.html
	spring.mustache.view-names= # whitelist of view names that can be resolved

	# JERSEY ({sc-spring-boot-autoconfigure}}/jersey/JerseyProperties.{sc-ext}[JerseyProperties])
	spring.jersey.type=servlet # servlet or filter
	spring.jersey.init= # init params
	spring.jersey.filter.order=

	# INTERNATIONALIZATION ({sc-spring-boot-autoconfigure}/MessageSourceAutoConfiguration.{sc-ext}[MessageSourceAutoConfiguration])
	spring.messages.basename=messages
	spring.messages.cache-seconds=-1
	spring.messages.encoding=UTF-8
	spring.messages.fallback-to-system-locale=true # set whether to fall back to the system Locale

	[[common-application-properties-security]]
	# SECURITY ({sc-spring-boot-autoconfigure}/security/SecurityProperties.{sc-ext}[SecurityProperties])
	security.user.name=user # login username
	security.user.password= # login password
	security.user.role=USER # role assigned to the user
	security.require-ssl=false # advanced settings ...
	security.enable-csrf=false
	security.basic.enabled=true
	security.basic.realm=Spring
	security.basic.path= # /**
	security.basic.authorize-mode= # ROLE, AUTHENTICATED, NONE
	security.filter-order=0
	security.headers.xss=false
	security.headers.cache=false
	security.headers.frame=false
	security.headers.content-type=false
	security.headers.hsts=all # none / domain / all
	security.sessions=stateless # always / never / if_required / stateless
	security.ignored= # Comma-separated list of paths to exclude from the default secured paths

	# SECURITY OAUTH2 CLIENT ({sc-spring-boot-autoconfigure}/security/oauth2/OAuth2ClientProperties.{sc-ext}[OAuth2ClientProperties]
	security.oauth2.client.client-id= # OAuth2 client id
    security.oauth2.client.client-secret= # OAuth2 client secret. A random secret is generated by default

    # SECURITY OAUTH2 SSO ({sc-spring-boot-autoconfigure}/security/oauth2/client/OAuth2SsoProperties.{sc-ext}[OAuth2SsoProperties]
    security.oauth2.sso.filter-order= # Filter order to apply if not providing an explicit WebSecurityConfigurerAdapter
    security.oauth2.sso.login-path= # Path to the login page, i.e. the one that triggers the redirect to the OAuth2 Authorization Server

	# DATASOURCE ({sc-spring-boot-autoconfigure}/jdbc/DataSourceAutoConfiguration.{sc-ext}[DataSourceAutoConfiguration] & {sc-spring-boot-autoconfigure}/jdbc/DataSourceProperties.{sc-ext}[DataSourceProperties])
	spring.datasource.name=testdb # name of the data source
	spring.datasource.initialize=true # populate using data.sql
	spring.datasource.schema= # a schema (DDL) script resource reference
	spring.datasource.data= # a data (DML) script resource reference
	spring.datasource.sql-script-encoding= # a charset for reading SQL scripts
	spring.datasource.platform= # the platform to use in the schema resource (schema-${platform}.sql)
	spring.datasource.continue-on-error=false # continue even if can't be initialized
	spring.datasource.separator=; # statement separator in SQL initialization scripts
	spring.datasource.type= # fully qualified name of the connection pool implementation to use
	spring.datasource.driver-class-name= # JDBC Settings...
	spring.datasource.url=
	spring.datasource.username=
	spring.datasource.password=
	spring.datasource.jndi-name= # For JNDI lookup (class, url, username & password are ignored when set)
	spring.datasource.max-active=100 # Advanced configuration...
	spring.datasource.max-idle=8
	spring.datasource.min-idle=8
	spring.datasource.initial-size=10
	spring.datasource.validation-query=
	spring.datasource.test-on-borrow=false
	spring.datasource.test-on-return=false
	spring.datasource.test-while-idle=
	spring.datasource.time-between-eviction-runs-millis=
	spring.datasource.min-evictable-idle-time-millis=
	spring.datasource.max-wait=
	spring.datasource.jmx-enabled=false # Export JMX MBeans (if supported)

	# DAO ({sc-spring-boot-autoconfigure}/dao/PersistenceExceptionTranslationAutoConfiguration.{sc-ext}[PersistenceExceptionTranslationAutoConfiguration])
	spring.dao.exceptiontranslation.enabled=true

	# CASSANDRA ({sc-spring-boot-autoconfigure}/cassandra/CassandraProperties.{sc-ext}[CassandraProperties])
	spring.data.cassandra.cluster-name= # the cluster name
	spring.data.cassandra.contact-points=localhost # comma-list of cluster node addresses
	spring.data.cassandra.keyspace-name= # the keyspace name
	spring.data.cassandra.port= # the connection port
	spring.data.cassandra.compression= # compression method (none/snappy/lz4)
	spring.data.cassandra.loadbalancing-policy= # class name for a LoadBalancingPolicy
	spring.data.cassandra.consistency-level= # consistency level (any/one/two/three/quorum/all...)
	spring.data.cassandra.serial-consistency-level= # serial consistency level (any/one/two/three/quorum/all...)
	spring.data.cassandra.fetch-size=
	spring.data.cassandra.reconnection-policy= # class name for a ReconnectionPolicy
	spring.data.cassandra.retry-policy= # class name for a RetryPolicy
	spring.data.cassandra.connect-timeout-millis= # connect timeout (ms)
	spring.data.cassandra.read-timeout-millis= # read timeout (ms)
	spring.data.cassandra.ssl=false

	# MONGODB ({sc-spring-boot-autoconfigure}/mongo/MongoProperties.{sc-ext}[MongoProperties])
	spring.data.mongodb.host= # the db host
	spring.data.mongodb.port=27017 # the connection port (defaults to 27017)
	spring.data.mongodb.uri=mongodb://localhost/test # connection URL
	spring.data.mongodb.database=
	spring.data.mongodb.authentication-database=
	spring.data.mongodb.grid-fs-database=
	spring.data.mongodb.username=
	spring.data.mongodb.password=
	spring.data.mongodb.repositories.enabled=true # if spring data repository support is enabled
	spring.data.mongodb.field-naming-strategy= # fully qualified name of the FieldNamingStrategy to use

	# EMBEDDED MONGODB ({sc-spring-boot-autoconfigure}/mongo/embedded/EmbeddedMongoProperties.{sc-ext}[EmbeddedMongoProperties])
	spring.mongodb.embedded.version=2.6.10 # version of Mongo to use
	spring.mongodb.embedded.features=SYNC_DELAY # comma-separated list of features to enable

	# JPA ({sc-spring-boot-autoconfigure}/orm/jpa/JpaBaseConfiguration.{sc-ext}[JpaBaseConfiguration], {sc-spring-boot-autoconfigure}/orm/jpa/HibernateJpaAutoConfiguration.{sc-ext}[HibernateJpaAutoConfiguration])
	spring.jpa.properties.*= # properties to set on the JPA connection
	spring.jpa.open-in-view=true
	spring.jpa.show-sql=true
	spring.jpa.database-platform=
	spring.jpa.database=
	spring.jpa.generate-ddl=false # ignored by Hibernate, might be useful for other vendors
	spring.jpa.hibernate.naming-strategy= # naming classname
	spring.jpa.hibernate.ddl-auto= # defaults to create-drop for embedded dbs
	spring.data.jpa.repositories.enabled=true # if spring data repository support is enabled

	# JTA ({sc-spring-boot-autoconfigure}/transaction/jta/JtaAutoConfiguration.{sc-ext}[JtaAutoConfiguration])
	spring.jta.log-dir= # transaction log dir
	spring.jta.*= # technology specific configuration

	# JOOQ ({sc-spring-boot-autoconfigure}/jooq/JooqAutoConfiguration.{sc-ext}[JooqAutoConfiguration])
	spring.jooq.sql-dialect=

	# ATOMIKOS
	spring.jta.atomikos.connectionfactory.borrow-connection-timeout=30 # Timeout, in seconds, for borrowing connections from the pool
	spring.jta.atomikos.connectionfactory.ignore-session-transacted-flag=true # Whether or not to ignore the transacted flag when creating session
	spring.jta.atomikos.connectionfactory.local-transaction-mode=false # Whether or not local transactions are desired
	spring.jta.atomikos.connectionfactory.maintenance-interval=60 # The time, in seconds, between runs of the pool's maintenance thread
	spring.jta.atomikos.connectionfactory.max-idle-time=60 # The time, in seconds, after which connections are cleaned up from the pool
	spring.jta.atomikos.connectionfactory.max-lifetime=0 # The time, in seconds, that a connection can be pooled for before being destroyed. 0 denotes no limit.
	spring.jta.atomikos.connectionfactory.max-pool-size=1 # The maximum size of the pool
	spring.jta.atomikos.connectionfactory.min-pool-size=1 # The minimum size of the pool
	spring.jta.atomikos.connectionfactory.reap-timeout=0 # The reap timeout, in seconds, for borrowed connections. 0 denotes no limit.
	spring.jta.atomikos.connectionfactory.unique-resource-name=jmsConnectionFactory # The unique name used to identify the resource during recovery
	spring.jta.atomikos.datasource.borrow-connection-timeout=30 # Timeout, in seconds, for borrowing connections from the pool
	spring.jta.atomikos.datasource.default-isolation-level= # Default isolation level of connections provided by the pool
	spring.jta.atomikos.datasource.login-timeout= # Timeout, in seconds, for establishing a database connection
	spring.jta.atomikos.datasource.maintenance-interval=60 # The time, in seconds, between runs of the pool's maintenance thread
	spring.jta.atomikos.datasource.max-idle-time=60 # The time, in seconds, after which connections are cleaned up from the pool
	spring.jta.atomikos.datasource.max-lifetime=0 # The time, in seconds, that a connection can be pooled for before being destroyed. 0 denotes no limit.
	spring.jta.atomikos.datasource.max-pool-size=1 # The maximum size of the pool
	spring.jta.atomikos.datasource.min-pool-size=1 # The minimum size of the pool
	spring.jta.atomikos.datasource.reap-timeout=0 # The reap timeout, in seconds, for borrowed connections. 0 denotes no limit.
	spring.jta.atomikos.datasource.test-query= # SQL query or statement used to validate a connection before returning it
	spring.jta.atomikos.datasource.unique-resource-name=dataSource # The unique name used to identify the resource during recovery

	# BITRONIX
	spring.jta.bitronix.connectionfactory.acquire-increment=1 # Number of connections to create when growing the pool
	spring.jta.bitronix.connectionfactory.acquisition-interval=1 # Time, in seconds, to wait before trying to acquire a connection again after an invalid connection was acquired
	spring.jta.bitronix.connectionfactory.acquisition-timeout=30 # Timeout, in seconds, for acquiring connections from the pool
	spring.jta.bitronix.connectionfactory.allow-local-transactions=true # Whether or not the transaction manager should allow mixing XA and non-XA transactions
	spring.jta.bitronix.connectionfactory.apply-transaction-timeout=false # Whether or not the transaction timeout should be set on the XAResource when it is enlisted
	spring.jta.bitronix.connectionfactory.automatic-enlisting-enabled=true # Whether or not resources should be enlisted and delisted automatically
	spring.jta.bitronix.connectionfactory.cache-producers-consumers=true # Whether or not produces and consumers should be cached
	spring.jta.bitronix.connectionfactory.defer-connection-release=true # Whether or not the provider can run many transactions on the same connection and supports transaction interleaving
	spring.jta.bitronix.connectionfactory.ignore-recovery-failures=false # Whether or not recovery failures should be ignored
	spring.jta.bitronix.connectionfactory.max-idle-time=60 # The time, in seconds, after which connections are cleaned up from the pool
	spring.jta.bitronix.connectionfactory.max-pool-size=10 # The maximum size of the pool. 0 denotes no limit
	spring.jta.bitronix.connectionfactory.min-pool-size=0 # The minimum size of the pool
	spring.jta.bitronix.connectionfactory.password= # The password to use to connect to the JMS provider
	spring.jta.bitronix.connectionfactory.share-transaction-connections=false #  Whether or not connections in the ACCESSIBLE state can be shared within the context of a transaction
	spring.jta.bitronix.connectionfactory.test-connections=true # Whether or not connections should be tested when acquired from the pool
	spring.jta.bitronix.connectionfactory.two-pc-ordering-position=1 # The postion that this resource should take during two-phase commit (always first is Integer.MIN_VALUE, always last is Integer.MAX_VALUE)
	spring.jta.bitronix.connectionfactory.unique-name=jmsConnectionFactory # The unique name used to identify the resource during recovery
	spring.jta.bitronix.connectionfactory.use-tm-join=true Whether or not TMJOIN should be used when starting XAResources
	spring.jta.bitronix.connectionfactory.user= # The user to use to connect to the JMS provider
	spring.jta.bitronix.datasource.acquire-increment=1 # Number of connections to create when growing the pool
	spring.jta.bitronix.datasource.acquisition-interval=1 # Time, in seconds, to wait before trying to acquire a connection again after an invalid connection was acquired
	spring.jta.bitronix.datasource.acquisition-timeout=30 # Timeout, in seconds, for acquiring connections from the pool
	spring.jta.bitronix.datasource.allow-local-transactions=true # Whether or not the transaction manager should allow mixing XA and non-XA transactions
	spring.jta.bitronix.datasource.apply-transaction-timeout=false # Whether or not the transaction timeout should be set on the XAResource when it is enlisted
	spring.jta.bitronix.datasource.automatic-enlisting-enabled=true # Whether or not resources should be enlisted and delisted automatically
	spring.jta.bitronix.datasource.cursor-holdability= # The default cursor holdability for connections
	spring.jta.bitronix.datasource.defer-connection-release=true # Whether or not the database can run many transactions on the same connection and supports transaction interleaving
	spring.jta.bitronix.datasource.enable-jdbc4-connection-test= # Whether or not Connection.isValid() is called when acquiring a connection from the pool
	spring.jta.bitronix.datasource.ignore-recovery-failures=false # Whether or not recovery failures should be ignored
	spring.jta.bitronix.datasource.isolation-level= # The default isolation level for connections
	spring.jta.bitronix.datasource.local-auto-commit= # The default auto-commit mode for local transactions
	spring.jta.bitronix.datasource.login-timeout= # Timeout, in seconds, for establishing a database connection
	spring.jta.bitronix.datasource.max-idle-time=60 # The time, in seconds, after which connections are cleaned up from the pool
	spring.jta.bitronix.datasource.max-pool-size=10 # The maximum size of the pool. 0 denotes no limit
	spring.jta.bitronix.datasource.min-pool-size=0 # The minimum size of the pool
	spring.jta.bitronix.datasource.prepared-statement-cache-size=0 # The target size of the prepared statement cache. 0 disables the cache
	spring.jta.bitronix.datasource.share-transaction-connections=false #  Whether or not connections in the ACCESSIBLE state can be shared within the context of a transaction
	spring.jta.bitronix.datasource.test-query= # SQL query or statement used to validate a connection before returning it
	spring.jta.bitronix.datasource.two-pc-ordering-position=1 # The position that this resource should take during two-phase commit (always first is Integer.MIN_VALUE, always last is Integer.MAX_VALUE)
	spring.jta.bitronix.datasource.unique-name=dataSource # The unique name used to identify the resource during recovery
	spring.jta.bitronix.datasource.use-tm-join=true Whether or not TMJOIN should be used when starting XAResources

	# SOLR ({sc-spring-boot-autoconfigure}/solr/SolrProperties.{sc-ext}[SolrProperties])
	spring.data.solr.host=http://127.0.0.1:8983/solr
	spring.data.solr.zk-host=
	spring.data.solr.repositories.enabled=true # if spring data repository support is enabled

	# ELASTICSEARCH ({sc-spring-boot-autoconfigure}/elasticsearch/ElasticsearchProperties.{sc-ext}[ElasticsearchProperties])
	spring.data.elasticsearch.cluster-name= # The cluster name (defaults to elasticsearch)
	spring.data.elasticsearch.cluster-nodes= # The address(es) of the server node (comma-separated; if not specified starts a client node)
	spring.data.elasticsearch.properties.*= # Additional properties used to configure the client
	spring.data.elasticsearch.repositories.enabled=true # if spring data repository support is enabled

	# DATA REST ({sc-spring-boot-autoconfigure}/data/rest/RepositoryRestProperties.{sc-ext}[RepositoryRestProperties])
	spring.data.rest.base-path= # base path to be used by Spring Data REST to expose repository resources
    spring.data.rest.default-page-size= # default size of pages
    spring.data.rest.enable-enum-translation= # enable enum value translation via the Spring Data REST default resource bundle
    spring.data.rest.limit-param-name= # name of the URL query string parameter that indicates how many results to return at once
    spring.data.rest.max-page-size= # maximum size of pages
    spring.data.rest.page-param-name= # name of the URL query string parameter that indicates what page to return
    spring.data.rest.return-body-on-create= # return a response body after creating an entity
    spring.data.rest.return-body-on-update= # return a response body after updating an entity
    spring.data.rest.sort-param-name= # name of the URL query string parameter that indicates what direction to sort results

	# FLYWAY ({sc-spring-boot-autoconfigure}/flyway/FlywayProperties.{sc-ext}[FlywayProperties])
	flyway.*= # Any public property available on the auto-configured `Flyway` object
	flyway.check-location=false # check that migration scripts location exists
	flyway.locations=classpath:db/migration # locations of migrations scripts
	flyway.schemas= # schemas to update
	flyway.init-version= 1 # version to start migration
	flyway.init-sqls= # SQL statements to execute to initialize a connection immediately after obtaining it
	flyway.sql-migration-prefix=V
	flyway.sql-migration-suffix=.sql
	flyway.enabled=true
	flyway.url= # JDBC url if you want Flyway to create its own DataSource
	flyway.user= # JDBC username if you want Flyway to create its own DataSource
	flyway.password= # JDBC password if you want Flyway to create its own DataSource

	# LIQUIBASE ({sc-spring-boot-autoconfigure}/liquibase/LiquibaseProperties.{sc-ext}[LiquibaseProperties])
	liquibase.change-log=classpath:/db/changelog/db.changelog-master.yaml
	liquibase.check-change-log-location=true # check the change log location exists
	liquibase.contexts= # runtime contexts to use
	liquibase.labels= # runtime labels to use
	liquibase.default-schema= # default database schema to use
	liquibase.drop-first=false
	liquibase.enabled=true
	liquibase.url= # specific JDBC url (if not set the default datasource is used)
	liquibase.user= # user name for liquibase.url
	liquibase.password= # password for liquibase.url
	liquibase.parameters= # change log parameters

	# JMX
	spring.jmx.default-domain= # JMX domain name
	spring.jmx.enabled=true # Expose MBeans from Spring
	spring.jmx.server=mbeanServer # MBeanServer bean name

	# RABBIT ({sc-spring-boot-autoconfigure}/amqp/RabbitProperties.{sc-ext}[RabbitProperties])
	spring.rabbitmq.addresses= # connection addresses (e.g. myhost:9999,otherhost:1111)
	spring.rabbitmq.dynamic=true # create an AmqpAdmin bean
	spring.rabbitmq.host= # connection host
	spring.rabbitmq.port= # connection port
	spring.rabbitmq.password= # login password
	spring.rabbitmq.requested-heartbeat= # requested heartbeat timeout, in seconds; zero for none
	spring.rabbitmq.listener.acknowledge-mode= # acknowledge mode of container
	spring.rabbitmq.listener.auto-startup=true # start the container automatically on startup
	spring.rabbitmq.listener.concurrency= # minimum number of consumers
	spring.rabbitmq.listener.max-concurrency= # maximum number of consumers
	spring.rabbitmq.listener.prefetch= # number of messages to be handled in a single request
	spring.rabbitmq.listener.transaction-size= # number of messages to be processed in a transaction
	spring.rabbitmq.ssl.enabled=false # enable SSL support
	spring.rabbitmq.ssl.key-store= # path to the key store that holds the SSL certificate
	spring.rabbitmq.ssl.key-store-password= # password used to access the key store
	spring.rabbitmq.ssl.trust-store= # trust store that holds SSL certificates
	spring.rabbitmq.ssl.trust-store-password= # password used to access the trust store
	spring.rabbitmq.username= # login user
	spring.rabbitmq.virtual-host= # virtual host to use when connecting to the broker

	# REDIS ({sc-spring-boot-autoconfigure}/redis/RedisProperties.{sc-ext}[RedisProperties])
	spring.redis.database= # database name
	spring.redis.host=localhost # server host
	spring.redis.password= # server password
	spring.redis.port=6379 # connection port
	spring.redis.pool.max-idle=8 # pool settings ...
	spring.redis.pool.min-idle=0
	spring.redis.pool.max-active=8
	spring.redis.pool.max-wait=-1
	spring.redis.sentinel.master= # name of Redis server
	spring.redis.sentinel.nodes= # comma-separated list of host:port pairs
	spring.redis.timeout= # connection timeout in milliseconds

	# ACTIVEMQ ({sc-spring-boot-autoconfigure}/jms/activemq/ActiveMQProperties.{sc-ext}[ActiveMQProperties])
	spring.activemq.broker-url=tcp://localhost:61616 # connection URL
	spring.activemq.user=
	spring.activemq.password=
	spring.activemq.in-memory=true # broker kind to create if no broker-url is specified
	spring.activemq.pooled=false

	# ARTEMIS ({sc-spring-boot-autoconfigure}/jms/artemis/ArtemisProperties.{sc-ext}[ArtemisProperties])
	spring.artemis.mode= # connection mode (native, embedded)
	spring.artemis.host=localhost # hornetQ host (native mode)
	spring.artemis.port=5445 # hornetQ port (native mode)
	spring.artemis.embedded.enabled=true # if the embedded server is enabled (needs hornetq-jms-server.jar)
	spring.artemis.embedded.server-id= # auto-generated id of the embedded server (integer)
	spring.artemis.embedded.persistent=false # message persistence
	spring.artemis.embedded.data-directory= # location of data content (when persistence is enabled)
	spring.artemis.embedded.queues= # comma-separated queues to create on startup
	spring.artemis.embedded.topics= # comma-separated topics to create on startup
	spring.artemis.embedded.cluster-password= # customer password (randomly generated by default)

	# HORNETQ ({sc-spring-boot-autoconfigure}/jms/hornetq/HornetQProperties.{sc-ext}[HornetQProperties])
	spring.hornetq.mode= # connection mode (native, embedded)
	spring.hornetq.host=localhost # hornetQ host (native mode)
	spring.hornetq.port=5445 # hornetQ port (native mode)
	spring.hornetq.embedded.enabled=true # if the embedded server is enabled (needs hornetq-jms-server.jar)
	spring.hornetq.embedded.server-id= # auto-generated id of the embedded server (integer)
	spring.hornetq.embedded.persistent=false # message persistence
	spring.hornetq.embedded.data-directory= # location of data content (when persistence is enabled)
	spring.hornetq.embedded.queues= # comma-separated queues to create on startup
	spring.hornetq.embedded.topics= # comma-separated topics to create on startup
	spring.hornetq.embedded.cluster-password= # customer password (randomly generated by default)

	# JMS ({sc-spring-boot-autoconfigure}/jms/JmsProperties.{sc-ext}[JmsProperties])
	spring.jms.jndi-name= # JNDI location of a JMS ConnectionFactory
	spring.jms.listener.acknowledge-mode= # session acknowledgment mode
	spring.jms.listener.auto-startup=true # start the container automatically on startup
	spring.jms.listener.concurrency= # minimum number of concurrent consumers
	spring.jms.listener.max-concurrency= # maximum number of concurrent consumers
	spring.jms.pub-sub-domain= # false for queue (default), true for topic

	# Email ({sc-spring-boot-autoconfigure}/mail/MailProperties.{sc-ext}[MailProperties])
	spring.mail.host=smtp.acme.org # mail server host
	spring.mail.port= # mail server port
	spring.mail.protocol=smtp # mail server protocol
	spring.mail.username=
	spring.mail.password=
	spring.mail.default-encoding=UTF-8 # encoding to use for MimeMessages
	spring.mail.properties.*= # properties to set on the JavaMail session
	spring.mail.jndi-name= # JNDI location of a Mail Session
	spring.mail.test-connection=false # Test that the mail server is available on startup

	# SPRING BATCH ({sc-spring-boot-autoconfigure}/batch/BatchProperties.{sc-ext}[BatchProperties])
	spring.batch.job.names=job1,job2
	spring.batch.job.enabled=true
	spring.batch.initializer.enabled=true
	spring.batch.schema= # batch schema to load
	spring.batch.table-prefix= # table prefix for all the batch meta-data tables

	# SPRING CACHE ({sc-spring-boot-autoconfigure}/cache/CacheProperties.{sc-ext}[CacheProperties])
	spring.cache.type= # generic, ehcache, hazelcast, infinispan, jcache, redis, guava, simple, none
	spring.cache.cache-names= # cache names to create on startup
	spring.cache.ehcache.config= # location of the ehcache configuration
	spring.cache.hazelcast.config= # location of the hazelcast configuration
	spring.cache.infinispan.config= # location of the infinispan configuration
	spring.cache.jcache.config= # location of jcache configuration
	spring.cache.jcache.provider= # fully qualified name of the CachingProvider implementation to use
	spring.cache.guava.spec= # link:http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/cache/CacheBuilderSpec.html[guava specs]

	# HAZELCAST ({sc-spring-boot-autoconfigure}/hazelcast/HazelcastProperties.{sc-ext}[HazelcastProperties])
	spring.hazelcast.config= # location of the hazelcast configuration

	# AOP
	spring.aop.auto=
	spring.aop.proxy-target-class=

	# FILE ENCODING ({sc-spring-boot}/context/FileEncodingApplicationListener.{sc-ext}[FileEncodingApplicationListener])
	spring.mandatory-file-encoding= # Expected character encoding the application must use

	# SPRING SOCIAL ({sc-spring-boot-autoconfigure}/social/SocialWebAutoConfiguration.{sc-ext}[SocialWebAutoConfiguration])
	spring.social.auto-connection-views=true # Set to true for default connection views or false if you provide your own

	# SPRING SOCIAL FACEBOOK ({sc-spring-boot-autoconfigure}/social/FacebookAutoConfiguration.{sc-ext}[FacebookAutoConfiguration])
	spring.social.facebook.app-id= # your application's Facebook App ID
	spring.social.facebook.app-secret= # your application's Facebook App Secret

	# SPRING SOCIAL LINKEDIN ({sc-spring-boot-autoconfigure}/social/LinkedInAutoConfiguration.{sc-ext}[LinkedInAutoConfiguration])
	spring.social.linkedin.app-id= # your application's LinkedIn App ID
	spring.social.linkedin.app-secret= # your application's LinkedIn App Secret

	# SPRING SOCIAL TWITTER ({sc-spring-boot-autoconfigure}/social/TwitterAutoConfiguration.{sc-ext}[TwitterAutoConfiguration])
	spring.social.twitter.app-id= # your application's Twitter App ID
	spring.social.twitter.app-secret= # your application's Twitter App Secret

	# SPRING MOBILE SITE PREFERENCE ({sc-spring-boot-autoconfigure}/mobile/SitePreferenceAutoConfiguration.{sc-ext}[SitePreferenceAutoConfiguration])
	spring.mobile.sitepreference.enabled=true # enabled by default

	# SPRING MOBILE DEVICE VIEWS ({sc-spring-boot-autoconfigure}/mobile/DeviceDelegatingViewResolverAutoConfiguration.{sc-ext}[DeviceDelegatingViewResolverAutoConfiguration])
	spring.mobile.devicedelegatingviewresolver.enabled=true # disabled by default
	spring.mobile.devicedelegatingviewresolver.enable-fallback= # enable support for fallback resolution, default to false.
	spring.mobile.devicedelegatingviewresolver.normal-prefix=
	spring.mobile.devicedelegatingviewresolver.normal-suffix=
	spring.mobile.devicedelegatingviewresolver.mobile-prefix=mobile/
	spring.mobile.devicedelegatingviewresolver.mobile-suffix=
	spring.mobile.devicedelegatingviewresolver.tablet-prefix=tablet/
	spring.mobile.devicedelegatingviewresolver.tablet-suffix=

	# ----------------------------------------
	# DEVTOOLS PROPERTIES
	# ----------------------------------------

    # DEVTOOLS ({sc-spring-boot-devtools}/autoconfigure/DevToolsProperties.{sc-ext}[DevToolsProperties])
    spring.devtools.restart.additional-paths= # additional paths to watch for changes
    spring.devtools.restart.enabled=true # enable automatic restart
    spring.devtools.restart.exclude= # patterns that should be excluded from triggering a full restart
    spring.devtools.restart.additional-exclude= # additional patterns that should be excluded from triggering a full restart
    spring.devtools.restart.poll-interval= # amount of time (in milliseconds) to wait between polling for classpath changes
    spring.devtools.restart.quiet-period= # amount of quiet time (in milliseconds) required without any classpath changes before a restart is triggered
    spring.devtools.restart.trigger-file= # name of a specific file that when changed will trigger the restart
	spring.devtools.livereload.enabled=true # enable a livereload.com compatible server
    spring.devtools.livereload.port=35729 # server port.

    # REMOTE DEVTOOLS ({sc-spring-boot-devtools}/autoconfigure/RemoteDevToolsProperties.{sc-ext}[RemoteDevToolsProperties])
    spring.devtools.remote.context-path=/.~~spring-boot!~ # context path used to handle the remote connection
    spring.devtools.remote.debug.enabled=true # enable remote debug support
    spring.devtools.remote.debug.local-port=8000 # local remote debug server port
    spring.devtools.remote.proxy.host= # the host of the proxy to use to connect to the remote application
    spring.devtools.remote.proxy.port= # the port of the proxy to use to connect to the remote application
    spring.devtools.remote.restart.enabled=true # enable remote restart
    spring.devtools.remote.secret= # a shared secret required to establish a connection
    spring.devtools.remote.secret-header-name=X-AUTH-TOKEN # HTTP header used to transfer the shared secret

	# ----------------------------------------
	# ACTUATOR PROPERTIES
	# ----------------------------------------

	# MANAGEMENT HTTP SERVER ({sc-spring-boot-actuator}/autoconfigure/ManagementServerProperties.{sc-ext}[ManagementServerProperties])
	management.port= # defaults to 'server.port'
	management.address= # bind to a specific NIC
	management.context-path= # default to '/'
	management.add-application-context-header= # default to true
	management.security.enabled=true # enable security
	management.security.role=ADMIN # role required to access the management endpoint
	management.security.sessions=stateless # session creating policy to use (always, never, if_required, stateless)

	# PID FILE ({sc-spring-boot-actuator}/system/ApplicationPidFileWriter.{sc-ext}[ApplicationPidFileWriter])
	spring.pid.file= # Location of the PID file to write
	spring.pid.fail-on-write-error= # Fail if the PID file cannot be written

	# ENDPOINTS ({sc-spring-boot-actuator}/endpoint/AbstractEndpoint.{sc-ext}[AbstractEndpoint] subclasses)
	endpoints.autoconfig.id=autoconfig
	endpoints.autoconfig.sensitive=true
	endpoints.autoconfig.enabled=true
	endpoints.beans.id=beans
	endpoints.beans.sensitive=true
	endpoints.beans.enabled=true
	endpoints.configprops.id=configprops
	endpoints.configprops.sensitive=true
	endpoints.configprops.enabled=true
	endpoints.configprops.keys-to-sanitize=password,secret,key,.*credentials.*,vcap_services # suffix or regex
	endpoints.dump.id=dump
	endpoints.dump.sensitive=true
	endpoints.dump.enabled=true
	endpoints.enabled=true # enable all endpoints
	endpoints.env.id=env
	endpoints.env.sensitive=true
	endpoints.env.enabled=true
	endpoints.env.keys-to-sanitize=password,secret,key,.*credentials.*,vcap_services # suffix or regex
	endpoints.health.id=health
	endpoints.health.sensitive=true
	endpoints.health.enabled=true
	endpoints.health.mapping.*= # mapping of health statuses to HttpStatus codes
	endpoints.health.time-to-live=1000
	endpoints.info.id=info
	endpoints.info.sensitive=false
	endpoints.info.enabled=true
	endpoints.logfile.path=/logfile
	endpoints.logfile.sensitive=true
	endpoints.logfile.enabled=true
	endpoints.mappings.enabled=true
	endpoints.mappings.id=mappings
	endpoints.mappings.sensitive=true
	endpoints.metrics.id=metrics
	endpoints.metrics.sensitive=true
	endpoints.metrics.enabled=true
	endpoints.shutdown.id=shutdown
	endpoints.shutdown.sensitive=true
	endpoints.shutdown.enabled=false
	endpoints.trace.id=trace
	endpoints.trace.sensitive=true
	endpoints.trace.enabled=true

	# HYPERMEDIA ENDPOINTS
	endpoints.actuator.enabled=true
	endpoints.actuator.path=/actuator
	endpoints.actuator.sensitive=false
	endpoints.docs.curies.enabled=false
	endpoints.docs.enabled=true
	endpoints.docs.path=/docs
	endpoints.docs.sensitive=false
	endpoints.flyway.enabled=true
	endpoints.flyway.id=flyway
	endpoints.flyway.sensitive=true
	endpoints.liquibase.enabled=true
	endpoints.liquibase.id=liquibase
	endpoints.liquibase.sensitive=false

	# ENDPOINTS CORS CONFIGURATION ({sc-spring-boot-actuator}/autoconfigure/MvcEndpointCorsProperties.{sc-ext}[MvcEndpointCorsProperties])
	endpoints.cors.allow-credentials= # set whether user credentials are support. When not set, credentials are not supported.
	endpoints.cors.allowed-origins= # comma-separated list of origins to allow. * allows all origins. When not set, CORS support is disabled.
	endpoints.cors.allowed-methods= # comma-separated list of methods to allow. * allows all methods. When not set, defaults to GET.
	endpoints.cors.allowed-headers= # comma-separated list of headers to allow in a request. * allows all headers.
	endpoints.cors.exposed-headers= # comma-separated list of headers to include in a response.
	endpoints.cors.max-age=1800 # how long, in seconds, the response from a pre-flight request can be cached by clients.

	# HEALTH INDICATORS (previously health.*)
	management.health.db.enabled=true
	management.health.defaults.enabled=true # enable default health indicators
	management.health.diskspace.enabled=true
	management.health.diskspace.path=.
	management.health.diskspace.threshold=10485760
	management.health.elasticsearch.enabled=true
	management.health.elasticsearch.indices=  # comma-separated index names
	management.health.elasticsearch.response-timeout=100 # the time, in milliseconds, to wait for a response from the cluster
	management.health.jms.enabled=true
	management.health.mail.enabled=true
	management.health.mongo.enabled=true
	management.health.rabbit.enabled=true
	management.health.redis.enabled=true
	management.health.solr.enabled=true
	management.health.status.order=DOWN, OUT_OF_SERVICE, UNKNOWN, UP

	# MVC ONLY ENDPOINTS
	endpoints.jolokia.path=/jolokia
	endpoints.jolokia.sensitive=true
	endpoints.jolokia.enabled=true # when using Jolokia

	# JMX ENDPOINT ({sc-spring-boot-actuator}/autoconfigure/EndpointMBeanExportProperties.{sc-ext}[EndpointMBeanExportProperties])
	endpoints.jmx.enabled=true # enable JMX export of all endpoints
	endpoints.jmx.domain= # the JMX domain, defaults to 'org.springboot'
	endpoints.jmx.unique-names=false
	endpoints.jmx.static-names=

	# JOLOKIA ({sc-spring-boot-actuator}/autoconfigure/JolokiaProperties.{sc-ext}[JolokiaProperties])
	jolokia.config.*= # See Jolokia manual

	# REMOTE SHELL
	shell.auth=simple # jaas, key, simple, spring
	shell.command-refresh-interval=-1
	shell.command-path-patterns= # classpath*:/commands/**, classpath*:/crash/commands/**
	shell.config-path-patterns= # classpath*:/crash/*
	shell.disabled-commands=jpa*,jdbc*,jndi* # comma-separated list of commands to disable
	shell.disabled-plugins=false # don't expose plugins
	shell.ssh.enabled= # ssh settings ...
	shell.ssh.key-path=
	shell.ssh.port=
	shell.telnet.enabled= # telnet settings ...
	shell.telnet.port=
	shell.auth.jaas.domain= # authentication settings ...
	shell.auth.key.path=
	shell.auth.simple.user.name=
	shell.auth.simple.user.password=
	shell.auth.spring.roles=

	# METRICS EXPORT ({sc-spring-boot-actuator}/metrics/export/MetricExportProperties.{sc-ext}[MetricExportProperties])
	spring.metrics.export.aggregate.key-pattern= # pattern that tells the aggregator what to do with the keys from the source repository
	spring.metrics.export.aggregate.prefix= # prefix for global repository if active
	spring.metrics.export.enabled=true # flag to disable all metric exports (assuming any MetricWriters are available)
	spring.metrics.export.delay-millis=5000 # delay in milliseconds between export ticks
	spring.metrics.export.send-latest=true # flag to switch off any available optimizations based on not exporting unchanged metric values
	spring.metrics.export.includes= # list of patterns for metric names to include
	spring.metrics.export.excludes= # list of patterns for metric names to exclude. Applied after the includes
	spring.metrics.export.redis.prefix=spring.metrics # prefix for redis repository if active
	spring.metrics.export.redis.key=keys.spring.metrics # key for redis repository export (if active)
	spring.metrics.export.statsd.host= # host of the statsd server
	spring.metrics.export.statsd.port=8125 # port of the statsd server
	spring.metrics.export.statsd.prefix= # prefix for exported metrics
	spring.metrics.export.triggers.*= # specific trigger properties per MetricWriter bean name

	# SENDGRID ({sc-spring-boot-autoconfigure}/sendgrid/SendGridAutoConfiguration.{sc-ext}[SendGridAutoConfiguration])
	spring.sendgrid.username= # SendGrid account username
	spring.sendgrid.password= # SendGrid account password
	spring.sendgrid.proxy.host= # SendGrid proxy host
	spring.sendgrid.proxy.port= # SendGrid proxy port

	# GIT INFO
	spring.git.properties= # resource ref to generated git info properties file
----
