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

== Spring Boot Auto-Configuration

When using barcode 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-barcode-starter</artifactId>
  <version>x.x.x</version>
  <!-- use the same version as your Camel core version -->
</dependency>
----


The component supports 5 options, which are listed below.



[width="100%",cols="2,5,^1,2",options="header"]
|===
| Name | Description | Default | Type
| *camel.dataformat.barcode.barcode-format* | Barcode format such as QR-Code |  | String
| *camel.dataformat.barcode.enabled* | Whether to enable auto configuration of the barcode data format. This is enabled by default. |  | Boolean
| *camel.dataformat.barcode.height* | Height of the barcode |  | Integer
| *camel.dataformat.barcode.image-type* | Image type of the barcode such as png |  | String
| *camel.dataformat.barcode.width* | Width of the barcode |  | Integer
|===
// spring-boot-auto-configure options: END
