Upload folder using huggingface_hub

camel-aggregate-eip.md

@@ -0,0 +1,673 @@
+# Aggregate-eip.md
+
+The
+[Aggregator](http://www.enterpriseintegrationpatterns.com/Aggregator.html)
+from the [EIP patterns](#enterprise-integration-patterns.adoc) allows
+you to combine a number of messages into a single message.
+
+How do we combine the results of individual, but related, messages so
+that they can be processed as a whole?
+
+<figure>
+<img src="eip/Aggregator.gif" alt="image" />
+</figure>
+
+Use a stateful filter, an Aggregator, to collect and store individual
+messages until a complete set of related messages has been received.
+Then, the Aggregator publishes a single message distilled from the
+individual messages.
+
+The aggregator is one of the most complex EIP and has many features and
+configurations.
+
+The logic for combing messages together is *correlated* in buckets based
+on a *correlation key*. Messages with the same correlation key are
+aggregated together, using an `AggregationStrategy`.
+
+# Aggregate options
+
+# Exchange properties
+
+# Worker pools
+
+The aggregate EIP will always use a worker pool used to process all the
+outgoing messages from the aggregator. The worker pool is determined
+accordingly:
+
+-   If a custom `ExecutorService` has been configured, then this is used
+    as worker pool.
+
+-   If `parallelProcessing=true` then a *default* worker pool (is 10
+    worker threads by default) is created. However, the thread pool size
+    and other configurations can be configured using *thread pool
+    profiles*.
+
+-   Otherwise, a single threaded worker pool is created.
+
+-   To achieve synchronous aggregation, use an instance of
+    `SynchronousExecutorService` for the `executorService` option. The
+    aggregated output will execute in the same thread that called the
+    aggregator.
+
+# Aggregating
+
+The `AggregationStrategy` is used for aggregating the old, and the new
+exchanges together into a single exchange; that becomes the next old,
+when the next message is aggregated, and so forth.
+
+Possible implementations include performing some kind of combining or
+delta processing. For instance, adding line items together into an
+invoice or just using the newest exchange and removing old exchanges
+such as for state tracking or market data prices, where old values are
+of little use.
+
+Notice the aggregation strategy is a mandatory option and must be
+provided to the aggregator.
+
+In the aggregate method, do not create a new exchange instance to
+return, instead return either the old or new exchange from the input
+parameters; favor returning the old exchange whenever possible.
+
+Here are a few example `AggregationStrategy` implementations that should
+help you create your own custom strategy.
+
+    //simply combines Exchange String body values using '+' as a delimiter
+    class StringAggregationStrategy implements AggregationStrategy {
+    
+        public Exchange aggregate(Exchange oldExchange, Exchange newExchange) {
+            if (oldExchange == null) {
+                return newExchange;
+            }
+    
+            String oldBody = oldExchange.getIn().getBody(String.class);
+            String newBody = newExchange.getIn().getBody(String.class);
+            oldExchange.getIn().setBody(oldBody + "+" + newBody);
+            return oldExchange;
+        }
+    }
+    
+    //simply combines Exchange body values into an ArrayList<Object>
+    class ArrayListAggregationStrategy implements AggregationStrategy {
+    
+        public Exchange aggregate(Exchange oldExchange, Exchange newExchange) {
+            Object newBody = newExchange.getIn().getBody();
+            ArrayList<Object> list = null;
+            if (oldExchange == null) {
+                list = new ArrayList<Object>();
+                list.add(newBody);
+                newExchange.getIn().setBody(list);
+                return newExchange;
+            } else {
+                list = oldExchange.getIn().getBody(ArrayList.class);
+                list.add(newBody);
+                return oldExchange;
+            }
+        }
+    }
+
+The `org.apache.camel.builder.AggregationStrategies` is a builder that
+can be used for creating commonly used aggregation strategies without
+having to create a class.
+
+## Aggregate by grouping exchanges
+
+In the route below we group all the exchanges together using
+`GroupedExchangeAggregationStrategy`:
+
+    from("direct:start")
+        // aggregates all using the same expression and group the
+        // exchanges, so we get one single exchange containing all
+        // the others
+        .aggregate(new GroupedExchangeAggregationStrategy()).constant(true)
+        // wait for 0.5 seconds to aggregate
+        .completionTimeout(500L).to("mock:result");
+
+As a result we have one outgoing `Exchange` being routed to the
+`"mock:result"` endpoint. The exchange is a holder containing all the
+incoming Exchanges.
+
+The output of the aggregator will then contain the exchanges grouped
+together in a list as shown below:
+
+    List<Exchange> grouped = exchange.getMessage().getBody(List.class);
+
+## Aggregating into a List
+
+If you want to aggregate some value from the messages `<V>` into a
+`List<V>` then you can use the
+`org.apache.camel.processor.aggregate.AbstractListAggregationStrategy`
+abstract class.
+
+The completed Exchange sent out of the aggregator will contain the
+`List<V>` in the message body.
+
+For example, to aggregate a `List<Integer>` you can extend this class as
+shown below, and implement the `getValue` method:
+
+    public class MyListOfNumbersStrategy extends AbstractListAggregationStrategy<Integer> {
+    
+        @Override
+        public Integer getValue(Exchange exchange) {
+            // the message body contains a number, so return that as-is
+            return exchange.getIn().getBody(Integer.class);
+        }
+    }
+
+The `org.apache.camel.builder.AggregationStrategies` is a builder that
+can be used for creating commonly used aggregation strategies without
+having to create a class.
+
+The previous example can also be built using the builder as shown:
+
+    AggregationStrategy agg = AggregationStrategies.flexible(Integer.class)
+        .accumulateInCollection(ArrayList.class)
+        .pick(body());
+
+## Aggregating on timeout
+
+If your aggregation strategy implements
+`TimeoutAwareAggregationStrategy`, then Camel will invoke the `timeout`
+method when the timeout occurs. Notice that the values for index and
+total parameters will be -1, and the timeout parameter will be provided
+only if configured as a fixed value. You must **not** throw any
+exceptions from the `timeout` method.
+
+## Aggregate with persistent repository
+
+The aggregator provides a pluggable repository which you can implement
+your own `org.apache.camel.spi.AggregationRepository`.
+
+If you need a persistent repository, then Camel provides numerous
+implementations, such as from the
+[Caffeine](#ROOT:caffeine-cache-component.adoc),
+[CassandraQL](#ROOT:cql-component.adoc),
+[EHCache](#ROOT:ehcache-component.adoc),
+[Infinispan](#ROOT:infinispan-component.adoc),
+[JCache](#ROOT:jcache-component.adoc), [LevelDB](#others:leveldb.adoc),
+[Redis](#others:redis.adoc), or [SQL](#ROOT:sql-component.adoc)
+components.
+
+# Completion
+
+When aggregation [Exchange](#manual::exchange.adoc)s at some point, you
+need to indicate that the aggregated exchanges are complete, so they can
+be sent out of the aggregator. Camel allows you to indicate completion
+in various ways as follows:
+
+-   *completionTimeout*: Is an inactivity timeout in that is triggered
+    if no new exchanges have been aggregated for that particular
+    correlation key within the period.
+
+-   *completionInterval*: Once every X period all the current aggregated
+    exchanges are completed.
+
+-   *completionSize*: Is a number indicating that after X aggregated
+    exchanges its complete.
+
+-   *completionPredicate*: Runs a [Predicate](#manual::predicate.adoc)
+    when a new exchange is aggregated to determine if we are complete or
+    not. The configured aggregationStrategy can implement the Predicate
+    interface and will be used as the completionPredicate if no
+    completionPredicate is configured. The configured
+    aggregationStrategy can override the `preComplete` method and will
+    be used as the completionPredicate in pre-complete check mode. See
+    further below for more details.
+
+-   *completionFromBatchConsumer*: Special option for [Batch
+    Consumer](#manual::batch-consumer.adoc), which allows you to
+    complete when all the messages from the batch have been aggregated.
+
+-   *forceCompletionOnStop*: Indicates to complete all current
+    aggregated exchanges when the context is stopped
+
+-   *AggregateController*: which allows to use an external source
+    (`AggregateController` implementation) to complete groups or all
+    groups. This can be done using Java or JMX API.
+
+All the different completions are per correlation key. You can combine
+them in any way you like. It’s basically the first that triggers that
+wins. So you can use a completion size together with a completion
+timeout. Only completionTimeout and completionInterval cannot be used at
+the same time.
+
+Completion is mandatory and must be configured on the aggregation.
+
+## Pre-completion mode
+
+There can be use-cases where you want the incoming
+[Exchange](#manual::exchange.adoc) to determine if the correlation group
+should pre-complete, and then the incoming
+[Exchange](#manual::exchange.adoc) is starting a new group from scratch.
+The pre-completion mode must be enabled by the `AggregationStrategy` by
+overriding the `canPreComplete` method to return a `true` value.
+
+When pre-completion is enabled then the `preComplete` method is invoked:
+
+    /**
+     * Determines if the aggregation should complete the current group, and start a new group, or the aggregation
+     * should continue using the current group.
+     *
+     * @param oldExchange the oldest exchange (is <tt>null</tt> on first aggregation as we only have the new exchange)
+     * @param newExchange the newest exchange (can be <tt>null</tt> if there was no data possible to acquire)
+     * @return <tt>true</tt> to complete current group and start a new group, or <tt>false</tt> to keep using current
+     */
+    boolean preComplete(Exchange oldExchange, Exchange newExchange);
+
+If the `preComplete` method returns `true`, then the existing
+correlation group is completed (without aggregating the incoming
+exchange (`newExchange`). Then the `newExchange` is used to start the
+correlation group from scratch, so the group would contain only that new
+incoming exchange. This is known as pre-completion mode.
+
+The `newExchange` contains the following exchange properties, which can
+be used to determine whether to pre complete.
+
+<table>
+<colgroup>
+<col style="width: 30%" />
+<col style="width: 10%" />
+<col style="width: 59%" />
+</colgroup>
+<thead>
+<tr class="header">
+<th style="text-align: left;">Property</th>
+<th style="text-align: left;">Type</th>
+<th style="text-align: left;">Description</th>
+</tr>
+</thead>
+<tbody>
+<tr class="odd">
+<td
+style="text-align: left;"><p><code>CamelAggregatedSize</code></p></td>
+<td style="text-align: left;"><p><code>int</code></p></td>
+<td style="text-align: left;"><p>The total number of messages
+aggregated.</p></td>
+</tr>
+<tr class="even">
+<td
+style="text-align: left;"><p><code>CamelAggregatedCorrelationKey</code></p></td>
+<td style="text-align: left;"><p><code>String</code></p></td>
+<td style="text-align: left;"><p>The correlation identifier as a
+<code>String</code>.</p></td>
+</tr>
+</tbody>
+</table>
+
+When the aggregation is in *pre-completion* mode, then only the
+following completions are in use:
+
+-   *completionTimeout* or *completionInterval* can also be used as
+    fallback completions
+
+-   any other completions are not used (such as by size, from batch
+    consumer, etc.)
+
+-   *eagerCheckCompletion* is implied as `true`, but the option has no
+    effect
+
+## CompletionAwareAggregationStrategy
+
+If your aggregation strategy implements
+`CompletionAwareAggregationStrategy`, then Camel will invoke the
+`onComplete` method when the aggregated `Exchange` is completed. This
+allows you to do any last minute custom logic such as to clean up some
+resources, or additional work on the exchange as it’s now completed. You
+must **not** throw any exceptions from the `onCompletion` method.
+
+## Completing the current group decided from the AggregationStrategy
+
+The `AggregationStrategy` supports checking for the exchange property
+(`Exchange.AGGREGATION_COMPLETE_CURRENT_GROUP`) on the returned
+`Exchange` that contains a boolean to indicate if the current group
+should be completed. This allows to overrule any existing completion
+predicates / sizes / timeouts etc., and complete the group.
+
+For example, the following logic will complete the group if the message
+body size is larger than 5. This is done by setting the exchange
+property `Exchange.AGGREGATION_COMPLETE_CURRENT_GROUP` to `true`.
+
+    public final class MyCompletionStrategy implements AggregationStrategy {
+        @Override
+        public Exchange aggregate(Exchange oldExchange, Exchange newExchange) {
+            if (oldExchange == null) {
+                return newExchange;
+            }
+            String body = oldExchange.getIn().getBody(String.class) + "+"
+                + newExchange.getIn().getBody(String.class);
+            oldExchange.getIn().setBody(body);
+            if (body.length() >= 5) {
+                oldExchange.setProperty(Exchange.AGGREGATION_COMPLETE_CURRENT_GROUP, true);
+            }
+            return oldExchange;
+        }
+    }
+
+## Completing all previous group decided from the AggregationStrategy
+
+The `AggregationStrategy` checks an exchange property, from the returned
+exchange, indicating if all previous groups should be completed.
+
+This allows to overrule any existing completion predicates / sizes /
+timeouts etc., and complete all the existing previous group.
+
+The following logic will complete all the previous groups, and start a
+new aggregation group.
+
+This is done by setting the property
+`Exchange.AGGREGATION_COMPLETE_ALL_GROUPS` to `true` on the returned
+exchange.
+
+    public final class MyCompletionStrategy implements AggregationStrategy {
+        @Override
+        public Exchange aggregate(Exchange oldExchange, Exchange newExchange) {
+            if (oldExchange == null) {
+                // we start a new correlation group, so complete all previous groups
+                newExchange.setProperty(Exchange.AGGREGATION_COMPLETE_ALL_GROUPS, true);
+                return newExchange;
+            }
+    
+            String body1 = oldExchange.getIn().getBody(String.class);
+            String body2 = newExchange.getIn().getBody(String.class);
+    
+            oldExchange.getIn().setBody(body1 + body2);
+            return oldExchange;
+        }
+    }
+
+## Manually force the completion of all aggregated Exchanges immediately
+
+You can manually trigger completion of all current aggregated exchanges
+by sending an exchange containing the exchange property
+`Exchange.AGGREGATION_COMPLETE_ALL_GROUPS` set to `true`. The message is
+considered a signal message only, the message headers/contents will not
+be processed otherwise.
+
+You can alternatively set the exchange property
+`Exchange.AGGREGATION_COMPLETE_ALL_GROUPS_INCLUSIVE` to `true` to
+trigger completion of all groups after processing the current message.
+
+## Using a controller to force the aggregator to complete
+
+The `org.apache.camel.processor.aggregate.AggregateController` allows
+you to control the aggregate at runtime using Java or JMX API. This can
+be used to force completing groups of exchanges, or query its current
+runtime statistics.
+
+The aggregator provides a default implementation if no custom one has
+been configured, which can be accessed using `getAggregateController()`
+method. Though it may be easier to configure a controller in the route
+using `aggregateController` as shown below:
+
+    private AggregateController controller = new DefaultAggregateController();
+    
+    from("direct:start")
+       .aggregate(header("id"), new MyAggregationStrategy())
+          .completionSize(10).id("myAggregator")
+          .aggregateController(controller)
+          .to("mock:aggregated");
+
+Then there is API on `AggregateController` to force completion. For
+example, to complete a group with key foo:
+
+    int groups = controller.forceCompletionOfGroup("foo");
+
+The returned value is the number of groups completed. A value of 1 is
+returned if the foo group existed, otherwise 0 is returned.
+
+There is also a method to complete all groups:
+
+    int groups = controller.forceCompletionOfAllGroups();
+
+The controller can also be used in XML DSL using the
+`aggregateController` to refer to a bean with the controller
+implementation, which is looked up in the registry.
+
+When using Spring XML, you can create the bean with `<bean>` as shown:
+
+    <bean id="myController" class="org.apache.camel.processor.aggregate.DefaultAggregateController"/>
+    
+    <camelContext xmlns="http://camel.apache.org/schema/spring">
+        <route>
+            <from uri="direct:start"/>
+            <aggregate aggregationStrategy="myAppender" completionSize="10"
+                       aggregateController="myController">
+                <correlationExpression>
+                    <header>id</header>
+                </correlationExpression>
+                <to uri="mock:result"/>
+            </aggregate>
+        </route>
+    </camelContext>
+
+There is also JMX API on the aggregator which is available under the
+processors node in the Camel JMX tree.
+
+# Aggregating with Beans
+
+To use the `AggregationStrategy` you had to implement the
+`org.apache.camel.AggregationStrategy` interface, which means your logic
+would be tied to the Camel API. You can use a bean for the logic and let
+Camel adapt to your bean. To use a bean, then a convention must be
+followed:
+
+-   there must be a public method to use
+
+-   the method must not be void
+
+-   the method can be static or non-static
+
+-   the method must have two or more parameters
+
+-   the parameters are paired, so the first half is applied to the
+    `oldExchange`, and the reminder half is for the `newExchange`.
+    Therefore, there must be an equal number of parameters, e.g., 2, 4,
+    6, etc.
+
+The paired methods are expected to be ordered as follows:
+
+-   the first parameter is the message body
+
+-   optional, the second parameter is a `Map` of the headers
+
+-   optional, the third parameter is a `Map` of the exchange properties
+
+This convention is best explained with some examples.
+
+In the method below, we have only two parameters, so the first parameter
+is the body of the `oldExchange`, and the second is paired to the body
+of the `newExchange`:
+
+    public String append(String existing, String next) {
+        return existing + next;
+    }
+
+In the method below, we have only four parameters, so the first
+parameter is the body of the `oldExchange`, and the second is the `Map`
+of the `oldExchange` headers, and the third is paired to the body of the
+`newExchange`, and the fourth parameter is the `Map` of the
+`newExchange` headers:
+
+    public String append(String existing, Map existingHeaders, String next, Map nextHeaders) {
+        return existing + next;
+    }
+
+And finally, if we have six parameters, that includes the exchange
+properties:
+
+    public String append(String existing, Map existingHeaders, Map existingProperties,
+                         String next, Map nextHeaders, Map nextProperties) {
+        return existing + next;
+    }
+
+To use this with the aggregate EIP, we can use a bean with the aggregate
+logic as follows:
+
+    public class MyBodyAppender {
+    
+        public String append(String existing, String next) {
+            return next + existing;
+        }
+    
+    }
+
+And then in the Camel route we create an instance of our bean, and then
+refer to the bean in the route using `bean` method from
+`org.apache.camel.builder.AggregationStrategies` as shown:
+
+    private MyBodyAppender appender = new MyBodyAppender();
+    
+    public void configure() throws Exception {
+        from("direct:start")
+            .aggregate(constant(true), AggregationStrategies.bean(appender, "append"))
+                .completionSize(3)
+                .to("mock:result");
+    }
+
+We can also provide the bean class type directly:
+
+    public void configure() throws Exception {
+        from("direct:start")
+            .aggregate(constant(true), AggregationStrategies.bean(MyBodyAppender.class, "append"))
+                .completionSize(3)
+                .to("mock:result");
+    }
+
+And if the bean has only one method, we do not need to specify the name
+of the method:
+
+    public void configure() throws Exception {
+        from("direct:start")
+            .aggregate(constant(true), AggregationStrategies.bean(MyBodyAppender.class))
+                .completionSize(3)
+                .to("mock:result");
+    }
+
+And the `append` method could be static:
+
+    public class MyBodyAppender {
+    
+        public static String append(String existing, String next) {
+            return next + existing;
+        }
+    
+    }
+
+If you are using XML DSL, then we need to declare a `<bean>` with the
+bean:
+
+    <bean id="myAppender" class="com.foo.MyBodyAppender"/>
+
+And in the Camel route we use `aggregationStrategy` to refer to the bean
+by its id, and the `strategyMethodName` can be used to define the method
+name to call:
+
+    <camelContext xmlns="http://camel.apache.org/schema/spring">
+        <route>
+            <from uri="direct:start"/>
+            <aggregate aggregationStrategy="myAppender" aggregationStrategyMethodName="append" completionSize="3">
+                <correlationExpression>
+                    <constant>true</constant>
+                </correlationExpression>
+                <to uri="mock:result"/>
+            </aggregate>
+        </route>
+    </camelContext>
+
+When using XML DSL, you can also specify the bean class directly in
+`aggregationStrategy` using the `#class:` syntax as shown:
+
+    <route>
+        <from uri="direct:start"/>
+        <aggregate aggregationStrategy="#class:com.foo.MyBodyAppender" aggregationStrategyMethodName="append" completionSize="3">
+            <correlationExpression>
+                <constant>true</constant>
+            </correlationExpression>
+            <to uri="mock:result"/>
+        </aggregate>
+    </route>
+
+You can use this in XML DSL when you are not using the classic Spring
+XML files ( where you use XML only for Camel routes).
+
+## Aggregating when no data
+
+When using bean as `AggregationStrategy`, then the method is **only**
+invoked when there is data to be aggregated, meaning that the message
+body is not `null`. In cases where you want to have the method invoked,
+even when there are no data (message body is `null`), then set the
+`strategyMethodAllowNull` to `true`.
+
+When using beans, this can be configured a bit easier using the
+`beanAllowNull` method from `AggregationStrategies` as shown:
+
+    public void configure() throws Exception {
+        from("direct:start")
+            .pollEnrich("seda:foo", 1000, AggregationStrategies.beanAllowNull(appender, "append"))
+                .to("mock:result");
+    }
+
+Then the `append` method in the bean would need to deal with the
+situation that `newExchange` can be `null`:
+
+    public class MyBodyAppender {
+    
+        public String append(String existing, String next) {
+            if (next == null) {
+                return "NewWasNull" + existing;
+            } else {
+                return existing + next;
+            }
+        }
+    
+    }
+
+In the example above we use the [Content
+Enricher](#content-enricher.adoc) EIP using `pollEnrich`. The
+`newExchange` will be `null` in the situation we could not get any data
+from the "seda:foo" endpoint, and a timeout was hit after 1 second.
+
+So if we need to do special merge logic, we would need to set
+`setAllowNullNewExchange=true`. If we didn’t do this, then on timeout
+the append method would normally not be invoked, meaning the [Content
+Enricher](#content-enricher.adoc) did not merge/change the message.
+
+In XML DSL you would configure the `strategyMethodAllowNull` option and
+set it to `true` as shown below:
+
+    <camelContext xmlns="http://camel.apache.org/schema/spring">
+        <route>
+            <from uri="direct:start"/>
+            <aggregate aggregationStrategy="myAppender"
+                       aggregationStrategyMethodName="append"
+                       aggregationStrategyMethodAllowNull="true"
+                       completionSize="3">
+                <correlationExpression>
+                    <constant>true</constant>
+                </correlationExpression>
+                <to uri="mock:result"/>
+            </aggregate>
+        </route>
+    </camelContext>
+
+## Aggregating with different body types
+
+When, for example, using `strategyMethodAllowNull` as `true`, then the
+parameter type of the message bodies does not have to be the same. For
+example suppose we want to aggregate from a `com.foo.User` type to a
+`List<String>` that contains the name of the user. We could code a bean
+as follows:
+
+    public final class MyUserAppender {
+    
+        public List addUsers(List names, User user) {
+            if (names == null) {
+                names = new ArrayList();
+            }
+            names.add(user.getName());
+            return names;
+        }
+    }
+
+Notice that the return type is a `List` which we want to contain the
+name of the users. The first parameter is the `List` of names, and the
+second parameter is the incoming `com.foo.User` type.

camel-ai-summary.md

@@ -0,0 +1,10 @@
+# Ai-summary.md
+
+The Camel AI components are a group of components for applying Apache
+Camel to various AI-related technologies.
+
+# AI components
+
+See the following for usage of each component:
+
+indexDescriptionList::\[attributes=*group=AI*,descriptionformat=description\]

camel-asn1-dataformat.md

@@ -0,0 +1,83 @@
+# Asn1-dataformat.md
+
+**Since Camel 2.20**
+
+The [ASN.1 Data
+Format](https://www.itu.int/en/ITU-T/asn1/Pages/introduction.aspx) is a
+Camel Framework’s data format implementation based on Bouncy Castle’s
+bcprov-jdk18on library and jASN.1’s java compiler for the formal
+notation used for describing data transmitted by telecommunications
+protocols, regardless of language implementation and physical
+representation of these data, whatever the application, whether complex
+or very simple. Messages can be unmarshalled (conversion to simple Java
+POJO(s)) to plain Java objects. With the help of Camel’s routing engine
+and data transformations, you can then play with POJO(s) and apply
+customized formatting and call other Camel Components to convert and
+send messages to upstream systems.
+
+# ASN.1 Data Format Options
+
+# Unmarshal
+
+There are 3 different ways to unmarshal ASN.1 structured messages.
+(Usually binary files)
+
+In this first example, we unmarshal BER file payload to OutputStream and
+send it to mock endpoint.
+
+    from("direct:unmarshal").unmarshal(asn1).to("mock:unmarshal");
+
+In the second example, we unmarshal BER file payload to a byte array
+using Split EIP. The reason for applying Split EIP is that usually each
+BER file or (ASN.1 structured file) contains multiple records to process
+and Split EIP helps us to get each record in a file as byte arrays which
+is actually ASN1Primitive’s instance (by the use of Bouncy Castle’s
+ASN.1 support in bcprov-jdk18on library) Byte arrays then may be
+converted to ASN1Primitive by the help of public static method in
+(ASN1Primitive.fromByteArray) In such example, note that you need to set
+`usingIterator=true`
+
+    from("direct:unmarshal")
+        .unmarshal(asn1)
+        .split(bodyAs(Iterator.class)).streaming()
+            .to("mock:unmarshal");
+
+In the last example, we unmarshalled a BER file payload to plain old
+Java Objects using Split EIP. The reason for applying Split EIP is
+already mentioned in the previous example. Please note and keep in mind
+that reason. In such example we also need to set the fully qualified
+name of the class or \<YourObject\>.class reference through data
+format. The important thing to note here is that your object should have
+been generated by jasn1 compiler, which is a nice tool to generate java
+object representations of your ASN.1 structure. For the reference usage
+of jasn1 compiler, see the [JASN.1 Project
+Page](https://www.beanit.com/asn1/) and please also see how the compiler
+is invoked with the help of maven’s exec plugin. For example, in this
+data format’s unit tests an example ASN.1 structure(TestSMSBerCdr.asn1)
+is added in `src/test/resources/asn1_structure`. jasn1 compiler is
+invoked, and java object’s representations are generated in
+`${basedir}/target/generated/src/test/java` The nice thing about this
+example, you will get POJO instance at the mock endpoint or at whatever
+your endpoint is.
+
+    from("direct:unmarshaldsl")
+             .unmarshal()
+             .asn1("org.apache.camel.dataformat.asn1.model.testsmscbercdr.SmsCdr")
+             .split(bodyAs(Iterator.class)).streaming()
+                .to("mock:unmarshaldsl");
+
+# Dependencies
+
+To use ASN.1 data format in your camel routes you need to add a
+dependency on **camel-asn1** which implements this data format.
+
+If you use Maven you can add the following to your `pom.xml`,
+substituting the version number for the latest \& greatest release (see
+the download page for the latest versions).
+
+    <dependency>
+      <groupId>org.apache.camel</groupId>
+      <artifactId>camel-asn1</artifactId>
+      <version>x.x.x</version>
+      <!-- use the same version as your Camel core version -->
+    </dependency>

camel-atmosphere-websocket.md

@@ -88,7 +88,7 @@ And the equivalent Spring sample:
 |---|---|---|---|
 |servicePath|Name of websocket endpoint||string|
 |chunked|If this option is false the Servlet will disable the HTTP streaming and set the content-length header on the response|true|boolean|
-|disableStreamCache|Determines whether or not the raw input stream from Servlet is cached or not (Camel will read the stream into a in memory/overflow to file, Stream caching) cache. By default Camel will cache the Servlet input stream to support reading it multiple times to ensure it Camel can retrieve all data from the stream. However you can set this option to true when you for example need to access the raw stream, such as streaming it directly to a file or other persistent store. DefaultHttpBinding will copy the request input stream into a stream cache and put it into message body if this option is false to support reading the stream multiple times. If you use Servlet to bridge/proxy an endpoint then consider enabling this option to improve performance, in case you do not need to read the message payload multiple times. The http producer will by default cache the response body stream. If setting this option to true, then the producers will not cache the response body stream but use the response stream as-is as the message body.|false|boolean|
+|disableStreamCache|Determines whether or not the raw input stream is cached or not. The Camel consumer (camel-servlet, camel-jetty etc.) will by default cache the input stream to support reading it multiple times to ensure it Camel can retrieve all data from the stream. However you can set this option to true when you for example need to access the raw stream, such as streaming it directly to a file or other persistent store. DefaultHttpBinding will copy the request input stream into a stream cache and put it into message body if this option is false to support reading the stream multiple times. If you use Servlet to bridge/proxy an endpoint then consider enabling this option to improve performance, in case you do not need to read the message payload multiple times. The producer (camel-http) will by default cache the response body stream. If setting this option to true, then the producers will not cache the response body stream but use the response stream as-is (the stream can only be read once) as the message body.|false|boolean|
 |sendToAll|Whether to send to all (broadcast) or send to a single receiver.|false|boolean|
 |transferException|If enabled and an Exchange failed processing on the consumer side, and if the caused Exception was send back serialized in the response as a application/x-java-serialized-object content type. On the producer side the exception will be deserialized and thrown as is, instead of the HttpOperationFailedException. The caused exception is required to be serialized. This is by default turned off. If you enable this then be aware that Java will deserialize the incoming data from the request to Java and that can be a potential security risk.|false|boolean|
 |useStreaming|To enable streaming to send data as multiple text fragments.|false|boolean|
@@ -114,6 +114,3 @@ And the equivalent Spring sample:
 |traceEnabled|Specifies whether to enable HTTP TRACE for this Servlet consumer. By default TRACE is turned off.|false|boolean|
 |bridgeEndpoint|If the option is true, HttpProducer will ignore the Exchange.HTTP\_URI header, and use the endpoint's URI for request. You may also set the option throwExceptionOnFailure to be false to let the HttpProducer send all the fault response back.|false|boolean|
 |lazyStartProducer|Whether the producer should be started lazy (on the first message). By starting lazy you can use this to allow CamelContext and routes to startup in situations where a producer may otherwise fail during starting and cause the route to fail being started. By deferring this startup to be lazy then the startup failure can be handled during routing messages via Camel's routing error handlers. Beware that when the first message is processed then creating and starting the producer may take a little time and prolong the total processing time of the processing.|false|boolean|
-|oauth2ClientId|OAuth2 client id||string|
-|oauth2ClientSecret|OAuth2 client secret||string|
-|oauth2TokenEndpoint|OAuth2 Token endpoint||string|

camel-atom.md

@@ -39,21 +39,21 @@ Depending on the `splitEntries` flag Camel will either return one
 <col style="width: 79%" />
 </colgroup>
 <thead>
-<tr>
+<tr class="header">
 <th style="text-align: left;">Option</th>
 <th style="text-align: left;">Value</th>
 <th style="text-align: left;">Behavior</th>
 </tr>
 </thead>
 <tbody>
-<tr>
+<tr class="odd">
 <td style="text-align: left;"><p><code>splitEntries</code></p></td>
 <td style="text-align: left;"><p><code>true</code></p></td>
 <td style="text-align: left;"><p>Only a single entry from the currently
 being processed feed is set:
 <code>exchange.in.body(Entry)</code></p></td>
 </tr>
-<tr>
+<tr class="even">
 <td style="text-align: left;"><p><code>splitEntries</code></p></td>
 <td style="text-align: left;"><p><code>false</code></p></td>
 <td style="text-align: left;"><p>The entire list of entries from the

camel-attachments.md

@@ -0,0 +1,22 @@
+# Attachments.md
+
+**Since Camel 3.0**
+
+The Attachments component provides the `javax.attachments` API support
+for Apache Camel. A few Camel component uses attachments such as mail
+and web-service components. The Attachments component is included
+automatically when using these components.
+
+The Attachments support is on Camel `Message` level, for example to get
+the `javax.activation.DataHandler` instance of the attachment, you can
+do as shown below:
+
+    AttachmentMessage attMsg = exchange.getIn(AttachmentMessage.class);
+    Attachment attachment = attMsg.getAttachmentObject("myAttachment");
+    DataHandler dh = attachment.getDataHandler();
+
+And if you want to add an attachment, to a Camel `Message` you can do as
+shown:
+
+    AttachmentMessage attMsg = exchange.getIn(AttachmentMessage.class);
+    attMsg.addAttachment("message1.xml", new DataHandler(new FileDataSource(new File("myMessage1.xml"))));

camel-avro-dataformat.md

@@ -0,0 +1,69 @@
+# Avro-dataformat.md
+
+**Since Camel 2.14**
+
+This component provides a dataformat for avro, which allows
+serialization and deserialization of messages using Apache Avro’s binary
+dataformat. Since Camel 3.2 rpc functionality was moved into separate
+`camel-avro-rpc` component.
+
+There is also `camel-jackson-avro` which is a more powerful Camel
+dataformat for using Avro.
+
+Maven users will need to add the following dependency to their `pom.xml`
+for this component:
+
+    <dependency>
+        <groupId>org.apache.camel</groupId>
+        <artifactId>camel-avro</artifactId>
+        <version>x.x.x</version>
+        <!-- use the same version as your Camel core version -->
+    </dependency>
+
+You can easily generate classes from a schema, using maven, ant etc.
+More details can be found at the [Apache Avro
+documentation](http://avro.apache.org/docs/current/).
+
+# Avro Dataformat Options
+
+# Examples
+
+## Avro Data Format usage
+
+Using the avro data format is as easy as specifying that the class that
+you want to marshal or unmarshal in your route.
+
+    AvroDataFormat format = new AvroDataFormat(Value.SCHEMA$);
+    
+    from("direct:in").marshal(format).to("direct:marshal");
+    from("direct:back").unmarshal(format).to("direct:unmarshal");
+
+Where Value is an Avro Maven Plugin Generated class.
+
+or in XML
+
+        <camelContext id="camel" xmlns="http://camel.apache.org/schema/spring">
+            <route>
+                <from uri="direct:in"/>
+                <marshal>
+                    <avro instanceClass="org.apache.camel.dataformat.avro.Message" library="ApacheAvro"/>
+                </marshal>
+                <to uri="log:out"/>
+            </route>
+        </camelContext>
+
+An alternative can be to specify the dataformat inside the context and
+reference it from your route.
+
+        <camelContext id="camel" xmlns="http://camel.apache.org/schema/spring">
+             <dataFormats>
+                <avro id="avro" instanceClass="org.apache.camel.dataformat.avro.Message" library="ApacheAvro"/>
+            </dataFormats>
+            <route>
+                <from uri="direct:in"/>
+                <marshal><custom ref="avro"/></marshal>
+                <to uri="log:out"/>
+            </route>
+        </camelContext>
+
+In the same manner, you can unmarshal using the avro data format.

camel-avro.md

@@ -79,7 +79,9 @@ schema above:
 *Note: Existing classes can be used only for RPC (see below), not in
 data format.*
 
-# Using Avro RPC in Camel
+# Usage
+
+## Using Avro RPC in Camel
 
 As mentioned above, Avro also provides RPC support over multiple
 transports such as http and netty. Camel provides consumers and
@@ -164,7 +166,7 @@ is used and `getProcessor` will receive Value class directly in body,
 while `putProcessor` will receive an array of size 2 with `String` key
 and `Value` value filled as array contents.
 
-# Avro via HTTP SPI
+## Avro via HTTP SPI
 
 The Avro RPC component offers the
 `org.apache.camel.component.avro.spi.AvroRpcHttpServerFactory` service

camel-avroJackson-dataformat.md

@@ -0,0 +1,54 @@
+# AvroJackson-dataformat.md
+
+**Since Camel 3.10**
+
+Jackson Avro is a Data Format which uses the [Jackson
+library](https://github.com/FasterXML/jackson/) with the [Avro
+extension](https://github.com/FasterXML/jackson-dataformats-binary) to
+unmarshal an Avro payload into Java objects or to marshal Java objects
+into an Avro payload.
+
+If you are familiar with Jackson, this Avro data format behaves in the
+same way as its JSON counterpart, and thus can be used with classes
+annotated for JSON serialization/deserialization.
+
+    from("kafka:topic").
+      unmarshal().avro(JsonNode.class).
+      to("log:info");
+
+# Avro Jackson Options
+
+# Usage
+
+## Configuring the `SchemaResolver`
+
+Since Avro serialization is schema-based, this data format requires that
+you provide a SchemaResolver object that is able to look up the schema
+for each exchange that is going to be marshalled/unmarshalled.
+
+You can add a single SchemaResolver to the registry, and it will be
+looked up automatically. Or you can explicitly specify the reference to
+a custom SchemaResolver.
+
+## Using custom AvroMapper
+
+You can configure `JacksonAvroDataFormat` to use a custom `AvroMapper`
+in case you need more control of the mapping configuration.
+
+If you set up a single `AvroMapper` in the registry, then Camel will
+automatic lookup and use this `AvroMapper`.
+
+# Dependencies
+
+To use Avro Jackson in your Camel routes, you need to add the dependency
+on **camel-jackson-avro**, which implements this data format.
+
+If you use Maven, you could add the following to your pom.xml,
+substituting the version number for the latest \& greatest release.
+
+    <dependency>
+      <groupId>org.apache.camel</groupId>
+      <artifactId>camel-jackson-avro</artifactId>
+      <version>x.x.x</version>
+      <!-- use the same version as your Camel core version -->
+    </dependency>

camel-aws-bedrock.md

@@ -661,7 +661,9 @@ producer side:
 
 -   invokeEmbeddingsModel
 
-# Producer Examples
+# Examples
+
+## Producer Examples
 
 -   invokeTextModel: this operation will invoke a model from Bedrock.
     This is an example for both Titan Express and Titan Lite.

camel-aws-cloudtrail.md

@@ -13,7 +13,19 @@ You must have a valid Amazon Web Services developer account, and be
 signed up to use Amazon Cloudtrail. More information is available at
 [AWS Cloudtrail](https://aws.amazon.com/cloudtrail/)
 
-# Static credentials, Default Credential Provider and Profile Credentials Provider
+# URI Format
+
+    aws-cloudtrail://label[?options]
+
+The stream needs to be created prior to it being used.
+
+You can append query options to the URI in the following format:
+
+`?options=value&option2=value&...`
+
+# Usage
+
+## Static credentials, Default Credential Provider and Profile Credentials Provider
 
 You have the possibility of avoiding the usage of explicit static
 credentials by specifying the useDefaultCredentialsProvider option and
@@ -47,7 +59,7 @@ same time.
 For more information about this you can look at [AWS credentials
 documentation](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/credentials.html)
 
-# Cloudtrail Events consumed
+## Cloudtrail Events consumed
 
 The Cloudtrail consumer will use an API method called LookupEvents.
 
@@ -61,16 +73,6 @@ logs stored on S3, in case of creation of a new Trail.
 This is important to notice, and it must be taken into account when
 using this component.
 
-# URI Format
-
-    aws-cloudtrail://label[?options]
-
-The stream needs to be created prior to it being used.
-
-You can append query options to the URI in the following format:
-
-`?options=value&option2=value&...`
-
 ## Component Configurations
 
   

camel-aws-secrets-manager.md

@@ -98,6 +98,11 @@ file such as:
     camel.vault.aws.profileName = test-account
     camel.vault.aws.region = region
 
+`camel.vault.aws` configuration only applies to the AWS Secrets Manager
+properties function (E.g when resolving properties). When using the
+`operation` option to create, get, list secrets etc., you should provide
+the usual options for connecting to AWS Services.
+
 At this point, you’ll be able to reference a property in the following
 way:
 
@@ -142,7 +147,7 @@ example:
     <camelContext>
         <route>
             <from uri="direct:start"/>
-            <log message="Username is {{aws:database/username}}"/>
+            <log message="Username is {{aws:database#username}}"/>
         </route>
     </camelContext>
 
@@ -154,7 +159,7 @@ is not present on AWS Secret Manager:
     <camelContext>
         <route>
             <from uri="direct:start"/>
-            <log message="Username is {{aws:database/username:admin}}"/>
+            <log message="Username is {{aws:database#username:admin}}"/>
         </route>
     </camelContext>
 
@@ -190,7 +195,7 @@ secret doesn’t exist or the version doesn’t exist.
     <camelContext>
         <route>
             <from uri="direct:start"/>
-            <log message="Username is {{aws:database/username:admin@bf9b4f4b-8e63-43fd-a73c-3e2d3748b451}}"/>
+            <log message="Username is {{aws:database#username:admin@bf9b4f4b-8e63-43fd-a73c-3e2d3748b451}}"/>
         </route>
     </camelContext>
 
@@ -318,6 +323,8 @@ the producer side:
 
 -   getSecret
 
+-   batchGetSecret
+
 -   updateSecret
 
 -   replicateSecretToRegions

camel-aws-summary.md

@@ -0,0 +1,13 @@
+# Aws-summary.md
+
+The **aws-** component allows you to work with the
+[AWS](https://aws.amazon.com/). AWS offers a great palette of different
+components like cloudwatch, DynamoDB streams, storage service, email and
+queue services. The main reason to use AWS is its cloud computing
+platform.
+
+# AWS components
+
+See the following for usage of each component:
+
+indexDescriptionList::\[attributes=*group=AWS*,descriptionformat=description\]

camel-aws-xray.md

@@ -0,0 +1,175 @@
+# Aws-xray.md
+
+**Since Camel 2.21**
+
+The camel-aws-xray component is used for tracing and timing incoming and
+outgoing Camel messages using [AWS XRay](https://aws.amazon.com/xray/).
+
+Events (subsegments) are captured for incoming and outgoing messages
+being sent to/from Camel.
+
+# Configuration
+
+The configuration properties for the AWS XRay tracer are:
+
+<table>
+<colgroup>
+<col style="width: 10%" />
+<col style="width: 10%" />
+<col style="width: 79%" />
+</colgroup>
+<thead>
+<tr class="header">
+<th style="text-align: left;">Option</th>
+<th style="text-align: left;">Default</th>
+<th style="text-align: left;">Description</th>
+</tr>
+</thead>
+<tbody>
+<tr class="odd">
+<td style="text-align: left;"><p>addExcludePatterns</p></td>
+<td style="text-align: left;"><p> </p></td>
+<td style="text-align: left;"><p>Sets exclude pattern(s) that will
+disable tracing for Camel messages that matches the pattern. The content
+is a Set&lt;String&gt; where the key is a pattern matching routeId’s.
+The pattern uses the rules from Intercept.</p></td>
+</tr>
+<tr class="even">
+<td style="text-align: left;"><p>setTracingStrategy</p></td>
+<td style="text-align: left;"><p>NoopTracingStrategy</p></td>
+<td style="text-align: left;"><p>Allows a custom Camel
+<code>InterceptStrategy</code> to be provided to track invoked processor
+definitions like <code>BeanDefinition</code> or
+<code>ProcessDefinition</code>.
+<code>TraceAnnotatedTracingStrategy</code> will track any classes
+invoked via <code>.bean(...)</code> or <code>.process(...)</code> that
+contain a <code>@XRayTrace</code> annotation at class level.</p></td>
+</tr>
+</tbody>
+</table>
+
+There is currently only one way an AWS XRay tracer can be configured to
+provide distributed tracing for a Camel application:
+
+## Explicit
+
+Include the `camel-aws-xray` component in your POM, along with any
+specific dependencies associated with the AWS XRay Tracer.
+
+To explicitly configure AWS XRay support, instantiate the `XRayTracer`
+and initialize the camel context. You can optionally specify a `Tracer`,
+or alternatively it can be implicitly discovered using the `Registry` or
+`ServiceLoader`.
+
+    XRayTracer xrayTracer = new XRayTracer();
+    // By default, it uses a NoopTracingStrategy, but you can override it with a specific InterceptStrategy implementation.
+    xrayTracer.setTracingStrategy(...);
+    // And then initialize the context
+    xrayTracer.init(camelContext);
+
+To use XRayTracer in XML, all you need to do is to define the AWS XRay
+tracer bean. Camel will automatically discover and use it.
+
+      <bean id="tracingStrategy" class="..."/>
+      <bean id="aws-xray-tracer" class="org.apache.camel.component.aws.xray.XRayTracer">
+        <property name="tracer" ref="tracingStrategy"/>
+      </bean>
+
+In case of the default `NoopTracingStrategy` only the creation and
+deletion of exchanges is tracked but not the invocation of certain beans
+or EIP patterns.
+
+## Tracking of comprehensive route execution
+
+To track the execution of an exchange among multiple routes, on exchange
+creation a unique trace ID is generated and stored in the headers if no
+corresponding value was yet available. This trace ID is copied over to
+new exchanges to keep a consistent view of the processed exchange.
+
+As AWS XRay traces work on a thread-local basis, the current sub/segment
+should be copied over to the new thread and set as explained in [the AWS
+XRay
+documentation](https://docs.aws.amazon.com/xray/latest/devguide/xray-sdk-java-multithreading.html).
+The Camel AWS XRay component therefore provides an additional header
+field that the component will use to set the passed AWS XRay `Entity` to
+the new thread and thus keep the tracked data to the route rather than
+exposing a new segment which seems uncorrelated with any of the executed
+routes.
+
+The component will use the following constants found in the headers of
+the exchange:
+
+<table>
+<colgroup>
+<col style="width: 30%" />
+<col style="width: 69%" />
+</colgroup>
+<thead>
+<tr class="header">
+<th style="text-align: left;">Header</th>
+<th style="text-align: left;">Description</th>
+</tr>
+</thead>
+<tbody>
+<tr class="odd">
+<td style="text-align: left;"><p>Camel-AWS-XRay-Trace-ID</p></td>
+<td style="text-align: left;"><p>Contains a reference to the AWS XRay
+<code>TraceID</code> object to provide a comprehensive view of the
+invoked routes</p></td>
+</tr>
+<tr class="even">
+<td style="text-align: left;"><p>Camel-AWS-XRay-Trace-Entity</p></td>
+<td style="text-align: left;"><p>Contains a reference to the actual AWS
+XRay <code>Segment</code> or <code>Subsegment</code> which is copied
+over to the new thread. This header should be set in case a new thread
+is spawned and the performed tasks should be exposed as part of the
+executed route instead of creating a new unrelated segment.</p></td>
+</tr>
+</tbody>
+</table>
+
+Note that the AWS XRay `Entity` (i.e., `Segment` and `Subsegment`) are
+not serializable and therefore should not get passed to other JVM
+processes.
+
+# Example
+
+You can find an example demonstrating the way to configure AWS XRay
+tracing within the tests accompanying this project.
+
+# Dependency
+
+To include AWS XRay support into Camel, the archive containing the Camel
+related AWS XRay related classes needs to be added to the project. In
+addition to that, AWS XRay libraries also need to be available.
+
+To include both AWS XRay and Camel dependencies, use the following Maven
+imports:
+
+      <dependencyManagement>
+        <dependencies>
+          <dependency>
+            <groupId>com.amazonaws</groupId>
+            <artifactId>aws-xray-recorder-sdk-bom</artifactId>
+            <version>2.4.0</version>
+            <type>pom</type>
+            <scope>import</scope>
+          </dependency>
+        </dependencies>
+      </dependencyManagement>
+    
+      <dependencies>
+          <dependency>
+            <groupId>org.apache.camel</groupId>
+            <artifactId>camel-aws-xray</artifactId>
+          </dependency>
+    
+          <dependency>
+            <groupId>com.amazonaws</groupId>
+            <artifactId>aws-xray-recorder-sdk-core</artifactId>
+          </dependency>
+          <dependency>
+            <groupId>com.amazonaws</groupId>
+            <artifactId>aws-xray-recorder-sdk-aws-sdk</artifactId>
+          </dependency>
+      </dependencies>

camel-aws2-athena.md

@@ -361,12 +361,12 @@ Camel.
 |accessKey|Amazon AWS Access Key.||string|
 |encryptionOption|The encryption type to use when storing query results in S3. One of SSE\_S3, SSE\_KMS, or CSE\_KMS.||object|
 |kmsKey|For SSE-KMS and CSE-KMS, this is the KMS key ARN or ID.||string|
-|profileCredentialsName|If using a profile credentials provider this parameter will set the profile name||string|
+|profileCredentialsName|If using a profile credentials provider, this parameter will set the profile name||string|
 |secretKey|Amazon AWS Secret Key.||string|
 |sessionToken|Amazon AWS Session Token used when the user needs to assume an IAM role||string|
 |useDefaultCredentialsProvider|Set whether the Athena client should expect to load credentials through a default credentials provider or to expect static credentials to be passed in|false|boolean|
 |useProfileCredentialsProvider|Set whether the Athena client should expect to load credentials through a profile credentials provider.|false|boolean|
-|useSessionCredentials|Set whether the Athena client should expect to use Session Credentials. This is useful in a situation in which the user needs to assume a IAM role for doing operations in Athena.|false|boolean|
+|useSessionCredentials|Set whether the Athena client should expect to use Session Credentials. This is useful in a situation in which the user needs to assume an IAM role for doing operations in Athena.|false|boolean|
 
 ## Endpoint Configurations
 
@@ -400,9 +400,9 @@ Camel.
 |accessKey|Amazon AWS Access Key.||string|
 |encryptionOption|The encryption type to use when storing query results in S3. One of SSE\_S3, SSE\_KMS, or CSE\_KMS.||object|
 |kmsKey|For SSE-KMS and CSE-KMS, this is the KMS key ARN or ID.||string|
-|profileCredentialsName|If using a profile credentials provider this parameter will set the profile name||string|
+|profileCredentialsName|If using a profile credentials provider, this parameter will set the profile name||string|
 |secretKey|Amazon AWS Secret Key.||string|
 |sessionToken|Amazon AWS Session Token used when the user needs to assume an IAM role||string|
 |useDefaultCredentialsProvider|Set whether the Athena client should expect to load credentials through a default credentials provider or to expect static credentials to be passed in|false|boolean|
 |useProfileCredentialsProvider|Set whether the Athena client should expect to load credentials through a profile credentials provider.|false|boolean|
-|useSessionCredentials|Set whether the Athena client should expect to use Session Credentials. This is useful in a situation in which the user needs to assume a IAM role for doing operations in Athena.|false|boolean|
+|useSessionCredentials|Set whether the Athena client should expect to use Session Credentials. This is useful in a situation in which the user needs to assume an IAM role for doing operations in Athena.|false|boolean|

camel-aws2-ddb.md

@@ -91,7 +91,7 @@ URI:
 
 The `#client` refers to a `DynamoDbClient` in the Registry.
 
-# Supported producer operations
+## Supported producer operations
 
 -   BatchGetItems
 

camel-aws2-ddbstream.md

@@ -72,9 +72,9 @@ same time.
 For more information about this you can look at [AWS credentials
 documentation](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/credentials.html)
 
-# Coping with Downtime
+## Coping with Downtime
 
-## AWS DynamoDB Streams outage of less than 24 hours
+### AWS DynamoDB Streams outage of less than 24 hours
 
 The consumer will resume from the last seen sequence number (as
 implemented for

camel-aws2-ec2.md

@@ -63,7 +63,7 @@ same time.
 For more information about this you can look at [AWS credentials
 documentation](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/credentials.html)
 
-# Supported producer operations
+## Supported producer operations
 
 -   createAndRunInstances
 
@@ -149,7 +149,7 @@ documentation](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/c
             })
          .to("aws2-ec2://TestDomain?accessKey=xxxx&secretKey=xxxx&operation=terminateInstances");
 
-# Using a POJO as body
+## Using a POJO as body
 
 Sometimes building an AWS Request can be complex because of multiple
 options. We introduce the possibility to use a POJO as a body. In AWS

camel-aws2-ecs.md

@@ -85,7 +85,7 @@ side:
     from("direct:listClusters")
         .to("aws2-ecs://test?ecsClient=#amazonEcsClient&operation=listClusters")
 
-# Using a POJO as body
+## Using a POJO as body
 
 Sometimes building an AWS Request can be complex because of multiple
 options. We introduce the possibility to use a POJO as a body. In AWS

camel-aws2-eks.md

@@ -76,7 +76,9 @@ side:
 
 -   deleteCluster
 
-# Producer Examples
+# Examples
+
+## Producer Examples
 
 -   listClusters: this operation will list the available clusters in EKS
 
@@ -85,7 +87,7 @@ side:
     from("direct:listClusters")
         .to("aws2-eks://test?eksClient=#amazonEksClient&operation=listClusters")
 
-# Using a POJO as body
+## Using a POJO as body
 
 Sometimes building an AWS Request can be complex because of multiple
 options. We introduce the possibility to use a POJO as a body. In AWS

camel-aws2-eventbridge.md

@@ -28,6 +28,8 @@ You can append query options to the URI in the following format:
 
 `?options=value&option2=value&...`
 
+# Usage
+
 ## Static credentials, Default Credential Provider and Profile Credentials Provider
 
 You have the possibility of avoiding the usage of explicit static
@@ -289,7 +291,7 @@ this operation will return a list of rules associated with a target.
 this operation will return a list of entries with related ID sent to
 servicebus.
 
-# Updating the rule
+## Updating the rule
 
 To update a rule, you’ll need to perform the putRule operation again.
 There is no explicit update rule operation in the Java SDK.

camel-aws2-iam.md

@@ -97,7 +97,9 @@ producer side:
 
 -   removeUserFromGroup
 
-# Producer Examples
+# Examples
+
+## Producer Examples
 
 -   createUser: this operation will create a user in IAM
 
@@ -145,7 +147,7 @@ producer side:
     from("direct:listUsers")
         .to("aws2-iam://test?iamClient=#amazonIAMClient&operation=listGroups")
 
-# Using a POJO as body
+## Using a POJO as body
 
 Sometimes building an AWS Request can be complex because of multiple
 options. We introduce the possibility to use a POJO as a body. In AWS

camel-aws2-kinesis-firehose.md

@@ -13,8 +13,6 @@ You must have a valid Amazon Web Services developer account, and be
 signed up to use Amazon Kinesis Firehose. More information is available
 at [AWS Kinesis Firehose](https://aws.amazon.com/kinesis/firehose/)
 
-The AWS2 Kinesis Firehose component is not supported in OSGI
-
 # URI Format
 
     aws2-kinesis-firehose://delivery-stream-name[?options]

camel-aws2-kinesis.md

@@ -33,7 +33,9 @@ Required Kinesis component options
 You have to provide the KinesisClient in the Registry with proxies and
 relevant credentials configured.
 
-# Batch Consumer
+# Usage
+
+## Batch Consumer
 
 This component implements the Batch Consumer.
 
@@ -47,7 +49,7 @@ therefore, if you leave the *shardId* property in the DSL configuration
 empty, then it’ll consume all available shards otherwise only the
 specified shard corresponding to the shardId will be consumed.
 
-# Batch Producer
+## Batch Producer
 
 This component implements the Batch Producer.
 
@@ -60,8 +62,6 @@ it can be a `List`, `Set` or any other collection type. The message type
 can be one or more of types `byte[]`, `ByteBuffer`, UTF-8 `String`, or
 `InputStream`. Other types are not supported.
 
-# Usage
-
 ## Static credentials, Default Credential Provider and Profile Credentials Provider
 
 You have the possibility of avoiding the usage of explicit static
@@ -164,7 +164,7 @@ Camel.
 |iteratorType|Defines where in the Kinesis stream to start getting records|TRIM\_HORIZON|object|
 |maxResultsPerRequest|Maximum number of records that will be fetched in each poll|1|integer|
 |sequenceNumber|The sequence number to start polling from. Required if iteratorType is set to AFTER\_SEQUENCE\_NUMBER or AT\_SEQUENCE\_NUMBER||string|
-|shardClosed|Define what will be the behavior in case of shard closed. Possible value are ignore, silent and fail. In case of ignore a message will be logged and the consumer will restart from the beginning,in case of silent there will be no logging and the consumer will start from the beginning,in case of fail a ReachedClosedStateException will be raised|ignore|object|
+|shardClosed|Define what will be the behavior in case of shard closed. Possible value are ignore, silent and fail. In case of ignore a WARN message will be logged once and the consumer will not process new messages until restarted,in case of silent there will be no logging and the consumer will not process new messages until restarted,in case of fail a ReachedClosedStateException will be thrown|ignore|object|
 |shardId|Defines which shardId in the Kinesis stream to get records from||string|
 |shardMonitorInterval|The interval in milliseconds to wait between shard polling|10000|integer|
 |lazyStartProducer|Whether the producer should be started lazy (on the first message). By starting lazy you can use this to allow CamelContext and routes to startup in situations where a producer may otherwise fail during starting and cause the route to fail being started. By deferring this startup to be lazy then the startup failure can be handled during routing messages via Camel's routing error handlers. Beware that when the first message is processed then creating and starting the producer may take a little time and prolong the total processing time of the processing.|false|boolean|
@@ -202,7 +202,7 @@ Camel.
 |maxResultsPerRequest|Maximum number of records that will be fetched in each poll|1|integer|
 |sendEmptyMessageWhenIdle|If the polling consumer did not poll any files, you can enable this option to send an empty message (no body) instead.|false|boolean|
 |sequenceNumber|The sequence number to start polling from. Required if iteratorType is set to AFTER\_SEQUENCE\_NUMBER or AT\_SEQUENCE\_NUMBER||string|
-|shardClosed|Define what will be the behavior in case of shard closed. Possible value are ignore, silent and fail. In case of ignore a message will be logged and the consumer will restart from the beginning,in case of silent there will be no logging and the consumer will start from the beginning,in case of fail a ReachedClosedStateException will be raised|ignore|object|
+|shardClosed|Define what will be the behavior in case of shard closed. Possible value are ignore, silent and fail. In case of ignore a WARN message will be logged once and the consumer will not process new messages until restarted,in case of silent there will be no logging and the consumer will not process new messages until restarted,in case of fail a ReachedClosedStateException will be thrown|ignore|object|
 |shardId|Defines which shardId in the Kinesis stream to get records from||string|
 |bridgeErrorHandler|Allows for bridging the consumer to the Camel routing Error Handler, which mean any exceptions (if possible) occurred while the Camel consumer is trying to pickup incoming messages, or the likes, will now be processed as a message and handled by the routing Error Handler. Important: This is only possible if the 3rd party component allows Camel to be alerted if an exception was thrown. Some components handle this internally only, and therefore bridgeErrorHandler is not possible. In other situations we may improve the Camel component to hook into the 3rd party component and make this possible for future releases. 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|
 |exceptionHandler|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.||object|

camel-aws2-kms.md

@@ -80,7 +80,9 @@ side:
 
 -   enableKey
 
-# Producer Examples
+# Examples
+
+## Producer Examples
 
 -   listKeys: this operation will list the available keys in KMS
 
@@ -112,7 +114,7 @@ side:
           .setHeader(KMS2Constants.KEY_ID, constant("123")
           .to("aws2-kms://test?kmsClient=#amazonKmsClient&operation=enableKey")
 
-# Using a POJO as body
+## Using a POJO as body
 
 Sometimes building an AWS Request can be complex because of multiple
 options. We introduce the possibility to use a POJO as the body. In AWS

camel-aws2-mq.md

@@ -133,7 +133,7 @@ side:
         .setHeader(MQ2Constants.BROKER_ID, constant("123")
         .to("aws2-mq://test?amazonMqClient=#amazonMqClient&operation=rebootBroker")
 
-# Using a POJO as body
+## Using a POJO as body
 
 Sometimes building an AWS Request can be complex because of multiple
 options. We introduce the possibility to use a POJO as the body. In AWS

camel-aws2-msk.md

@@ -116,7 +116,7 @@ side:
         })
         .to("aws2-msk://test?mskClient=#amazonMskClient&operation=deleteCluster")
 
-# Using a POJO as body
+## Using a POJO as body
 
 Sometimes building an AWS Request can be complex because of multiple
 options. We introduce the possibility to use a POJO as the body. In AWS

camel-aws2-redshift-data.md

@@ -92,7 +92,9 @@ the producer side:
 
 -   getStatementResult
 
-# Producer Examples
+# Examples
+
+## Producer Examples
 
 -   listDatabases: this operation will list redshift databases
 
@@ -101,7 +103,7 @@ the producer side:
     from("direct:listDatabases")
         .to("aws2-redshift-data://test?awsRedshiftDataClient=#awsRedshiftDataClient&operation=listDatabases")
 
-# Using a POJO as body
+## Using a POJO as body
 
 Sometimes building an AWS Request can be complex because of multiple
 options. We introduce the possibility to use a POJO as body. In AWS

camel-aws2-s3.md

@@ -28,7 +28,9 @@ Required S3 component options
 You have to provide the amazonS3Client in the Registry or your accessKey
 and secretKey to access the [Amazon’s S3](https://aws.amazon.com/s3).
 
-# Batch Consumer
+# Usage
+
+## Batch Consumer
 
 This component implements the Batch Consumer.
 
@@ -36,14 +38,6 @@ This allows you, for instance, to know how many messages exist in this
 batch and for instance, let the Aggregator aggregate this number of
 messages.
 
-# Usage
-
-For example, to read file `hello.txt` from bucket `helloBucket`, use the
-following snippet:
-
-    from("aws2-s3://helloBucket?accessKey=yourAccessKey&secretKey=yourSecretKey&prefix=hello.txt")
-      .to("file:/var/downloaded");
-
 ## S3 Producer operations
 
 Camel-AWS2-S3 component provides the following operation on the producer
@@ -71,6 +65,14 @@ If you don’t specify an operation, explicitly the producer will do:
 
 -   a multipart upload if multiPartUpload option is enabled
 
+# Examples
+
+For example, to read file `hello.txt` from bucket `helloBucket`, use the
+following snippet:
+
+    from("aws2-s3://helloBucket?accessKey=yourAccessKey&secretKey=yourSecretKey&prefix=hello.txt")
+      .to("file:/var/downloaded");
+
 ## Advanced AmazonS3 configuration
 
 If your Camel Application is running behind a firewall or if you need to
@@ -301,7 +303,84 @@ If checksum validations are enabled, the url will no longer be browser
 compatible because it adds a signed header that must be included in the
 HTTP request.
 
-# Streaming Upload mode
+## AWS S3 Producer minimum permissions
+
+For making the producer work, you’ll need at least PutObject and
+ListBuckets permissions. The following policy will be enough:
+
+    {
+        "Version": "2012-10-17",
+        "Statement": [
+            {
+                "Effect": "Allow",
+                "Action": "s3:PutObject",
+                "Resource": "arn:aws:s3:::*/*"
+            },
+            {
+                "Effect": "Allow",
+                "Action": "s3:ListBucket",
+                "Resource": "arn:aws:s3:::*"
+            }
+        ]
+    }
+
+A variation to the minimum permissions is related to the usage of Bucket
+autocreation. In that case the permissions will need to be increased
+with CreateBucket permission
+
+    {
+        "Version": "2012-10-17",
+        "Statement": [
+            {
+                "Effect": "Allow",
+                "Action": "s3:PutObject",
+                "Resource": "arn:aws:s3:::*/*"
+            },
+            {
+                "Effect": "Allow",
+                "Action": "s3:ListBucket",
+                "Resource": "arn:aws:s3:::*"
+            },
+            {
+                "Effect": "Allow",
+                "Action": "s3:CreateBucket",
+                "Resource": "arn:aws:s3:::*"
+            }
+        ]
+    }
+
+## AWS S3 Consumer minimum permissions
+
+For making the producer work, you’ll need at least GetObject,
+ListBuckets and DeleteObject permissions. The following policy will be
+enough:
+
+    {
+        "Version": "2012-10-17",
+        "Statement": [
+            {
+                "Effect": "Allow",
+                "Action": "s3:ListBucket",
+                "Resource": "arn:aws:s3:::*"
+            },
+            {
+                "Effect": "Allow",
+                "Action": "s3:GetObject",
+                "Resource": "arn:aws:s3:::*/*"
+            },
+            {
+                "Effect": "Allow",
+                "Action": "s3:DeleteObject",
+                "Resource": "arn:aws:s3:::*/*"
+            }
+        ]
+    }
+
+By Default the consumer will use the deleteAfterRead option, this means
+the object will be deleted once consumed, this is why the DeleteObject
+permission is required.
+
+## Streaming Upload mode
 
 With the stream mode enabled, users will be able to upload data to S3
 without knowing ahead of time the dimension of the data, by leveraging
@@ -373,14 +452,14 @@ As an example:
 
 In this case, the upload will be completed after 10 seconds.
 
-# Bucket Auto-creation
+## Bucket Auto-creation
 
 With the option `autoCreateBucket` users are able to avoid the
 auto-creation of an S3 Bucket in case it doesn’t exist. The default for
 this option is `false`. If set to false, any operation on a not-existent
 bucket in AWS won’t be successful and an error will be returned.
 
-# Moving stuff between a bucket and another bucket
+## Moving stuff between a bucket and another bucket
 
 Some users like to consume stuff from a bucket and move the content in a
 different one without using the copyObject feature of this component. If
@@ -388,7 +467,7 @@ this is case for you, remember to remove the bucketName header from the
 incoming exchange of the consumer, otherwise the file will always be
 overwritten on the same original bucket.
 
-# MoveAfterRead consumer option
+## MoveAfterRead consumer option
 
 In addition to deleteAfterRead, it has been added another option,
 moveAfterRead. With this option enabled, the consumed object will be
@@ -418,7 +497,7 @@ to true as default).
 So if the file name is test, in the *myothercamelbucket* you should see
 a file called pre-test-suff.
 
-# Using customer key as encryption
+## Using the customer key as encryption
 
 We introduced also the customer key support (an alternative of using
 KMS). The following code shows an example.
@@ -435,7 +514,7 @@ KMS). The following code shows an example.
         .setBody(constant("Test"))
         .to(awsEndpoint);
 
-# Using a POJO as body
+## Using a POJO as body
 
 Sometimes building an AWS Request can be complex because of multiple
 options. We introduce the possibility to use a POJO as the body. In AWS
@@ -449,7 +528,7 @@ brokers request, you can do something like:
 In this way, you’ll pass the request directly without the need of
 passing headers and options specifically related to this operation.
 
-# Create S3 client and add component to registry
+## Create S3 client and add component to registry
 
 Sometimes you would want to perform some advanced configuration using
 AWS2S3Configuration, which also allows to set the S3 client. You can
@@ -504,6 +583,7 @@ Camel.
 |configuration|The component configuration||object|
 |delimiter|The delimiter which is used in the com.amazonaws.services.s3.model.ListObjectsRequest to only consume objects we are interested in.||string|
 |forcePathStyle|Set whether the S3 client should use path-style URL instead of virtual-hosted-style|false|boolean|
+|ignoreBody|If it is true, the S3 Object Body will be ignored completely if it is set to false, the S3 Object will be put in the body. Setting this to true will override any behavior defined by includeBody option.|false|boolean|
 |overrideEndpoint|Set the need for overriding the endpoint. This option needs to be used in combination with the uriEndpointOverride option|false|boolean|
 |pojoRequest|If we want to use a POJO request as body or not|false|boolean|
 |policy|The policy for this queue to set in the com.amazonaws.services.s3.AmazonS3#setBucketPolicy() method.||string|
@@ -520,7 +600,6 @@ Camel.
 |destinationBucketSuffix|Define the destination bucket suffix to use when an object must be moved, and moveAfterRead is set to true.||string|
 |doneFileName|If provided, Camel will only consume files if a done file exists.||string|
 |fileName|To get the object from the bucket with the given file name||string|
-|ignoreBody|If it is true, the S3 Object Body will be ignored completely if it is set to false, the S3 Object will be put in the body. Setting this to true will override any behavior defined by includeBody option.|false|boolean|
 |includeBody|If it is true, the S3Object exchange will be consumed and put into the body and closed. If false, the S3Object stream will be put raw into the body and the headers will be set with the S3 object metadata. This option is strongly related to the autocloseBody option. In case of setting includeBody to true because the S3Object stream will be consumed then it will also be closed, while in case of includeBody false then it will be up to the caller to close the S3Object stream. However, setting autocloseBody to true when includeBody is false it will schedule to close the S3Object stream automatically on exchange completion.|true|boolean|
 |includeFolders|If it is true, the folders/directories will be consumed. If it is false, they will be ignored, and Exchanges will not be created for those|true|boolean|
 |moveAfterRead|Move objects from S3 bucket to a different bucket after they have been retrieved. To accomplish the operation, the destinationBucket option must be set. The copy bucket operation is only performed if the Exchange is committed. If a rollback occurs, the object is not moved.|false|boolean|
@@ -569,6 +648,7 @@ Camel.
 |autoCreateBucket|Setting the autocreation of the S3 bucket bucketName. This will apply also in case of moveAfterRead option enabled, and it will create the destinationBucket if it doesn't exist already.|false|boolean|
 |delimiter|The delimiter which is used in the com.amazonaws.services.s3.model.ListObjectsRequest to only consume objects we are interested in.||string|
 |forcePathStyle|Set whether the S3 client should use path-style URL instead of virtual-hosted-style|false|boolean|
+|ignoreBody|If it is true, the S3 Object Body will be ignored completely if it is set to false, the S3 Object will be put in the body. Setting this to true will override any behavior defined by includeBody option.|false|boolean|
 |overrideEndpoint|Set the need for overriding the endpoint. This option needs to be used in combination with the uriEndpointOverride option|false|boolean|
 |pojoRequest|If we want to use a POJO request as body or not|false|boolean|
 |policy|The policy for this queue to set in the com.amazonaws.services.s3.AmazonS3#setBucketPolicy() method.||string|
@@ -584,7 +664,6 @@ Camel.
 |destinationBucketSuffix|Define the destination bucket suffix to use when an object must be moved, and moveAfterRead is set to true.||string|
 |doneFileName|If provided, Camel will only consume files if a done file exists.||string|
 |fileName|To get the object from the bucket with the given file name||string|
-|ignoreBody|If it is true, the S3 Object Body will be ignored completely if it is set to false, the S3 Object will be put in the body. Setting this to true will override any behavior defined by includeBody option.|false|boolean|
 |includeBody|If it is true, the S3Object exchange will be consumed and put into the body and closed. If false, the S3Object stream will be put raw into the body and the headers will be set with the S3 object metadata. This option is strongly related to the autocloseBody option. In case of setting includeBody to true because the S3Object stream will be consumed then it will also be closed, while in case of includeBody false then it will be up to the caller to close the S3Object stream. However, setting autocloseBody to true when includeBody is false it will schedule to close the S3Object stream automatically on exchange completion.|true|boolean|
 |includeFolders|If it is true, the folders/directories will be consumed. If it is false, they will be ignored, and Exchanges will not be created for those|true|boolean|
 |maxConnections|Set the maxConnections parameter in the S3 client configuration|60|integer|

camel-aws2-sns.md

@@ -33,8 +33,6 @@ You have to provide the amazonSNSClient in the Registry or your
 accessKey and secretKey to access the [Amazon’s
 SNS](https://aws.amazon.com/sns).
 
-# Usage
-
 ## Static credentials, Default Credential Provider and Profile Credentials Provider
 
 You have the possibility of avoiding the usage of explicit static
@@ -69,6 +67,8 @@ same time.
 For more information about this you can look at [AWS credentials
 documentation](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/credentials.html)
 
+# Usage
+
 ## Advanced AmazonSNS configuration
 
 If you need more control over the `SnsClient` instance configuration you
@@ -97,14 +97,14 @@ your SQS Queue
     from("aws2-sqs://test-camel?amazonSQSClient=#amazonSQSClient&delay=50&maxMessagesPerPoll=5")
         .to(...);
 
-# Topic Autocreation
+## Topic Auto-creation
 
 With the option `autoCreateTopic` users are able to avoid the
-autocreation of an SNS Topic in case it doesn’t exist. The default for
+auto-creation of an SNS Topic in case it doesn’t exist. The default for
 this option is `false`. If set to false, any operation on a non-existent
 topic in AWS won’t be successful and an error will be returned.
 
-# SNS FIFO
+## SNS FIFO
 
 SNS FIFO are supported. While creating the SQS queue, you will subscribe
 to the SNS topic there is an important point to remember, you’ll need to
@@ -112,10 +112,10 @@ make possible for the SNS Topic to send the message to the SQS Queue.
 
 This is clear with an example.
 
-Suppose you created an SNS FIFO Topic called Order.fifo and an SQS Queue
-called QueueSub.fifo.
+Suppose you created an SNS FIFO Topic called `Order.fifo` and an SQS
+Queue called `QueueSub.fifo`.
 
-In the access Policy of the QueueSub.fifo you should submit something
+In the access Policy of the `QueueSub.fifo` you should submit something
 like this
 
     {

camel-aws2-sqs.md

@@ -29,7 +29,9 @@ You have to provide the amazonSQSClient in the Registry or your
 accessKey and secretKey to access the [Amazon’s
 SQS](https://aws.amazon.com/sqs).
 
-# Batch Consumer
+# Usage
+
+## Batch Consumer
 
 This component implements the Batch Consumer.
 
@@ -37,8 +39,6 @@ This allows you, for instance, to know how many messages exist in this
 batch and for instance, let the Aggregator aggregate this number of
 messages.
 
-# Usage
-
 ## Static credentials, Default Credential Provider and Profile Credentials Provider
 
 You have the possibility of avoiding the usage of explicit static
@@ -73,6 +73,8 @@ same time.
 For more information about this you can look at [AWS credentials
 documentation](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/credentials.html)
 
+# Examples
+
 ## Advanced AmazonSQS configuration
 
 If your Camel Application is running behind a firewall or if you need to
@@ -121,7 +123,7 @@ related option are: `serverSideEncryptionEnabled`, `keyMasterKeyId` and
 explicitly set the option to true and set the related parameters as
 queue attributes.
 
-# JMS-style Selectors
+## JMS-style Selectors
 
 SQS does not allow selectors, but you can effectively achieve this by
 using the Camel Filter EIP and setting an appropriate
@@ -146,7 +148,7 @@ consumers.
 Note we must set the property `Sqs2Constants.SQS_DELETE_FILTERED` to
 `true` to instruct Camel to send the DeleteMessage, if being filtered.
 
-# Available Producer Operations
+## Available Producer Operations
 
 -   single message (default)
 
@@ -156,13 +158,13 @@ Note we must set the property `Sqs2Constants.SQS_DELETE_FILTERED` to
 
 -   listQueues
 
-# Send Message
+## Send Message
 
     from("direct:start")
       .setBody(constant("Camel rocks!"))
       .to("aws2-sqs://camel-1?accessKey=RAW(xxx)&secretKey=RAW(xxx)&region=eu-west-1");
 
-# Send Batch Message
+## Send Batch Message
 
 You can set a `SendMessageBatchRequest` or an `Iterable`
 
@@ -186,7 +188,7 @@ As result, you’ll get an exchange containing a
 messages were successful and what not. The id set on each message of the
 batch will be a Random UUID.
 
-# Delete single Message
+## Delete single Message
 
 Use deleteMessage operation to delete a single message. You’ll need to
 set a receipt handle header for the message you want to delete.
@@ -199,7 +201,7 @@ set a receipt handle header for the message you want to delete.
 As result, you’ll get an exchange containing a `DeleteMessageResponse`
 instance, that you can use to check if the message was deleted or not.
 
-# List Queues
+## List Queues
 
 Use listQueues operation to list queues.
 
@@ -210,7 +212,7 @@ Use listQueues operation to list queues.
 As result, you’ll get an exchange containing a `ListQueuesResponse`
 instance, that you can examine to check the actual queues.
 
-# Purge Queue
+## Purge Queue
 
 Use purgeQueue operation to purge queue.
 
@@ -221,7 +223,7 @@ Use purgeQueue operation to purge queue.
 As result you’ll get an exchange containing a `PurgeQueueResponse`
 instance.
 
-# Queue Auto-creation
+## Queue Auto-creation
 
 With the option `autoCreateQueue` users are able to avoid the
 autocreation of an SQS Queue in case it doesn’t exist. The default for
@@ -229,7 +231,7 @@ this option is `false`. If set to *false*, any operation on a
 non-existent queue in AWS won’t be successful and an error will be
 returned.
 
-# Send Batch Message and Message Deduplication Strategy
+## Send Batch Message and Message Deduplication Strategy
 
 In case you’re using a SendBatchMessage Operation, you can set two
 different kinds of Message Deduplication Strategy: - useExchangeId -
@@ -275,6 +277,7 @@ Camel.
 |attributeNames|A list of attribute names to receive when consuming. Multiple names can be separated by comma.||string|
 |bridgeErrorHandler|Allows for bridging the consumer to the Camel routing Error Handler, which mean any exceptions (if possible) occurred while the Camel consumer is trying to pickup incoming messages, or the likes, will now be processed as a message and handled by the routing Error Handler. Important: This is only possible if the 3rd party component allows Camel to be alerted if an exception was thrown. Some components handle this internally only, and therefore bridgeErrorHandler is not possible. In other situations we may improve the Camel component to hook into the 3rd party component and make this possible for future releases. 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|
 |concurrentConsumers|Allows you to use multiple threads to poll the sqs queue to increase throughput|1|integer|
+|concurrentRequestLimit|The maximum number of concurrent receive request send to AWS in single consumer polling.|50|integer|
 |defaultVisibilityTimeout|The default visibility timeout (in seconds)||integer|
 |deleteAfterRead|Delete message from SQS after it has been read|true|boolean|
 |deleteIfFiltered|Whether to send the DeleteMessage to the SQS queue if the exchange has property with key Sqs2Constants#SQS\_DELETE\_FILTERED (CamelAwsSqsDeleteFiltered) set to true.|true|boolean|
@@ -283,6 +286,7 @@ Camel.
 |kmsMasterKeyId|The ID of an AWS-managed customer master key (CMK) for Amazon SQS or a custom CMK.||string|
 |messageAttributeNames|A list of message attribute names to receive when consuming. Multiple names can be separated by comma.||string|
 |serverSideEncryptionEnabled|Define if Server Side Encryption is enabled or not on the queue|false|boolean|
+|sortAttributeName|The name of the message attribute used for sorting the messages. When specified, the messages polled by the consumer will be sorted by this attribute. This configuration may be of importance when you configure maxMessagesPerPoll parameter exceeding 10. In such cases, the messages will be fetched concurrently so the ordering is not guaranteed.||string|
 |visibilityTimeout|The duration (in seconds) that the received messages are hidden from subsequent retrieve requests after being retrieved by a ReceiveMessage request to set in the com.amazonaws.services.sqs.model.SetQueueAttributesRequest. This only makes sense if it's different from defaultVisibilityTimeout. It changes the queue visibility timeout attribute permanently.||integer|
 |waitTimeSeconds|Duration in seconds (0 to 20) that the ReceiveMessage action call will wait until a message is in the queue to include in the response.||integer|
 |batchSeparator|Set the separator when passing a String to send batch message operation|,|string|
@@ -331,6 +335,7 @@ Camel.
 |uriEndpointOverride|Set the overriding uri endpoint. This option needs to be used in combination with overrideEndpoint option||string|
 |attributeNames|A list of attribute names to receive when consuming. Multiple names can be separated by comma.||string|
 |concurrentConsumers|Allows you to use multiple threads to poll the sqs queue to increase throughput|1|integer|
+|concurrentRequestLimit|The maximum number of concurrent receive request send to AWS in single consumer polling.|50|integer|
 |defaultVisibilityTimeout|The default visibility timeout (in seconds)||integer|
 |deleteAfterRead|Delete message from SQS after it has been read|true|boolean|
 |deleteIfFiltered|Whether to send the DeleteMessage to the SQS queue if the exchange has property with key Sqs2Constants#SQS\_DELETE\_FILTERED (CamelAwsSqsDeleteFiltered) set to true.|true|boolean|
@@ -341,6 +346,7 @@ Camel.
 |messageAttributeNames|A list of message attribute names to receive when consuming. Multiple names can be separated by comma.||string|
 |sendEmptyMessageWhenIdle|If the polling consumer did not poll any files, you can enable this option to send an empty message (no body) instead.|false|boolean|
 |serverSideEncryptionEnabled|Define if Server Side Encryption is enabled or not on the queue|false|boolean|
+|sortAttributeName|The name of the message attribute used for sorting the messages. When specified, the messages polled by the consumer will be sorted by this attribute. This configuration may be of importance when you configure maxMessagesPerPoll parameter exceeding 10. In such cases, the messages will be fetched concurrently so the ordering is not guaranteed.||string|
 |visibilityTimeout|The duration (in seconds) that the received messages are hidden from subsequent retrieve requests after being retrieved by a ReceiveMessage request to set in the com.amazonaws.services.sqs.model.SetQueueAttributesRequest. This only makes sense if it's different from defaultVisibilityTimeout. It changes the queue visibility timeout attribute permanently.||integer|
 |waitTimeSeconds|Duration in seconds (0 to 20) that the ReceiveMessage action call will wait until a message is in the queue to include in the response.||integer|
 |bridgeErrorHandler|Allows for bridging the consumer to the Camel routing Error Handler, which mean any exceptions (if possible) occurred while the Camel consumer is trying to pickup incoming messages, or the likes, will now be processed as a message and handled by the routing Error Handler. Important: This is only possible if the 3rd party component allows Camel to be alerted if an exception was thrown. Some components handle this internally only, and therefore bridgeErrorHandler is not possible. In other situations we may improve the Camel component to hook into the 3rd party component and make this possible for future releases. 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|

camel-aws2-step-functions.md

@@ -110,7 +110,9 @@ the producer side:
 
 -   getExecutionHistory
 
-# Producer Examples
+# Examples
+
+## Producer Examples
 
 -   createStateMachine: this operation will create a state machine
 
@@ -119,7 +121,7 @@ the producer side:
     from("direct:createStateMachine")
         .to("aws2-step-functions://test?awsSfnClient=#awsSfnClient&operation=createMachine")
 
-# Using a POJO as body
+## Using a POJO as body
 
 Sometimes building an AWS Request can be complex because of multiple
 options. We introduce the possibility to use a POJO as the body. In AWS

camel-aws2-sts.md

@@ -77,7 +77,9 @@ side:
 
 -   getFederationToken
 
-# Producer Examples
+# Examples
+
+## Producer Examples
 
 -   assumeRole: this operation will make an AWS user assume a different
     role temporary
@@ -106,7 +108,7 @@ side:
         .setHeader(STS2Constants.FEDERATED_NAME, constant("federation-account"))
         .to("aws2-sts://test?stsClient=#amazonSTSClient&operation=getSessionToken")
 
-# Using a POJO as body
+## Using a POJO as body
 
 Sometimes building an AWS Request can be complex because of multiple
 options. We introduce the possibility to use a POJO as the body. In AWS

camel-aws2-timestream.md

@@ -149,7 +149,9 @@ producer side:
     
     -   cancelQuery
 
-# Producer Examples
+# Examples
+
+## Producer Examples
 
 -   Write Operation
     
@@ -172,7 +174,7 @@ producer side:
         .setHeader(Timestream2Constants.QUERY_STRING, constant("SELECT * FROM testDb.testTable ORDER BY time DESC LIMIT 10"))
         .to("aws2-timestream://query:test?awsTimestreamQueryClient=#awsTimestreamQueryClient&operation=query")
 
-# Using a POJO as body
+## Using a POJO as body
 
 Sometimes building an AWS Request can be complex because of multiple
 options. We introduce the possibility to use a POJO as the body. In AWS

camel-aws2-translate.md

@@ -71,7 +71,9 @@ producer side:
 
 -   translateText
 
-# Translate Text example
+# Examples
+
+## Translate Text example
 
     from("direct:start")
       .setHeader(TranslateConstants.SOURCE_LANGUAGE, TranslateLanguageEnum.ITALIAN)
@@ -81,7 +83,7 @@ producer side:
 
 As a result, you’ll get an exchange containing the translated text.
 
-# Using a POJO as body
+## Using a POJO as body
 
 Sometimes building an AWS Request can be complex because of multiple
 options. We introduce the possibility to use a POJO as the body. In AWS

camel-azure-cosmosdb.md

@@ -37,7 +37,9 @@ operation being requested in container level, e.g: readItem, then
 You can append query options to the URI in the following format,
 `?options=value&option2=value&`…
 
-# Authentication Information
+# Usage
+
+## Authentication Information
 
 To use this component, you have two options to provide the required
 Azure authentication information:
@@ -50,21 +52,13 @@ Azure authentication information:
     [CosmosAsyncClient](https://docs.microsoft.com/en-us/java/api/com.azure.cosmos.cosmosasyncclient?view=azure-java-stable)
     instance which can be provided into `cosmosAsyncClient`.
 
-# Async Consumer and Producer
+## Async Consumer and Producer
 
 This component implements the async Consumer and producer.
 
 This allows camel route to consume and produce events asynchronously
 without blocking any threads.
 
-# Usage
-
-For example, to consume records from a specific container in a specific
-database to a file, use the following snippet:
-
-    from("azure-cosmosdb://camelDb/myContainer?accountKey=MyaccountKey&databaseEndpoint=https//myazure.com:443&leaseDatabaseName=myLeaseDB&createLeaseDatabaseIfNotExists=true&createLeaseContainerIfNotExists=true").
-    to("file://directory");
-
 ## Message headers evaluated by the component producer
 
 <table>
@@ -75,7 +69,7 @@ database to a file, use the following snippet:
 <col style="width: 69%" />
 </colgroup>
 <thead>
-<tr>
+<tr class="header">
 <th style="text-align: left;">Header</th>
 <th style="text-align: left;">Variable Name</th>
 <th style="text-align: left;">Type</th>
@@ -83,7 +77,7 @@ database to a file, use the following snippet:
 </tr>
 </thead>
 <tbody>
-<tr>
+<tr class="odd">
 <td
 style="text-align: left;"><p><code>CamelAzureCosmosDbDatabaseName</code></p></td>
 <td
@@ -94,7 +88,7 @@ the name of the Cosmos database that component should connect to. In
 case you are producing data and have createDatabaseIfNotExists=true, the
 component will automatically auto create a Cosmos database.</p></td>
 </tr>
-<tr>
+<tr class="even">
 <td
 style="text-align: left;"><p><code>CamelAzureCosmosDbContainerName</code></p></td>
 <td
@@ -106,7 +100,7 @@ case you are producing data and have createContainerIfNotExists=true,
 the component will automatically auto create a Cosmos
 container.</p></td>
 </tr>
-<tr>
+<tr class="odd">
 <td
 style="text-align: left;"><p><code>CamelAzureCosmosDbOperation</code></p></td>
 <td
@@ -116,7 +110,7 @@ style="text-align: left;"><p><code>CosmosDbOperationsDefinition</code></p></td>
 <td style="text-align: left;"><p>Set the producer operation which can be
 used to execute a specific operation on the producer.</p></td>
 </tr>
-<tr>
+<tr class="even">
 <td
 style="text-align: left;"><p><code>CamelAzureCosmosDbQuery</code></p></td>
 <td
@@ -125,7 +119,7 @@ style="text-align: left;"><p><code>CosmosDbConstants.QUERY</code></p></td>
 <td style="text-align: left;"><p>Set the SQL query to execute on a given
 producer query operations.</p></td>
 </tr>
-<tr>
+<tr class="odd">
 <td
 style="text-align: left;"><p><code>CamelAzureCosmosDbQueryRequestOptions</code></p></td>
 <td
@@ -136,7 +130,7 @@ style="text-align: left;"><p><code>CosmosQueryRequestOptions</code></p></td>
 can be used with queryItems, queryContainers, queryDatabases,
 listDatabases, listItems, listContainers operations.</p></td>
 </tr>
-<tr>
+<tr class="even">
 <td
 style="text-align: left;"><p><code>CamelAzureCosmosDbCreateDatabaseIfNotExist</code></p></td>
 <td
@@ -146,7 +140,7 @@ style="text-align: left;"><p><code>CosmosDbConstants.CREATE_DATABASE_IF_NOT_EXIS
 Cosmos database automatically in case it doesn’t exist in the Cosmos
 account.</p></td>
 </tr>
-<tr>
+<tr class="odd">
 <td
 style="text-align: left;"><p><code>CamelAzureCosmosDbCreateContainerIfNotExist</code></p></td>
 <td
@@ -156,7 +150,7 @@ style="text-align: left;"><p><code>CosmosDbConstants.CREATE_CONTAINER_IF_NOT_EXI
 Cosmos container automatically in case it doesn’t exist in the Cosmos
 account.</p></td>
 </tr>
-<tr>
+<tr class="even">
 <td
 style="text-align: left;"><p><code>CamelAzureCosmosDbThroughputProperties</code></p></td>
 <td
@@ -166,7 +160,7 @@ style="text-align: left;"><p><code>ThroughputProperties</code></p></td>
 <td style="text-align: left;"><p>Sets throughput of the resources in the
 Azure Cosmos DB service.</p></td>
 </tr>
-<tr>
+<tr class="odd">
 <td
 style="text-align: left;"><p><code>CamelAzureCosmosDbDatabaseRequestOptions</code></p></td>
 <td
@@ -176,7 +170,7 @@ style="text-align: left;"><p><code>CosmosDatabaseRequestOptions</code></p></td>
 <td style="text-align: left;"><p>Sets additional options to execute on
 database operations.</p></td>
 </tr>
-<tr>
+<tr class="even">
 <td
 style="text-align: left;"><p><code>CamelAzureCosmosDbContainerPartitionKeyPath</code></p></td>
 <td
@@ -185,7 +179,7 @@ style="text-align: left;"><p><code>CosmosDbConstants.CONTAINER_PARTITION_KEY_PAT
 <td style="text-align: left;"><p>Set the container partition key
 path.</p></td>
 </tr>
-<tr>
+<tr class="odd">
 <td
 style="text-align: left;"><p><code>CamelAzureCosmosDbContainerRequestOptions</code></p></td>
 <td
@@ -195,7 +189,7 @@ style="text-align: left;"><p><code>CosmosContainerRequestOptions</code></p></td>
 <td style="text-align: left;"><p>Set additional options to execute on
 container operations.</p></td>
 </tr>
-<tr>
+<tr class="even">
 <td
 style="text-align: left;"><p><code>CamelAzureCosmosDbItemPartitionKey</code></p></td>
 <td
@@ -205,7 +199,7 @@ style="text-align: left;"><p><code>CosmosDbConstants.ITEM_PARTITION_KEY</code></
 partition key value in the Azure Cosmos DB database service. A partition
 key identifies the partition where the item is stored in.</p></td>
 </tr>
-<tr>
+<tr class="odd">
 <td
 style="text-align: left;"><p><code>CamelAzureCosmosDbItemRequestOptions</code></p></td>
 <td
@@ -215,7 +209,7 @@ style="text-align: left;"><p><code>CosmosItemRequestOptions</code></p></td>
 <td style="text-align: left;"><p>Set additional options to execute on
 item operations.</p></td>
 </tr>
-<tr>
+<tr class="even">
 <td
 style="text-align: left;"><p><code>CamelAzureCosmosDbItemId</code></p></td>
 <td
@@ -237,7 +231,7 @@ operation on item like <em>delete</em>, <em>replace</em>.</p></td>
 <col style="width: 69%" />
 </colgroup>
 <thead>
-<tr>
+<tr class="header">
 <th style="text-align: left;">Header</th>
 <th style="text-align: left;">Variable Name</th>
 <th style="text-align: left;">Type</th>
@@ -245,7 +239,7 @@ operation on item like <em>delete</em>, <em>replace</em>.</p></td>
 </tr>
 </thead>
 <tbody>
-<tr>
+<tr class="odd">
 <td
 style="text-align: left;"><p><code>CamelAzureCosmosDbRecourseId</code></p></td>
 <td
@@ -254,7 +248,7 @@ style="text-align: left;"><p><code>CosmosDbConstants.RESOURCE_ID</code></p></td>
 <td style="text-align: left;"><p>The resource ID of the requested
 resource.</p></td>
 </tr>
-<tr>
+<tr class="even">
 <td
 style="text-align: left;"><p><code>CamelAzureCosmosDbEtag</code></p></td>
 <td
@@ -263,7 +257,7 @@ style="text-align: left;"><p><code>CosmosDbConstants.E_TAG</code></p></td>
 <td style="text-align: left;"><p>The Etag ID of the requested
 resource.</p></td>
 </tr>
-<tr>
+<tr class="odd">
 <td
 style="text-align: left;"><p><code>CamelAzureCosmosDbTimestamp</code></p></td>
 <td
@@ -272,7 +266,7 @@ style="text-align: left;"><p><code>CosmosDbConstants.TIMESTAMP</code></p></td>
 <td style="text-align: left;"><p>The timestamp of the requested
 resource.</p></td>
 </tr>
-<tr>
+<tr class="even">
 <td
 style="text-align: left;"><p><code>CamelAzureCosmosDbResponseHeaders</code></p></td>
 <td
@@ -281,7 +275,7 @@ style="text-align: left;"><p><code>CosmosDbConstants.RESPONSE_HEADERS</code></p>
 <td style="text-align: left;"><p>The response headers of the requested
 resource.</p></td>
 </tr>
-<tr>
+<tr class="odd">
 <td
 style="text-align: left;"><p><code>CamelAzureCosmosDbStatusCode</code></p></td>
 <td
@@ -290,7 +284,7 @@ style="text-align: left;"><p><code>CosmosDbConstants.STATUS_CODE</code></p></td>
 <td style="text-align: left;"><p>The status code of the requested
 resource.</p></td>
 </tr>
-<tr>
+<tr class="even">
 <td
 style="text-align: left;"><p><code>CamelAzureCosmosDbDefaultTimeToLiveInSeconds</code></p></td>
 <td
@@ -299,7 +293,7 @@ style="text-align: left;"><p><code>CosmosDbConstants.DEFAULT_TIME_TO_LIVE_SECOND
 <td style="text-align: left;"><p>The TTL of the requested
 resource.</p></td>
 </tr>
-<tr>
+<tr class="odd">
 <td
 style="text-align: left;"><p><code>CamelAzureCosmosDbManualThroughput</code></p></td>
 <td
@@ -308,7 +302,7 @@ style="text-align: left;"><p><code>CosmosDbConstants.MANUAL_THROUGHPUT</code></p
 <td style="text-align: left;"><p>The manual throughput of the requested
 resource.</p></td>
 </tr>
-<tr>
+<tr class="even">
 <td
 style="text-align: left;"><p><code>CamelAzureCosmosDbAutoscaleMaxThroughput</code></p></td>
 <td
@@ -336,24 +330,24 @@ For these operations, `databaseName` is **required** except for
 <col style="width: 89%" />
 </colgroup>
 <thead>
-<tr>
+<tr class="header">
 <th style="text-align: left;">Operation</th>
 <th style="text-align: left;">Description</th>
 </tr>
 </thead>
 <tbody>
-<tr>
+<tr class="odd">
 <td style="text-align: left;"><p><code>listDatabases</code></p></td>
 <td style="text-align: left;"><p>Gets a list of all databases as
 <code>List&lt;CosmosDatabaseProperties&gt;</code> set in the exchange
 message body.</p></td>
 </tr>
-<tr>
+<tr class="even">
 <td style="text-align: left;"><p><code>createDatabase</code></p></td>
 <td style="text-align: left;"><p>Create a database in the specified
 Azure CosmosDB account.</p></td>
 </tr>
-<tr>
+<tr class="odd">
 <td style="text-align: left;"><p><code>queryDatabases</code></p></td>
 <td style="text-align: left;"><p><strong><code>query</code> is
 required</strong> Execute an SQL query against the service level in
@@ -376,35 +370,35 @@ here and `containerName` only for `createContainer` and
 <col style="width: 89%" />
 </colgroup>
 <thead>
-<tr>
+<tr class="header">
 <th style="text-align: left;">Operation</th>
 <th style="text-align: left;">Description</th>
 </tr>
 </thead>
 <tbody>
-<tr>
+<tr class="odd">
 <td style="text-align: left;"><p><code>deleteDatabase</code></p></td>
 <td style="text-align: left;"><p>Delete a database from the Azure
 CosmosDB account.</p></td>
 </tr>
-<tr>
+<tr class="even">
 <td style="text-align: left;"><p><code>createContainer</code></p></td>
 <td style="text-align: left;"><p>Create a container in the specified
 Azure CosmosDB database.</p></td>
 </tr>
-<tr>
+<tr class="odd">
 <td
 style="text-align: left;"><p><code>replaceDatabaseThroughput</code></p></td>
 <td style="text-align: left;"><p>Replace the throughput for the
 specified Azure CosmosDB database.</p></td>
 </tr>
-<tr>
+<tr class="even">
 <td style="text-align: left;"><p><code>listContainers</code></p></td>
 <td style="text-align: left;"><p>Gets a list of all containers in the
 specified database as <code>List&lt;CosmosContainerProperties&gt;</code>
 set in the exchange message body.</p></td>
 </tr>
-<tr>
+<tr class="odd">
 <td style="text-align: left;"><p><code>queryContainers</code></p></td>
 <td style="text-align: left;"><p><strong><code>query</code> is
 required</strong> Executes an SQL query against the database level in
@@ -427,57 +421,57 @@ for all operations here.
 <col style="width: 89%" />
 </colgroup>
 <thead>
-<tr>
+<tr class="header">
 <th style="text-align: left;">Operation</th>
 <th style="text-align: left;">Description</th>
 </tr>
 </thead>
 <tbody>
-<tr>
+<tr class="odd">
 <td style="text-align: left;"><p><code>deleteContainer</code></p></td>
 <td style="text-align: left;"><p>Delete a container from the specified
 Azure CosmosDB database.</p></td>
 </tr>
-<tr>
+<tr class="even">
 <td
 style="text-align: left;"><p><code>replaceContainerThroughput</code></p></td>
 <td style="text-align: left;"><p>Replace the throughput for the
 specified Azure CosmosDB container.</p></td>
 </tr>
-<tr>
+<tr class="odd">
 <td style="text-align: left;"><p><code>createItem</code></p></td>
 <td style="text-align: left;"><p><strong><code>itemPartitionKey</code>
 is required</strong> Creates an item in the specified container, it
 accepts POJO or key value as <code>Map&lt;String, ?&gt;</code>.</p></td>
 </tr>
-<tr>
+<tr class="even">
 <td style="text-align: left;"><p><code>upsertItem</code></p></td>
 <td style="text-align: left;"><p><strong><code>itemPartitionKey</code>
 is required</strong> Creates an item in the specified container if it
 doesn’t exist otherwise overwrite it if it exists, it accepts POJO or
 key value as <code>Map&lt;String, ?&gt;</code>.</p></td>
 </tr>
-<tr>
+<tr class="odd">
 <td style="text-align: left;"><p><code>replaceItem</code></p></td>
 <td style="text-align: left;"><p><strong><code>itemPartitionKey</code>
 and <code>itemId</code> are required</strong> Overwrites an item in the
 specified container, it accepts POJO or key value as
 <code>Map&lt;String, ?&gt;</code>.</p></td>
 </tr>
-<tr>
+<tr class="even">
 <td style="text-align: left;"><p><code>deleteItem</code></p></td>
 <td style="text-align: left;"><p><strong><code>itemPartitionKey</code>
 and <code>itemId</code> are required</strong> Deletes an item in the
 specified container.</p></td>
 </tr>
-<tr>
+<tr class="odd">
 <td style="text-align: left;"><p><code>readItem</code></p></td>
 <td style="text-align: left;"><p><strong><code>itemPartitionKey</code>
 and <code>itemId</code> are required</strong> Gets an item in the
 specified container as <code>Map&lt;String,?&gt;</code> set in the
 exchange body message.</p></td>
 </tr>
-<tr>
+<tr class="even">
 <td style="text-align: left;"><p><code>readItem</code></p></td>
 <td
 style="text-align: left;"><p><strong><code>itemPartitionKey</code></strong>
@@ -486,7 +480,7 @@ Gets a list of items in the specified container per the
 <code>List&lt;Map&lt;String,?&gt;&gt;</code> set in the exchange body
 message.</p></td>
 </tr>
-<tr>
+<tr class="odd">
 <td style="text-align: left;"><p><code>queryItems</code></p></td>
 <td style="text-align: left;"><p><strong><code>query</code> is
 required</strong> Execute an SQL query against the container level in
@@ -500,7 +494,17 @@ message body.</p></td>
 Refer to the example section in this page to learn how to use these
 operations into your camel application.
 
-### Examples
+# Examples
+
+## Consuming records from a specific container
+
+For example, to consume records from a specific container in a specific
+database to a file, use the following snippet:
+
+    from("azure-cosmosdb://camelDb/myContainer?accountKey=MyaccountKey&databaseEndpoint=https//myazure.com:443&leaseDatabaseName=myLeaseDB&createLeaseDatabaseIfNotExists=true&createLeaseContainerIfNotExists=true").
+    to("file://directory");
+
+## Operations
 
 -   `listDatabases`:
 
@@ -692,7 +696,7 @@ this feature:
 The consumer will set `List<Map<String,>>` in exchange message body
 which reflect the list of items in a single feed.
 
-### Example:
+### Example
 
 For example, to listen to the events in `myContainer` container in
 `myDb`:
@@ -700,7 +704,7 @@ For example, to listen to the events in `myContainer` container in
     from("azure-cosmosdb://myDb/myContainer?leaseDatabaseName=myLeaseDb&createLeaseDatabaseIfNotExists=true&createLeaseContainerIfNotExists=true")
       .to("mock:result");
 
-## Development Notes (Important)
+# Important Development Notes
 
 When developing on this component, you will need to obtain your Azure
 accessKey in order to run the integration tests. In addition to the
@@ -719,15 +723,15 @@ is the access key being generated from Azure CosmosDB portal.
   
 |Name|Description|Default|Type|
 |---|---|---|---|
-|clientTelemetryEnabled|Sets the flag to enable client telemetry which will periodically collect database operations aggregation statistics, system information like cpu/memory and send it to cosmos monitoring service, which will be helpful during debugging. DEFAULT value is false indicating this is opt in feature, by default no telemetry collection.|false|boolean|
+|clientTelemetryEnabled|Sets the flag to enable client telemetry which will periodically collect database operations aggregation statistics, system information like cpu/memory and send it to cosmos monitoring service, which will be helpful during debugging. DEFAULT value is false indicating this is an opt-in feature, by default no telemetry collection.|false|boolean|
 |configuration|The component configurations||object|
-|connectionSharingAcrossClientsEnabled|Enables connections sharing across multiple Cosmos Clients. The default is false. When you have multiple instances of Cosmos Client in the same JVM interacting to multiple Cosmos accounts, enabling this allows connection sharing in Direct mode if possible between instances of Cosmos Client. Please note, when setting this option, the connection configuration (e.g., socket timeout config, idle timeout config) of the first instantiated client will be used for all other client instances.|false|boolean|
+|connectionSharingAcrossClientsEnabled|Enables connections sharing across multiple Cosmos Clients. The default is false. When you have multiple instances of Cosmos Client in the same JVM interacting with multiple Cosmos accounts, enabling this allows connection sharing in Direct mode if possible between instances of Cosmos Client. Please note, when setting this option, the connection configuration (e.g., socket timeout config, idle timeout config) of the first instantiated client will be used for all other client instances.|false|boolean|
 |consistencyLevel|Sets the consistency levels supported for Azure Cosmos DB client operations in the Azure Cosmos DB service. The requested ConsistencyLevel must match or be weaker than that provisioned for the database account. Consistency levels by order of strength are STRONG, BOUNDED\_STALENESS, SESSION and EVENTUAL. Refer to consistency level documentation for additional details: https://docs.microsoft.com/en-us/azure/cosmos-db/consistency-levels|SESSION|object|
 |containerPartitionKeyPath|Sets the container partition key path.||string|
-|contentResponseOnWriteEnabled|Sets the boolean to only return the headers and status code in Cosmos DB response in case of Create, Update and Delete operations on CosmosItem. In Consumer, it is enabled by default because of the ChangeFeed in the consumer that needs this flag to be enabled and thus is shouldn't be overridden. In Producer, it advised to disable it since it reduces the network overhead|true|boolean|
+|contentResponseOnWriteEnabled|Sets the boolean to only return the headers and status code in Cosmos DB response in case of Create, Update and Delete operations on CosmosItem. In Consumer, it is enabled by default because of the ChangeFeed in the consumer that needs this flag to be enabled, and thus it shouldn't be overridden. In Producer, it is advised to disable it since it reduces the network overhead|true|boolean|
 |cosmosAsyncClient|Inject an external CosmosAsyncClient into the component which provides a client-side logical representation of the Azure Cosmos DB service. This asynchronous client is used to configure and execute requests against the service.||object|
-|createContainerIfNotExists|Sets if the component should create Cosmos container automatically in case it doesn't exist in Cosmos database|false|boolean|
-|createDatabaseIfNotExists|Sets if the component should create Cosmos database automatically in case it doesn't exist in Cosmos account|false|boolean|
+|createContainerIfNotExists|Sets if the component should create the Cosmos container automatically in case it doesn't exist in the Cosmos database|false|boolean|
+|createDatabaseIfNotExists|Sets if the component should create the Cosmos database automatically in case it doesn't exist in the Cosmos account|false|boolean|
 |databaseEndpoint|Sets the Azure Cosmos database endpoint the component will connect to.||string|
 |multipleWriteRegionsEnabled|Sets the flag to enable writes on any regions for geo-replicated database accounts in the Azure Cosmos DB service. When the value of this property is true, the SDK will direct write operations to available writable regions of geo-replicated database account. Writable regions are ordered by PreferredRegions property. Setting the property value to true has no effect until EnableMultipleWriteRegions in DatabaseAccount is also set to true. DEFAULT value is true indicating that writes are directed to available writable regions of geo-replicated database account.|true|boolean|
 |preferredRegions|Sets the comma separated preferred regions for geo-replicated database accounts. For example, East US as the preferred region. When EnableEndpointDiscovery is true and PreferredRegions is non-empty, the SDK will prefer to use the regions in the container in the order they are specified to perform operations.||string|
@@ -736,10 +740,10 @@ is the access key being generated from Azure CosmosDB portal.
 |bridgeErrorHandler|Allows for bridging the consumer to the Camel routing Error Handler, which mean any exceptions (if possible) occurred while the Camel consumer is trying to pickup incoming messages, or the likes, will now be processed as a message and handled by the routing Error Handler. Important: This is only possible if the 3rd party component allows Camel to be alerted if an exception was thrown. Some components handle this internally only, and therefore bridgeErrorHandler is not possible. In other situations we may improve the Camel component to hook into the 3rd party component and make this possible for future releases. 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|
 |changeFeedProcessorOptions|Sets the ChangeFeedProcessorOptions to be used. Unless specifically set the default values that will be used are: maximum items per page or FeedResponse: 100 lease renew interval: 17 seconds lease acquire interval: 13 seconds lease expiration interval: 60 seconds feed poll delay: 5 seconds maximum scale count: unlimited||object|
 |createLeaseContainerIfNotExists|Sets if the component should create Cosmos lease container for the consumer automatically in case it doesn't exist in Cosmos database|false|boolean|
-|createLeaseDatabaseIfNotExists|Sets if the component should create Cosmos lease database for the consumer automatically in case it doesn't exist in Cosmos account|false|boolean|
+|createLeaseDatabaseIfNotExists|Sets if the component should create the Cosmos lease database for the consumer automatically in case it doesn't exist in the Cosmos account|false|boolean|
 |hostName|Sets the hostname. The host: a host is an application instance that uses the change feed processor to listen for changes. Multiple instances with the same lease configuration can run in parallel, but each instance should have a different instance name. If not specified, this will be a generated random hostname.||string|
-|leaseContainerName|Sets the lease container which acts as a state storage and coordinates processing the change feed across multiple workers. The lease container can be stored in the same account as the monitored container or in a separate account. It will be auto created if createLeaseContainerIfNotExists is set to true.|camel-lease|string|
-|leaseDatabaseName|Sets the lease database where the leaseContainerName will be stored. If it is not specified, this component will store the lease container in the same database that is specified in databaseName. It will be auto created if createLeaseDatabaseIfNotExists is set to true.||string|
+|leaseContainerName|Sets the lease container which acts as a state storage and coordinates processing the change feed across multiple workers. The lease container can be stored in the same account as the monitored container or in a separate account. It will be auto-created if createLeaseContainerIfNotExists is set to true.|camel-lease|string|
+|leaseDatabaseName|Sets the lease database where the leaseContainerName will be stored. If it is not specified, this component will store the lease container in the same database that is specified in databaseName. It will be auto-created if createLeaseDatabaseIfNotExists is set to true.||string|
 |itemId|Sets the itemId in case needed for operation on item like delete, replace||string|
 |itemPartitionKey|Sets partition key. Represents a partition key value in the Azure Cosmos DB database service. A partition key identifies the partition where the item is stored in.||string|
 |lazyStartProducer|Whether the producer should be started lazy (on the first message). By starting lazy you can use this to allow CamelContext and routes to startup in situations where a producer may otherwise fail during starting and cause the route to fail being started. By deferring this startup to be lazy then the startup failure can be handled during routing messages via Camel's routing error handlers. Beware that when the first message is processed then creating and starting the producer may take a little time and prolong the total processing time of the processing.|false|boolean|
@@ -758,14 +762,14 @@ is the access key being generated from Azure CosmosDB portal.
 |---|---|---|---|
 |databaseName|The name of the Cosmos database that component should connect to. In case you are producing data and have createDatabaseIfNotExists=true, the component will automatically auto create a Cosmos database.||string|
 |containerName|The name of the Cosmos container that component should connect to. In case you are producing data and have createContainerIfNotExists=true, the component will automatically auto create a Cosmos container.||string|
-|clientTelemetryEnabled|Sets the flag to enable client telemetry which will periodically collect database operations aggregation statistics, system information like cpu/memory and send it to cosmos monitoring service, which will be helpful during debugging. DEFAULT value is false indicating this is opt in feature, by default no telemetry collection.|false|boolean|
-|connectionSharingAcrossClientsEnabled|Enables connections sharing across multiple Cosmos Clients. The default is false. When you have multiple instances of Cosmos Client in the same JVM interacting to multiple Cosmos accounts, enabling this allows connection sharing in Direct mode if possible between instances of Cosmos Client. Please note, when setting this option, the connection configuration (e.g., socket timeout config, idle timeout config) of the first instantiated client will be used for all other client instances.|false|boolean|
+|clientTelemetryEnabled|Sets the flag to enable client telemetry which will periodically collect database operations aggregation statistics, system information like cpu/memory and send it to cosmos monitoring service, which will be helpful during debugging. DEFAULT value is false indicating this is an opt-in feature, by default no telemetry collection.|false|boolean|
+|connectionSharingAcrossClientsEnabled|Enables connections sharing across multiple Cosmos Clients. The default is false. When you have multiple instances of Cosmos Client in the same JVM interacting with multiple Cosmos accounts, enabling this allows connection sharing in Direct mode if possible between instances of Cosmos Client. Please note, when setting this option, the connection configuration (e.g., socket timeout config, idle timeout config) of the first instantiated client will be used for all other client instances.|false|boolean|
 |consistencyLevel|Sets the consistency levels supported for Azure Cosmos DB client operations in the Azure Cosmos DB service. The requested ConsistencyLevel must match or be weaker than that provisioned for the database account. Consistency levels by order of strength are STRONG, BOUNDED\_STALENESS, SESSION and EVENTUAL. Refer to consistency level documentation for additional details: https://docs.microsoft.com/en-us/azure/cosmos-db/consistency-levels|SESSION|object|
 |containerPartitionKeyPath|Sets the container partition key path.||string|
-|contentResponseOnWriteEnabled|Sets the boolean to only return the headers and status code in Cosmos DB response in case of Create, Update and Delete operations on CosmosItem. In Consumer, it is enabled by default because of the ChangeFeed in the consumer that needs this flag to be enabled and thus is shouldn't be overridden. In Producer, it advised to disable it since it reduces the network overhead|true|boolean|
+|contentResponseOnWriteEnabled|Sets the boolean to only return the headers and status code in Cosmos DB response in case of Create, Update and Delete operations on CosmosItem. In Consumer, it is enabled by default because of the ChangeFeed in the consumer that needs this flag to be enabled, and thus it shouldn't be overridden. In Producer, it is advised to disable it since it reduces the network overhead|true|boolean|
 |cosmosAsyncClient|Inject an external CosmosAsyncClient into the component which provides a client-side logical representation of the Azure Cosmos DB service. This asynchronous client is used to configure and execute requests against the service.||object|
-|createContainerIfNotExists|Sets if the component should create Cosmos container automatically in case it doesn't exist in Cosmos database|false|boolean|
-|createDatabaseIfNotExists|Sets if the component should create Cosmos database automatically in case it doesn't exist in Cosmos account|false|boolean|
+|createContainerIfNotExists|Sets if the component should create the Cosmos container automatically in case it doesn't exist in the Cosmos database|false|boolean|
+|createDatabaseIfNotExists|Sets if the component should create the Cosmos database automatically in case it doesn't exist in the Cosmos account|false|boolean|
 |databaseEndpoint|Sets the Azure Cosmos database endpoint the component will connect to.||string|
 |multipleWriteRegionsEnabled|Sets the flag to enable writes on any regions for geo-replicated database accounts in the Azure Cosmos DB service. When the value of this property is true, the SDK will direct write operations to available writable regions of geo-replicated database account. Writable regions are ordered by PreferredRegions property. Setting the property value to true has no effect until EnableMultipleWriteRegions in DatabaseAccount is also set to true. DEFAULT value is true indicating that writes are directed to available writable regions of geo-replicated database account.|true|boolean|
 |preferredRegions|Sets the comma separated preferred regions for geo-replicated database accounts. For example, East US as the preferred region. When EnableEndpointDiscovery is true and PreferredRegions is non-empty, the SDK will prefer to use the regions in the container in the order they are specified to perform operations.||string|
@@ -773,10 +777,10 @@ is the access key being generated from Azure CosmosDB portal.
 |throughputProperties|Sets throughput of the resources in the Azure Cosmos DB service.||object|
 |changeFeedProcessorOptions|Sets the ChangeFeedProcessorOptions to be used. Unless specifically set the default values that will be used are: maximum items per page or FeedResponse: 100 lease renew interval: 17 seconds lease acquire interval: 13 seconds lease expiration interval: 60 seconds feed poll delay: 5 seconds maximum scale count: unlimited||object|
 |createLeaseContainerIfNotExists|Sets if the component should create Cosmos lease container for the consumer automatically in case it doesn't exist in Cosmos database|false|boolean|
-|createLeaseDatabaseIfNotExists|Sets if the component should create Cosmos lease database for the consumer automatically in case it doesn't exist in Cosmos account|false|boolean|
+|createLeaseDatabaseIfNotExists|Sets if the component should create the Cosmos lease database for the consumer automatically in case it doesn't exist in the Cosmos account|false|boolean|
 |hostName|Sets the hostname. The host: a host is an application instance that uses the change feed processor to listen for changes. Multiple instances with the same lease configuration can run in parallel, but each instance should have a different instance name. If not specified, this will be a generated random hostname.||string|
-|leaseContainerName|Sets the lease container which acts as a state storage and coordinates processing the change feed across multiple workers. The lease container can be stored in the same account as the monitored container or in a separate account. It will be auto created if createLeaseContainerIfNotExists is set to true.|camel-lease|string|
-|leaseDatabaseName|Sets the lease database where the leaseContainerName will be stored. If it is not specified, this component will store the lease container in the same database that is specified in databaseName. It will be auto created if createLeaseDatabaseIfNotExists is set to true.||string|
+|leaseContainerName|Sets the lease container which acts as a state storage and coordinates processing the change feed across multiple workers. The lease container can be stored in the same account as the monitored container or in a separate account. It will be auto-created if createLeaseContainerIfNotExists is set to true.|camel-lease|string|
+|leaseDatabaseName|Sets the lease database where the leaseContainerName will be stored. If it is not specified, this component will store the lease container in the same database that is specified in databaseName. It will be auto-created if createLeaseDatabaseIfNotExists is set to true.||string|
 |bridgeErrorHandler|Allows for bridging the consumer to the Camel routing Error Handler, which mean any exceptions (if possible) occurred while the Camel consumer is trying to pickup incoming messages, or the likes, will now be processed as a message and handled by the routing Error Handler. Important: This is only possible if the 3rd party component allows Camel to be alerted if an exception was thrown. Some components handle this internally only, and therefore bridgeErrorHandler is not possible. In other situations we may improve the Camel component to hook into the 3rd party component and make this possible for future releases. 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|
 |exceptionHandler|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.||object|
 |exchangePattern|Sets the exchange pattern when the consumer creates an exchange.||object|

camel-azure-eventhubs.md

@@ -4,24 +4,19 @@
 
 **Both producer and consumer are supported**
 
-The Azure Event Hubs used to integrate [Azure Event
-Hubs](https://azure.microsoft.com/en-us/services/event-hubs/) using
+The Azure Event Hubs component provides the capability to produce and
+consume events with [Azure Event
+Hubs](https://azure.microsoft.com/en-us/services/event-hubs/) using the
 [AMQP
 protocol](https://en.wikipedia.org/wiki/Advanced_Message_Queuing_Protocol).
 Azure EventHubs is a highly scalable publish-subscribe service that can
 ingest millions of events per second and stream them to multiple
 consumers.
 
-Besides AMQP protocol support, Event Hubs as well supports Kafka and
-HTTPS protocols. Therefore, you can also use the [Camel
-Kafka](#components::kafka-component.adoc) component to produce and
-consume to Azure Event Hubs. You can lean more
-[here](https://docs.microsoft.com/en-us/azure/event-hubs/event-hubs-quickstart-kafka-enabled-event-hubs).
+**Prerequisites**
 
-Prerequisites
-
-You must have a valid Windows Azure Event Hubs account. More information
-is available at [Azure Documentation
+You must have a valid Microsoft Azure Event Hubs account. More
+information is available at the [Azure Documentation
 Portal](https://docs.microsoft.com/azure/).
 
 Maven users will need to add the following dependency to their `pom.xml`
@@ -38,42 +33,44 @@ for this component:
 
     azure-eventhubs://[namespace/eventHubName][?options]
 
-In case you supply the `connectionString`, `namespace` and
-`eventHubName` are not required as these options already included in the
+When providing a `connectionString`, the `namespace` and `eventHubName`
+options are not required as they are already included in the
 `connectionString`
 
-# Authentication Information
+# Usage
+
+## Authentication Information
 
-You have three different Credential Types: AZURE\_IDENTITY,
-TOKEN\_CREDENTIAL and CONNECTION\_STRING. You can also provide a client
-instance yourself. To use this component, you have three options to
-provide the required Azure authentication information:
+There are three different Credential Types: `AZURE_IDENTITY`,
+`TOKEN_CREDENTIAL` and `CONNECTION_STRING`.
 
 **CONNECTION\_STRING**:
 
--   Provide `sharedAccessName` and `sharedAccessKey` for your Azure
-    Event Hubs account. The sharedAccessKey can be generated through
-    your Event Hubs Azure portal.
+You can either:
 
--   Provide `connectionString` string, if you provide the connection
-    string, you don’t supply `namespace`, `eventHubName`,
-    `sharedAccessKey` and `sharedAccessName` as these data already
-    included in the `connectionString`, therefore is the simplest option
-    to get started. Learn more
+-   Provide the `connectionString` option. Using this options means that
+    you don’t need to specify additional options `namespace`,
+    `eventHubName`, `sharedAccessKey` and `sharedAccessName` , as this
+    data is already included within the `connectionString`. Learn more
     [here](https://docs.microsoft.com/en-us/azure/event-hubs/event-hubs-get-connection-string)
     on how to generate the connection string.
 
+Or
+
+-   Provide `sharedAccessName` and `sharedAccessKey` options for your
+    Azure Event Hubs account. The `sharedAccessKey` can be generated
+    through the Event Hubs Azure portal. The connection String will then
+    be generated automatically for you by the azure-eventhubs component.
+
 **TOKEN\_CREDENTIAL**:
 
--   Provide an implementation of
-    `com.azure.core.credential.TokenCredential` into the Camel’s
-    Registry, e.g., using the
-    `com.azure.identity.DefaultAzureCredentialBuilder().build();` API.
-    See the documentation [here about Azure-AD
+-   Bind an implementation of
+    `com.azure.core.credential.TokenCredential` to the Camel Registry
+    (see example below). See the documentation [here about Azure-AD
     authentication](https://docs.microsoft.com/en-us/azure/active-directory/authentication/overview-authentication).
 
-AZURE\_IDENTITY: - This will use
-`com.azure.identity.DefaultAzureCredentialBuilder().build();` instance.
+**AZURE\_IDENTITY**: - This will use an
+`com.azure.identity.DefaultAzureCredentialBuilder().build()` instance.
 This will follow the Default Azure Credential Chain. See the
 documentation [here about Azure-AD
 authentication](https://docs.microsoft.com/en-us/azure/active-directory/authentication/overview-authentication).
@@ -82,60 +79,45 @@ authentication](https://docs.microsoft.com/en-us/azure/active-directory/authenti
 
 -   Provide a
     [EventHubProducerAsyncClient](https://docs.microsoft.com/en-us/java/api/com.azure.messaging.eventhubs.eventhubproducerasyncclient?view=azure-java-stable)
-    instance which can be provided into `producerAsyncClient`. However,
-    this is **only possible for camel producer**, for the camel
-    consumer, is not possible to inject the client due to some design
-    constraint by the `EventProcessorClient`.
+    instance which can be used for the `producerAsyncClient` option.
+    However, this is **only supported for azure-eventhubs producer**,
+    for the consumer, it is not possible to inject the client due to
+    some design constraints in the `EventProcessorClient`.
 
-# Checkpoint Store Information
+## Checkpoint Store Information
 
-A checkpoint store stores and retrieves partition ownership information
+A checkpoint store, stores and retrieves partition ownership information
 and checkpoint details for each partition in a given consumer group of
 an event hub instance. Users are not meant to implement a
-CheckpointStore. Users are expected to choose existing implementations
+`CheckpointStore`. Users are expected to choose existing implementations
 of this interface, instantiate it, and pass it to the component through
-`checkpointStore` option. Users are not expected to use any of the
-methods on a checkpoint store, these are used internally by the client.
+the `checkpointStore` option.
 
-Having said that, if the user does not pass any `CheckpointStore`
-implementation, the component will fall back to use
+When no `CheckpointStore` implementation is provided, the
+azure-eventhubs component will fall back to use
 [`BlobCheckpointStore`](https://docs.microsoft.com/en-us/javascript/api/@azure/eventhubs-checkpointstore-blob/blobcheckpointstore?view=azure-node-latest)
-to store the checkpoint info in the Azure Blob Storage account. If you
-chose to use the default `BlobCheckpointStore`, you will need to supply
-the following options:
+to store the checkpoint information in the Azure Blob Storage account.
+If you chose to use the default `BlobCheckpointStore`, you will need to
+supply the following options:
 
--   `blobAccountName`: It sets Azure account name to be used for
+-   `blobAccountName`: The Azure account name to be used for
     authentication with azure blob services.
 
--   `blobAccessKey`: It sets the access key for the associated azure
-    account name to be used for authentication with azure blob services.
-
--   `blobContainerName`: It sets the blob container that shall be used
-    by the BlobCheckpointStore to store the checkpoint offsets.
-
-# Async Consumer and Producer
-
-This component implements the async Consumer and producer.
+-   `blobAccessKey`: The access key for the associated azure account
+    name to be used for authentication with azure blob services.
 
-This allows camel route to consume and produce events asynchronously
-without blocking any threads.
-
-# Usage
-
-For example, to consume event from EventHub, use the following snippet:
-
-    from("azure-eventhubs:/camel/camelHub?sharedAccessName=SASaccountName&sharedAccessKey=SASaccessKey&blobAccountName=accountName&blobAccessKey=accessKey&blobContainerName=containerName")
-      .to("file://queuedirectory");
+-   `blobContainerName`: The name of the blob container that shall be
+    used by the BlobCheckpointStore to store the checkpoint offsets.
 
 ## Message body type
 
-The component’s producer expects the data in the message body to be in
-`byte[]`. This allows the user to utilize Camel TypeConverter to
-marshal/unmarshal data with ease. The same goes as well for the
-component’s consumer, it will set the encoded data as `byte[]` in the
-message body.
+The azure-eventhubs producer expects the data in the message body to be
+of type `byte[]`. This allows the simple messages (E.g. `String` based
+ones) to be marshalled /unmarshalled with ease. The same is true for the
+azure-eventhubs consumer, it will set the encoded data as `byte[]` in
+the message body.
 
-## Automatic detection of EventHubProducerAsyncClient client in registry
+## Automatic detection of EventHubProducerAsyncClient client in the Camel registry
 
 The component is capable of detecting the presence of an
 EventHubProducerAsyncClient bean into the registry. If it’s the only
@@ -143,41 +125,39 @@ instance of that type, it will be used as the client, and you won’t have
 to define it as uri parameter, like the example above. This may be
 really useful for smarter configuration of the endpoint.
 
+# Examples
+
 ## Consumer Example
 
-The example below will unmarshal the events that were originally
-produced in JSON:
+To consume events:
 
-    from("azure-eventhubs:?connectionString=RAW({{connectionString}})"&blobContainerName=containerTest&eventPosition=#eventPosition"
-        +"&blobAccountName={{blobAccountName}}&blobAccessKey=RAW({{blobAccessKey}})")
-    .unmarshal().json(JsonLibrary.Jackson)
-    .to(result);
+    from("azure-eventhubs:/camel/camelHub?sharedAccessName=SASaccountName&sharedAccessKey=SASaccessKey&blobAccountName=accountName&blobAccessKey=accessKey&blobContainerName=containerName")
+        .to("file://queuedirectory");
 
 ## Producer Example
 
-The example below will send events as String to EventHubs:
+To produce events:
 
     from("direct:start")
-    .process(exchange -> {
+        .process(exchange -> {
             exchange.getIn().setHeader(EventHubsConstants.PARTITION_ID, firstPartition);
             exchange.getIn().setBody("test event");
-    })
-    .to("azure-eventhubs:?connectionString=RAW({{connectionString}})"
+        })
+        .to("azure-eventhubs:?connectionString=RAW({{connectionString}})"
 
-Also, the component supports as well **aggregation** of messages by
-sending events as **iterable** of either Exchanges/Messages or normal
-data (e.g.: list of Strings). For example:
+The azure-eventhubs producer supports sending sending events as an
+`Iterable` (E.g. as a `List`). For example:
 
     from("direct:start")
-    .process(exchange -> {
+        .process(exchange -> {
             final List<String> messages = new LinkedList<>();
             messages.add("Test String Message 1");
             messages.add("Test String Message 2");
     
             exchange.getIn().setHeader(EventHubsConstants.PARTITION_ID, firstPartition);
             exchange.getIn().setBody(messages);
-    })
-    .to("azure-eventhubs:?connectionString=RAW({{connectionString}})"
+        })
+        .to("azure-eventhubs:?connectionString=RAW({{connectionString}})"
 
 ## Azure-AD Authentication example
 
@@ -191,9 +171,9 @@ about what environment variables you need to set for this to work:
     }
     
     from("direct:start")
-    .to("azure-eventhubs:namespace/eventHubName?tokenCredential=#myTokenCredential&credentialType=TOKEN_CREDENTIAL)"
+        .to("azure-eventhubs:namespace/eventHubName?tokenCredential=#myTokenCredential&credentialType=TOKEN_CREDENTIAL)"
 
-## Development Notes (Important)
+# Important Development Notes
 
 When developing on this component, you will need to obtain your Azure
 accessKey to run the integration tests. In addition to the mocked unit
@@ -213,30 +193,30 @@ is the access key being generated from Azure portal and
   
 |Name|Description|Default|Type|
 |---|---|---|---|
-|amqpRetryOptions|Sets the retry policy for EventHubAsyncClient. If not specified, the default retry options are used.||object|
-|amqpTransportType|Sets the transport type by which all the communication with Azure Event Hubs occurs. Default value is AmqpTransportType#AMQP.|AMQP|object|
+|amqpRetryOptions|Sets the retry policy for EventHubProducerAsyncClient. If not specified, the default retry options are used.||object|
+|amqpTransportType|Sets the transport type by which all the communication with Azure Event Hubs occurs.|AMQP|object|
 |configuration|The component configurations||object|
 |blobAccessKey|In case you chose the default BlobCheckpointStore, this sets access key for the associated azure account name to be used for authentication with azure blob services.||string|
 |blobAccountName|In case you chose the default BlobCheckpointStore, this sets Azure account name to be used for authentication with azure blob services.||string|
 |blobContainerName|In case you chose the default BlobCheckpointStore, this sets the blob container that shall be used by the BlobCheckpointStore to store the checkpoint offsets.||string|
 |blobStorageSharedKeyCredential|In case you chose the default BlobCheckpointStore, StorageSharedKeyCredential can be injected to create the azure client, this holds the important authentication information.||object|
 |bridgeErrorHandler|Allows for bridging the consumer to the Camel routing Error Handler, which mean any exceptions (if possible) occurred while the Camel consumer is trying to pickup incoming messages, or the likes, will now be processed as a message and handled by the routing Error Handler. Important: This is only possible if the 3rd party component allows Camel to be alerted if an exception was thrown. Some components handle this internally only, and therefore bridgeErrorHandler is not possible. In other situations we may improve the Camel component to hook into the 3rd party component and make this possible for future releases. 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|
-|checkpointBatchSize|Sets the batch size between each checkpoint updates. Works jointly with checkpointBatchTimeout.|500|integer|
-|checkpointBatchTimeout|Sets the batch timeout between each checkpoint updates. Works jointly with checkpointBatchSize.|5000|integer|
-|checkpointStore|Sets the CheckpointStore the EventProcessorClient will use for storing partition ownership and checkpoint information. Users can, optionally, provide their own implementation of CheckpointStore which will store ownership and checkpoint information. By default it set to use com.azure.messaging.eventhubs.checkpointstore.blob.BlobCheckpointStore which stores all checkpoint offsets into Azure Blob Storage.|BlobCheckpointStore|object|
-|consumerGroupName|Sets the name of the consumer group this consumer is associated with. Events are read in the context of this group. The name of the consumer group that is created by default is {code $Default}.|$Default|string|
-|eventPosition|Sets the map containing the event position to use for each partition if a checkpoint for the partition does not exist in CheckpointStore. This map is keyed off of the partition id. If there is no checkpoint in CheckpointStore and there is no entry in this map, the processing of the partition will start from {link EventPosition#latest() latest} position.||object|
+|checkpointBatchSize|Sets the batch size between each checkpoint update. Works jointly with checkpointBatchTimeout.|500|integer|
+|checkpointBatchTimeout|Sets the batch timeout between each checkpoint update. Works jointly with checkpointBatchSize.|5000|integer|
+|checkpointStore|Sets the CheckpointStore the EventProcessorClient will use for storing partition ownership and checkpoint information. Users can, optionally, provide their own implementation of CheckpointStore which will store ownership and checkpoint information. By default, it's set to use com.azure.messaging.eventhubs.checkpointstore.blob.BlobCheckpointStore which stores all checkpoint offsets into Azure Blob Storage.|BlobCheckpointStore|object|
+|consumerGroupName|Sets the name of the consumer group this consumer is associated with. Events are read in the context of this group. The name of the consumer group that is created by default is $Default.|$Default|string|
+|eventPosition|Sets the map containing the event position to use for each partition if a checkpoint for the partition does not exist in CheckpointStore. This map is keyed off of the partition id. If there is no checkpoint in CheckpointStore and there is no entry in this map, the processing of the partition will start from EventPosition#latest() position.||object|
 |prefetchCount|Sets the count used by the receiver to control the number of events the Event Hub consumer will actively receive and queue locally without regard to whether a receive operation is currently active.|500|integer|
 |lazyStartProducer|Whether the producer should be started lazy (on the first message). By starting lazy you can use this to allow CamelContext and routes to startup in situations where a producer may otherwise fail during starting and cause the route to fail being started. By deferring this startup to be lazy then the startup failure can be handled during routing messages via Camel's routing error handlers. Beware that when the first message is processed then creating and starting the producer may take a little time and prolong the total processing time of the processing.|false|boolean|
-|partitionId|Sets the identifier of the Event Hub partition that the events will be sent to. If the identifier is not specified, the Event Hubs service will be responsible for routing events that are sent to an available partition.||string|
-|partitionKey|Sets a hashing key to be provided for the batch of events, which instructs the Event Hubs service to map this key to a specific partition. The selection of a partition is stable for a given partition hashing key. Should any other batches of events be sent using the same exact partition hashing key, the Event Hubs service will route them all to the same partition. This should be specified only when there is a need to group events by partition, but there is flexibility into which partition they are routed. If ensuring that a batch of events is sent only to a specific partition, it is recommended that the {link #setPartitionId(String) identifier of the position be specified directly} when sending the batch.||string|
-|producerAsyncClient|Sets the EventHubProducerAsyncClient.An asynchronous producer responsible for transmitting EventData to a specific Event Hub, grouped together in batches. Depending on the options specified when creating an {linkEventDataBatch}, the events may be automatically routed to an available partition or specific to a partition. Use by this component to produce the data in camel producer.||object|
+|partitionId|Sets the identifier of the Event Hub partition that the EventData events will be sent to. If the identifier is not specified, the Event Hubs service will be responsible for routing events that are sent to an available partition.||string|
+|partitionKey|Sets a hashing key to be provided for the batch of events, which instructs the Event Hubs service to map this key to a specific partition. The selection of a partition is stable for a given partition hashing key. Should any other batches of events be sent using the same exact partition hashing key, the Event Hubs service will route them all to the same partition. This should be specified only when there is a need to group events by partition, but there is flexibility into which partition they are routed. If ensuring that a batch of events is sent only to a specific partition, it is recommended that the identifier of the position be specified directly when sending the batch.||string|
+|producerAsyncClient|Sets the EventHubProducerAsyncClient.An asynchronous producer responsible for transmitting EventData to a specific Event Hub, grouped together in batches. Depending on the com.azure.messaging.eventhubs.models.CreateBatchOptions options specified when creating an com.azure.messaging.eventhubs.EventDataBatch, the events may be automatically routed to an available partition or specific to a partition. Use by this component to produce the data in camel producer.||object|
 |autowiredEnabled|Whether autowiring is enabled. This is used for automatic autowiring options (the option must be marked as autowired) by looking up in the registry to find if there is a single instance of matching type, which then gets configured on the component. This can be used for automatic configuring JDBC data sources, JMS connection factories, AWS Clients, etc.|true|boolean|
-|connectionString|Instead of supplying namespace, sharedAccessKey, sharedAccessName ... etc, you can just supply the connection string for your eventHub. The connection string for EventHubs already include all the necessary information to connection to your EventHub. To learn on how to generate the connection string, take a look at this documentation: https://docs.microsoft.com/en-us/azure/event-hubs/event-hubs-get-connection-string||string|
+|connectionString|Instead of supplying namespace, sharedAccessKey, sharedAccessName, etc. you can supply the connection string for your eventHub. The connection string for EventHubs already includes all the necessary information to connect to your EventHub. To learn how to generate the connection string, take a look at this documentation: https://docs.microsoft.com/en-us/azure/event-hubs/event-hubs-get-connection-string||string|
 |credentialType|Determines the credential strategy to adopt|CONNECTION\_STRING|object|
 |sharedAccessKey|The generated value for the SharedAccessName.||string|
 |sharedAccessName|The name you chose for your EventHubs SAS keys.||string|
-|tokenCredential|Still another way of authentication (beside supplying namespace, sharedAccessKey, sharedAccessName or connection string) is through Azure-AD authentication using an implementation instance of TokenCredential.||object|
+|tokenCredential|Provide custom authentication credentials using an implementation of TokenCredential.||object|
 
 ## Endpoint Configurations
 
@@ -245,27 +225,27 @@ is the access key being generated from Azure portal and
 |---|---|---|---|
 |namespace|EventHubs namespace created in Azure Portal.||string|
 |eventHubName|EventHubs name under a specific namespace.||string|
-|amqpRetryOptions|Sets the retry policy for EventHubAsyncClient. If not specified, the default retry options are used.||object|
-|amqpTransportType|Sets the transport type by which all the communication with Azure Event Hubs occurs. Default value is AmqpTransportType#AMQP.|AMQP|object|
+|amqpRetryOptions|Sets the retry policy for EventHubProducerAsyncClient. If not specified, the default retry options are used.||object|
+|amqpTransportType|Sets the transport type by which all the communication with Azure Event Hubs occurs.|AMQP|object|
 |blobAccessKey|In case you chose the default BlobCheckpointStore, this sets access key for the associated azure account name to be used for authentication with azure blob services.||string|
 |blobAccountName|In case you chose the default BlobCheckpointStore, this sets Azure account name to be used for authentication with azure blob services.||string|
 |blobContainerName|In case you chose the default BlobCheckpointStore, this sets the blob container that shall be used by the BlobCheckpointStore to store the checkpoint offsets.||string|
 |blobStorageSharedKeyCredential|In case you chose the default BlobCheckpointStore, StorageSharedKeyCredential can be injected to create the azure client, this holds the important authentication information.||object|
-|checkpointBatchSize|Sets the batch size between each checkpoint updates. Works jointly with checkpointBatchTimeout.|500|integer|
-|checkpointBatchTimeout|Sets the batch timeout between each checkpoint updates. Works jointly with checkpointBatchSize.|5000|integer|
-|checkpointStore|Sets the CheckpointStore the EventProcessorClient will use for storing partition ownership and checkpoint information. Users can, optionally, provide their own implementation of CheckpointStore which will store ownership and checkpoint information. By default it set to use com.azure.messaging.eventhubs.checkpointstore.blob.BlobCheckpointStore which stores all checkpoint offsets into Azure Blob Storage.|BlobCheckpointStore|object|
-|consumerGroupName|Sets the name of the consumer group this consumer is associated with. Events are read in the context of this group. The name of the consumer group that is created by default is {code $Default}.|$Default|string|
-|eventPosition|Sets the map containing the event position to use for each partition if a checkpoint for the partition does not exist in CheckpointStore. This map is keyed off of the partition id. If there is no checkpoint in CheckpointStore and there is no entry in this map, the processing of the partition will start from {link EventPosition#latest() latest} position.||object|
+|checkpointBatchSize|Sets the batch size between each checkpoint update. Works jointly with checkpointBatchTimeout.|500|integer|
+|checkpointBatchTimeout|Sets the batch timeout between each checkpoint update. Works jointly with checkpointBatchSize.|5000|integer|
+|checkpointStore|Sets the CheckpointStore the EventProcessorClient will use for storing partition ownership and checkpoint information. Users can, optionally, provide their own implementation of CheckpointStore which will store ownership and checkpoint information. By default, it's set to use com.azure.messaging.eventhubs.checkpointstore.blob.BlobCheckpointStore which stores all checkpoint offsets into Azure Blob Storage.|BlobCheckpointStore|object|
+|consumerGroupName|Sets the name of the consumer group this consumer is associated with. Events are read in the context of this group. The name of the consumer group that is created by default is $Default.|$Default|string|
+|eventPosition|Sets the map containing the event position to use for each partition if a checkpoint for the partition does not exist in CheckpointStore. This map is keyed off of the partition id. If there is no checkpoint in CheckpointStore and there is no entry in this map, the processing of the partition will start from EventPosition#latest() position.||object|
 |prefetchCount|Sets the count used by the receiver to control the number of events the Event Hub consumer will actively receive and queue locally without regard to whether a receive operation is currently active.|500|integer|
 |bridgeErrorHandler|Allows for bridging the consumer to the Camel routing Error Handler, which mean any exceptions (if possible) occurred while the Camel consumer is trying to pickup incoming messages, or the likes, will now be processed as a message and handled by the routing Error Handler. Important: This is only possible if the 3rd party component allows Camel to be alerted if an exception was thrown. Some components handle this internally only, and therefore bridgeErrorHandler is not possible. In other situations we may improve the Camel component to hook into the 3rd party component and make this possible for future releases. 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|
 |exceptionHandler|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.||object|
 |exchangePattern|Sets the exchange pattern when the consumer creates an exchange.||object|
-|partitionId|Sets the identifier of the Event Hub partition that the events will be sent to. If the identifier is not specified, the Event Hubs service will be responsible for routing events that are sent to an available partition.||string|
-|partitionKey|Sets a hashing key to be provided for the batch of events, which instructs the Event Hubs service to map this key to a specific partition. The selection of a partition is stable for a given partition hashing key. Should any other batches of events be sent using the same exact partition hashing key, the Event Hubs service will route them all to the same partition. This should be specified only when there is a need to group events by partition, but there is flexibility into which partition they are routed. If ensuring that a batch of events is sent only to a specific partition, it is recommended that the {link #setPartitionId(String) identifier of the position be specified directly} when sending the batch.||string|
-|producerAsyncClient|Sets the EventHubProducerAsyncClient.An asynchronous producer responsible for transmitting EventData to a specific Event Hub, grouped together in batches. Depending on the options specified when creating an {linkEventDataBatch}, the events may be automatically routed to an available partition or specific to a partition. Use by this component to produce the data in camel producer.||object|
+|partitionId|Sets the identifier of the Event Hub partition that the EventData events will be sent to. If the identifier is not specified, the Event Hubs service will be responsible for routing events that are sent to an available partition.||string|
+|partitionKey|Sets a hashing key to be provided for the batch of events, which instructs the Event Hubs service to map this key to a specific partition. The selection of a partition is stable for a given partition hashing key. Should any other batches of events be sent using the same exact partition hashing key, the Event Hubs service will route them all to the same partition. This should be specified only when there is a need to group events by partition, but there is flexibility into which partition they are routed. If ensuring that a batch of events is sent only to a specific partition, it is recommended that the identifier of the position be specified directly when sending the batch.||string|
+|producerAsyncClient|Sets the EventHubProducerAsyncClient.An asynchronous producer responsible for transmitting EventData to a specific Event Hub, grouped together in batches. Depending on the com.azure.messaging.eventhubs.models.CreateBatchOptions options specified when creating an com.azure.messaging.eventhubs.EventDataBatch, the events may be automatically routed to an available partition or specific to a partition. Use by this component to produce the data in camel producer.||object|
 |lazyStartProducer|Whether the producer should be started lazy (on the first message). By starting lazy you can use this to allow CamelContext and routes to startup in situations where a producer may otherwise fail during starting and cause the route to fail being started. By deferring this startup to be lazy then the startup failure can be handled during routing messages via Camel's routing error handlers. Beware that when the first message is processed then creating and starting the producer may take a little time and prolong the total processing time of the processing.|false|boolean|
-|connectionString|Instead of supplying namespace, sharedAccessKey, sharedAccessName ... etc, you can just supply the connection string for your eventHub. The connection string for EventHubs already include all the necessary information to connection to your EventHub. To learn on how to generate the connection string, take a look at this documentation: https://docs.microsoft.com/en-us/azure/event-hubs/event-hubs-get-connection-string||string|
+|connectionString|Instead of supplying namespace, sharedAccessKey, sharedAccessName, etc. you can supply the connection string for your eventHub. The connection string for EventHubs already includes all the necessary information to connect to your EventHub. To learn how to generate the connection string, take a look at this documentation: https://docs.microsoft.com/en-us/azure/event-hubs/event-hubs-get-connection-string||string|
 |credentialType|Determines the credential strategy to adopt|CONNECTION\_STRING|object|
 |sharedAccessKey|The generated value for the SharedAccessName.||string|
 |sharedAccessName|The name you chose for your EventHubs SAS keys.||string|
-|tokenCredential|Still another way of authentication (beside supplying namespace, sharedAccessKey, sharedAccessName or connection string) is through Azure-AD authentication using an implementation instance of TokenCredential.||object|
+|tokenCredential|Provide custom authentication credentials using an implementation of TokenCredential.||object|

camel-azure-files.md

@@ -70,7 +70,9 @@ Azure authentication information:
     
     azure-files://camelazurefiles/samples/inbox/spam?sharedKey=FAKE502UyuBD...3Z%2BASt9dCmJg%3D%3D&delete=true
 
-# Paths
+# Usage
+
+## Paths
 
 The path separator is `/`. The absolute paths start with the path
 separator. The absolute paths do not include the share name, and they
@@ -82,18 +84,18 @@ path separator appears, and the relative paths are relative to the share
 root (rather than to the current working directory or to the endpoint
 starting directory) so interpret them with a grain of salt.
 
-# Concurrency
+## Concurrency
 
 This component does not support concurrency on its endpoints.
 
-# More Information
+## More Information
 
 This component mimics the FTP component. So, there are more samples and
 details on the FTP component page.
 
 This component uses the Azure Java SDK libraries for the actual work.
 
-# Consuming Files
+## Consuming Files
 
 The remote consumer will by default leave the consumed files untouched
 on the remote cloud files server. You have to configure it explicitly if
@@ -108,7 +110,7 @@ to a `.camel` sub directory. The reason Camel does **not** do this by
 default for the remote consumer is that it may lack permissions by
 default to be able to move or delete files.
 
-## Body Type Options
+### Body Type Options
 
 For each matching file, the consumer sends to the Camel exchange a
 message with a selected body type:
@@ -122,7 +124,7 @@ message with a selected body type:
 The body type configuration should be tuned to fit available resources,
 performance targets, route processors, caching, resuming, etc.
 
-## Limitations
+### Limitations
 
 The option **readLock** can be used to force Camel **not** to consume
 files that are currently in the progress of being written. However, this
@@ -150,23 +152,23 @@ The consumer sets the following exchange properties
 <col style="width: 50%" />
 </colgroup>
 <thead>
-<tr>
+<tr class="header">
 <th style="text-align: left;">Header</th>
 <th style="text-align: left;">Description</th>
 </tr>
 </thead>
 <tbody>
-<tr>
+<tr class="odd">
 <td style="text-align: left;"><p><code>CamelBatchIndex</code></p></td>
 <td style="text-align: left;"><p>The current index out of total number
 of files being consumed in this batch.</p></td>
 </tr>
-<tr>
+<tr class="even">
 <td style="text-align: left;"><p><code>CamelBatchSize</code></p></td>
 <td style="text-align: left;"><p>The total number of files being
 consumed in this batch.</p></td>
 </tr>
-<tr>
+<tr class="odd">
 <td
 style="text-align: left;"><p><code>CamelBatchComplete</code></p></td>
 <td style="text-align: left;"><p>True if there are no more files in this
@@ -175,7 +177,7 @@ batch.</p></td>
 </tbody>
 </table>
 
-# Producing Files
+## Producing Files
 
 The Files producer is optimized for two body types:
 
@@ -187,7 +189,7 @@ In either case, the remote file size is allocated and then rewritten
 with body content. Any inconsistency between declared file length and
 stream length results in a corrupted remote file.
 
-## Limitations
+### Limitations
 
 The underlying Azure Files service does not allow growing files. The
 file length must be known at its creation time, consequently:
@@ -197,7 +199,7 @@ file length must be known at its creation time, consequently:
 
 -   No appending mode is supported.
 
-# About Timeouts
+## About Timeouts
 
 You can use the `connectTimeout` option to set a timeout in millis to
 connect or disconnect.
@@ -211,7 +213,7 @@ For now, the file upload has no timeout. During the upload, the
 underlying library could log timeout warnings. They are recoverable and
 upload could continue.
 
-# Using Local Work Directory
+## Using Local Work Directory
 
 Camel supports consuming from remote files servers and downloading the
 files directly into a local work directory. This avoids reading the
@@ -238,7 +240,7 @@ directly on the work file `java.io.File` handle and perform a
 local work file, it can optimize and use a rename instead of a file
 copy, as the work file is meant to be deleted anyway.
 
-# Custom Filtering
+## Custom Filtering
 
 Camel supports pluggable filtering strategies. This strategy it to use
 the build in `org.apache.camel.component.file.GenericFileFilter` in
@@ -262,7 +264,7 @@ The accept(file) file argument has properties:
 
 -   file length: if not a directory, then a length of the file in bytes
 
-# Filtering using ANT path matcher
+## Filtering using ANT path matcher
 
 The ANT path matcher is a filter shipped out-of-the-box in the
 **camel-spring** jar. So you need to depend on **camel-spring** if you
@@ -283,13 +285,13 @@ The sample below demonstrates how to use it:
 
     from("azure-files://...&antInclude=**/*.txt").to("...");
 
-# Using a Proxy
+## Using a Proxy
 
 Consult the [underlying
 library](https://learn.microsoft.com/en-us/azure/developer/java/sdk/proxying)
 documentation.
 
-# Consuming a single file using a fixed name
+## Consuming a single file using a fixed name
 
 Unlike FTP component that features a special combination of options:
 
@@ -303,7 +305,7 @@ to optimize *the single file using a fixed name* use case, it is
 necessary to fall back to regular filters (i.e. the list permission is
 needed).
 
-# Debug logging
+## Debug logging
 
 This component has log level **TRACE** that can be helpful if you have
 problems.

camel-azure-key-vault.md

@@ -53,6 +53,11 @@ You can also enable the usage of Azure Identity in the
     camel.vault.azure.azureIdentityEnabled = true
     camel.vault.azure.vaultName = vaultName
 
+`camel.vault.azure` configuration only applies to the Azure Key Vault
+properties function (E.g when resolving properties). When using the
+`operation` option to create, get, list secrets etc., you should provide
+the usual options for connecting to Azure Services.
+
 At this point, you’ll be able to reference a property in the following
 way:
 
@@ -97,7 +102,7 @@ example:
     <camelContext>
         <route>
             <from uri="direct:start"/>
-            <log message="Username is {{azure:database/username}}"/>
+            <log message="Username is {{azure:database#username}}"/>
         </route>
     </camelContext>
 
@@ -109,7 +114,7 @@ is not present on Azure Key Vault:
     <camelContext>
         <route>
             <from uri="direct:start"/>
-            <log message="Username is {{azure:database/username:admin}}"/>
+            <log message="Username is {{azure:database#username:admin}}"/>
         </route>
     </camelContext>
 
@@ -145,7 +150,7 @@ secret doesn’t exist or the version doesn’t exist.
     <camelContext>
         <route>
             <from uri="direct:start"/>
-            <log message="Username is {{azure:database/username:admin@bf9b4f4b-8e63-43fd-a73c-3e2d3748b451}}"/>
+            <log message="Username is {{azure:database#username:admin@bf9b4f4b-8e63-43fd-a73c-3e2d3748b451}}"/>
         </route>
     </camelContext>
 
@@ -223,6 +228,98 @@ or the properties with an `azure:` prefix.
 The only requirement is adding the camel-azure-key-vault jar to your
 Camel application.
 
+## Automatic Camel context reloading on Secret Refresh - Required Infrastructure’s creation
+
+First of all we need to create an application
+
+\`\`\` az ad app create --display-name test-app-key-vault \`\`\`
+
+Then we need to obtain credentials
+
+\`\`\` az ad app credential reset --id \<appId\> --append
+\--display-name *Description: Key Vault app client* --end-date
+*2024-12-31* \`\`\`
+
+This will return a result like this
+
+\`\`\` { "appId": "appId", "password": "pwd", "tenant": "tenantId" }
+\`\`\`
+
+You should take note of the password and use it as clientSecret
+parameter, together with the clientId and tenantId.
+
+Now create the key vault
+
+\`\`\` az keyvault create --name \<vaultName\> --resource-group
+\<resourceGroup\> \`\`\`
+
+Create a service principal associated with the application Id
+
+\`\`\` az ad sp create --id \<appId\> \`\`\`
+
+At this point we need to add a role to the application with role
+assignment
+
+\`\`\` az role assignment create --assignee \<appId\> --role "Key
+Vault Administrator" --scope
+/subscriptions/\<subscriptionId\>/resourceGroups/\<resourceGroup\>/providers/Microsoft.KeyVault/vaults/\<vaultName\>
+\`\`\`
+
+Last step is to create policy on what can be or cannot be done with the
+application. In this case we just want to read the secret value. So This
+should be enough.
+
+\`\`\` az keyvault set-policy --name \<vaultName\> --spn
+\<appId\> --secret-permissions get \`\`\`
+
+You can create a secret through Azure CLI with the following command:
+
+\`\`\` az keyvault secret set --name \<secret\_name\> --vault-name
+\<vaultName\> -f \<json-secret\> \`\`\`
+
+Now we need to setup the Eventhub/EventGrid notification for being
+informed about secrets updates.
+
+First of all we’ll need a Blob account and Blob container, to track
+Eventhub consuming activities.
+
+\`\`\` az storage account create --name \<blobAccountName\>
+\--resource-group \<resourceGroup\> \`\`\`
+
+Then create a container
+
+\`\`\` az storage container create --account-name
+\<blobAccountName\> --name \<blobContainerName\> \`\`\`
+
+Then recover the access key for this purpose
+
+\`\`\` az storage account keys list -g \<resourceGroup\> -n
+\<blobAccountName\> \`\`\`
+
+Take note of the blob Account name, blob Container name and Blob Access
+Key to be used for setting up the vault.
+
+Let’s now create the Eventhub side
+
+Create the namespace first
+
+\`\`\` az eventhubs namespace create --resource-group
+\<resourceGroup\> --name \<eventhub-namespace\> --location
+westus --sku Standard --enable-auto-inflate --maximum-throughput-units
+20 \`\`\`
+
+Now create the resource
+
+\`\`\` az eventhubs eventhub create --resource-group
+\<resourceGroup\> --namespace-name \<eventhub-namespace\> --name
+\<eventhub-name\> --cleanup-policy Delete --partition-count 15
+\`\`\`
+
+In the Azure portal create a shared policy for the just created eventhub
+resource with "MANAGE" permissions and copy the connection string.
+
+You now have all the required parameters to set up the vault.
+
 ## Azure Key Vault Producer operations
 
 Azure Key Vault component provides the following operation on the

camel-azure-schema-registry.md

@@ -0,0 +1,6 @@
+# Azure-schema-registry.md
+
+**Since Camel 4.2**
+
+The camel-azure-schema-registry component contains some useful classes
+to deal with authentication against the Azure Schema Registry

camel-azure-servicebus.md

@@ -25,11 +25,11 @@ Portal](https://docs.microsoft.com/azure/).
         <!-- use the same version as your Camel core version -->
     </dependency>
 
-# Consumer and Producer
+# Usage
 
-This component implements the Consumer and Producer.
+## Consumer and Producer
 
-# Usage
+This component implements the Consumer and Producer.
 
 ## Authentication Information
 
@@ -84,18 +84,18 @@ In the consumer, the returned message body will be of type \`String.
 <col style="width: 89%" />
 </colgroup>
 <thead>
-<tr>
+<tr class="header">
 <th style="text-align: left;">Operation</th>
 <th style="text-align: left;">Description</th>
 </tr>
 </thead>
 <tbody>
-<tr>
+<tr class="odd">
 <td style="text-align: left;"><p><code>sendMessages</code></p></td>
 <td style="text-align: left;"><p>Sends a set of messages to a Service
 Bus queue or topic using a batched approach.</p></td>
 </tr>
-<tr>
+<tr class="even">
 <td style="text-align: left;"><p><code>scheduleMessages</code></p></td>
 <td style="text-align: left;"><p>Sends a scheduled message to the Azure
 Service Bus entity this sender is connected to. A scheduled message is
@@ -113,18 +113,18 @@ time.</p></td>
 <col style="width: 89%" />
 </colgroup>
 <thead>
-<tr>
+<tr class="header">
 <th style="text-align: left;">Operation</th>
 <th style="text-align: left;">Description</th>
 </tr>
 </thead>
 <tbody>
-<tr>
+<tr class="odd">
 <td style="text-align: left;"><p><code>receiveMessages</code></p></td>
 <td style="text-align: left;"><p>Receives an &lt;b&gt;infinite&lt;/b&gt;
 stream of messages from the Service Bus entity.</p></td>
 </tr>
-<tr>
+<tr class="even">
 <td style="text-align: left;"><p><code>peekMessages</code></p></td>
 <td style="text-align: left;"><p>Reads the next batch of active messages
 without changing the state of the receiver or the message
@@ -133,7 +133,7 @@ source.</p></td>
 </tbody>
 </table>
 
-### Examples
+# Examples
 
 -   `sendMessages`
 

camel-azure-storage-blob.md

@@ -129,19 +129,19 @@ For these operations, `accountName` is **required**.
 <col style="width: 89%" />
 </colgroup>
 <thead>
-<tr>
+<tr class="header">
 <th style="text-align: left;">Operation</th>
 <th style="text-align: left;">Description</th>
 </tr>
 </thead>
 <tbody>
-<tr>
+<tr class="odd">
 <td
 style="text-align: left;"><p><code>listBlobContainers</code></p></td>
 <td style="text-align: left;"><p>Get the content of the blob. You can
 restrict the output of this operation to a blob range.</p></td>
 </tr>
-<tr>
+<tr class="even">
 <td style="text-align: left;"><p><code>getChangeFeed</code></p></td>
 <td style="text-align: left;"><p>Returns transaction logs of all the
 changes that occur to the blobs and the blob metadata in your storage
@@ -162,27 +162,27 @@ For these operations, `accountName` and `containerName` are
 <col style="width: 89%" />
 </colgroup>
 <thead>
-<tr>
+<tr class="header">
 <th style="text-align: left;">Operation</th>
 <th style="text-align: left;">Description</th>
 </tr>
 </thead>
 <tbody>
-<tr>
+<tr class="odd">
 <td
 style="text-align: left;"><p><code>createBlobContainer</code></p></td>
 <td style="text-align: left;"><p>Create a new container within a storage
 account. If a container with the same name already exists, the producer
 will ignore it.</p></td>
 </tr>
-<tr>
+<tr class="even">
 <td
 style="text-align: left;"><p><code>deleteBlobContainer</code></p></td>
 <td style="text-align: left;"><p>Delete the specified container in the
 storage account. If the container doesn’t exist, the operation
 fails.</p></td>
 </tr>
-<tr>
+<tr class="odd">
 <td style="text-align: left;"><p><code>listBlobs</code></p></td>
 <td style="text-align: left;"><p>Returns a list of blobs in this
 container, with folder structures flattened.</p></td>
@@ -202,25 +202,25 @@ For these operations, `accountName`, `containerName` and `blobName` are
 <col style="width: 79%" />
 </colgroup>
 <thead>
-<tr>
+<tr class="header">
 <th style="text-align: left;">Operation</th>
 <th style="text-align: left;">Blob Type</th>
 <th style="text-align: left;">Description</th>
 </tr>
 </thead>
 <tbody>
-<tr>
+<tr class="odd">
 <td style="text-align: left;"><p><code>getBlob</code></p></td>
 <td style="text-align: left;"><p>Common</p></td>
 <td style="text-align: left;"><p>Get the content of the blob. You can
 restrict the output of this operation to a blob range.</p></td>
 </tr>
-<tr>
+<tr class="even">
 <td style="text-align: left;"><p><code>deleteBlob</code></p></td>
 <td style="text-align: left;"><p>Common</p></td>
 <td style="text-align: left;"><p>Delete a blob.</p></td>
 </tr>
-<tr>
+<tr class="odd">
 <td
 style="text-align: left;"><p><code>downloadBlobToFile</code></p></td>
 <td style="text-align: left;"><p>Common</p></td>
@@ -229,7 +229,7 @@ specified by the path. The file will be created and must not exist, if
 the file already exists a <code>FileAlreadyExistsException</code> will
 be thrown.</p></td>
 </tr>
-<tr>
+<tr class="even">
 <td style="text-align: left;"><p><code>downloadLink</code></p></td>
 <td style="text-align: left;"><p>Common</p></td>
 <td style="text-align: left;"><p>Generate the download link for the
@@ -237,7 +237,7 @@ specified blob using shared access signatures (SAS). This by default
 only limits to 1hour of allowed access. However, you can override the
 default expiration duration through the headers.</p></td>
 </tr>
-<tr>
+<tr class="odd">
 <td style="text-align: left;"><p><code>uploadBlockBlob</code></p></td>
 <td style="text-align: left;"><p>BlockBlob</p></td>
 <td style="text-align: left;"><p>Creates a new block blob, or updates
@@ -246,7 +246,7 @@ overwrites any existing metadata on the blob. Partial updates are not
 supported with PutBlob; the content of the existing blob is overwritten
 with the new content.</p></td>
 </tr>
-<tr>
+<tr class="even">
 <td
 style="text-align: left;"><p><code>stageBlockBlobList</code></p></td>
 <td style="text-align: left;"><p><code>BlockBlob</code></p></td>
@@ -257,7 +257,7 @@ commitBlobBlockList. However, in case header
 <code>commitBlockListLater</code> is set to false, this will commit the
 blocks immediately after staging the blocks.</p></td>
 </tr>
-<tr>
+<tr class="odd">
 <td
 style="text-align: left;"><p><code>commitBlobBlockList</code></p></td>
 <td style="text-align: left;"><p><code>BlockBlob</code></p></td>
@@ -270,20 +270,20 @@ those blocks that have changed, then committing the new and existing
 blocks together. Any blocks not specified in the block list and
 permanently deleted.</p></td>
 </tr>
-<tr>
+<tr class="even">
 <td style="text-align: left;"><p><code>getBlobBlockList</code></p></td>
 <td style="text-align: left;"><p><code>BlockBlob</code></p></td>
 <td style="text-align: left;"><p>Returns the list of blocks that have
 been uploaded as part of a block blob using the specified blocklist
 filter.</p></td>
 </tr>
-<tr>
+<tr class="odd">
 <td style="text-align: left;"><p><code>createAppendBlob</code></p></td>
 <td style="text-align: left;"><p><code>AppendBlob</code></p></td>
 <td style="text-align: left;"><p>Creates a 0-length append blob. Call
 commitAppendBlo`b operation to append data to an append blob.</p></td>
 </tr>
-<tr>
+<tr class="even">
 <td style="text-align: left;"><p><code>commitAppendBlob</code></p></td>
 <td style="text-align: left;"><p><code>AppendBlob</code></p></td>
 <td style="text-align: left;"><p>Commits a new block of data to the end
@@ -293,14 +293,14 @@ of the existing append blob. In case of header
 the appendBlob through internal call to <code>createAppendBlob</code>
 operation first before committing.</p></td>
 </tr>
-<tr>
+<tr class="odd">
 <td style="text-align: left;"><p><code>createPageBlob</code></p></td>
 <td style="text-align: left;"><p><code>PageBlob</code></p></td>
 <td style="text-align: left;"><p>Creates a page blob of the specified
 length. Call <code>uploadPageBlob</code> operation to upload data to a
 page blob.</p></td>
 </tr>
-<tr>
+<tr class="even">
 <td style="text-align: left;"><p><code>uploadPageBlob</code></p></td>
 <td style="text-align: left;"><p><code>PageBlob</code></p></td>
 <td style="text-align: left;"><p>Write one or more pages to the page
@@ -310,25 +310,25 @@ blob. The size must be a multiple of 512. In case of header
 the appendBlob through internal call to <code>createPageBlob</code>
 operation first before uploading.</p></td>
 </tr>
-<tr>
+<tr class="odd">
 <td style="text-align: left;"><p><code>resizePageBlob</code></p></td>
 <td style="text-align: left;"><p><code>PageBlob</code></p></td>
 <td style="text-align: left;"><p>Resizes the page blob to the specified
 size, which must be a multiple of 512.</p></td>
 </tr>
-<tr>
+<tr class="even">
 <td style="text-align: left;"><p><code>clearPageBlob</code></p></td>
 <td style="text-align: left;"><p><code>PageBlob</code></p></td>
 <td style="text-align: left;"><p>Free the specified pages from the page
 blob. The size of the range must be a multiple of 512.</p></td>
 </tr>
-<tr>
+<tr class="odd">
 <td style="text-align: left;"><p><code>getPageBlobRanges</code></p></td>
 <td style="text-align: left;"><p><code>PageBlob</code></p></td>
 <td style="text-align: left;"><p>Returns the list of valid page ranges
 for a page blob or snapshot of a page blob.</p></td>
 </tr>
-<tr>
+<tr class="even">
 <td style="text-align: left;"><p><code>copyBlob</code></p></td>
 <td style="text-align: left;"><p><code>Common</code></p></td>
 <td style="text-align: left;"><p>Copy a blob from one container to
@@ -340,6 +340,8 @@ another one, even from different accounts.</p></td>
 Refer to the example section in this page to learn how to use these
 operations into your camel application.
 
+# Examples
+
 ## Consumer Examples
 
 To consume a blob into a file using the file component, this can be done
@@ -690,7 +692,7 @@ file so that it can be loaded by the camel route, for example:
     from("direct:copyBlob")
       .to("azure-storage-blob://account/containerblob2?operation=uploadBlockBlob&credentialType=AZURE_SAS")
 
-## Development Notes (Important)
+# Important Development Notes
 
 All integration tests use
 [Testcontainers](https://www.testcontainers.org/) and run by default.

camel-azure-storage-datalake.md

@@ -90,13 +90,13 @@ For these operations, `accountName` option is required
 <col style="width: 89%" />
 </colgroup>
 <thead>
-<tr>
+<tr class="header">
 <th style="text-align: left;">Operation</th>
 <th style="text-align: left;">Description</th>
 </tr>
 </thead>
 <tbody>
-<tr>
+<tr class="odd">
 <td style="text-align: left;"><p><code>listFileSystem</code></p></td>
 <td style="text-align: left;"><p>List all the file systems that are
 present in the given azure account.</p></td>
@@ -115,23 +115,23 @@ required
 <col style="width: 89%" />
 </colgroup>
 <thead>
-<tr>
+<tr class="header">
 <th style="text-align: left;">Operation</th>
 <th style="text-align: left;">Description</th>
 </tr>
 </thead>
 <tbody>
-<tr>
+<tr class="odd">
 <td style="text-align: left;"><p><code>createFileSystem</code></p></td>
 <td style="text-align: left;"><p>Create a new file System with the
 storage account</p></td>
 </tr>
-<tr>
+<tr class="even">
 <td style="text-align: left;"><p><code>deleteFileSystem</code></p></td>
 <td style="text-align: left;"><p>Delete the specified file system within
 the storage account</p></td>
 </tr>
-<tr>
+<tr class="odd">
 <td style="text-align: left;"><p><code>listPaths</code></p></td>
 <td style="text-align: left;"><p>Returns list of all the files within
 the given path in the given file system, with folder structure
@@ -151,18 +151,18 @@ For these operations, `accountName`, `fileSystemName` and
 <col style="width: 89%" />
 </colgroup>
 <thead>
-<tr>
+<tr class="header">
 <th style="text-align: left;">Operation</th>
 <th style="text-align: left;">Description</th>
 </tr>
 </thead>
 <tbody>
-<tr>
+<tr class="odd">
 <td style="text-align: left;"><p><code>createFile</code></p></td>
 <td style="text-align: left;"><p>Create a new file in the specified
 directory within the fileSystem</p></td>
 </tr>
-<tr>
+<tr class="even">
 <td style="text-align: left;"><p><code>deleteDirectory</code></p></td>
 <td style="text-align: left;"><p>Delete the specified directory within
 the file system</p></td>
@@ -181,44 +181,44 @@ options are required
 <col style="width: 89%" />
 </colgroup>
 <thead>
-<tr>
+<tr class="header">
 <th style="text-align: left;">Operation</th>
 <th style="text-align: left;">Description</th>
 </tr>
 </thead>
 <tbody>
-<tr>
+<tr class="odd">
 <td style="text-align: left;"><p><code>getFile</code></p></td>
 <td style="text-align: left;"><p>Get the contents of a file</p></td>
 </tr>
-<tr>
+<tr class="even">
 <td style="text-align: left;"><p><code>downloadToFile</code></p></td>
 <td style="text-align: left;"><p>Download the entire file from the file
 system into a path specified by fileDir.</p></td>
 </tr>
-<tr>
+<tr class="odd">
 <td style="text-align: left;"><p><code>downloadLink</code></p></td>
 <td style="text-align: left;"><p>Generate a download link for the
 specified file using Shared Access Signature (SAS). The expiration time
 to be set for the link can be specified otherwise 1 hour is taken as
 default.</p></td>
 </tr>
-<tr>
+<tr class="even">
 <td style="text-align: left;"><p><code>deleteFile</code></p></td>
 <td style="text-align: left;"><p>Delete the specified file.</p></td>
 </tr>
-<tr>
+<tr class="odd">
 <td style="text-align: left;"><p><code>appendToFile</code></p></td>
 <td style="text-align: left;"><p>Appends the data passed to the
 specified file in the file System. Flush command is required after
 append.</p></td>
 </tr>
-<tr>
+<tr class="even">
 <td style="text-align: left;"><p><code>flushToFile</code></p></td>
 <td style="text-align: left;"><p>Flushes the data already appended to
 the specified file.</p></td>
 </tr>
-<tr>
+<tr class="odd">
 <td
 style="text-align: left;"><p><code>openQueryInputStream</code></p></td>
 <td style="text-align: left;"><p>Opens an <code>InputStream</code> based
@@ -231,6 +231,8 @@ register the query acceleration feature with your subscription.</p></td>
 Refer to the examples section below for more details on how to use these
 operations
 
+# Examples
+
 ## Consumer Examples
 
 To consume a file from the storage datalake into a file using the file

camel-azure-storage-queue.md

@@ -124,13 +124,13 @@ For these operations, `accountName` is **required**.
 <col style="width: 89%" />
 </colgroup>
 <thead>
-<tr>
+<tr class="header">
 <th style="text-align: left;">Operation</th>
 <th style="text-align: left;">Description</th>
 </tr>
 </thead>
 <tbody>
-<tr>
+<tr class="odd">
 <td style="text-align: left;"><p><code>listQueues</code></p></td>
 <td style="text-align: left;"><p>Lists the queues in the storage account
 that pass the filter starting at the specified marker.</p></td>
@@ -148,26 +148,26 @@ For these operations, `accountName` and `queueName` are **required**.
 <col style="width: 89%" />
 </colgroup>
 <thead>
-<tr>
+<tr class="header">
 <th style="text-align: left;">Operation</th>
 <th style="text-align: left;">Description</th>
 </tr>
 </thead>
 <tbody>
-<tr>
+<tr class="odd">
 <td style="text-align: left;"><p><code>createQueue</code></p></td>
 <td style="text-align: left;"><p>Creates a new queue.</p></td>
 </tr>
-<tr>
+<tr class="even">
 <td style="text-align: left;"><p><code>deleteQueue</code></p></td>
 <td style="text-align: left;"><p>Permanently deletes the queue.</p></td>
 </tr>
-<tr>
+<tr class="odd">
 <td style="text-align: left;"><p><code>clearQueue</code></p></td>
 <td style="text-align: left;"><p>Deletes all messages in the
 queue..</p></td>
 </tr>
-<tr>
+<tr class="even">
 <td style="text-align: left;"><p><code>sendMessage</code></p></td>
 <td style="text-align: left;"><p><strong>Default Producer
 Operation</strong> Sends a message with a given time-to-live and timeout
@@ -178,24 +178,24 @@ disable this, set the config <code>createQueue</code> or header
 <code>CamelAzureStorageQueueCreateQueue</code> to
 <code>false</code>.</p></td>
 </tr>
-<tr>
+<tr class="odd">
 <td style="text-align: left;"><p><code>deleteMessage</code></p></td>
 <td style="text-align: left;"><p>Deletes the specified message in the
 queue.</p></td>
 </tr>
-<tr>
+<tr class="even">
 <td style="text-align: left;"><p><code>receiveMessages</code></p></td>
 <td style="text-align: left;"><p>Retrieves up to the maximum number of
 messages from the queue and hides them from other operations for the
 timeout period. However, it will not dequeue the message from the queue
 due to reliability reasons.</p></td>
 </tr>
-<tr>
+<tr class="odd">
 <td style="text-align: left;"><p><code>peekMessages</code></p></td>
 <td style="text-align: left;"><p>Peek messages from the front of the
 queue up to the maximum number of messages.</p></td>
 </tr>
-<tr>
+<tr class="even">
 <td style="text-align: left;"><p><code>updateMessage</code></p></td>
 <td style="text-align: left;"><p>Updates the specific message in the
 queue with a new message and resets the visibility timeout. The message
@@ -207,6 +207,8 @@ text is evaluated from the exchange message body.</p></td>
 Refer to the example section in this page to learn how to use these
 operations into your camel application.
 
+# Examples
+
 ## Consumer Examples
 
 To consume a queue into a file component with maximum five messages in
@@ -345,7 +347,7 @@ one batch, this can be done like this:
         })
         .to("azure-storage-queue://cameldev/test?serviceClient=#client&operation=updateMessage");
 
-## Development Notes (Important)
+# Important Development Notes
 
 When developing on this component, you will need to obtain your Azure
 `accessKey` to run the integration tests. In addition to the mocked unit

camel-azure-summary.md

@@ -0,0 +1,11 @@
+# Azure-summary.md
+
+The Camel Components for [Microsoft Azure
+Services](https://azure.microsoft.com/) provide connectivity to Azure
+services from Camel.
+
+# Azure components
+
+See the following for usage of each component:
+
+indexDescriptionList::\[attributes=*group=Azure*,descriptionformat=description\]

camel-barcode-dataformat.md

@@ -0,0 +1,157 @@
+# Barcode-dataformat.md
+
+**Since Camel 2.14**
+
+The Barcode data format is based on the [zxing
+library](https://github.com/zxing/zxing). The goal of this component is
+to create a barcode image from a String (marshal) and a String from a
+barcode image (unmarshal). You’re free to use all features that zxing
+offers.
+
+# Dependencies
+
+To use the barcode data format in your camel routes, you need to add a
+dependency on **camel-barcode** which implements this data format.
+
+If you use maven, you could just add the following to your pom.xml,
+substituting the version number for the latest \& greatest release (see
+the download page for the latest versions).
+
+    <dependency>
+      <groupId>org.apache.camel</groupId>
+      <artifactId>camel-barcode</artifactId>
+      <version>x.x.x</version>
+    </dependency>
+
+# Barcode Options
+
+# Using the Java DSL
+
+First, you have to initialize the barcode data format class. You can use
+the default constructor, or one of parameterized (see JavaDoc). The
+default values are:
+
+<table>
+<colgroup>
+<col style="width: 10%" />
+<col style="width: 89%" />
+</colgroup>
+<thead>
+<tr class="header">
+<th style="text-align: left;">Parameter</th>
+<th style="text-align: left;">Default Value</th>
+</tr>
+</thead>
+<tbody>
+<tr class="odd">
+<td style="text-align: left;"><p>image type (BarcodeImageType)</p></td>
+<td style="text-align: left;"><p>PNG</p></td>
+</tr>
+<tr class="even">
+<td style="text-align: left;"><p>width</p></td>
+<td style="text-align: left;"><p>100 px</p></td>
+</tr>
+<tr class="odd">
+<td style="text-align: left;"><p>height</p></td>
+<td style="text-align: left;"><p>100 px</p></td>
+</tr>
+<tr class="even">
+<td style="text-align: left;"><p>encoding</p></td>
+<td style="text-align: left;"><p>UTF-8</p></td>
+</tr>
+<tr class="odd">
+<td style="text-align: left;"><p>barcode format (BarcodeFormat)</p></td>
+<td style="text-align: left;"><p>QR-Code</p></td>
+</tr>
+</tbody>
+</table>
+
+    // QR-Code default
+    DataFormat code = new BarcodeDataFormat();
+
+If you want to use zxing hints, you can use the *addToHintMap* method of
+your BarcodeDataFormat instance:
+
+    code.addToHintMap(DecodeHintType.TRY_HARDER, Boolean.true);
+
+For possible hints, please consult the xzing documentation.
+
+## Marshalling
+
+    from("direct://code")
+      .marshal(code)
+      .to("file://barcode_out");
+
+You can call the route from a test class with:
+
+    template.sendBody("direct://code", "This is a testmessage!");
+
+You should find inside the *barcode\_out* folder this image:
+
+<figure>
+<img src="ROOT:qr-code.png" alt="image" />
+</figure>
+
+## Unmarshalling
+
+The unmarshaller is generic. For unmarshalling, you can use any
+BarcodeDataFormat instance. If you’ve two instances, one for
+(generating) QR-Code and one for PDF417, it doesn’t matter which one
+will be used.
+
+    from("file://barcode_in?noop=true")
+      .unmarshal(code) // for unmarshalling, the instance doesn't matter
+      .to("mock:out");
+
+If you’ll paste the QR-Code image above into the *barcode\_in* folder,
+you should find *`This is a testmessage!`* inside the mock. You can find
+the barcode data format as header variable:
+
+<table>
+<colgroup>
+<col style="width: 10%" />
+<col style="width: 10%" />
+<col style="width: 79%" />
+</colgroup>
+<thead>
+<tr class="header">
+<th style="text-align: left;">Name</th>
+<th style="text-align: left;">Type</th>
+<th style="text-align: left;">Description</th>
+</tr>
+</thead>
+<tbody>
+<tr class="odd">
+<td style="text-align: left;"><p>BarcodeFormat</p></td>
+<td style="text-align: left;"><p>String</p></td>
+<td style="text-align: left;"><p>Value of
+com.google.zxing.BarcodeFormat.</p></td>
+</tr>
+</tbody>
+</table>
+
+If you’ll paste the code 39 barcode that is rotated some degrees into
+the *barcode\_in* folder, You can find the ORIENTATION as header
+variable:
+
+<table>
+<colgroup>
+<col style="width: 10%" />
+<col style="width: 10%" />
+<col style="width: 79%" />
+</colgroup>
+<thead>
+<tr class="header">
+<th style="text-align: left;">Name</th>
+<th style="text-align: left;">Type</th>
+<th style="text-align: left;">Description</th>
+</tr>
+</thead>
+<tbody>
+<tr class="odd">
+<td style="text-align: left;"><p>ORIENTATION</p></td>
+<td style="text-align: left;"><p>Integer</p></td>
+<td style="text-align: left;"><p>rotate value in degrees .</p></td>
+</tr>
+</tbody>
+</table>

camel-base64-dataformat.md

@@ -0,0 +1,76 @@
+# Base64-dataformat.md
+
+**Since Camel 2.11**
+
+The Base64 data format is used for base64 encoding and decoding.
+
+# Options
+
+In Spring DSL, you configure the data format using this tag:
+
+    <camelContext>
+        <dataFormats>
+            <!-- for a newline character (\n), use the HTML entity notation coupled with the ASCII code. -->
+            <base64 lineSeparator="&#10;" id="base64withNewLine" />
+            <base64 lineLength="64" id="base64withLineLength64" />
+        </dataFormats>
+        ...
+    </camelContext>
+
+Then you can use it later by its reference:
+
+    <route>
+         <from uri="direct:startEncode" />
+         <marshal ref="base64withLineLength64" />
+         <to uri="mock:result" />
+    </route>
+
+Most of the time, you won’t need to declare the data format if you use
+the default options. In that case, you can declare the data format
+inline as shown below.
+
+# Marshal
+
+In this example, we marshal the file content to a base64 object.
+
+    from("file://data.bin")
+        .marshal().base64()
+        .to("jms://myqueue");
+
+In Spring DSL:
+
+     <from uri="file://data.bin">
+     <marshal>
+         <base64/>
+     </marshal>
+     <to uri="jms://myqueue"/>
+
+# Unmarshal
+
+In this example, we unmarshal the payload from the JMS queue to a
+byte\[\] object, before its processed by the `newOrder` processor.
+
+    from("jms://queue/order")
+        .unmarshal().base64()
+        .process("newOrder");
+
+In Spring DSL:
+
+     <from uri="jms://queue/order">
+     <unmarshal>
+         <base64/>
+     </unmarshal>
+     <to uri="bean:newOrder"/>
+
+# Dependencies
+
+To use Base64 in your Camel routes, you need to add a dependency on
+**camel-base64** which implements this data format.
+
+If you use Maven, you can add the following to your pom.xml:
+
+    <dependency>
+      <groupId>org.apache.camel</groupId>
+      <artifactId>camel-base64</artifactId>
+      <version>x.x.x</version>  <!-- use the same version as your Camel core version -->
+    </dependency>

camel-batchConfig-eip.md

@@ -0,0 +1,5 @@
+# BatchConfig-eip.md
+
+Configuring for [Resequence EIP](#resequence-eip.adoc) in batching mode.
+
+# Exchange properties

camel-bean-eip.md

@@ -0,0 +1,141 @@
+# Bean-eip.md
+
+The Bean EIP is used for invoking a method on a bean, and the returned
+value is the new message body.
+
+The Bean EIP is similar to the [Bean](#ROOT:bean-component.adoc)
+component which also is used for invoking beans, but in the form as a
+Camel component.
+
+# URI Format
+
+    bean:beanID[?options]
+
+Where **beanID** can be any string used to look up the bean in the
+[Registry](#manual::registry.adoc).
+
+# EIP options
+
+# Exchange properties
+
+## Bean scope
+
+When using `singleton` scope (default) the bean is created or looked up
+only once and reused for the lifetime of the endpoint. The bean should
+be thread-safe in case concurrent threads are calling the bean at the
+same time.
+
+When using `request` scope the bean is created or looked up once per
+request (exchange). This can be used if you want to store state on a
+bean while processing a request, and you want to call the same bean
+instance multiple times while processing the request. The bean does not
+have to be thread-safe as the instance is only called from the same
+request.
+
+When using `prototype` scope, then the bean will be looked up or created
+per call. However, in case of lookup then this is delegated to the bean
+registry such as Spring or CDI (if in use), which depends on their
+configuration can act as either singleton or prototype scope. However,
+when using `prototype` then behaviour is dependent on the delegated
+registry (such as Spring, Quarkus or CDI).
+
+# Example
+
+The Bean EIP can be used directly in the routes as shown below:
+
+Java  
+// lookup bean from registry and invoke the given method by the name
+from("direct:foo").bean("myBean", "myMethod");
+
+    // lookup bean from registry and invoke best matching method
+    from("direct:bar").bean("myBean");
+
+XML  
+With Spring XML you can declare the bean using `<bean>` as shown:
+
+    <bean id="myBean" class="com.foo.ExampleBean"/>
+
+And in XML DSL you can call this bean:
+
+    <routes>
+        <route>
+          <from uri="direct:foo"/>
+          <bean ref="myBean" method="myMethod"/>
+        </route>
+        <route>
+          <from uri="direct:bar"/>
+          <bean ref="myBean"/>
+        </route>
+    </routes>
+
+YAML  
+\- from:
+uri: direct:start
+steps:
+\- bean:
+ref: myBean
+method: myMethod
+\- from:
+uri: direct:start
+steps:
+\- bean:
+ref: myBean
+\- beans:
+\- name: myBean
+type: com.foo.ExampleBean
+
+Instead of passing the name of the reference to the bean (so that Camel
+will look up for it in the registry), you can provide the bean:
+
+Java  
+// Send a message to the given bean instance.
+from("direct:foo").bean(new ExampleBean());
+
+    // Explicit selection of bean method to be invoked.
+    from("direct:bar").bean(new ExampleBean(), "myMethod");
+    
+    // Camel will create a singleton instance of the bean, and reuse the instance for the following calls (see scope)
+    from("direct:cheese").bean(ExampleBean.class);
+
+XML  
+<routes>  
+<route>  
+<from uri="direct:foo"/>  
+<bean beanType="com.foo.ExampleBean" method="myMethod"/>  
+</route>  
+<route>  
+<from uri="direct:bar"/>  
+<bean beanType="com.foo.ExampleBean"/>  
+</route>  
+<route>  
+<from uri="direct:cheese"/>  
+<bean beanType="com.foo.ExampleBean"/>  
+</route>  
+</routes>
+
+YAML  
+\- from:
+uri: direct:foo
+steps:
+\- bean:
+beanType: com.foo.ExampleBean
+method: myMethod
+\- from:
+uri: direct:bar
+steps:
+\- bean:
+beanType: com.foo.ExampleBean
+\- from:
+uri: direct:cheese
+steps:
+\- bean:
+beanType: com.foo.ExampleBean
+
+# Bean binding
+
+How bean methods to be invoked are chosen (if they are not specified
+explicitly through the **method** parameter) and how parameter values
+are constructed from the [Message](#message.adoc) are all defined by the
+[Bean Binding](#manual::bean-binding.adoc) mechanism. This is used
+throughout all the various [Bean
+Integration](#manual::bean-integration.adoc) mechanisms in Camel.

camel-bean-language.md

@@ -0,0 +1,85 @@
+# Bean-language.md
+
+**Since Camel 1.3**
+
+The Bean language is used for calling a method on an existing Java bean.
+
+Camel adapts to the method being called via [Bean
+Binding](#manual::bean-binding.adoc). The binding process will, for
+example, automatically convert the message payload to the parameter of
+type of the first parameter in the method. The binding process has a lot
+more features, so it is recommended to read the [Bean
+Binding](#manual::bean-binding.adoc) documentation for mor details.
+
+# Bean Method options
+
+# Examples
+
+In the given route below, we call a Java Bean Method with `method`,
+where "myBean" is the id of the bean to use (lookup from
+[Registry](#manual::registry.adoc)), and "isGoldCustomer" is the name of
+the method to call.
+
+Java  
+from("activemq:topic:OrdersTopic")
+.filter().method("myBean", "isGoldCustomer")
+.to("activemq:BigSpendersQueue");
+
+It is also possible to omit the method name. In this case, then Camel
+would choose the best suitable method to use. This process is complex,
+so it is good practice to specify the method name.
+
+XML  
+<route>  
+<from uri="activemq:topic:OrdersTopic"/>  
+<filter>  
+<method ref="myBean" method="isGoldCustomer"/>  
+<to uri="activemq:BigSpendersQueue"/>  
+</filter>  
+</route>
+
+The bean could be implemented as follows:
+
+    public class MyBean {
+      public boolean isGoldCustomer(Exchange exchange) {
+         // ...
+      }
+    }
+
+How this method uses `Exchange` in the method signature. You would often
+not do that, and use non-Camel types. For example, by using `String`
+then Camel will automatically convert the message body to this type when
+calling the method:
+
+    public boolean isGoldCustomer(String body) {...}
+
+## Using Annotations for bean integration
+
+You can also use the [Bean Integration](#manual::bean-integration.adoc)
+annotations, such as `@Header`, `@Body`, `@Variable` etc
+
+    public boolean isGoldCustomer(@Header(name = "foo") Integer fooHeader) {...}
+
+So you can bind parameters of the method to the `Exchange`, the
+[Message](#eips:message.adoc) or individual headers, properties, the
+body or other expressions.
+
+## Non-Registry Beans
+
+The Bean Method Language also supports invoking beans that are not
+registered in the [Registry](#manual::registry.adoc).
+
+Camel can instantiate the bean of a given type and invoke the method or
+invoke the method on an already existing instance.
+
+    from("activemq:topic:OrdersTopic")
+      .filter().method(MyBean.class, "isGoldCustomer")
+      .to("activemq:BigSpendersQueue");
+
+The first parameter can also be an existing instance of a Bean such as:
+
+    private MyBean my = ...;
+    
+    from("activemq:topic:OrdersTopic")
+      .filter().method(my, "isGoldCustomer")
+      .to("activemq:BigSpendersQueue");