// spring-boot-auto-configure options: START
:page-partial:
:doctitle: Camel Spring Boot Starter for bindy

== Spring Boot Auto-Configuration

When using bindy with Spring Boot make sure to use the following Maven dependency to have support for auto configuration:

[source,xml]
----
<dependency>
  <groupId>org.apache.camel.springboot</groupId>
  <artifactId>camel-bindy-starter</artifactId>
  <version>x.x.x</version>
  <!-- use the same version as your Camel core version -->
</dependency>
----


The component supports 18 options, which are listed below.



[width="100%",cols="2,5,^1,2",options="header"]
|===
| Name | Description | Default | Type
| *camel.dataformat.bindy-csv.allow-empty-stream* | Whether to allow empty streams in the unmarshal process. If true, no exception will be thrown when a body without records is provided. | false | Boolean
| *camel.dataformat.bindy-csv.class-type* | Name of model class to use. |  | String
| *camel.dataformat.bindy-csv.enabled* | Whether to enable auto configuration of the bindy-csv data format. This is enabled by default. |  | Boolean
| *camel.dataformat.bindy-csv.locale* | To configure a default locale to use, such as us for united states. To use the JVM platform default locale then use the name default |  | String
| *camel.dataformat.bindy-csv.type* | Whether to use Csv, Fixed, or KeyValue. |  | String
| *camel.dataformat.bindy-csv.unwrap-single-instance* | When unmarshalling should a single instance be unwrapped and returned instead of wrapped in a java.util.List. | true | Boolean
| *camel.dataformat.bindy-fixed.allow-empty-stream* | Whether to allow empty streams in the unmarshal process. If true, no exception will be thrown when a body without records is provided. | false | Boolean
| *camel.dataformat.bindy-fixed.class-type* | Name of model class to use. |  | String
| *camel.dataformat.bindy-fixed.enabled* | Whether to enable auto configuration of the bindy-fixed data format. This is enabled by default. |  | Boolean
| *camel.dataformat.bindy-fixed.locale* | To configure a default locale to use, such as us for united states. To use the JVM platform default locale then use the name default |  | String
| *camel.dataformat.bindy-fixed.type* | Whether to use Csv, Fixed, or KeyValue. |  | String
| *camel.dataformat.bindy-fixed.unwrap-single-instance* | When unmarshalling should a single instance be unwrapped and returned instead of wrapped in a java.util.List. | true | Boolean
| *camel.dataformat.bindy-kvp.allow-empty-stream* | Whether to allow empty streams in the unmarshal process. If true, no exception will be thrown when a body without records is provided. | false | Boolean
| *camel.dataformat.bindy-kvp.class-type* | Name of model class to use. |  | String
| *camel.dataformat.bindy-kvp.enabled* | Whether to enable auto configuration of the bindy-kvp data format. This is enabled by default. |  | Boolean
| *camel.dataformat.bindy-kvp.locale* | To configure a default locale to use, such as us for united states. To use the JVM platform default locale then use the name default |  | String
| *camel.dataformat.bindy-kvp.type* | Whether to use Csv, Fixed, or KeyValue. |  | String
| *camel.dataformat.bindy-kvp.unwrap-single-instance* | When unmarshalling should a single instance be unwrapped and returned instead of wrapped in a java.util.List. | true | Boolean
|===
// spring-boot-auto-configure options: END
