// kafka-connector options: START
[[camel-cmis-kafka-connector-sink]]
= camel-cmis-kafka-connector sink configuration

When using camel-cmis-kafka-connector as sink make sure to use the following Maven dependency to have support for the connector:

[source,xml]
----
<dependency>
  <groupId>org.apache.camel.kafkaconnector</groupId>
  <artifactId>camel-cmis-kafka-connector</artifactId>
  <version>x.x.x</version>
  <!-- use the same version as your Camel Kafka connector version -->
</dependency>
----


The camel-cmis sink connector supports 15 options, which are listed below.



[width="100%",cols="2,5,^1,2",options="header"]
|===
| Name | Description | Default | Priority
| *camel.sink.path.cmsUrl* | URL to the cmis repository | null | ConfigDef.Importance.HIGH
| *camel.sink.endpoint.pageSize* | Number of nodes to retrieve per page | 100 | ConfigDef.Importance.MEDIUM
| *camel.sink.endpoint.readContent* | If set to true, the content of document node will be retrieved in addition to the properties | false | ConfigDef.Importance.MEDIUM
| *camel.sink.endpoint.readCount* | Max number of nodes to read | null | ConfigDef.Importance.MEDIUM
| *camel.sink.endpoint.repositoryId* | The Id of the repository to use. If not specified the first available repository is used | null | ConfigDef.Importance.MEDIUM
| *camel.sink.endpoint.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 | ConfigDef.Importance.MEDIUM
| *camel.sink.endpoint.queryMode* | If true, will execute the cmis query from the message body and return result, otherwise will create a node in the cmis repository | false | ConfigDef.Importance.MEDIUM
| *camel.sink.endpoint.basicPropertyBinding* | Whether the endpoint should use basic property binding (Camel 2.x) or the newer property binding with additional capabilities | false | ConfigDef.Importance.MEDIUM
| *camel.sink.endpoint.sessionFacadeFactory* | To use a custom CMISSessionFacadeFactory to create the CMISSessionFacade instances | null | ConfigDef.Importance.MEDIUM
| *camel.sink.endpoint.synchronous* | Sets whether synchronous processing should be strictly used, or Camel is allowed to use asynchronous processing (if supported). | false | ConfigDef.Importance.MEDIUM
| *camel.sink.endpoint.password* | Password for the cmis repository | null | ConfigDef.Importance.MEDIUM
| *camel.sink.endpoint.username* | Username for the cmis repository | null | ConfigDef.Importance.MEDIUM
| *camel.component.cmis.sessionFacadeFactory* | To use a custom CMISSessionFacadeFactory to create the CMISSessionFacade instances | null | ConfigDef.Importance.MEDIUM
| *camel.component.cmis.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 | ConfigDef.Importance.MEDIUM
| *camel.component.cmis.basicPropertyBinding* | Whether the component should use basic property binding (Camel 2.x) or the newer property binding with additional capabilities | false | ConfigDef.Importance.MEDIUM
|===
// kafka-connector options: END
