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

== Spring Boot Auto-Configuration

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


The component supports 17 options, which are listed below.



[width="100%",cols="2,5,^1,2",options="header"]
|===
| Name | Description | Default | Type
| *camel.component.aws2-translate.access-key* | Amazon AWS Access Key |  | String
| *camel.component.aws2-translate.autodetect-source-language* | Being able to autodetect the source language | false | Boolean
| *camel.component.aws2-translate.autowired-enabled* | 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
| *camel.component.aws2-translate.configuration* | Component configuration. The option is a org.apache.camel.component.aws2.translate.Translate2Configuration type. |  | Translate2Configuration
| *camel.component.aws2-translate.enabled* | Whether to enable auto configuration of the aws2-translate component. This is enabled by default. |  | Boolean
| *camel.component.aws2-translate.lazy-start-producer* | 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
| *camel.component.aws2-translate.operation* | The operation to perform |  | Translate2Operations
| *camel.component.aws2-translate.pojo-request* | If we want to use a POJO request as body or not | false | Boolean
| *camel.component.aws2-translate.proxy-host* | To define a proxy host when instantiating the Translate client |  | String
| *camel.component.aws2-translate.proxy-port* | To define a proxy port when instantiating the Translate client |  | Integer
| *camel.component.aws2-translate.proxy-protocol* | To define a proxy protocol when instantiating the Translate client |  | Protocol
| *camel.component.aws2-translate.region* | The region in which Translate client needs to work. When using this parameter, the configuration will expect the lowercase name of the region (for example ap-east-1) You'll need to use the name Region.EU_WEST_1.id() |  | String
| *camel.component.aws2-translate.secret-key* | Amazon AWS Secret Key |  | String
| *camel.component.aws2-translate.source-language* | Source language to use |  | String
| *camel.component.aws2-translate.target-language* | Target language to use |  | String
| *camel.component.aws2-translate.translate-client* | To use a existing configured AWS Translate as client. The option is a software.amazon.awssdk.services.translate.TranslateClient type. |  | TranslateClient
| *camel.component.aws2-translate.trust-all-certificates* | If we want to trust all certificates in case of overriding the endpoint | false | Boolean
|===
// spring-boot-auto-configure options: END
