[camel] branch master updated: Regen

[davsclaus]

This is an automated email from the ASF dual-hosted git repository.

davsclaus pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/camel.git


The following commit(s) were added to refs/heads/master by this push:
     new cc105f9  Regen
cc105f9 is described below

commit cc105f95aba076fab44db18ed267662e05a9c696
Author: Claus Ibsen <claus.ib...@gmail.com>
AuthorDate: Tue Feb 5 06:13:52 2019 +0100

    Regen
---
 components/readme.adoc                             |  51 +++-
 docs/components/modules/ROOT/nav.adoc              |   1 +
 .../modules/ROOT/pages/activemq-component.adoc     | 326 +++++++++++++++++++++
 3 files changed, 374 insertions(+), 4 deletions(-)

diff --git a/components/readme.adoc b/components/readme.adoc
index e551b0e..ec1a2a4 100644
--- a/components/readme.adoc
+++ b/components/readme.adoc
@@ -1,14 +1,14 @@
 ==== Components
 
 // components: START
-Number of Components: 284 in 209 JAR artifacts (0 deprecated)
+Number of Components: 289 in 210 JAR artifacts (0 deprecated)
 
 [width="100%",cols="4,1,5",options="header"]
 |===
 | Component | Available From | Description
 
 | link:camel-activemq/src/main/docs/activemq-component.adoc[ActiveMQ] 
(camel-activemq) +
-`activemq:destinationType:destinationName` |  | The activemq component allows 
messages to be sent to (or consumed from) Apache ActiveMQ.
+`activemq:destinationType:destinationName` |  | The activemq component allows 
messages to be sent to (or consumed from) Apache ActiveMQ. This component 
extends the Camel JMS component.
 
 | link:camel-ahc/src/main/docs/ahc-component.adoc[AHC] (camel-ahc) +
 `ahc:httpUri` | 2.8 | To call external HTTP services using Async Http Client.
@@ -121,6 +121,9 @@ Number of Components: 284 in 209 JAR artifacts (0 
deprecated)
 | link:camel-azure/src/main/docs/azure-queue-component.adoc[Azure Storage 
Queue Service] (camel-azure) +
 `azure-queue:containerAndQueueUri` | 2.19 | The azure-queue component is used 
for storing and retrieving messages from Azure Storage Queue Service.
 
+| link:../camel-core/src/main/docs/bean-component.adoc[Bean] (camel-core) +
+`bean:beanName` | 1.0 | The bean component is for invoking Java beans from 
Camel.
+
 | link:camel-bean-validator/src/main/docs/bean-validator-component.adoc[Bean 
Validator] (camel-bean-validator) +
 `bean-validator:label` | 2.3 | The Validator component performs bean 
validation of the message body using the Java Bean Validation API.
 
@@ -151,6 +154,9 @@ Number of Components: 284 in 209 JAR artifacts (0 
deprecated)
 | link:camel-chunk/src/main/docs/chunk-component.adoc[Chunk] (camel-chunk) +
 `chunk:resourceUri` | 2.15 | Transforms the message using a Chunk template.
 
+| link:../camel-core/src/main/docs/class-component.adoc[Class] (camel-core) +
+`class:beanName` | 2.4 | The Class Component is for invoking Java Classes 
(Java beans) from Camel.
+
 | link:camel-cm-sms/src/main/docs/cm-sms-component.adoc[CM SMS Gateway] 
(camel-cm-sms) +
 `cm-sms:host` | 2.18 | The cm-sms component allows to integrate with CM SMS 
Gateway.
 
@@ -193,6 +199,9 @@ Number of Components: 284 in 209 JAR artifacts (0 
deprecated)
 | link:camel-dataformat/src/main/docs/dataformat-component.adoc[Data Format] 
(camel-dataformat) +
 `dataformat:name:operation` | 2.12 | The dataformat component is used for 
working with Data Formats as if it was a regular Component supporting Endpoints 
and URIs.
 
+| link:../camel-core/src/main/docs/dataset-component.adoc[Dataset] 
(camel-core) +
+`dataset:name` | 1.3 | The dataset component provides a mechanism to easily 
perform load & soak testing of your system.
+
 | 
link:camel-digitalocean/src/main/docs/digitalocean-component.adoc[DigitalOcean] 
(camel-digitalocean) +
 `digitalocean:operation` | 2.19 | The DigitalOcean component allows you to 
manage Droplets and resources within the DigitalOcean cloud.
 
@@ -541,6 +550,9 @@ Number of Components: 284 in 209 JAR artifacts (0 
deprecated)
 | link:camel-mllp/src/main/docs/mllp-component.adoc[MLLP] (camel-mllp) +
 `mllp:hostname:port` | 2.17 | Provides functionality required by Healthcare 
providers to communicate with other systems using the MLLP protocol.
 
+| link:../camel-core/src/main/docs/mock-component.adoc[Mock] (camel-core) +
+`mock:name` | 1.0 | The mock component is used for testing routes and 
mediation rules using mocks.
+
 | link:camel-mongodb3/src/main/docs/mongodb3-component.adoc[MongoDB] 
(camel-mongodb3) +
 `mongodb3:connectionBean` | 2.19 | Component for working with documents stored 
in MongoDB database.
 
@@ -784,6 +796,9 @@ Number of Components: 284 in 209 JAR artifacts (0 
deprecated)
 | link:camel-telegram/src/main/docs/telegram-component.adoc[Telegram] 
(camel-telegram) +
 `telegram:type/authorizationToken` | 2.18 | The telegram component provides 
access to the Telegram Bot API.
 
+| link:../camel-core/src/main/docs/test-component.adoc[Test] (camel-core) +
+`test:name` | 1.3 | The test component extends the mock component by on 
startup to pull messages from another endpoint to set the expected message 
bodies.
+
 | link:camel-thrift/src/main/docs/thrift-component.adoc[Thrift] (camel-thrift) 
+
 `thrift:host:port/service` | 2.20 | The Thrift component allows to call and 
expose remote procedures (RPC) with Apache Thrift data format and serialization 
mechanism
 
@@ -866,7 +881,7 @@ Number of Components: 284 in 209 JAR artifacts (0 
deprecated)
 ==== Data Formats
 
 // dataformats: START
-Number of Data Formats: 41 in 34 JAR artifacts (0 deprecated)
+Number of Data Formats: 45 in 35 JAR artifacts (0 deprecated)
 
 [width="100%",cols="4,1,5",options="header"]
 |===
@@ -900,12 +915,16 @@ Number of Data Formats: 41 in 34 JAR artifacts (0 
deprecated)
 
 | link:camel-flatpack/src/main/docs/flatpack-dataformat.adoc[Flatpack] 
(camel-flatpack) | 2.1 | The Flatpack data format is used for working with flat 
payloads (such as CSV, delimited, or fixed length formats).
 
+| link:../camel-core/src/main/docs/gzip-dataformat.adoc[GZip] (camel-core) | 
2.0 | The GZip data format is a message compression and de-compression format 
(which works with the popular gzip/gunzip tools).
+
 | link:camel-hl7/src/main/docs/hl7-dataformat.adoc[HL7] (camel-hl7) | 2.0 | 
The HL7 data format can be used to marshal or unmarshal HL7 (Health Care) model 
objects.
 
 | link:camel-ical/src/main/docs/ical-dataformat.adoc[iCal] (camel-ical) | 2.12 
| The iCal dataformat is used for working with iCalendar messages.
 
 | link:camel-jacksonxml/src/main/docs/jacksonxml-dataformat.adoc[JacksonXML] 
(camel-jacksonxml) | 2.16 | JacksonXML data format is used for unmarshal a XML 
payload to POJO or to marshal POJO back to XML payload.
 
+| link:../camel-core/src/main/docs/serialization-dataformat.adoc[Java Object 
Serialization] (camel-core) | 2.12 | Serialization is a data format which uses 
the standard Java Serialization mechanism to unmarshal a binary payload into 
Java objects or to marshal Java objects into a binary blob.
+
 | link:camel-jaxb/src/main/docs/jaxb-dataformat.adoc[JAXB] (camel-jaxb) | 1.0 
| JAXB data format uses the JAXB2 XML marshalling standard to unmarshal an XML 
payload into Java objects or to marshal Java objects into an XML payload.
 
 | link:camel-jibx/src/main/docs/jibx-dataformat.adoc[JiBX] (camel-jibx) | 2.6 
| JiBX data format is used for unmarshal a XML payload to POJO or to marshal 
POJO back to XML payload.
@@ -932,6 +951,8 @@ Number of Data Formats: 41 in 34 JAR artifacts (0 
deprecated)
 
 | link:camel-soap/src/main/docs/soapjaxb-dataformat.adoc[SOAP] (camel-soap) | 
2.3 | SOAP is a data format which uses JAXB2 and JAX-WS annotations to marshal 
and unmarshal SOAP payloads.
 
+| link:../camel-core/src/main/docs/string-dataformat.adoc[String Encoding] 
(camel-core) | 2.12 | String data format is a textual based format that 
supports character encoding.
+
 | link:camel-syslog/src/main/docs/syslog-dataformat.adoc[Syslog] 
(camel-syslog) | 2.6 | The Syslog dataformat is used for working with RFC3164 
and RFC5424 messages (logging and monitoring).
 
 | link:camel-tarfile/src/main/docs/tarfile-dataformat.adoc[Tar File] 
(camel-tarfile) | 2.16 | The Tar File data format is a message compression and 
de-compression format of tar files.
@@ -952,6 +973,8 @@ Number of Data Formats: 41 in 34 JAR artifacts (0 
deprecated)
 
 | link:camel-snakeyaml/src/main/docs/yaml-snakeyaml-dataformat.adoc[YAML 
SnakeYAML] (camel-snakeyaml) | 2.17 | YAML is a data format to marshal and 
unmarshal Java objects to and from YAML.
 
+| link:../camel-core/src/main/docs/zip-dataformat.adoc[Zip Deflate 
Compression] (camel-core) | 2.12 | Zip Deflate Compression data format is a 
message compression and de-compression format (not zip files).
+
 | link:camel-zipfile/src/main/docs/zipfile-dataformat.adoc[Zip File] 
(camel-zipfile) | 2.11 | The Zip File data format is a message compression and 
de-compression format of zip files.
 |===
 // dataformats: END
@@ -960,14 +983,24 @@ Number of Data Formats: 41 in 34 JAR artifacts (0 
deprecated)
 ==== Expression Languages
 
 // languages: START
-Number of Languages: 8 in 8 JAR artifacts (1 deprecated)
+Number of Languages: 18 in 9 JAR artifacts (1 deprecated)
 
 [width="100%",cols="4,1,5",options="header"]
 |===
 | Language | Available From | Description
 
+| link:../camel-core/src/main/docs/bean-language.adoc[Bean method] 
(camel-core) | 1.3 | To use a Java bean (aka method call) in Camel expressions 
or predicates.
+
+| link:../camel-core/src/main/docs/constant-language.adoc[Constant] 
(camel-core) | 1.5 | To use a constant value in Camel expressions or predicates.
+
+| 
link:../camel-core/src/main/docs/exchangeProperty-language.adoc[ExchangeProperty]
 (camel-core) | 2.0 | To use a Camel Exchange property in expressions or 
predicates.
+
+| link:../camel-core/src/main/docs/file-language.adoc[File] (camel-core) | 1.1 
| For expressions and predicates using the file/simple language
+
 | link:camel-groovy/src/main/docs/groovy-language.adoc[Groovy] (camel-groovy) 
| 1.3 | To use Groovy scripts in Camel expressions or predicates.
 
+| link:../camel-core/src/main/docs/header-language.adoc[Header] (camel-core) | 
1.5 | To use a Camel Message header in expressions or predicates.
+
 | link:camel-hl7/src/main/docs/terser-language.adoc[HL7 Terser] (camel-hl7) | 
2.11 | To use HL7 terser scripts in Camel expressions or predicates.
 
 | link:camel-script/src/main/docs/javaScript-language.adoc[JavaScript] 
(camel-script) | 1.0 | *deprecated* To use JavaScript in Camel expressions or 
predicates.
@@ -978,8 +1011,18 @@ Number of Languages: 8 in 8 JAR artifacts (1 deprecated)
 
 | link:camel-ognl/src/main/docs/ognl-language.adoc[OGNL] (camel-ognl) | 1.1 | 
To use OGNL scripts in Camel expressions or predicates.
 
+| link:../camel-core/src/main/docs/ref-language.adoc[Ref] (camel-core) | 2.8 | 
Reference to an existing Camel expression or predicate, which is looked up from 
the Camel registry.
+
+| link:../camel-core/src/main/docs/simple-language.adoc[Simple] (camel-core) | 
1.1 | To use Camels built-in Simple language in Camel expressions or predicates.
+
 | link:camel-spring/src/main/docs/spel-language.adoc[SpEL] (camel-spring) | 
2.7 | To use Spring Expression Language (SpEL) in Camel expressions or 
predicates.
 
+| link:../camel-core/src/main/docs/tokenize-language.adoc[Tokenize] 
(camel-core) | 2.0 | To use Camel message body or header with a tokenizer in 
Camel expressions or predicates.
+
+| link:../camel-core/src/main/docs/xtokenize-language.adoc[XML Tokenize] 
(camel-core) | 2.14 | To use Camel message body or header with a XML tokenizer 
in Camel expressions or predicates.
+
+| link:../camel-core/src/main/docs/xpath-language.adoc[XPath] (camel-core) | 
1.1 | To use XPath (XML) in Camel expressions or predicates.
+
 | link:camel-saxon/src/main/docs/xquery-language.adoc[XQuery] (camel-saxon) | 
1.0 | To use XQuery (XML) in Camel expressions or predicates.
 |===
 // languages: END
diff --git a/docs/components/modules/ROOT/nav.adoc 
b/docs/components/modules/ROOT/nav.adoc
index cb098d6..8c52671 100644
--- a/docs/components/modules/ROOT/nav.adoc
+++ b/docs/components/modules/ROOT/nav.adoc
@@ -1,3 +1,4 @@
+* xref:activemq-component.adoc[ActiveMQ Component]
 * xref:ahc-ws-component.adoc[AHC Websocket Component]
 * xref:ahc-component.adoc[AHC Component]
 * xref:amqp-component.adoc[AMQP Component]
diff --git a/docs/components/modules/ROOT/pages/activemq-component.adoc 
b/docs/components/modules/ROOT/pages/activemq-component.adoc
new file mode 100644
index 0000000..3f92026
--- /dev/null
+++ b/docs/components/modules/ROOT/pages/activemq-component.adoc
@@ -0,0 +1,326 @@
+[[activemq-component]]
+== ActiveMQ Component
+
+*Available as of Camel version *
+
+
+#### Component options
+
+// component options: START
+The ActiveMQ component supports 85 options, which are listed below.
+
+
+
+[width="100%",cols="2,5,^1,2",options="header"]
+|===
+| Name | Description | Default | Type
+| *brokerURL* (common) | Sets the broker URL to use to connect to ActiveMQ 
using the ActiveMQ URI format |  | String
+| *trustAllPackages* (common) | Define if all packages are trusted or not | 
false | boolean
+| *exposeAllQueues* (common) | If enabled this will cause all Queues in the 
ActiveMQ broker to be eagerly populated into the CamelContext so that they can 
be easily browsed by any Camel tooling. This option is disabled by default. | 
false | boolean
+| *usePooledConnection* (common) | Enables or disables whether a 
PooledConnectionFactory will be used so that when messages are sent to ActiveMQ 
from outside of a message consuming thread, pooling will be used rather than 
the default with the Spring JmsTemplate which will create a new connection, 
session, producer for each message then close them all down again. The default 
value is true. Note that this requires an extra dependency on commons-pool2. | 
false | boolean
+| *useSingleConnection* (common) | Enables or disables whether a Spring 
SingleConnectionFactory will be used so that when messages are sent to ActiveMQ 
from outside of a message consuming thread, pooling will be used rather than 
the default with the Spring JmsTemplate which will create a new connection, 
session, producer for each message then close them all down again. The default 
value is false and a pooled connection is used by default. | false | boolean
+| *configuration* (common) | Configuration of ActiveMQ |  | JmsConfiguration
+| *acceptMessagesWhile Stopping* (consumer) | Specifies whether the consumer 
accept messages while it is stopping. You may consider enabling this option, if 
you start and stop JMS routes at runtime, while there are still messages 
enqueued on the queue. If this option is false, and you stop the JMS route, 
then messages may be rejected, and the JMS broker would have to attempt 
redeliveries, which yet again may be rejected, and eventually the message may 
be moved at a dead letter queue on t [...]
+| *allowReplyManagerQuick Stop* (consumer) | Whether the 
DefaultMessageListenerContainer used in the reply managers for request-reply 
messaging allow the DefaultMessageListenerContainer.runningAllowed flag to 
quick stop in case JmsConfiguration#isAcceptMessagesWhileStopping is enabled, 
and org.apache.camel.CamelContext is currently being stopped. This quick stop 
ability is enabled by default in the regular JMS consumers but to enable for 
reply managers you must enable this flag. | false  [...]
+| *acknowledgementMode* (consumer) | The JMS acknowledgement mode defined as 
an Integer. Allows you to set vendor-specific extensions to the acknowledgment 
mode. For the regular modes, it is preferable to use the 
acknowledgementModeName instead. |  | int
+| *eagerLoadingOf Properties* (consumer) | Enables eager loading of JMS 
properties as soon as a message is loaded which generally is inefficient as the 
JMS properties may not be required but sometimes can catch early any issues 
with the underlying JMS provider and the use of JMS properties | false | boolean
+| *acknowledgementModeName* (consumer) | The JMS acknowledgement name, which 
is one of: SESSION_TRANSACTED, CLIENT_ACKNOWLEDGE, AUTO_ACKNOWLEDGE, 
DUPS_OK_ACKNOWLEDGE | AUTO_ ACKNOWLEDGE | String
+| *autoStartup* (consumer) | Specifies whether the consumer container should 
auto-startup. | true | boolean
+| *cacheLevel* (consumer) | Sets the cache level by ID for the underlying JMS 
resources. See cacheLevelName option for more details. |  | int
+| *cacheLevelName* (consumer) | Sets the cache level by name for the 
underlying JMS resources. Possible values are: CACHE_AUTO, CACHE_CONNECTION, 
CACHE_CONSUMER, CACHE_NONE, and CACHE_SESSION. The default setting is 
CACHE_AUTO. See the Spring documentation and Transactions Cache Levels for more 
information. | CACHE_AUTO | String
+| *replyToCacheLevelName* (producer) | Sets the cache level by name for the 
reply consumer when doing request/reply over JMS. This option only applies when 
using fixed reply queues (not temporary). Camel will by default use: 
CACHE_CONSUMER for exclusive or shared w/ replyToSelectorName. And 
CACHE_SESSION for shared without replyToSelectorName. Some JMS brokers such as 
IBM WebSphere may require to set the replyToCacheLevelName=CACHE_NONE to work. 
Note: If using temporary queues then CACHE [...]
+| *clientId* (common) | Sets the JMS client ID to use. Note that this value, 
if specified, must be unique and can only be used by a single JMS connection 
instance. It is typically only required for durable topic subscriptions. If 
using Apache ActiveMQ you may prefer to use Virtual Topics instead. |  | String
+| *concurrentConsumers* (consumer) | Specifies the default number of 
concurrent consumers when consuming from JMS (not for request/reply over JMS). 
See also the maxMessagesPerTask option to control dynamic scaling up/down of 
threads. When doing request/reply over JMS then the option 
replyToConcurrentConsumers is used to control number of concurrent consumers on 
the reply message listener. | 1 | int
+| *replyToConcurrent Consumers* (producer) | Specifies the default number of 
concurrent consumers when doing request/reply over JMS. See also the 
maxMessagesPerTask option to control dynamic scaling up/down of threads. | 1 | 
int
+| *connectionFactory* (common) | The connection factory to be use. A 
connection factory must be configured either on the component or endpoint. |  | 
ConnectionFactory
+| *username* (security) | Username to use with the ConnectionFactory. You can 
also configure username/password directly on the ConnectionFactory. |  | String
+| *password* (security) | Password to use with the ConnectionFactory. You can 
also configure username/password directly on the ConnectionFactory. |  | String
+| *deliveryPersistent* (producer) | Specifies whether persistent delivery is 
used by default. | true | boolean
+| *deliveryMode* (producer) | Specifies the delivery mode to be used. 
Possibles values are those defined by javax.jms.DeliveryMode. NON_PERSISTENT = 
1 and PERSISTENT = 2. |  | Integer
+| *durableSubscriptionName* (common) | The durable subscriber name for 
specifying durable topic subscriptions. The clientId option must be configured 
as well. |  | String
+| *exceptionListener* (advanced) | Specifies the JMS Exception Listener that 
is to be notified of any underlying JMS exceptions. |  | ExceptionListener
+| *errorHandler* (advanced) | Specifies a 
org.springframework.util.ErrorHandler to be invoked in case of any uncaught 
exceptions thrown while processing a Message. By default these exceptions will 
be logged at the WARN level, if no errorHandler has been configured. You can 
configure logging level and whether stack traces should be logged using 
errorHandlerLoggingLevel and errorHandlerLogStackTrace options. This makes it 
much easier to configure, than having to code a custom errorHandler. [...]
+| *errorHandlerLogging Level* (logging) | Allows to configure the default 
errorHandler logging level for logging uncaught exceptions. | WARN | 
LoggingLevel
+| *errorHandlerLogStack Trace* (logging) | Allows to control whether 
stacktraces should be logged or not, by the default errorHandler. | true | 
boolean
+| *explicitQosEnabled* (producer) | Set if the deliveryMode, priority or 
timeToLive qualities of service should be used when sending messages. This 
option is based on Spring's JmsTemplate. The deliveryMode, priority and 
timeToLive options are applied to the current endpoint. This contrasts with the 
preserveMessageQos option, which operates at message granularity, reading QoS 
properties exclusively from the Camel In message headers. | false | boolean
+| *exposeListenerSession* (consumer) | Specifies whether the listener session 
should be exposed when consuming messages. | false | boolean
+| *idleTaskExecutionLimit* (advanced) | Specifies the limit for idle 
executions of a receive task, not having received any message within its 
execution. If this limit is reached, the task will shut down and leave 
receiving to other executing tasks (in the case of dynamic scheduling; see the 
maxConcurrentConsumers setting). There is additional doc available from Spring. 
| 1 | int
+| *idleConsumerLimit* (advanced) | Specify the limit for the number of 
consumers that are allowed to be idle at any given time. | 1 | int
+| *maxConcurrentConsumers* (consumer) | Specifies the maximum number of 
concurrent consumers when consuming from JMS (not for request/reply over JMS). 
See also the maxMessagesPerTask option to control dynamic scaling up/down of 
threads. When doing request/reply over JMS then the option 
replyToMaxConcurrentConsumers is used to control number of concurrent consumers 
on the reply message listener. |  | int
+| *replyToMaxConcurrent Consumers* (producer) | Specifies the maximum number 
of concurrent consumers when using request/reply over JMS. See also the 
maxMessagesPerTask option to control dynamic scaling up/down of threads. |  | 
int
+| *replyOnTimeoutToMax ConcurrentConsumers* (producer) | Specifies the maximum 
number of concurrent consumers for continue routing when timeout occurred when 
using request/reply over JMS. | 1 | int
+| *maxMessagesPerTask* (advanced) | The number of messages per task. -1 is 
unlimited. If you use a range for concurrent consumers (eg min max), then this 
option can be used to set a value to eg 100 to control how fast the consumers 
will shrink when less work is required. | -1 | int
+| *messageConverter* (advanced) | To use a custom Spring 
org.springframework.jms.support.converter.MessageConverter so you can be in 
control how to map to/from a javax.jms.Message. |  | MessageConverter
+| *mapJmsMessage* (advanced) | Specifies whether Camel should auto map the 
received JMS message to a suited payload type, such as javax.jms.TextMessage to 
a String etc. See section about how mapping works below for more details. | 
true | boolean
+| *messageIdEnabled* (advanced) | When sending, specifies whether message IDs 
should be added. This is just an hint to the JMS Broker. If the JMS provider 
accepts this hint, these messages must have the message ID set to null; if the 
provider ignores the hint, the message ID must be set to its normal unique 
value. | true | boolean
+| *messageTimestampEnabled* (advanced) | Specifies whether timestamps should 
be enabled by default on sending messages. This is just an hint to the JMS 
broker. If the JMS provider accepts this hint, these messages must have the 
timestamp set to zero; if the provider ignores the hint the timestamp must be 
set to its normal value. | true | boolean
+| *alwaysCopyMessage* (producer) | If true, Camel will always make a JMS 
message copy of the message when it is passed to the producer for sending. 
Copying the message is needed in some situations, such as when a 
replyToDestinationSelectorName is set (incidentally, Camel will set the 
alwaysCopyMessage option to true, if a replyToDestinationSelectorName is set). 
| false | boolean
+| *useMessageIDAs CorrelationID* (advanced) | Specifies whether JMSMessageID 
should always be used as JMSCorrelationID for InOut messages. | false | boolean
+| *priority* (producer) | Values greater than 1 specify the message priority 
when sending (where 0 is the lowest priority and 9 is the highest). The 
explicitQosEnabled option must also be enabled in order for this option to have 
any effect. | 4 | int
+| *pubSubNoLocal* (advanced) | Specifies whether to inhibit the delivery of 
messages published by its own connection. | false | boolean
+| *receiveTimeout* (advanced) | The timeout for receiving messages (in 
milliseconds). | 1000 | long
+| *recoveryInterval* (advanced) | Specifies the interval between recovery 
attempts, i.e. when a connection is being refreshed, in milliseconds. The 
default is 5000 ms, that is, 5 seconds. | 5000 | long
+| *taskExecutor* (consumer) | Allows you to specify a custom task executor for 
consuming messages. |  | TaskExecutor
+| *timeToLive* (producer) | When sending messages, specifies the time-to-live 
of the message (in milliseconds). | -1 | long
+| *transacted* (transaction) | Specifies whether to use transacted mode | 
false | boolean
+| *lazyCreateTransaction Manager* (transaction) | If true, Camel will create a 
JmsTransactionManager, if there is no transactionManager injected when option 
transacted=true. | true | boolean
+| *transactionManager* (transaction) | The Spring transaction manager to use. 
|  | PlatformTransaction Manager
+| *transactionName* (transaction) | The name of the transaction to use. |  | 
String
+| *transactionTimeout* (transaction) | The timeout value of the transaction 
(in seconds), if using transacted mode. | -1 | int
+| *testConnectionOn Startup* (common) | Specifies whether to test the 
connection on startup. This ensures that when Camel starts that all the JMS 
consumers have a valid connection to the JMS broker. If a connection cannot be 
granted then Camel throws an exception on startup. This ensures that Camel is 
not started with failed connections. The JMS producers is tested as well. | 
false | boolean
+| *asyncStartListener* (advanced) | Whether to startup the JmsConsumer message 
listener asynchronously, when starting a route. For example if a JmsConsumer 
cannot get a connection to a remote JMS broker, then it may block while 
retrying and/or failover. This will cause Camel to block while starting routes. 
By setting this option to true, you will let routes startup, while the 
JmsConsumer connects to the JMS broker using a dedicated thread in asynchronous 
mode. If this option is used, the [...]
+| *asyncStopListener* (advanced) | Whether to stop the JmsConsumer message 
listener asynchronously, when stopping a route. | false | boolean
+| *forceSendOriginal Message* (producer) | When using mapJmsMessage=false 
Camel will create a new JMS message to send to a new JMS destination if you 
touch the headers (get or set) during the route. Set this option to true to 
force Camel to send the original JMS message that was received. | false | 
boolean
+| *requestTimeout* (producer) | The timeout for waiting for a reply when using 
the InOut Exchange Pattern (in milliseconds). The default is 20 seconds. You 
can include the header CamelJmsRequestTimeout to override this endpoint 
configured timeout value, and thus have per message individual timeout values. 
See also the requestTimeoutCheckerInterval option. | 20000 | long
+| *requestTimeoutChecker Interval* (advanced) | Configures how often Camel 
should check for timed out Exchanges when doing request/reply over JMS. By 
default Camel checks once per second. But if you must react faster when a 
timeout occurs, then you can lower this interval, to check more frequently. The 
timeout is determined by the option requestTimeout. | 1000 | long
+| *transferExchange* (advanced) | You can transfer the exchange over the wire 
instead of just the body and headers. The following fields are transferred: In 
body, Out body, Fault body, In headers, Out headers, Fault headers, exchange 
properties, exchange exception. This requires that the objects are 
serializable. Camel will exclude any non-serializable objects and log it at 
WARN level. You must enable this option on both the producer and consumer side, 
so Camel knows the payloads is an E [...]
+| *transferException* (advanced) | If enabled and you are using Request Reply 
messaging (InOut) and an Exchange failed on the consumer side, then the caused 
Exception will be send back in response as a javax.jms.ObjectMessage. If the 
client is Camel, the returned Exception is rethrown. This allows you to use 
Camel JMS as a bridge in your routing - for example, using persistent queues to 
enable robust routing. Notice that if you also have transferExchange enabled, 
this option takes preced [...]
+| *transferFault* (advanced) | If enabled and you are using Request Reply 
messaging (InOut) and an Exchange failed with a SOAP fault (not exception) on 
the consumer side, then the fault flag on org.apache.camel.Message#isFault() 
will be send back in the response as a JMS header with the key 
JmsConstants#JMS_TRANSFER_FAULT. If the client is Camel, the returned fault 
flag will be set on the org.apache.camel.Message#setFault(boolean). You may 
want to enable this when using Camel components  [...]
+| *jmsOperations* (advanced) | Allows you to use your own implementation of 
the org.springframework.jms.core.JmsOperations interface. Camel uses 
JmsTemplate as default. Can be used for testing purpose, but not used much as 
stated in the spring API docs. |  | JmsOperations
+| *destinationResolver* (advanced) | A pluggable 
org.springframework.jms.support.destination.DestinationResolver that allows you 
to use your own resolver (for example, to lookup the real destination in a JNDI 
registry). |  | DestinationResolver
+| *replyToType* (producer) | Allows for explicitly specifying which kind of 
strategy to use for replyTo queues when doing request/reply over JMS. Possible 
values are: Temporary, Shared, or Exclusive. By default Camel will use 
temporary queues. However if replyTo has been configured, then Shared is used 
by default. This option allows you to use exclusive queues instead of shared 
ones. See Camel JMS documentation for more details, and especially the notes 
about the implications if running  [...]
+| *preserveMessageQos* (producer) | Set to true, if you want to send message 
using the QoS settings specified on the message, instead of the QoS settings on 
the JMS endpoint. The following three headers are considered JMSPriority, 
JMSDeliveryMode, and JMSExpiration. You can provide all or only some of them. 
If not provided, Camel will fall back to use the values from the endpoint 
instead. So, when using this option, the headers override the values from the 
endpoint. The explicitQosEnable [...]
+| *asyncConsumer* (consumer) | Whether the JmsConsumer processes the Exchange 
asynchronously. If enabled then the JmsConsumer may pickup the next message 
from the JMS queue, while the previous message is being processed 
asynchronously (by the Asynchronous Routing Engine). This means that messages 
may be processed not 100% strictly in order. If disabled (as default) then the 
Exchange is fully processed before the JmsConsumer will pickup the next message 
from the JMS queue. Note if transac [...]
+| *allowNullBody* (producer) | Whether to allow sending messages with no body. 
If this option is false and the message body is null, then an JMSException is 
thrown. | true | boolean
+| *includeSentJMS MessageID* (producer) | Only applicable when sending to JMS 
destination using InOnly (eg fire and forget). Enabling this option will enrich 
the Camel Exchange with the actual JMSMessageID that was used by the JMS client 
when the message was sent to the JMS destination. | false | boolean
+| *includeAllJMSX Properties* (advanced) | Whether to include all JMSXxxx 
properties when mapping from JMS to Camel Message. Setting this to true will 
include properties such as JMSXAppID, and JMSXUserID etc. Note: If you are 
using a custom headerFilterStrategy then this option does not apply. | false | 
boolean
+| *defaultTaskExecutor Type* (consumer) | Specifies what default TaskExecutor 
type to use in the DefaultMessageListenerContainer, for both consumer endpoints 
and the ReplyTo consumer of producer endpoints. Possible values: SimpleAsync 
(uses Spring's SimpleAsyncTaskExecutor) or ThreadPool (uses Spring's 
ThreadPoolTaskExecutor with optimal values - cached threadpool-like). If not 
set, it defaults to the previous behaviour, which uses a cached thread pool for 
consumer endpoints and SimpleAs [...]
+| *jmsKeyFormatStrategy* (advanced) | Pluggable strategy for encoding and 
decoding JMS keys so they can be compliant with the JMS specification. Camel 
provides two implementations out of the box: default and passthrough. The 
default strategy will safely marshal dots and hyphens (. and -). The 
passthrough strategy leaves the key as is. Can be used for JMS brokers which do 
not care whether JMS header keys contain illegal characters. You can provide 
your own implementation of the org.apache [...]
+| *allowAdditionalHeaders* (producer) | This option is used to allow 
additional headers which may have values that are invalid according to JMS 
specification. For example some message systems such as WMQ do this with header 
names using prefix JMS_IBM_MQMD_ containing values with byte array or other 
invalid types. You can specify multiple header names separated by comma, and 
use as suffix for wildcard matching. |  | String
+| *queueBrowseStrategy* (advanced) | To use a custom QueueBrowseStrategy when 
browsing queues |  | QueueBrowseStrategy
+| *messageCreatedStrategy* (advanced) | To use the given 
MessageCreatedStrategy which are invoked when Camel creates new instances of 
javax.jms.Message objects when Camel is sending a JMS message. |  | 
MessageCreatedStrategy
+| *waitForProvision CorrelationToBeUpdated Counter* (advanced) | Number of 
times to wait for provisional correlation id to be updated to the actual 
correlation id when doing request/reply over JMS and when the option 
useMessageIDAsCorrelationID is enabled. | 50 | int
+| *waitForProvision CorrelationToBeUpdated ThreadSleepingTime* (advanced) | 
Interval in millis to sleep each time while waiting for provisional correlation 
id to be updated. | 100 | long
+| *correlationProperty* (producer) | Use this JMS property to correlate 
messages in InOut exchange pattern (request-reply) instead of JMSCorrelationID 
property. This allows you to exchange messages with systems that do not 
correlate messages using JMSCorrelationID JMS property. If used 
JMSCorrelationID will not be used or set by Camel. The value of here named 
property will be generated if not supplied in the header of the message under 
the same name. |  | String
+| *subscriptionDurable* (consumer) | Set whether to make the subscription 
durable. The durable subscription name to be used can be specified through the 
subscriptionName property. Default is false. Set this to true to register a 
durable subscription, typically in combination with a subscriptionName value 
(unless your message listener class name is good enough as subscription name). 
Only makes sense when listening to a topic (pub-sub domain), therefore this 
method switches the pubSubDomai [...]
+| *subscriptionShared* (consumer) | Set whether to make the subscription 
shared. The shared subscription name to be used can be specified through the 
subscriptionName property. Default is false. Set this to true to register a 
shared subscription, typically in combination with a subscriptionName value 
(unless your message listener class name is good enough as subscription name). 
Note that shared subscriptions may also be durable, so this flag can (and often 
will) be combined with subscrip [...]
+| *subscriptionName* (consumer) | Set the name of a subscription to create. To 
be applied in case of a topic (pub-sub domain) with a shared or durable 
subscription. The subscription name needs to be unique within this client's JMS 
client id. Default is the class name of the specified message listener. Note: 
Only 1 concurrent consumer (which is the default of this message listener 
container) is allowed for each subscription, except for a shared subscription 
(which requires JMS 2.0). |  | String
+| *streamMessageType Enabled* (producer) | Sets whether StreamMessage type is 
enabled or not. Message payloads of streaming kind such as files, InputStream, 
etc will either by sent as BytesMessage or StreamMessage. This option controls 
which kind will be used. By default BytesMessage is used which enforces the 
entire message payload to be read into memory. By enabling this option the 
message payload is read into memory in chunks and each chunk is then written to 
the StreamMessage until n [...]
+| *formatDateHeadersTo Iso8601* (producer) | Sets whether date headers should 
be formatted according to the ISO 8601 standard. | false | boolean
+| *headerFilterStrategy* (filter) | To use a custom 
org.apache.camel.spi.HeaderFilterStrategy to filter header to and from Camel 
message. |  | HeaderFilterStrategy
+| *resolveProperty Placeholders* (advanced) | Whether the component should 
resolve property placeholders on itself when starting. Only properties which 
are of String type can use property placeholders. | true | boolean
+|===
+// component options: END
+
+#### Endpoint options
+
+
+// endpoint options: START
+The ActiveMQ endpoint is configured using URI syntax:
+
+----
+activemq:destinationType:destinationName
+----
+
+with the following path and query parameters:
+
+==== Path Parameters (2 parameters):
+
+
+[width="100%",cols="2,5,^1,2",options="header"]
+|===
+| Name | Description | Default | Type
+| *destinationType* | The kind of destination to use | queue | String
+| *destinationName* | *Required* Name of the queue or topic to use as 
destination |  | String
+|===
+
+
+==== Query Parameters (91 parameters):
+
+
+[width="100%",cols="2,5,^1,2",options="header"]
+|===
+| Name | Description | Default | Type
+| *clientId* (common) | Sets the JMS client ID to use. Note that this value, 
if specified, must be unique and can only be used by a single JMS connection 
instance. It is typically only required for durable topic subscriptions. If 
using Apache ActiveMQ you may prefer to use Virtual Topics instead. |  | String
+| *connectionFactory* (common) | Sets the default connection factory to be 
used if a connection factory is not specified for either 
setTemplateConnectionFactory(ConnectionFactory) or 
setListenerConnectionFactory(ConnectionFactory) |  | ConnectionFactory
+| *disableReplyTo* (common) | Specifies whether Camel ignores the JMSReplyTo 
header in messages. If true, Camel does not send a reply back to the 
destination specified in the JMSReplyTo header. You can use this option if you 
want Camel to consume from a route and you do not want Camel to automatically 
send back a reply message because another component in your code handles the 
reply message. You can also use this option if you want to use Camel as a proxy 
between different message broker [...]
+| *durableSubscriptionName* (common) | The durable subscriber name for 
specifying durable topic subscriptions. The clientId option must be configured 
as well. |  | String
+| *jmsMessageType* (common) | Allows you to force the use of a specific 
javax.jms.Message implementation for sending JMS messages. Possible values are: 
Bytes, Map, Object, Stream, Text. By default, Camel would determine which JMS 
message type to use from the In body type. This option allows you to specify 
it. |  | JmsMessageType
+| *testConnectionOnStartup* (common) | Specifies whether to test the 
connection on startup. This ensures that when Camel starts that all the JMS 
consumers have a valid connection to the JMS broker. If a connection cannot be 
granted then Camel throws an exception on startup. This ensures that Camel is 
not started with failed connections. The JMS producers is tested as well. | 
false | boolean
+| *acknowledgementModeName* (consumer) | The JMS acknowledgement name, which 
is one of: SESSION_TRANSACTED, CLIENT_ACKNOWLEDGE, AUTO_ACKNOWLEDGE, 
DUPS_OK_ACKNOWLEDGE | AUTO_ ACKNOWLEDGE | String
+| *asyncConsumer* (consumer) | Whether the JmsConsumer processes the Exchange 
asynchronously. If enabled then the JmsConsumer may pickup the next message 
from the JMS queue, while the previous message is being processed 
asynchronously (by the Asynchronous Routing Engine). This means that messages 
may be processed not 100% strictly in order. If disabled (as default) then the 
Exchange is fully processed before the JmsConsumer will pickup the next message 
from the JMS queue. Note if transac [...]
+| *autoStartup* (consumer) | Specifies whether the consumer container should 
auto-startup. | true | boolean
+| *bridgeErrorHandler* (consumer) | Allows for bridging the consumer to the 
Camel routing Error Handler, which mean any exceptions occurred while the 
consumer is trying to pickup incoming messages, or the likes, will now be 
processed as a message and handled by the routing Error Handler. By default the 
consumer will use the org.apache.camel.spi.ExceptionHandler to deal with 
exceptions, that will be logged at WARN or ERROR level and ignored. | false | 
boolean
+| *cacheLevel* (consumer) | Sets the cache level by ID for the underlying JMS 
resources. See cacheLevelName option for more details. |  | int
+| *cacheLevelName* (consumer) | Sets the cache level by name for the 
underlying JMS resources. Possible values are: CACHE_AUTO, CACHE_CONNECTION, 
CACHE_CONSUMER, CACHE_NONE, and CACHE_SESSION. The default setting is 
CACHE_AUTO. See the Spring documentation and Transactions Cache Levels for more 
information. | CACHE_AUTO | String
+| *concurrentConsumers* (consumer) | Specifies the default number of 
concurrent consumers when consuming from JMS (not for request/reply over JMS). 
See also the maxMessagesPerTask option to control dynamic scaling up/down of 
threads. When doing request/reply over JMS then the option 
replyToConcurrentConsumers is used to control number of concurrent consumers on 
the reply message listener. | 1 | int
+| *maxConcurrentConsumers* (consumer) | Specifies the maximum number of 
concurrent consumers when consuming from JMS (not for request/reply over JMS). 
See also the maxMessagesPerTask option to control dynamic scaling up/down of 
threads. When doing request/reply over JMS then the option 
replyToMaxConcurrentConsumers is used to control number of concurrent consumers 
on the reply message listener. |  | int
+| *replyTo* (consumer) | Provides an explicit ReplyTo destination, which 
overrides any incoming value of Message.getJMSReplyTo(). |  | String
+| *replyToDeliveryPersistent* (consumer) | Specifies whether to use persistent 
delivery by default for replies. | true | boolean
+| *selector* (consumer) | Sets the JMS selector to use |  | String
+| *subscriptionDurable* (consumer) | Set whether to make the subscription 
durable. The durable subscription name to be used can be specified through the 
subscriptionName property. Default is false. Set this to true to register a 
durable subscription, typically in combination with a subscriptionName value 
(unless your message listener class name is good enough as subscription name). 
Only makes sense when listening to a topic (pub-sub domain), therefore this 
method switches the pubSubDomai [...]
+| *subscriptionName* (consumer) | Set the name of a subscription to create. To 
be applied in case of a topic (pub-sub domain) with a shared or durable 
subscription. The subscription name needs to be unique within this client's JMS 
client id. Default is the class name of the specified message listener. Note: 
Only 1 concurrent consumer (which is the default of this message listener 
container) is allowed for each subscription, except for a shared subscription 
(which requires JMS 2.0). |  | String
+| *subscriptionShared* (consumer) | Set whether to make the subscription 
shared. The shared subscription name to be used can be specified through the 
subscriptionName property. Default is false. Set this to true to register a 
shared subscription, typically in combination with a subscriptionName value 
(unless your message listener class name is good enough as subscription name). 
Note that shared subscriptions may also be durable, so this flag can (and often 
will) be combined with subscrip [...]
+| *acceptMessagesWhileStopping* (consumer) | Specifies whether the consumer 
accept messages while it is stopping. You may consider enabling this option, if 
you start and stop JMS routes at runtime, while there are still messages 
enqueued on the queue. If this option is false, and you stop the JMS route, 
then messages may be rejected, and the JMS broker would have to attempt 
redeliveries, which yet again may be rejected, and eventually the message may 
be moved at a dead letter queue on th [...]
+| *allowReplyManagerQuickStop* (consumer) | Whether the 
DefaultMessageListenerContainer used in the reply managers for request-reply 
messaging allow the DefaultMessageListenerContainer#runningAllowed() flag to 
quick stop in case JmsConfiguration#isAcceptMessagesWhileStopping() is enabled, 
and org.apache.camel.CamelContext is currently being stopped. This quick stop 
ability is enabled by default in the regular JMS consumers but to enable for 
reply managers you must enable this flag. | fal [...]
+| *consumerType* (consumer) | The consumer type to use, which can be one of: 
Simple, Default, or Custom. The consumer type determines which Spring JMS 
listener to use. Default will use 
org.springframework.jms.listener.DefaultMessageListenerContainer, Simple will 
use org.springframework.jms.listener.SimpleMessageListenerContainer. When 
Custom is specified, the MessageListenerContainerFactory defined by the 
messageListenerContainerFactory option will determine what 
org.springframework.jms. [...]
+| *defaultTaskExecutorType* (consumer) | Specifies what default TaskExecutor 
type to use in the DefaultMessageListenerContainer, for both consumer endpoints 
and the ReplyTo consumer of producer endpoints. Possible values: SimpleAsync 
(uses Spring's SimpleAsyncTaskExecutor) or ThreadPool (uses Spring's 
ThreadPoolTaskExecutor with optimal values - cached threadpool-like). If not 
set, it defaults to the previous behaviour, which uses a cached thread pool for 
consumer endpoints and SimpleAsy [...]
+| *eagerLoadingOfProperties* (consumer) | Enables eager loading of JMS 
properties and payload as soon as a message is loaded which generally is 
inefficient as the JMS properties may not be required but sometimes can catch 
early any issues with the underlying JMS provider and the use of JMS properties 
| false | boolean
+| *exceptionHandler* (consumer) | To let the consumer use a custom 
ExceptionHandler. Notice if the option bridgeErrorHandler is enabled then this 
option is not in use. By default the consumer will deal with exceptions, that 
will be logged at WARN or ERROR level and ignored. |  | ExceptionHandler
+| *exchangePattern* (consumer) | Sets the exchange pattern when the consumer 
creates an exchange. |  | ExchangePattern
+| *exposeListenerSession* (consumer) | Specifies whether the listener session 
should be exposed when consuming messages. | false | boolean
+| *replyToSameDestination Allowed* (consumer) | Whether a JMS consumer is 
allowed to send a reply message to the same destination that the consumer is 
using to consume from. This prevents an endless loop by consuming and sending 
back the same message to itself. | false | boolean
+| *taskExecutor* (consumer) | Allows you to specify a custom task executor for 
consuming messages. |  | TaskExecutor
+| *deliveryMode* (producer) | Specifies the delivery mode to be used. 
Possibles values are those defined by javax.jms.DeliveryMode. NON_PERSISTENT = 
1 and PERSISTENT = 2. |  | Integer
+| *deliveryPersistent* (producer) | Specifies whether persistent delivery is 
used by default. | true | boolean
+| *explicitQosEnabled* (producer) | Set if the deliveryMode, priority or 
timeToLive qualities of service should be used when sending messages. This 
option is based on Spring's JmsTemplate. The deliveryMode, priority and 
timeToLive options are applied to the current endpoint. This contrasts with the 
preserveMessageQos option, which operates at message granularity, reading QoS 
properties exclusively from the Camel In message headers. | false | Boolean
+| *formatDateHeadersToIso8601* (producer) | Sets whether date headers should 
be formatted according to the ISO 8601 standard. | false | boolean
+| *preserveMessageQos* (producer) | Set to true, if you want to send message 
using the QoS settings specified on the message, instead of the QoS settings on 
the JMS endpoint. The following three headers are considered JMSPriority, 
JMSDeliveryMode, and JMSExpiration. You can provide all or only some of them. 
If not provided, Camel will fall back to use the values from the endpoint 
instead. So, when using this option, the headers override the values from the 
endpoint. The explicitQosEnable [...]
+| *priority* (producer) | Values greater than 1 specify the message priority 
when sending (where 0 is the lowest priority and 9 is the highest). The 
explicitQosEnabled option must also be enabled in order for this option to have 
any effect. | 4 | int
+| *replyToConcurrentConsumers* (producer) | Specifies the default number of 
concurrent consumers when doing request/reply over JMS. See also the 
maxMessagesPerTask option to control dynamic scaling up/down of threads. | 1 | 
int
+| *replyToMaxConcurrent Consumers* (producer) | Specifies the maximum number 
of concurrent consumers when using request/reply over JMS. See also the 
maxMessagesPerTask option to control dynamic scaling up/down of threads. |  | 
int
+| *replyToOnTimeoutMax ConcurrentConsumers* (producer) | Specifies the maximum 
number of concurrent consumers for continue routing when timeout occurred when 
using request/reply over JMS. | 1 | int
+| *replyToOverride* (producer) | Provides an explicit ReplyTo destination in 
the JMS message, which overrides the setting of replyTo. It is useful if you 
want to forward the message to a remote Queue and receive the reply message 
from the ReplyTo destination. |  | String
+| *replyToType* (producer) | Allows for explicitly specifying which kind of 
strategy to use for replyTo queues when doing request/reply over JMS. Possible 
values are: Temporary, Shared, or Exclusive. By default Camel will use 
temporary queues. However if replyTo has been configured, then Shared is used 
by default. This option allows you to use exclusive queues instead of shared 
ones. See Camel JMS documentation for more details, and especially the notes 
about the implications if running  [...]
+| *requestTimeout* (producer) | The timeout for waiting for a reply when using 
the InOut Exchange Pattern (in milliseconds). The default is 20 seconds. You 
can include the header CamelJmsRequestTimeout to override this endpoint 
configured timeout value, and thus have per message individual timeout values. 
See also the requestTimeoutCheckerInterval option. | 20000 | long
+| *timeToLive* (producer) | When sending messages, specifies the time-to-live 
of the message (in milliseconds). | -1 | long
+| *allowAdditionalHeaders* (producer) | This option is used to allow 
additional headers which may have values that are invalid according to JMS 
specification. For example some message systems such as WMQ do this with header 
names using prefix JMS_IBM_MQMD_ containing values with byte array or other 
invalid types. You can specify multiple header names separated by comma, and 
use as suffix for wildcard matching. |  | String
+| *allowNullBody* (producer) | Whether to allow sending messages with no body. 
If this option is false and the message body is null, then an JMSException is 
thrown. | true | boolean
+| *alwaysCopyMessage* (producer) | If true, Camel will always make a JMS 
message copy of the message when it is passed to the producer for sending. 
Copying the message is needed in some situations, such as when a 
replyToDestinationSelectorName is set (incidentally, Camel will set the 
alwaysCopyMessage option to true, if a replyToDestinationSelectorName is set) | 
false | boolean
+| *correlationProperty* (producer) | Use this JMS property to correlate 
messages in InOut exchange pattern (request-reply) instead of JMSCorrelationID 
property. This allows you to exchange messages with systems that do not 
correlate messages using JMSCorrelationID JMS property. If used 
JMSCorrelationID will not be used or set by Camel. The value of here named 
property will be generated if not supplied in the header of the message under 
the same name. |  | String
+| *disableTimeToLive* (producer) | Use this option to force disabling time to 
live. For example when you do request/reply over JMS, then Camel will by 
default use the requestTimeout value as time to live on the message being sent. 
The problem is that the sender and receiver systems have to have their clocks 
synchronized, so they are in sync. This is not always so easy to archive. So 
you can use disableTimeToLive=true to not set a time to live value on the sent 
message. Then the message w [...]
+| *forceSendOriginalMessage* (producer) | When using mapJmsMessage=false Camel 
will create a new JMS message to send to a new JMS destination if you touch the 
headers (get or set) during the route. Set this option to true to force Camel 
to send the original JMS message that was received. | false | boolean
+| *includeSentJMSMessageID* (producer) | Only applicable when sending to JMS 
destination using InOnly (eg fire and forget). Enabling this option will enrich 
the Camel Exchange with the actual JMSMessageID that was used by the JMS client 
when the message was sent to the JMS destination. | false | boolean
+| *replyToCacheLevelName* (producer) | Sets the cache level by name for the 
reply consumer when doing request/reply over JMS. This option only applies when 
using fixed reply queues (not temporary). Camel will by default use: 
CACHE_CONSUMER for exclusive or shared w/ replyToSelectorName. And 
CACHE_SESSION for shared without replyToSelectorName. Some JMS brokers such as 
IBM WebSphere may require to set the replyToCacheLevelName=CACHE_NONE to work. 
Note: If using temporary queues then CACHE [...]
+| *replyToDestinationSelector Name* (producer) | Sets the JMS Selector using 
the fixed name to be used so you can filter out your own replies from the 
others when using a shared queue (that is, if you are not using a temporary 
reply queue). |  | String
+| *streamMessageTypeEnabled* (producer) | Sets whether StreamMessage type is 
enabled or not. Message payloads of streaming kind such as files, InputStream, 
etc will either by sent as BytesMessage or StreamMessage. This option controls 
which kind will be used. By default BytesMessage is used which enforces the 
entire message payload to be read into memory. By enabling this option the 
message payload is read into memory in chunks and each chunk is then written to 
the StreamMessage until no [...]
+| *allowSerializedHeaders* (advanced) | Controls whether or not to include 
serialized headers. Applies only when isTransferExchange() is true. This 
requires that the objects are serializable. Camel will exclude any 
non-serializable objects and log it at WARN level. | false | boolean
+| *asyncStartListener* (advanced) | Whether to startup the JmsConsumer message 
listener asynchronously, when starting a route. For example if a JmsConsumer 
cannot get a connection to a remote JMS broker, then it may block while 
retrying and/or failover. This will cause Camel to block while starting routes. 
By setting this option to true, you will let routes startup, while the 
JmsConsumer connects to the JMS broker using a dedicated thread in asynchronous 
mode. If this option is used, the [...]
+| *asyncStopListener* (advanced) | Whether to stop the JmsConsumer message 
listener asynchronously, when stopping a route. | false | boolean
+| *destinationResolver* (advanced) | A pluggable 
org.springframework.jms.support.destination.DestinationResolver that allows you 
to use your own resolver (for example, to lookup the real destination in a JNDI 
registry). |  | DestinationResolver
+| *errorHandler* (advanced) | Specifies a 
org.springframework.util.ErrorHandler to be invoked in case of any uncaught 
exceptions thrown while processing a Message. By default these exceptions will 
be logged at the WARN level, if no errorHandler has been configured. You can 
configure logging level and whether stack traces should be logged using 
errorHandlerLoggingLevel and errorHandlerLogStackTrace options. This makes it 
much easier to configure, than having to code a custom errorHandler. [...]
+| *exceptionListener* (advanced) | Specifies the JMS Exception Listener that 
is to be notified of any underlying JMS exceptions. |  | ExceptionListener
+| *headerFilterStrategy* (advanced) | To use a custom HeaderFilterStrategy to 
filter header to and from Camel message. |  | HeaderFilterStrategy
+| *idleConsumerLimit* (advanced) | Specify the limit for the number of 
consumers that are allowed to be idle at any given time. | 1 | int
+| *idleTaskExecutionLimit* (advanced) | Specifies the limit for idle 
executions of a receive task, not having received any message within its 
execution. If this limit is reached, the task will shut down and leave 
receiving to other executing tasks (in the case of dynamic scheduling; see the 
maxConcurrentConsumers setting). There is additional doc available from Spring. 
| 1 | int
+| *includeAllJMSXProperties* (advanced) | Whether to include all JMSXxxx 
properties when mapping from JMS to Camel Message. Setting this to true will 
include properties such as JMSXAppID, and JMSXUserID etc. Note: If you are 
using a custom headerFilterStrategy then this option does not apply. | false | 
boolean
+| *jmsKeyFormatStrategy* (advanced) | Pluggable strategy for encoding and 
decoding JMS keys so they can be compliant with the JMS specification. Camel 
provides two implementations out of the box: default and passthrough. The 
default strategy will safely marshal dots and hyphens (. and -). The 
passthrough strategy leaves the key as is. Can be used for JMS brokers which do 
not care whether JMS header keys contain illegal characters. You can provide 
your own implementation of the org.apache [...]
+| *mapJmsMessage* (advanced) | Specifies whether Camel should auto map the 
received JMS message to a suited payload type, such as javax.jms.TextMessage to 
a String etc. | true | boolean
+| *maxMessagesPerTask* (advanced) | The number of messages per task. -1 is 
unlimited. If you use a range for concurrent consumers (eg min max), then this 
option can be used to set a value to eg 100 to control how fast the consumers 
will shrink when less work is required. | -1 | int
+| *messageConverter* (advanced) | To use a custom Spring 
org.springframework.jms.support.converter.MessageConverter so you can be in 
control how to map to/from a javax.jms.Message. |  | MessageConverter
+| *messageCreatedStrategy* (advanced) | To use the given 
MessageCreatedStrategy which are invoked when Camel creates new instances of 
javax.jms.Message objects when Camel is sending a JMS message. |  | 
MessageCreatedStrategy
+| *messageIdEnabled* (advanced) | When sending, specifies whether message IDs 
should be added. This is just an hint to the JMS Broker. If the JMS provider 
accepts this hint, these messages must have the message ID set to null; if the 
provider ignores the hint, the message ID must be set to its normal unique 
value | true | boolean
+| *messageListenerContainer Factory* (advanced) | Registry ID of the 
MessageListenerContainerFactory used to determine what 
org.springframework.jms.listener.AbstractMessageListenerContainer to use to 
consume messages. Setting this will automatically set consumerType to Custom. | 
 | MessageListener ContainerFactory
+| *messageTimestampEnabled* (advanced) | Specifies whether timestamps should 
be enabled by default on sending messages. This is just an hint to the JMS 
Broker. If the JMS provider accepts this hint, these messages must have the 
timestamp set to zero; if the provider ignores the hint, the timestamp must be 
set to its normal value. | true | boolean
+| *pubSubNoLocal* (advanced) | Specifies whether to inhibit the delivery of 
messages published by its own connection. | false | boolean
+| *receiveTimeout* (advanced) | The timeout for receiving messages (in 
milliseconds). | 1000 | long
+| *recoveryInterval* (advanced) | Specifies the interval between recovery 
attempts, i.e. when a connection is being refreshed, in milliseconds. The 
default is 5000 ms, that is, 5 seconds. | 5000 | long
+| *requestTimeoutChecker Interval* (advanced) | Configures how often Camel 
should check for timed out Exchanges when doing request/reply over JMS. By 
default Camel checks once per second. But if you must react faster when a 
timeout occurs, then you can lower this interval, to check more frequently. The 
timeout is determined by the option requestTimeout. | 1000 | long
+| *synchronous* (advanced) | Sets whether synchronous processing should be 
strictly used, or Camel is allowed to use asynchronous processing (if 
supported). | false | boolean
+| *transferException* (advanced) | If enabled and you are using Request Reply 
messaging (InOut) and an Exchange failed on the consumer side, then the caused 
Exception will be send back in response as a javax.jms.ObjectMessage. If the 
client is Camel, the returned Exception is rethrown. This allows you to use 
Camel JMS as a bridge in your routing - for example, using persistent queues to 
enable robust routing. Notice that if you also have transferExchange enabled, 
this option takes preced [...]
+| *transferExchange* (advanced) | You can transfer the exchange over the wire 
instead of just the body and headers. The following fields are transferred: In 
body, Out body, Fault body, In headers, Out headers, Fault headers, exchange 
properties, exchange exception. This requires that the objects are 
serializable. Camel will exclude any non-serializable objects and log it at 
WARN level. You must enable this option on both the producer and consumer side, 
so Camel knows the payloads is an E [...]
+| *transferFault* (advanced) | If enabled and you are using Request Reply 
messaging (InOut) and an Exchange failed with a SOAP fault (not exception) on 
the consumer side, then the fault flag on org.apache.camel.Message#isFault() 
will be send back in the response as a JMS header with the key 
JmsConstants#JMS_TRANSFER_FAULT. If the client is Camel, the returned fault 
flag will be set on the org.apache.camel.Message#setFault(boolean). You may 
want to enable this when using Camel components  [...]
+| *useMessageIDAsCorrelation ID* (advanced) | Specifies whether JMSMessageID 
should always be used as JMSCorrelationID for InOut messages. | false | boolean
+| *waitForProvisionCorrelation ToBeUpdatedCounter* (advanced) | Number of 
times to wait for provisional correlation id to be updated to the actual 
correlation id when doing request/reply over JMS and when the option 
useMessageIDAsCorrelationID is enabled. | 50 | int
+| *waitForProvisionCorrelation ToBeUpdatedThreadSleeping Time* (advanced) | 
Interval in millis to sleep each time while waiting for provisional correlation 
id to be updated. | 100 | long
+| *errorHandlerLoggingLevel* (logging) | Allows to configure the default 
errorHandler logging level for logging uncaught exceptions. | WARN | 
LoggingLevel
+| *errorHandlerLogStackTrace* (logging) | Allows to control whether 
stacktraces should be logged or not, by the default errorHandler. | true | 
boolean
+| *password* (security) | Password to use with the ConnectionFactory. You can 
also configure username/password directly on the ConnectionFactory. |  | String
+| *username* (security) | Username to use with the ConnectionFactory. You can 
also configure username/password directly on the ConnectionFactory. |  | String
+| *transacted* (transaction) | Specifies whether to use transacted mode | 
false | boolean
+| *lazyCreateTransaction Manager* (transaction) | If true, Camel will create a 
JmsTransactionManager, if there is no transactionManager injected when option 
transacted=true. | true | boolean
+| *transactionManager* (transaction) | The Spring transaction manager to use. 
|  | PlatformTransaction Manager
+| *transactionName* (transaction) | The name of the transaction to use. |  | 
String
+| *transactionTimeout* (transaction) | The timeout value of the transaction 
(in seconds), if using transacted mode. | -1 | int
+|===
+// endpoint options: END
+
+// spring-boot-auto-configure options: START
+=== Spring Boot Auto-Configuration
+
+
+The component supports 86 options, which are listed below.
+
+
+
+[width="100%",cols="2,5,^1,2",options="header"]
+|===
+| Name | Description | Default | Type
+| *camel.component.activemq.accept-messages-while-stopping* | Specifies 
whether the consumer accept messages while it is stopping. You may consider 
enabling this option, if you start and stop JMS routes at runtime, while there 
are still messages enqueued on the queue. If this option is false, and you stop 
the JMS route, then messages may be rejected, and the JMS broker would have to 
attempt redeliveries, which yet again may be rejected, and eventually the 
message may be moved at a dead l [...]
+| *camel.component.activemq.acknowledgement-mode* | The JMS acknowledgement 
mode defined as an Integer. Allows you to set vendor-specific extensions to the 
acknowledgment mode. For the regular modes, it is preferable to use the 
acknowledgementModeName instead. |  | Integer
+| *camel.component.activemq.acknowledgement-mode-name* | The JMS 
acknowledgement name, which is one of: SESSION_TRANSACTED, CLIENT_ACKNOWLEDGE, 
AUTO_ACKNOWLEDGE, DUPS_OK_ACKNOWLEDGE | AUTO_ ACKNOWLEDGE | String
+| *camel.component.activemq.allow-additional-headers* | This option is used to 
allow additional headers which may have values that are invalid according to 
JMS specification. For example some message systems such as WMQ do this with 
header names using prefix JMS_IBM_MQMD_ containing values with byte array or 
other invalid types. You can specify multiple header names separated by comma, 
and use as suffix for wildcard matching. |  | String
+| *camel.component.activemq.allow-null-body* | Whether to allow sending 
messages with no body. If this option is false and the message body is null, 
then an JMSException is thrown. | true | Boolean
+| *camel.component.activemq.allow-reply-manager-quick-stop* | Whether the 
DefaultMessageListenerContainer used in the reply managers for request-reply 
messaging allow the DefaultMessageListenerContainer.runningAllowed flag to 
quick stop in case JmsConfiguration#isAcceptMessagesWhileStopping is enabled, 
and org.apache.camel.CamelContext is currently being stopped. This quick stop 
ability is enabled by default in the regular JMS consumers but to enable for 
reply managers you must enable th [...]
+| *camel.component.activemq.always-copy-message* | If true, Camel will always 
make a JMS message copy of the message when it is passed to the producer for 
sending. Copying the message is needed in some situations, such as when a 
replyToDestinationSelectorName is set (incidentally, Camel will set the 
alwaysCopyMessage option to true, if a replyToDestinationSelectorName is set). 
| false | Boolean
+| *camel.component.activemq.async-consumer* | Whether the JmsConsumer 
processes the Exchange asynchronously. If enabled then the JmsConsumer may 
pickup the next message from the JMS queue, while the previous message is being 
processed asynchronously (by the Asynchronous Routing Engine). This means that 
messages may be processed not 100% strictly in order. If disabled (as default) 
then the Exchange is fully processed before the JmsConsumer will pickup the 
next message from the JMS queue.  [...]
+| *camel.component.activemq.async-start-listener* | Whether to startup the 
JmsConsumer message listener asynchronously, when starting a route. For example 
if a JmsConsumer cannot get a connection to a remote JMS broker, then it may 
block while retrying and/or failover. This will cause Camel to block while 
starting routes. By setting this option to true, you will let routes startup, 
while the JmsConsumer connects to the JMS broker using a dedicated thread in 
asynchronous mode. If this opt [...]
+| *camel.component.activemq.async-stop-listener* | Whether to stop the 
JmsConsumer message listener asynchronously, when stopping a route. | false | 
Boolean
+| *camel.component.activemq.auto-startup* | Specifies whether the consumer 
container should auto-startup. | true | Boolean
+| *camel.component.activemq.broker-u-r-l* | Sets the broker URL to use to 
connect to ActiveMQ using the ActiveMQ URI format |  | String
+| *camel.component.activemq.cache-level* | Sets the cache level by ID for the 
underlying JMS resources. See cacheLevelName option for more details. |  | 
Integer
+| *camel.component.activemq.cache-level-name* | Sets the cache level by name 
for the underlying JMS resources. Possible values are: CACHE_AUTO, 
CACHE_CONNECTION, CACHE_CONSUMER, CACHE_NONE, and CACHE_SESSION. The default 
setting is CACHE_AUTO. See the Spring documentation and Transactions Cache 
Levels for more information. | CACHE_AUTO | String
+| *camel.component.activemq.client-id* | Sets the JMS client ID to use. Note 
that this value, if specified, must be unique and can only be used by a single 
JMS connection instance. It is typically only required for durable topic 
subscriptions. If using Apache ActiveMQ you may prefer to use Virtual Topics 
instead. |  | String
+| *camel.component.activemq.concurrent-consumers* | Specifies the default 
number of concurrent consumers when consuming from JMS (not for request/reply 
over JMS). See also the maxMessagesPerTask option to control dynamic scaling 
up/down of threads. When doing request/reply over JMS then the option 
replyToConcurrentConsumers is used to control number of concurrent consumers on 
the reply message listener. | 1 | Integer
+| *camel.component.activemq.configuration* | Configuration of ActiveMQ. The 
option is a org.apache.camel.component.jms.JmsConfiguration type. |  | String
+| *camel.component.activemq.connection-factory* | The connection factory to be 
use. A connection factory must be configured either on the component or 
endpoint. The option is a javax.jms.ConnectionFactory type. |  | String
+| *camel.component.activemq.correlation-property* | Use this JMS property to 
correlate messages in InOut exchange pattern (request-reply) instead of 
JMSCorrelationID property. This allows you to exchange messages with systems 
that do not correlate messages using JMSCorrelationID JMS property. If used 
JMSCorrelationID will not be used or set by Camel. The value of here named 
property will be generated if not supplied in the header of the message under 
the same name. |  | String
+| *camel.component.activemq.default-task-executor-type* | Specifies what 
default TaskExecutor type to use in the DefaultMessageListenerContainer, for 
both consumer endpoints and the ReplyTo consumer of producer endpoints. 
Possible values: SimpleAsync (uses Spring's SimpleAsyncTaskExecutor) or 
ThreadPool (uses Spring's ThreadPoolTaskExecutor with optimal values - cached 
threadpool-like). If not set, it defaults to the previous behaviour, which uses 
a cached thread pool for consumer endpoi [...]
+| *camel.component.activemq.delivery-mode* | Specifies the delivery mode to be 
used. Possibles values are those defined by javax.jms.DeliveryMode. 
NON_PERSISTENT = 1 and PERSISTENT = 2. |  | Integer
+| *camel.component.activemq.delivery-persistent* | Specifies whether 
persistent delivery is used by default. | true | Boolean
+| *camel.component.activemq.destination-resolver* | A pluggable 
org.springframework.jms.support.destination.DestinationResolver that allows you 
to use your own resolver (for example, to lookup the real destination in a JNDI 
registry). The option is a 
org.springframework.jms.support.destination.DestinationResolver type. |  | 
String
+| *camel.component.activemq.durable-subscription-name* | The durable 
subscriber name for specifying durable topic subscriptions. The clientId option 
must be configured as well. |  | String
+| *camel.component.activemq.eager-loading-of-properties* | Enables eager 
loading of JMS properties as soon as a message is loaded which generally is 
inefficient as the JMS properties may not be required but sometimes can catch 
early any issues with the underlying JMS provider and the use of JMS properties 
| false | Boolean
+| *camel.component.activemq.enabled* | Whether to enable auto configuration of 
the activemq component. This is enabled by default. |  | Boolean
+| *camel.component.activemq.error-handler* | Specifies a 
org.springframework.util.ErrorHandler to be invoked in case of any uncaught 
exceptions thrown while processing a Message. By default these exceptions will 
be logged at the WARN level, if no errorHandler has been configured. You can 
configure logging level and whether stack traces should be logged using 
errorHandlerLoggingLevel and errorHandlerLogStackTrace options. This makes it 
much easier to configure, than having to code a custo [...]
+| *camel.component.activemq.error-handler-log-stack-trace* | Allows to control 
whether stacktraces should be logged or not, by the default errorHandler. | 
true | Boolean
+| *camel.component.activemq.error-handler-logging-level* | Allows to configure 
the default errorHandler logging level for logging uncaught exceptions. |  | 
LoggingLevel
+| *camel.component.activemq.exception-listener* | Specifies the JMS Exception 
Listener that is to be notified of any underlying JMS exceptions. The option is 
a javax.jms.ExceptionListener type. |  | String
+| *camel.component.activemq.explicit-qos-enabled* | Set if the deliveryMode, 
priority or timeToLive qualities of service should be used when sending 
messages. This option is based on Spring's JmsTemplate. The deliveryMode, 
priority and timeToLive options are applied to the current endpoint. This 
contrasts with the preserveMessageQos option, which operates at message 
granularity, reading QoS properties exclusively from the Camel In message 
headers. | false | Boolean
+| *camel.component.activemq.expose-all-queues* | If enabled this will cause 
all Queues in the ActiveMQ broker to be eagerly populated into the CamelContext 
so that they can be easily browsed by any Camel tooling. This option is 
disabled by default. | false | Boolean
+| *camel.component.activemq.expose-listener-session* | Specifies whether the 
listener session should be exposed when consuming messages. | false | Boolean
+| *camel.component.activemq.force-send-original-message* | When using 
mapJmsMessage=false Camel will create a new JMS message to send to a new JMS 
destination if you touch the headers (get or set) during the route. Set this 
option to true to force Camel to send the original JMS message that was 
received. | false | Boolean
+| *camel.component.activemq.format-date-headers-to-iso8601* | Sets whether 
date headers should be formatted according to the ISO 8601 standard. | false | 
Boolean
+| *camel.component.activemq.header-filter-strategy* | To use a custom 
org.apache.camel.spi.HeaderFilterStrategy to filter header to and from Camel 
message. The option is a org.apache.camel.spi.HeaderFilterStrategy type. |  | 
String
+| *camel.component.activemq.idle-consumer-limit* | Specify the limit for the 
number of consumers that are allowed to be idle at any given time. | 1 | Integer
+| *camel.component.activemq.idle-task-execution-limit* | Specifies the limit 
for idle executions of a receive task, not having received any message within 
its execution. If this limit is reached, the task will shut down and leave 
receiving to other executing tasks (in the case of dynamic scheduling; see the 
maxConcurrentConsumers setting). There is additional doc available from Spring. 
| 1 | Integer
+| *camel.component.activemq.include-all-j-m-s-x-properties* | Whether to 
include all JMSXxxx properties when mapping from JMS to Camel Message. Setting 
this to true will include properties such as JMSXAppID, and JMSXUserID etc. 
Note: If you are using a custom headerFilterStrategy then this option does not 
apply. | false | Boolean
+| *camel.component.activemq.include-sent-j-m-s-message-i-d* | Only applicable 
when sending to JMS destination using InOnly (eg fire and forget). Enabling 
this option will enrich the Camel Exchange with the actual JMSMessageID that 
was used by the JMS client when the message was sent to the JMS destination. | 
false | Boolean
+| *camel.component.activemq.jms-key-format-strategy* | Pluggable strategy for 
encoding and decoding JMS keys so they can be compliant with the JMS 
specification. Camel provides two implementations out of the box: default and 
passthrough. The default strategy will safely marshal dots and hyphens (. and 
-). The passthrough strategy leaves the key as is. Can be used for JMS brokers 
which do not care whether JMS header keys contain illegal characters. You can 
provide your own implementation  [...]
+| *camel.component.activemq.jms-operations* | Allows you to use your own 
implementation of the org.springframework.jms.core.JmsOperations interface. 
Camel uses JmsTemplate as default. Can be used for testing purpose, but not 
used much as stated in the spring API docs. The option is a 
org.springframework.jms.core.JmsOperations type. |  | String
+| *camel.component.activemq.lazy-create-transaction-manager* | If true, Camel 
will create a JmsTransactionManager, if there is no transactionManager injected 
when option transacted=true. | true | Boolean
+| *camel.component.activemq.map-jms-message* | Specifies whether Camel should 
auto map the received JMS message to a suited payload type, such as 
javax.jms.TextMessage to a String etc. See section about how mapping works 
below for more details. | true | Boolean
+| *camel.component.activemq.max-concurrent-consumers* | Specifies the maximum 
number of concurrent consumers when consuming from JMS (not for request/reply 
over JMS). See also the maxMessagesPerTask option to control dynamic scaling 
up/down of threads. When doing request/reply over JMS then the option 
replyToMaxConcurrentConsumers is used to control number of concurrent consumers 
on the reply message listener. |  | Integer
+| *camel.component.activemq.max-messages-per-task* | The number of messages 
per task. -1 is unlimited. If you use a range for concurrent consumers (eg min 
max), then this option can be used to set a value to eg 100 to control how fast 
the consumers will shrink when less work is required. | -1 | Integer
+| *camel.component.activemq.message-converter* | To use a custom Spring 
org.springframework.jms.support.converter.MessageConverter so you can be in 
control how to map to/from a javax.jms.Message. The option is a 
org.springframework.jms.support.converter.MessageConverter type. |  | String
+| *camel.component.activemq.message-created-strategy* | To use the given 
MessageCreatedStrategy which are invoked when Camel creates new instances of 
javax.jms.Message objects when Camel is sending a JMS message. The option is a 
org.apache.camel.component.jms.MessageCreatedStrategy type. |  | String
+| *camel.component.activemq.message-id-enabled* | When sending, specifies 
whether message IDs should be added. This is just an hint to the JMS Broker. If 
the JMS provider accepts this hint, these messages must have the message ID set 
to null; if the provider ignores the hint, the message ID must be set to its 
normal unique value. | true | Boolean
+| *camel.component.activemq.message-timestamp-enabled* | Specifies whether 
timestamps should be enabled by default on sending messages. This is just an 
hint to the JMS broker. If the JMS provider accepts this hint, these messages 
must have the timestamp set to zero; if the provider ignores the hint the 
timestamp must be set to its normal value. | true | Boolean
+| *camel.component.activemq.password* | Password to use with the 
ConnectionFactory. You can also configure username/password directly on the 
ConnectionFactory. |  | String
+| *camel.component.activemq.preserve-message-qos* | Set to true, if you want 
to send message using the QoS settings specified on the message, instead of the 
QoS settings on the JMS endpoint. The following three headers are considered 
JMSPriority, JMSDeliveryMode, and JMSExpiration. You can provide all or only 
some of them. If not provided, Camel will fall back to use the values from the 
endpoint instead. So, when using this option, the headers override the values 
from the endpoint. The e [...]
+| *camel.component.activemq.priority* | Values greater than 1 specify the 
message priority when sending (where 0 is the lowest priority and 9 is the 
highest). The explicitQosEnabled option must also be enabled in order for this 
option to have any effect. | 4 | Integer
+| *camel.component.activemq.pub-sub-no-local* | Specifies whether to inhibit 
the delivery of messages published by its own connection. | false | Boolean
+| *camel.component.activemq.queue-browse-strategy* | To use a custom 
QueueBrowseStrategy when browsing queues. The option is a 
org.apache.camel.component.jms.QueueBrowseStrategy type. |  | String
+| *camel.component.activemq.receive-timeout* | The timeout for receiving 
messages (in milliseconds). | 1000 | Long
+| *camel.component.activemq.recovery-interval* | Specifies the interval 
between recovery attempts, i.e. when a connection is being refreshed, in 
milliseconds. The default is 5000 ms, that is, 5 seconds. | 5000 | Long
+| *camel.component.activemq.reply-on-timeout-to-max-concurrent-consumers* | 
Specifies the maximum number of concurrent consumers for continue routing when 
timeout occurred when using request/reply over JMS. | 1 | Integer
+| *camel.component.activemq.reply-to-cache-level-name* | Sets the cache level 
by name for the reply consumer when doing request/reply over JMS. This option 
only applies when using fixed reply queues (not temporary). Camel will by 
default use: CACHE_CONSUMER for exclusive or shared w/ replyToSelectorName. And 
CACHE_SESSION for shared without replyToSelectorName. Some JMS brokers such as 
IBM WebSphere may require to set the replyToCacheLevelName=CACHE_NONE to work. 
Note: If using temporary [...]
+| *camel.component.activemq.reply-to-concurrent-consumers* | Specifies the 
default number of concurrent consumers when doing request/reply over JMS. See 
also the maxMessagesPerTask option to control dynamic scaling up/down of 
threads. | 1 | Integer
+| *camel.component.activemq.reply-to-max-concurrent-consumers* | Specifies the 
maximum number of concurrent consumers when using request/reply over JMS. See 
also the maxMessagesPerTask option to control dynamic scaling up/down of 
threads. |  | Integer
+| *camel.component.activemq.reply-to-type* | Allows for explicitly specifying 
which kind of strategy to use for replyTo queues when doing request/reply over 
JMS. Possible values are: Temporary, Shared, or Exclusive. By default Camel 
will use temporary queues. However if replyTo has been configured, then Shared 
is used by default. This option allows you to use exclusive queues instead of 
shared ones. See Camel JMS documentation for more details, and especially the 
notes about the implicat [...]
+| *camel.component.activemq.request-timeout* | The timeout for waiting for a 
reply when using the InOut Exchange Pattern (in milliseconds). The default is 
20 seconds. You can include the header CamelJmsRequestTimeout to override this 
endpoint configured timeout value, and thus have per message individual timeout 
values. See also the requestTimeoutCheckerInterval option. | 20000 | Long
+| *camel.component.activemq.request-timeout-checker-interval* | Configures how 
often Camel should check for timed out Exchanges when doing request/reply over 
JMS. By default Camel checks once per second. But if you must react faster when 
a timeout occurs, then you can lower this interval, to check more frequently. 
The timeout is determined by the option requestTimeout. | 1000 | Long
+| *camel.component.activemq.resolve-property-placeholders* | Whether the 
component should resolve property placeholders on itself when starting. Only 
properties which are of String type can use property placeholders. | true | 
Boolean
+| *camel.component.activemq.stream-message-type-enabled* | Sets whether 
StreamMessage type is enabled or not. Message payloads of streaming kind such 
as files, InputStream, etc will either by sent as BytesMessage or 
StreamMessage. This option controls which kind will be used. By default 
BytesMessage is used which enforces the entire message payload to be read into 
memory. By enabling this option the message payload is read into memory in 
chunks and each chunk is then written to the Strea [...]
+| *camel.component.activemq.subscription-durable* | Set whether to make the 
subscription durable. The durable subscription name to be used can be specified 
through the subscriptionName property. Default is false. Set this to true to 
register a durable subscription, typically in combination with a 
subscriptionName value (unless your message listener class name is good enough 
as subscription name). Only makes sense when listening to a topic (pub-sub 
domain), therefore this method switches  [...]
+| *camel.component.activemq.subscription-name* | Set the name of a 
subscription to create. To be applied in case of a topic (pub-sub domain) with 
a shared or durable subscription. The subscription name needs to be unique 
within this client's JMS client id. Default is the class name of the specified 
message listener. Note: Only 1 concurrent consumer (which is the default of 
this message listener container) is allowed for each subscription, except for a 
shared subscription (which requires  [...]
+| *camel.component.activemq.subscription-shared* | Set whether to make the 
subscription shared. The shared subscription name to be used can be specified 
through the subscriptionName property. Default is false. Set this to true to 
register a shared subscription, typically in combination with a 
subscriptionName value (unless your message listener class name is good enough 
as subscription name). Note that shared subscriptions may also be durable, so 
this flag can (and often will) be combine [...]
+| *camel.component.activemq.task-executor* | Allows you to specify a custom 
task executor for consuming messages. The option is a 
org.springframework.core.task.TaskExecutor type. |  | String
+| *camel.component.activemq.test-connection-on-startup* | Specifies whether to 
test the connection on startup. This ensures that when Camel starts that all 
the JMS consumers have a valid connection to the JMS broker. If a connection 
cannot be granted then Camel throws an exception on startup. This ensures that 
Camel is not started with failed connections. The JMS producers is tested as 
well. | false | Boolean
+| *camel.component.activemq.time-to-live* | When sending messages, specifies 
the time-to-live of the message (in milliseconds). | -1 | Long
+| *camel.component.activemq.transacted* | Specifies whether to use transacted 
mode | false | Boolean
+| *camel.component.activemq.transaction-manager* | The Spring transaction 
manager to use. The option is a 
org.springframework.transaction.PlatformTransactionManager type. |  | String
+| *camel.component.activemq.transaction-name* | The name of the transaction to 
use. |  | String
+| *camel.component.activemq.transaction-timeout* | The timeout value of the 
transaction (in seconds), if using transacted mode. | -1 | Integer
+| *camel.component.activemq.transfer-exception* | If enabled and you are using 
Request Reply messaging (InOut) and an Exchange failed on the consumer side, 
then the caused Exception will be send back in response as a 
javax.jms.ObjectMessage. If the client is Camel, the returned Exception is 
rethrown. This allows you to use Camel JMS as a bridge in your routing - for 
example, using persistent queues to enable robust routing. Notice that if you 
also have transferExchange enabled, this opti [...]
+| *camel.component.activemq.transfer-exchange* | You can transfer the exchange 
over the wire instead of just the body and headers. The following fields are 
transferred: In body, Out body, Fault body, In headers, Out headers, Fault 
headers, exchange properties, exchange exception. This requires that the 
objects are serializable. Camel will exclude any non-serializable objects and 
log it at WARN level. You must enable this option on both the producer and 
consumer side, so Camel knows the p [...]
+| *camel.component.activemq.transfer-fault* | If enabled and you are using 
Request Reply messaging (InOut) and an Exchange failed with a SOAP fault (not 
exception) on the consumer side, then the fault flag on 
org.apache.camel.Message#isFault() will be send back in the response as a JMS 
header with the key JmsConstants#JMS_TRANSFER_FAULT. If the client is Camel, 
the returned fault flag will be set on the 
org.apache.camel.Message#setFault(boolean). You may want to enable this when 
using Ca [...]
+| *camel.component.activemq.trust-all-packages* | Define if all packages are 
trusted or not | false | Boolean
+| *camel.component.activemq.use-message-i-d-as-correlation-i-d* | Specifies 
whether JMSMessageID should always be used as JMSCorrelationID for InOut 
messages. | false | Boolean
+| *camel.component.activemq.use-pooled-connection* | Enables or disables 
whether a PooledConnectionFactory will be used so that when messages are sent 
to ActiveMQ from outside of a message consuming thread, pooling will be used 
rather than the default with the Spring JmsTemplate which will create a new 
connection, session, producer for each message then close them all down again. 
The default value is true. Note that this requires an extra dependency on 
commons-pool2. | false | Boolean
+| *camel.component.activemq.use-single-connection* | Enables or disables 
whether a Spring SingleConnectionFactory will be used so that when messages are 
sent to ActiveMQ from outside of a message consuming thread, pooling will be 
used rather than the default with the Spring JmsTemplate which will create a 
new connection, session, producer for each message then close them all down 
again. The default value is false and a pooled connection is used by default. | 
false | Boolean
+| *camel.component.activemq.username* | Username to use with the 
ConnectionFactory. You can also configure username/password directly on the 
ConnectionFactory. |  | String
+| 
*camel.component.activemq.wait-for-provision-correlation-to-be-updated-counter* 
| Number of times to wait for provisional correlation id to be updated to the 
actual correlation id when doing request/reply over JMS and when the option 
useMessageIDAsCorrelationID is enabled. | 50 | Integer
+| 
*camel.component.activemq.wait-for-provision-correlation-to-be-updated-thread-sleeping-time*
 | Interval in millis to sleep each time while waiting for provisional 
correlation id to be updated. | 100 | Long
+|===
+// spring-boot-auto-configure options: END