content: /*
   * Licensed to the Apache Software Foundation (ASF) under one or more
   * contributor license agreements.  See the NOTICE file distributed with
   * this work for additional information regarding copyright ownership.
   * The ASF licenses this file to You under the Apache License, Version 2.0
   * (the "License"); you may not use this file except in compliance with
   * the License.  You may obtain a copy of the License at
   *
   *      http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  package org.apache.camel.component.kafka.springboot;
  
  import java.util.Map;
  import java.util.concurrent.ExecutorService;
  import org.apache.camel.component.kafka.KafkaClientFactory;
  import org.apache.camel.component.kafka.KafkaComponent;
  import org.apache.camel.component.kafka.KafkaConfiguration;
  import org.apache.camel.component.kafka.PollExceptionStrategy;
  import org.apache.camel.component.kafka.PollOnError;
  import org.apache.camel.component.kafka.SeekPolicy;
  import org.apache.camel.component.kafka.consumer.KafkaManualCommitFactory;
  import org.apache.camel.component.kafka.serde.KafkaHeaderDeserializer;
  import org.apache.camel.component.kafka.serde.KafkaHeaderSerializer;
  import org.apache.camel.spi.HeaderFilterStrategy;
  import org.apache.camel.spi.StateRepository;
  import org.apache.camel.spring.boot.ComponentConfigurationPropertiesCommon;
  import org.apache.camel.support.jsse.SSLContextParameters;
  import org.springframework.boot.context.properties.ConfigurationProperties;
  
  /**
   * Send and receive messages to/from an Apache Kafka broker.
   * 
   * Generated by camel-package-maven-plugin - do not edit this file!
   */
  @ConfigurationProperties(prefix = "camel.component.kafka")
  public class KafkaComponentConfiguration
          extends
              ComponentConfigurationPropertiesCommon {
  
      /**
       * Whether to enable auto configuration of the kafka component. This is
       * enabled by default.
       */
      private Boolean enabled;
      /**
       * Sets additional properties for either kafka consumer or kafka producer in
       * case they can't be set directly on the camel configurations (e.g.: new
       * Kafka properties that are not reflected yet in Camel configurations), the
       * properties have to be prefixed with additionalProperties.., e.g.:
       * additionalProperties.transactional.id=12345&additionalProperties.schema.registry.url=http://localhost:8811/avro. If the properties are set in the application.properties file, they must be prefixed with camel.component.kafka.additional-properties and the property enclosed in square brackets, like this example: camel.component.kafka.additional-propertiesdelivery.timeout.ms=15000. This is a multi-value option with prefix: additionalProperties.
       */
      private Map<String, Object> additionalProperties;
      /**
       * URL of the Kafka brokers to use. The format is host1:port1,host2:port2,
       * and the list can be a subset of brokers or a VIP pointing to a subset of
       * brokers. This option is known as bootstrap.servers in the Kafka
       * documentation.
       */
      private String brokers;
      /**
       * The client id is a user-specified string sent in each request to help
       * trace calls. It should logically identify the application making the
       * request.
       */
      private String clientId;
      /**
       * Allows to pre-configure the Kafka component with common options that the
       * endpoints will reuse. The option is a
       * org.apache.camel.component.kafka.KafkaConfiguration type.
       */
      private KafkaConfiguration configuration;
      /**
       * To use a custom HeaderFilterStrategy to filter header to and from Camel
       * message. The option is a org.apache.camel.spi.HeaderFilterStrategy type.
       */
      private HeaderFilterStrategy headerFilterStrategy;
      /**
       * The maximum amount of time in milliseconds to wait when reconnecting to a
       * broker that has repeatedly failed to connect. If provided, the backoff
       * per host will increase exponentially for each consecutive connection
       * failure, up to this maximum. After calculating the backoff increase, 20%
       * random jitter is added to avoid connection storms.
       */
      private Integer reconnectBackoffMaxMs = 1000;
      /**
       * The maximum amount of time in milliseconds to wait when retrying a
       * request to the broker that has repeatedly failed. If provided, the
       * backoff per client will increase exponentially for each failed request,
       * up to this maximum. To prevent all clients from being synchronized upon
       * retry, a randomized jitter with a factor of 0.2 will be applied to the
       * backoff, resulting in the backoff falling within a range between 20%
       * below and 20% above the computed value. If retry.backoff.ms is set to be
       * higher than retry.backoff.max.ms, then retry.backoff.max.ms will be used
       * as a constant backoff from the beginning without any exponential increase
       */
      private Integer retryBackoffMaxMs = 1000;
      /**
       * The amount of time to wait before attempting to retry a failed request to
       * a given topic partition. This avoids repeatedly sending requests in a
       * tight loop under some failure scenarios. This value is the initial
       * backoff value and will increase exponentially for each failed request, up
       * to the retry.backoff.max.ms value.
       */
      private Integer retryBackoffMs = 100;
      /**
       * Timeout in milliseconds to wait gracefully for the consumer or producer
       * to shut down and terminate its worker threads.
       */
      private Integer shutdownTimeout = 30000;
      /**
       * Whether to allow doing manual commits via KafkaManualCommit. If this
       * option is enabled then an instance of KafkaManualCommit is stored on the
       * Exchange message header, which allows end users to access this API and
       * perform manual offset commits via the Kafka consumer.
       */
      private Boolean allowManualCommit = false;
      /**
       * If true, periodically commit to ZooKeeper the offset of messages already
       * fetched by the consumer. This committed offset will be used when the
       * process fails as the position from which the new consumer will begin.
       */
      private Boolean autoCommitEnable = true;
      /**
       * The frequency in ms that the consumer offsets are committed to zookeeper.
       */
      private Integer autoCommitIntervalMs = 5000;
      /**
       * What to do when there is no initial offset in ZooKeeper or if an offset
       * is out of range: earliest : automatically reset the offset to the
       * earliest offset latest: automatically reset the offset to the latest
       * offset fail: throw exception to the consumer
       */
      private String autoOffsetReset = "latest";
      /**
       * Whether to use batching for processing or streaming. The default is
       * false, which uses streaming. In streaming mode, then a single kafka
       * record is processed per Camel exchange in the message body. In batching
       * mode, then Camel groups many kafka records together as a List objects in
       * the message body. The option maxPollRecords is used to define the number
       * of records to group together in batching mode.
       */
      private Boolean batching = false;
      /**
       * In consumer batching mode, then this option is specifying a time in
       * millis, to trigger batch completion eager when the current batch size has
       * not reached the maximum size defined by maxPollRecords. Notice the
       * trigger is not exact at the given interval, as this can only happen
       * between kafka polls (see pollTimeoutMs option). So for example setting
       * this to 10000, then the trigger happens in the interval 10000
       * pollTimeoutMs. The default value for pollTimeoutMs is 5000, so this would
       * mean a trigger interval at about every 15 seconds.
       */
      private Integer batchingIntervalMs;
      /**
       * This options controls what happens when a consumer is processing an
       * exchange and it fails. If the option is false then the consumer continues
       * to the next message and processes it. If the option is true then the
       * consumer breaks out. Using the default NoopCommitManager will cause the
       * consumer to not commit the offset so that the message is re-attempted.
       * The consumer should use the KafkaManualCommit to determine the best way
       * to handle the message. Using either the SyncCommitManager or the
       * AsyncCommitManager, the consumer will seek back to the offset of the
       * message that caused a failure, and then re-attempt to process this
       * message. However, this can lead to endless processing of the same message
       * if it's bound to fail every time, e.g., a poison message. Therefore, it's
       * recommended to deal with that, for example, by using Camel's error
       * handler.
       */
      private Boolean breakOnFirstError = false;
      /**
       * 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.
       */
      private Boolean bridgeErrorHandler = false;
      /**
       * Automatically check the CRC32 of the records consumed. This ensures no
       * on-the-wire or on-disk corruption to the messages occurred. This check
       * adds some overhead, so it may be disabled in cases seeking extreme
       * performance.
       */
      private Boolean checkCrcs = true;
      /**
       * The maximum time, in milliseconds, that the code will wait for a
       * synchronous commit to complete. The option is a java.lang.Long type.
       */
      private Long commitTimeoutMs = 5000L;
      /**
       * The configuration controls the maximum amount of time the client will
       * wait for the response of a request. If the response is not received
       * before the timeout elapsed, the client will resend the request if
       * necessary or fail the request if retries are exhausted.
       */
      private Integer consumerRequestTimeoutMs = 30000;
      /**
       * The number of consumers that connect to kafka server. Each consumer is
       * run on a separate thread that retrieves and process the incoming data.
       */
      private Integer consumersCount = 1;
      /**
       * The maximum amount of data the server should return for a fetch request.
       * This is not an absolute maximum, if the first message in the first
       * non-empty partition of the fetch is larger than this value, the message
       * will still be returned to ensure that the consumer can make progress. The
       * maximum message size accepted by the broker is defined via
       * message.max.bytes (broker config) or max.message.bytes (topic config).
       * Note that the consumer performs multiple fetches in parallel.
       */
      private Integer fetchMaxBytes = 52428800;
      /**
       * The minimum amount of data the server should return for a fetch request.
       * If insufficient data is available, the request will wait for that much
       * data to accumulate before answering the request.
       */
      private Integer fetchMinBytes = 1;
      /**
       * The maximum amount of time the server will block before answering the
       * fetch request if there isn't enough data to immediately satisfy
       * fetch.min.bytes
       */
      private Integer fetchWaitMaxMs = 500;
      /**
       * A string that uniquely identifies the group of consumer processes to
       * which this consumer belongs. By setting the same group id, multiple
       * processes can indicate that they are all part of the same consumer group.
       * This option is required for consumers.
       */
      private String groupId;
      /**
       * A unique identifier of the consumer instance provided by the end user.
       * Only non-empty strings are permitted. If set, the consumer is treated as
       * a static member, which means that only one instance with this ID is
       * allowed in the consumer group at any time. This can be used in
       * combination with a larger session timeout to avoid group rebalances
       * caused by transient unavailability (e.g., process restarts). If not set,
       * the consumer will join the group as a dynamic member, which is the
       * traditional behavior.
       */
      private String groupInstanceId;
      /**
       * To use a custom KafkaHeaderDeserializer to deserialize kafka headers
       * values. The option is a
       * org.apache.camel.component.kafka.serde.KafkaHeaderDeserializer type.
       */
      private KafkaHeaderDeserializer headerDeserializer;
      /**
       * The expected time between heartbeats to the consumer coordinator when
       * using Kafka's group management facilities. Heartbeats are used to ensure
       * that the consumer's session stays active and to facilitate rebalancing
       * when new consumers join or leave the group. The value must be set lower
       * than session.timeout.ms, but typically should be set no higher than 1/3
       * of that value. It can be adjusted even lower to control the expected time
       * for normal rebalances.
       */
      private Integer heartbeatIntervalMs = 3000;
      /**
       * Deserializer class for the key that implements the Deserializer
       * interface.
       */
      private String keyDeserializer = "org.apache.kafka.common.serialization.StringDeserializer";
      /**
       * The maximum amount of data per-partition the server will return. The
       * maximum total memory used for a request will be #partitions
       * max.partition.fetch.bytes. This size must be at least as large as the
       * maximum message size the server allows or else it is possible for the
       * producer to send messages larger than the consumer can fetch. If that
       * happens, the consumer can get stuck trying to fetch a large message on a
       * certain partition.
       */
      private Integer maxPartitionFetchBytes = 1048576;
      /**
       * The maximum delay between invocations of poll() when using consumer group
       * management. This places an upper bound on the amount of time that the
       * consumer can be idle before fetching more records. If poll() is not
       * called before expiration of this timeout, then the consumer is considered
       * failed, and the group will re-balance to reassign the partitions to
       * another member. The option is a java.lang.Integer type.
       */
      private Integer maxPollIntervalMs;
      /**
       * The maximum number of records returned in a single call to poll()
       */
      private Integer maxPollRecords = 500;
      /**
       * The offset repository to use to locally store the offset of each
       * partition of the topic. Defining one will disable the autocommit. The
       * option is a org.apache.camel.spi.StateRepository<java.lang.String,
       * java.lang.String> type.
       */
      private StateRepository<String, String> offsetRepository;
      /**
       * The class name of the partition assignment strategy that the client will
       * use to distribute partition ownership amongst consumer instances when
       * group management is used
       */
      private String partitionAssignor = "org.apache.kafka.clients.consumer.RangeAssignor";
      /**
       * What to do if kafka threw an exception while polling for new messages.
       * Will by default use the value from the component configuration unless an
       * explicit value has been configured on the endpoint level. DISCARD will
       * discard the message and continue to poll the next message. ERROR_HANDLER
       * will use Camel's error handler to process the exception, and afterwards
       * continue to poll the next message. RECONNECT will re-connect the consumer
       * and try polling the message again. RETRY will let the consumer retry poll
       * the same message again. STOP will stop the consumer (it has to be
       * manually started/restarted if the consumer should be able to consume
       * messages again)
       */
      private PollOnError pollOnError = PollOnError.ERROR_HANDLER;
      /**
       * The timeout used when polling the KafkaConsumer. The option is a
       * java.lang.Long type.
       */
      private Long pollTimeoutMs = 5000L;
      /**
       * Whether to eager validate that broker host:port is valid and can be DNS
       * resolved to known host during starting this consumer. If the validation
       * fails, then an exception is thrown, which makes Camel fail fast.
       * Disabling this will postpone the validation after the consumer is
       * started, and Camel will keep re-connecting in case of validation or DNS
       * resolution error.
       */
      private Boolean preValidateHostAndPort = true;
      /**
       * Set if KafkaConsumer should read from the beginning or the end on
       * startup: SeekPolicy.BEGINNING: read from the beginning. SeekPolicy.END:
       * read from the end.
       */
      private SeekPolicy seekTo;
      /**
       * The timeout used to detect failures when using Kafka's group management
       * facilities.
       */
      private Integer sessionTimeoutMs = 45000;
      /**
       * This enables the use of a specific Avro reader for use with the in
       * multiple Schema registries documentation with Avro Deserializers
       * implementation. This option is only available externally (not standard
       * Apache Kafka)
       */
      private Boolean specificAvroReader = false;
      /**
       * Whether the topic is a pattern (regular expression). This can be used to
       * subscribe to dynamic number of topics matching the pattern.
       */
      private Boolean topicIsPattern = false;
      /**
       * Deserializer class for value that implements the Deserializer interface.
       */
      private String valueDeserializer = "org.apache.kafka.common.serialization.StringDeserializer";
      /**
       * The delay in millis seconds to wait before trying again to create the
       * kafka consumer (kafka-client).
       */
      private Long createConsumerBackoffInterval = 5000L;
      /**
       * Maximum attempts to create the kafka consumer (kafka-client), before
       * eventually giving up and failing. Error during creating the consumer may
       * be fatal due to invalid configuration and as such recovery is not
       * possible. However, one part of the validation is DNS resolution of the
       * bootstrap broker hostnames. This may be a temporary networking problem,
       * and could potentially be recoverable. While other errors are fatal, such
       * as some invalid kafka configurations. Unfortunately, kafka-client does
       * not separate this kind of errors. Camel will by default retry forever,
       * and therefore never give up. If you want to give up after many attempts
       * then set this option and Camel will then when giving up terminate the
       * consumer. To try again, you can manually restart the consumer by
       * stopping, and starting the route.
       */
      private Integer createConsumerBackoffMaxAttempts;
      /**
       * Controls how to read messages written transactionally. If set to
       * read_committed, consumer.poll() will only return transactional messages
       * which have been committed. If set to read_uncommitted (the default),
       * consumer.poll() will return all messages, even transactional messages
       * which have been aborted. Non-transactional messages will be returned
       * unconditionally in either mode. Messages will always be returned in
       * offset order. Hence, in read_committed mode, consumer.poll() will only
       * return messages up to the last stable offset (LSO), which is the one less
       * than the offset of the first open transaction. In particular, any
       * messages appearing after messages belonging to ongoing transactions will
       * be withheld until the relevant transaction has been completed. As a
       * result, read_committed consumers will not be able to read up to the high
       * watermark when there are in flight transactions. Further, when in
       * read_committed the seekToEnd method will return the LSO
       */
      private String isolationLevel = "read_uncommitted";
      /**
       * Factory to use for creating KafkaManualCommit instances. This allows to
       * plugin a custom factory to create custom KafkaManualCommit instances in
       * case special logic is needed when doing manual commits that deviates from
       * the default implementation that comes out of the box. The option is a
       * org.apache.camel.component.kafka.consumer.KafkaManualCommitFactory type.
       */
      private KafkaManualCommitFactory kafkaManualCommitFactory;
      /**
       * To use a custom strategy with the consumer to control how to handle
       * exceptions thrown from the Kafka broker while pooling messages. The
       * option is a org.apache.camel.component.kafka.PollExceptionStrategy type.
       */
      private PollExceptionStrategy pollExceptionStrategy;
      /**
       * The delay in millis seconds to wait before trying again to subscribe to
       * the kafka broker.
       */
      private Long subscribeConsumerBackoffInterval = 5000L;
      /**
       * Maximum number the kafka consumer will attempt to subscribe to the kafka
       * broker, before eventually giving up and failing. Error during subscribing
       * the consumer to the kafka topic could be temporary errors due to network
       * issues, and could potentially be recoverable. Camel will by default retry
       * forever, and therefore never give up. If you want to give up after many
       * attempts, then set this option and Camel will then when giving up
       * terminate the consumer. You can manually restart the consumer by stopping
       * and starting the route, to try again.
       */
      private Integer subscribeConsumerBackoffMaxAttempts;
      /**
       * Whether when a Camel Kafka consumer is subscribing to a Kafka broker then
       * check whether a topic already exist on the broker, and fail if it does
       * not. Otherwise, the Camel Kafka consumer will keep attempt to consume
       * from the topic, until it's created on the Kafka broker; and until then
       * the Camel Kafka consumer will fail and log a WARN about
       * UNKNOWN_TOPIC_OR_PARTITION. The option
       * subscribeConsumerBackoffMaxAttempts can be configured to give up trying
       * to subscribe after a given number of attempts.
       */
      private Boolean subscribeConsumerTopicMustExists = false;
      /**
       * If this feature is enabled and a single element of a batch is an Exchange
       * or Message, the producer will generate individual kafka header values for
       * it by using the batch Message to determine the values. Normal behavior
       * consists of always using the same header values (which are determined by
       * the parent Exchange which contains the Iterable or Iterator).
       */
      private Boolean batchWithIndividualHeaders = false;
      /**
       * The total bytes of memory the producer can use to buffer records waiting
       * to be sent to the server. If records are sent faster than they can be
       * delivered to the server, the producer will either block or throw an
       * exception based on the preference specified by block.on.buffer.full.This
       * setting should correspond roughly to the total memory the producer will
       * use, but is not a hard bound since not all memory the producer uses is
       * used for buffering. Some additional memory will be used for compression
       * (if compression is enabled) as well as for maintaining in-flight
       * requests.
       */
      private Integer bufferMemorySize = 33554432;
      /**
       * This parameter allows you to specify the compression codec for all data
       * generated by this producer. Valid values are none, gzip, snappy, lz4 and
       * zstd.
       */
      private String compressionCodec = "none";
      /**
       * Close idle connections after the number of milliseconds specified by this
       * config.
       */
      private Integer connectionMaxIdleMs = 540000;
      /**
       * An upper bound on the time to report success or failure after a call to
       * send() returns. This limits the total time that a record will be delayed
       * prior to sending, the time to await acknowledgement from the broker (if
       * expected), and the time allowed for retriable send failures.
       */
      private Integer deliveryTimeoutMs = 120000;
      /**
       * When set to 'true', the producer will ensure that exactly one copy of
       * each message is written in the stream. If 'false', producer retries due
       * to broker failures, etc., may write duplicates of the retried message in
       * the stream. Note that enabling idempotence requires
       * max.in.flight.requests.per.connection to be less than or equal to 5 (with
       * message ordering preserved for any allowable value), retries to be
       * greater than 0, and acks must be 'all'. Idempotence is enabled by default
       * if no conflicting configurations are set. If conflicting configurations
       * are set and idempotence is not explicitly enabled, idempotence is
       * disabled. If idempotence is explicitly enabled and conflicting
       * configurations are set, a ConfigException is thrown.
       */
      private Boolean enableIdempotence = true;
      /**
       * To use a custom KafkaHeaderSerializer to serialize kafka headers values.
       * The option is a
       * org.apache.camel.component.kafka.serde.KafkaHeaderSerializer type.
       */
      private KafkaHeaderSerializer headerSerializer;
      /**
       * The record key (or null if no key is specified). If this option has been
       * configured then it take precedence over header KafkaConstants#KEY
       */
      private String key;
      /**
       * The serializer class for keys (defaults to the same as for messages if
       * nothing is given).
       */
      private String keySerializer = "org.apache.kafka.common.serialization.StringSerializer";
      /**
       * 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.
       */
      private Boolean lazyStartProducer = false;
      /**
       * The producer groups together any records that arrive in between request
       * transmissions into a single, batched, request. Normally, this occurs only
       * under load when records arrive faster than they can be sent out. However,
       * in some circumstances, the client may want to reduce the number of
       * requests even under a moderate load. This setting achieves this by adding
       * a small amount of artificial delay. That is, rather than immediately
       * sending out a record, the producer will wait for up to the given delay to
       * allow other records to be sent so that they can be batched together. This
       * can be thought of as analogous to Nagle's algorithm in TCP. This setting
       * gives the upper bound on the delay for batching: once we get batch.size
       * worth of records for a partition, it will be sent immediately regardless
       * of this setting, however, if we have fewer than this many bytes
       * accumulated for this partition, we will 'linger' for the specified time
       * waiting for more records to show up. This setting defaults to 0 (i.e., no
       * delay). Setting linger.ms=5, for example, would have the effect of
       * reducing the number of requests sent but would add up to 5ms of latency
       * to records sent in the absence of load.
       */
      private Integer lingerMs = 0;
      /**
       * The configuration controls how long the KafkaProducer's send(),
       * partitionsFor(), initTransactions(), sendOffsetsToTransaction(),
       * commitTransaction() and abortTransaction() methods will block. For send()
       * this timeout bounds the total time waiting for both metadata fetch and
       * buffer allocation (blocking in the user-supplied serializers or
       * partitioner is not counted against this timeout). For partitionsFor()
       * this time out bounds the time spent waiting for metadata if it is
       * unavailable. The transaction-related methods always block, but may time
       * out if the transaction coordinator could not be discovered or did not
       * respond within the timeout.
       */
      private Integer maxBlockMs = 60000;
      /**
       * The maximum number of unacknowledged requests the client will send on a
       * single connection before blocking. Note that if this setting is set to be
       * greater than 1 and there are failed sends, there is a risk of message
       * re-ordering due to retries (i.e., if retries are enabled).
       */
      private Integer maxInFlightRequest = 5;
      /**
       * The maximum size of a request. This is also effectively a cap on the
       * maximum record size. Note that the server has its own cap on record size
       * which may be different from this. This setting will limit the number of
       * record batches the producer will send in a single request to avoid
       * sending huge requests.
       */
      private Integer maxRequestSize = 1048576;
      /**
       * The period of time in milliseconds after which we force a refresh of
       * metadata even if we haven't seen any partition leadership changes to
       * proactively discover any new brokers or partitions.
       */
      private Integer metadataMaxAgeMs = 300000;
      /**
       * A list of classes to use as metrics reporters. Implementing the
       * MetricReporter interface allows plugging in classes that will be notified
       * of new metric creation. The JmxReporter is always included to register
       * JMX statistics.
       */
      private String metricReporters;
      /**
       * The window of time a metrics sample is computed over.
       */
      private Integer metricsSampleWindowMs = 30000;
      /**
       * The number of samples maintained to compute metrics.
       */
      private Integer noOfMetricsSample = 2;
      /**
       * The partitioner class for partitioning messages amongst sub-topics. The
       * default partitioner is based on the hash of the key.
       */
      private String partitioner;
      /**
       * Whether the message keys should be ignored when computing the partition.
       * This setting has effect only when partitioner is not set
       */
      private Boolean partitionerIgnoreKeys = false;
      /**
       * The partition to which the record will be sent (or null if no partition
       * was specified). If this option has been configured then it take
       * precedence over header KafkaConstants#PARTITION_KEY
       */
      private Integer partitionKey;
      /**
       * The producer will attempt to batch records together into fewer requests
       * whenever multiple records are being sent to the same partition. This
       * helps performance on both the client and the server. This configuration
       * controls the default batch size in bytes. No attempt will be made to
       * batch records larger than this size. Requests sent to brokers will
       * contain multiple batches, one for each partition with data available to
       * be sent. A small batch size will make batching less common and may reduce
       * throughput (a batch size of zero will disable batching entirely). A very
       * large batch size may use memory a bit more wastefully as we will always
       * allocate a buffer of the specified batch size in anticipation of
       * additional records.
       */
      private Integer producerBatchSize = 16384;
      /**
       * The maximum number of unsent messages that can be queued up the producer
       * when using async mode before either the producer must be blocked or data
       * must be dropped.
       */
      private Integer queueBufferingMaxMessages = 10000;
      /**
       * The size of the TCP receive buffer (SO_RCVBUF) to use when reading data.
       */
      private Integer receiveBufferBytes = 65536;
      /**
       * The amount of time to wait before attempting to reconnect to a given
       * host. This avoids repeatedly connecting to a host in a tight loop. This
       * backoff applies to all requests sent by the consumer to the broker.
       */
      private Integer reconnectBackoffMs = 50;
      /**
       * The number of acknowledgments the producer requires the leader to have
       * received before considering a request complete. This controls the
       * durability of records that are sent. The following settings are allowed:
       * acks=0 If set to zero, then the producer will not wait for any
       * acknowledgment from the server at all. The record will be immediately
       * added to the socket buffer and considered sent. No guarantee can be made
       * that the server has received the record in this case, and the retry
       * configuration will not take effect (as the client won't generally know of
       * any failures). The offset given back for each record will always be set
       * to -1. acks=1 This will mean the leader will write the record to its
       * local log but will respond without awaiting full acknowledgment from all
       * followers. In this case should the leader fail immediately after
       * acknowledging the record, but before the followers have replicated it,
       * then the record will be lost. acks=all This means the leader will wait
       * for the full set of in-sync replicas to acknowledge the record. This
       * guarantees that the record will not be lost as long as at least one
       * in-sync replica remains alive. This is the strongest available guarantee.
       * This is equivalent to the acks=-1 setting. Note that enabling idempotence
       * requires this config value to be 'all'. If conflicting configurations are
       * set and idempotence is not explicitly enabled, idempotence is disabled.
       */
      private String requestRequiredAcks = "all";
      /**
       * The amount of time the broker will wait trying to meet the
       * request.required.acks requirement before sending back an error to the
       * client.
       */
      private Integer requestTimeoutMs = 30000;
      /**
       * Setting a value greater than zero will cause the client to resend any
       * record that has failed to be sent due to a potentially transient error.
       * Note that this retry is no different from if the client re-sending the
       * record upon receiving the error. Produce requests will be failed before
       * the number of retries has been exhausted if the timeout configured by
       * delivery.timeout.ms expires first before successful acknowledgement.
       * Users should generally prefer to leave this config unset and instead use
       * delivery.timeout.ms to control retry behavior. Enabling idempotence
       * requires this config value to be greater than 0. If conflicting
       * configurations are set and idempotence is not explicitly enabled,
       * idempotence is disabled. Allowing retries while setting
       * enable.idempotence to false and max.in.flight.requests.per.connection to
       * 1 will potentially change the ordering of records, because if two batches
       * are sent to a single partition, and the first fails and is retried but
       * the second succeeds; then the records in the second batch may appear
       * first.
       */
      private Integer retries;
      /**
       * Socket write buffer size
       */
      private Integer sendBufferBytes = 131072;
      /**
       * Indicates to create a transactional.id kafka property by using the
       * endpoint id and route id. This property is ignored in case there is
       * transactional.id kafka property or the transactionalId parameter.
       */
      private Boolean transacted = false;
      /**
       * Enable the kafka producer to be a transactional one by setting the
       * transactional.id property. In case this property is used, the transacted
       * parameter is ignored.
       */
      private String transactionalId;
      /**
       * Sets whether sending to kafka should send the message body as a single
       * record, or use a java.util.Iterator to send multiple records to kafka (if
       * the message body can be iterated).
       */
      private Boolean useIterator = true;
      /**
       * The serializer class for messages.
       */
      private String valueSerializer = "org.apache.kafka.common.serialization.StringSerializer";
      /**
       * To use a custom worker pool for continue routing Exchange after kafka
       * server has acknowledged the message that was sent to it from
       * KafkaProducer using asynchronous non-blocking processing. If using this
       * option, then you must handle the lifecycle of the thread pool to shut the
       * pool down when no longer needed. The option is a
       * java.util.concurrent.ExecutorService type.
       */
      private ExecutorService workerPool;
      /**
       * Number of core threads for the worker pool for continue routing Exchange
       * after kafka server has acknowledged the message that was sent to it from
       * KafkaProducer using asynchronous non-blocking processing.
       */
      private Integer workerPoolCoreSize = 10;
      /**
       * Maximum number of threads for the worker pool for continue routing
       * Exchange after kafka server has acknowledged the message that was sent to
       * it from KafkaProducer using asynchronous non-blocking processing.
       */
      private Integer workerPoolMaxSize = 20;
      /**
       * Whether the producer should store the RecordMetadata results from sending
       * to Kafka. The results are stored in a List containing the RecordMetadata
       * metadata's. The list is stored on a header with the key
       * KafkaConstants#KAFKA_RECORD_META
       */
      private Boolean recordMetadata = false;
      /**
       * 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.
       */
      private Boolean autowiredEnabled = true;
      /**
       * Factory to use for creating
       * org.apache.kafka.clients.consumer.KafkaConsumer and
       * org.apache.kafka.clients.producer.KafkaProducer instances. This allows
       * configuring a custom factory to create instances with logic that extends
       * the vanilla Kafka clients. The option is a
       * org.apache.camel.component.kafka.KafkaClientFactory type.
       */
      private KafkaClientFactory kafkaClientFactory;
      /**
       * Sets whether synchronous processing should be strictly used
       */
      private Boolean synchronous = false;
      /**
       * Used for enabling or disabling all consumer based health checks from this
       * component
       */
      private Boolean healthCheckConsumerEnabled = true;
      /**
       * Used for enabling or disabling all producer based health checks from this
       * component. Notice: Camel has by default disabled all producer based
       * health-checks. You can turn on producer checks globally by setting
       * camel.health.producersEnabled=true.
       */
      private Boolean healthCheckProducerEnabled = true;
      /**
       * Sets interceptors for producer or consumers. Producer interceptors have
       * to be classes implementing
       * org.apache.kafka.clients.producer.ProducerInterceptor Consumer
       * interceptors have to be classes implementing
       * org.apache.kafka.clients.consumer.ConsumerInterceptor Note that if you
       * use Producer interceptor on a consumer it will throw a class cast
       * exception in runtime
       */
      private String interceptorClasses;
      /**
       * URL of the schema registry servers to use. The format is
       * host1:port1,host2:port2. This is known as schema.registry.url in multiple
       * Schema registries documentation. This option is only available externally
       * (not standard Apache Kafka)
       */
      private String schemaRegistryURL;
      /**
       * Login thread sleep time between refresh attempts.
       */
      private Integer kerberosBeforeReloginMinTime = 60000;
      /**
       * Location of the kerberos config file.
       */
      private String kerberosConfigLocation;
      /**
       * Kerberos kinit command path. Default is /usr/bin/kinit
       */
      private String kerberosInitCmd = "/usr/bin/kinit";
      /**
       * A list of rules for mapping from principal names to short names
       * (typically operating system usernames). The rules are evaluated in order,
       * and the first rule that matches a principal name is used to map it to a
       * short name. Any later rules in the list are ignored. By default,
       * principal names of the form {username}/{hostname}{REALM} are mapped to
       * {username}. For more details on the format, please see the Security
       * Authorization and ACLs documentation (at the Apache Kafka project
       * website). Multiple values can be separated by comma
       */
      private String kerberosPrincipalToLocalRules = "DEFAULT";
      /**
       * Percentage of random jitter added to the renewal time.
       */
      private Double kerberosRenewJitter;
      /**
       * Login thread will sleep until the specified window factor of time from
       * last refresh to ticket's expiry has been reached, at which time it will
       * try to renew the ticket.
       */
      private Double kerberosRenewWindowFactor;
      /**
       * Expose the kafka sasl.jaas.config parameter Example:
       * org.apache.kafka.common.security.plain.PlainLoginModule required
       * username=USERNAME password=PASSWORD;
       */
      private String saslJaasConfig;
      /**
       * The Kerberos principal name that Kafka runs as. This can be defined
       * either in Kafka's JAAS config or in Kafka's config.
       */
      private String saslKerberosServiceName;
      /**
       * The Simple Authentication and Security Layer (SASL) Mechanism used. For
       * the valid values see
       * http://www.iana.org/assignments/sasl-mechanisms/sasl-mechanisms.xhtml
       */
      private String saslMechanism = "GSSAPI";
      /**
       * Protocol used to communicate with brokers. SASL_PLAINTEXT, PLAINTEXT,
       * SASL_SSL and SSL are supported
       */
      private String securityProtocol = "PLAINTEXT";
      /**
       * A list of cipher suites. This is a named combination of authentication,
       * encryption, MAC and key exchange algorithm used to negotiate the security
       * settings for a network connection using TLS or SSL network protocol. By
       * default, all the available cipher suites are supported.
       */
      private String sslCipherSuites;
      /**
       * SSL configuration using a Camel SSLContextParameters object. If
       * configured, it's applied before the other SSL endpoint parameters. NOTE:
       * Kafka only supports loading keystore from file locations, so prefix the
       * location with file: in the KeyStoreParameters.resource option. The option
       * is a org.apache.camel.support.jsse.SSLContextParameters type.
       */
      private SSLContextParameters sslContextParameters;
      /**
       * The list of protocols enabled for SSL connections. The default is
       * TLSv1.2,TLSv1.3 when running with Java 11 or newer, TLSv1.2 otherwise.
       * With the default value for Java 11, clients and servers will prefer
       * TLSv1.3 if both support it and fallback to TLSv1.2 otherwise (assuming
       * both support at least TLSv1.2). This default should be fine for most
       * cases. Also see the config documentation for SslProtocol.
       */
      private String sslEnabledProtocols;
      /**
       * The endpoint identification algorithm to validate server hostname using
       * server certificate. Use none or false to disable server hostname
       * verification.
       */
      private String sslEndpointAlgorithm = "https";
      /**
       * The algorithm used by key manager factory for SSL connections. Default
       * value is the key manager factory algorithm configured for the Java
       * Virtual Machine.
       */
      private String sslKeymanagerAlgorithm = "SunX509";
      /**
       * The password of the private key in the key store file or the PEM key
       * specified in sslKeystoreKey. This is required for clients only if two-way
       * authentication is configured.
       */
      private String sslKeyPassword;
      /**
       * The location of the key store file. This is optional for the client and
       * can be used for two-way authentication for the client.
       */
      private String sslKeystoreLocation;
      /**
       * The store password for the key store file. This is optional for the
       * client and only needed if sslKeystoreLocation is configured. Key store
       * password is not supported for PEM format.
       */
      private String sslKeystorePassword;
      /**
       * The file format of the key store file. This is optional for the client.
       * The default value is JKS
       */
      private String sslKeystoreType = "JKS";
      /**
       * The SSL protocol used to generate the SSLContext. The default is TLSv1.3
       * when running with Java 11 or newer, TLSv1.2 otherwise. This value should
       * be fine for most use cases. Allowed values in recent JVMs are TLSv1.2 and
       * TLSv1.3. TLS, TLSv1.1, SSL, SSLv2 and SSLv3 may be supported in older
       * JVMs, but their usage is discouraged due to known security
       * vulnerabilities. With the default value for this config and
       * sslEnabledProtocols, clients will downgrade to TLSv1.2 if the server does
       * not support TLSv1.3. If this config is set to TLSv1.2, clients will not
       * use TLSv1.3 even if it is one of the values in sslEnabledProtocols and
       * the server only supports TLSv1.3.
       */
      private String sslProtocol;
      /**
       * The name of the security provider used for SSL connections. Default value
       * is the default security provider of the JVM.
       */
      private String sslProvider;
      /**
       * The algorithm used by trust manager factory for SSL connections. Default
       * value is the trust manager factory algorithm configured for the Java
       * Virtual Machine.
       */
      private String sslTrustmanagerAlgorithm = "PKIX";
      /**
       * The location of the trust store file.
       */
      private String sslTruststoreLocation;
      /**
       * The password for the trust store file. If a password is not set, trust
       * store file configured will still be used, but integrity checking is
       * disabled. Trust store password is not supported for PEM format.
       */
      private String sslTruststorePassword;
      /**
       * The file format of the trust store file. The default value is JKS.
       */
      private String sslTruststoreType = "JKS";
      /**
       * Enable usage of global SSL context parameters.
       */
      private Boolean useGlobalSslContextParameters = false;
  
      public Map<String, Object> getAdditionalProperties() {
          return additionalProperties;
      }
  
      public void setAdditionalProperties(Map<String, Object> additionalProperties) {
          this.additionalProperties = additionalProperties;
      }
  
      public String getBrokers() {
          return brokers;
      }
  
      public void setBrokers(String brokers) {
          this.brokers = brokers;
      }
  
      public String getClientId() {
          return clientId;
      }
  
      public void setClientId(String clientId) {
          this.clientId = clientId;
      }
  
      public KafkaConfiguration getConfiguration() {
          return configuration;
      }
  
      public void setConfiguration(KafkaConfiguration configuration) {
          this.configuration = configuration;
      }
  
      public HeaderFilterStrategy getHeaderFilterStrategy() {
          return headerFilterStrategy;
      }
  
      public void setHeaderFilterStrategy(
              HeaderFilterStrategy headerFilterStrategy) {
          this.headerFilterStrategy = headerFilterStrategy;
      }
  
      public Integer getReconnectBackoffMaxMs() {
          return reconnectBackoffMaxMs;
      }
  
      public void setReconnectBackoffMaxMs(Integer reconnectBackoffMaxMs) {
          this.reconnectBackoffMaxMs = reconnectBackoffMaxMs;
      }
  
      public Integer getRetryBackoffMaxMs() {
          return retryBackoffMaxMs;
      }
  
      public void setRetryBackoffMaxMs(Integer retryBackoffMaxMs) {
          this.retryBackoffMaxMs = retryBackoffMaxMs;
      }
  
      public Integer getRetryBackoffMs() {
          return retryBackoffMs;
      }
  
      public void setRetryBackoffMs(Integer retryBackoffMs) {
          this.retryBackoffMs = retryBackoffMs;
      }
  
      public Integer getShutdownTimeout() {
          return shutdownTimeout;
      }
  
      public void setShutdownTimeout(Integer shutdownTimeout) {
          this.shutdownTimeout = shutdownTimeout;
      }
  
      public Boolean getAllowManualCommit() {
          return allowManualCommit;
      }
  
      public void setAllowManualCommit(Boolean allowManualCommit) {
          this.allowManualCommit = allowManualCommit;
      }
  
      public Boolean getAutoCommitEnable() {
          return autoCommitEnable;
      }
  
      public void setAutoCommitEnable(Boolean autoCommitEnable) {
          this.autoCommitEnable = autoCommitEnable;
      }
  
      public Integer getAutoCommitIntervalMs() {
          return autoCommitIntervalMs;
      }
  
      public void setAutoCommitIntervalMs(Integer autoCommitIntervalMs) {
          this.autoCommitIntervalMs = autoCommitIntervalMs;
      }
  
      public String getAutoOffsetReset() {
          return autoOffsetReset;
      }
  
      public void setAutoOffsetReset(String autoOffsetReset) {
          this.autoOffsetReset = autoOffsetReset;
      }
  
      public Boolean getBatching() {
          return batching;
      }
  
      public void setBatching(Boolean batching) {
          this.batching = batching;
      }
  
      public Integer getBatchingIntervalMs() {
          return batchingIntervalMs;
      }
  
      public void setBatchingIntervalMs(Integer batchingIntervalMs) {
          this.batchingIntervalMs = batchingIntervalMs;
      }
  
      public Boolean getBreakOnFirstError() {
          return breakOnFirstError;
      }
  
      public void setBreakOnFirstError(Boolean breakOnFirstError) {
          this.breakOnFirstError = breakOnFirstError;
      }
  
      public Boolean getBridgeErrorHandler() {
          return bridgeErrorHandler;
      }
  
      public void setBridgeErrorHandler(Boolean bridgeErrorHandler) {
          this.bridgeErrorHandler = bridgeErrorHandler;
      }
  
      public Boolean getCheckCrcs() {
          return checkCrcs;
      }
  
      public void setCheckCrcs(Boolean checkCrcs) {
          this.checkCrcs = checkCrcs;
      }
  
      public Long getCommitTimeoutMs() {
          return commitTimeoutMs;
      }
  
      public void setCommitTimeoutMs(Long commitTimeoutMs) {
          this.commitTimeoutMs = commitTimeoutMs;
      }
  
      public Integer getConsumerRequestTimeoutMs() {
          return consumerRequestTimeoutMs;
      }
  
      public void setConsumerRequestTimeoutMs(Integer consumerRequestTimeoutMs) {
          this.consumerRequestTimeoutMs = consumerRequestTimeoutMs;
      }
  
      public Integer getConsumersCount() {
          return consumersCount;
      }
  
      public void setConsumersCount(Integer consumersCount) {
          this.consumersCount = consumersCount;
      }
  
      public Integer getFetchMaxBytes() {
          return fetchMaxBytes;
      }
  
      public void setFetchMaxBytes(Integer fetchMaxBytes) {
          this.fetchMaxBytes = fetchMaxBytes;
      }
  
      public Integer getFetchMinBytes() {
          return fetchMinBytes;
      }
  
      public void setFetchMinBytes(Integer fetchMinBytes) {
          this.fetchMinBytes = fetchMinBytes;
      }
  
      public Integer getFetchWaitMaxMs() {
          return fetchWaitMaxMs;
      }
  
      public void setFetchWaitMaxMs(Integer fetchWaitMaxMs) {
          this.fetchWaitMaxMs = fetchWaitMaxMs;
      }
  
      public String getGroupId() {
          return groupId;
      }
  
      public void setGroupId(String groupId) {
          this.groupId = groupId;
      }
  
      public String getGroupInstanceId() {
          return groupInstanceId;
      }
  
      public void setGroupInstanceId(String groupInstanceId) {
          this.groupInstanceId = groupInstanceId;
      }
  
      public KafkaHeaderDeserializer getHeaderDeserializer() {
          return headerDeserializer;
      }
  
      public void setHeaderDeserializer(KafkaHeaderDeserializer headerDeserializer) {
          this.headerDeserializer = headerDeserializer;
      }
  
      public Integer getHeartbeatIntervalMs() {
          return heartbeatIntervalMs;
      }
  
      public void setHeartbeatIntervalMs(Integer heartbeatIntervalMs) {
          this.heartbeatIntervalMs = heartbeatIntervalMs;
      }
  
      public String getKeyDeserializer() {
          return keyDeserializer;
      }
  
      public void setKeyDeserializer(String keyDeserializer) {
          this.keyDeserializer = keyDeserializer;
      }
  
      public Integer getMaxPartitionFetchBytes() {
          return maxPartitionFetchBytes;
      }
  
      public void setMaxPartitionFetchBytes(Integer maxPartitionFetchBytes) {
          this.maxPartitionFetchBytes = maxPartitionFetchBytes;
      }
  
      public Integer getMaxPollIntervalMs() {
          return maxPollIntervalMs;
      }
  
      public void setMaxPollIntervalMs(Integer maxPollIntervalMs) {
          this.maxPollIntervalMs = maxPollIntervalMs;
      }
  
      public Integer getMaxPollRecords() {
          return maxPollRecords;
      }
  
      public void setMaxPollRecords(Integer maxPollRecords) {
          this.maxPollRecords = maxPollRecords;
      }
  
      public StateRepository<String, String> getOffsetRepository() {
          return offsetRepository;
      }
  
      public void setOffsetRepository(
              StateRepository<String, String> offsetRepository) {
          this.offsetRepository = offsetRepository;
      }
  
      public String getPartitionAssignor() {
          return partitionAssignor;
      }
  
      public void setPartitionAssignor(String partitionAssignor) {
          this.partitionAssignor = partitionAssignor;
      }
  
      public PollOnError getPollOnError() {
          return pollOnError;
      }
  
      public void setPollOnError(PollOnError pollOnError) {
          this.pollOnError = pollOnError;
      }
  
      public Long getPollTimeoutMs() {
          return pollTimeoutMs;
      }
  
      public void setPollTimeoutMs(Long pollTimeoutMs) {
          this.pollTimeoutMs = pollTimeoutMs;
      }
  
      public Boolean getPreValidateHostAndPort() {
          return preValidateHostAndPort;
      }
  
      public void setPreValidateHostAndPort(Boolean preValidateHostAndPort) {
          this.preValidateHostAndPort = preValidateHostAndPort;
      }
  
      public SeekPolicy getSeekTo() {
          return seekTo;
      }
  
      public void setSeekTo(SeekPolicy seekTo) {
          this.seekTo = seekTo;
      }
  
      public Integer getSessionTimeoutMs() {
          return sessionTimeoutMs;
      }
  
      public void setSessionTimeoutMs(Integer sessionTimeoutMs) {
          this.sessionTimeoutMs = sessionTimeoutMs;
      }
  
      public Boolean getSpecificAvroReader() {
          return specificAvroReader;
      }
  
      public void setSpecificAvroReader(Boolean specificAvroReader) {
          this.specificAvroReader = specificAvroReader;
      }
  
      public Boolean getTopicIsPattern() {
          return topicIsPattern;
      }
  
      public void setTopicIsPattern(Boolean topicIsPattern) {
          this.topicIsPattern = topicIsPattern;
      }
  
      public String getValueDeserializer() {
          return valueDeserializer;
      }
  
      public void setValueDeserializer(String valueDeserializer) {
          this.valueDeserializer = valueDeserializer;
      }
  
      public Long getCreateConsumerBackoffInterval() {
          return createConsumerBackoffInterval;
      }
  
      public void setCreateConsumerBackoffInterval(
              Long createConsumerBackoffInterval) {
          this.createConsumerBackoffInterval = createConsumerBackoffInterval;
      }
  
      public Integer getCreateConsumerBackoffMaxAttempts() {
          return createConsumerBackoffMaxAttempts;
      }
  
      public void setCreateConsumerBackoffMaxAttempts(
              Integer createConsumerBackoffMaxAttempts) {
          this.createConsumerBackoffMaxAttempts = createConsumerBackoffMaxAttempts;
      }
  
      public String getIsolationLevel() {
          return isolationLevel;
      }
  
      public void setIsolationLevel(String isolationLevel) {
          this.isolationLevel = isolationLevel;
      }
  
      public KafkaManualCommitFactory getKafkaManualCommitFactory() {
          return kafkaManualCommitFactory;
      }
  
      public void setKafkaManualCommitFactory(
              KafkaManualCommitFactory kafkaManualCommitFactory) {
          this.kafkaManualCommitFactory = kafkaManualCommitFactory;
      }
  
      public PollExceptionStrategy getPollExceptionStrategy() {
          return pollExceptionStrategy;
      }
  
      public void setPollExceptionStrategy(
              PollExceptionStrategy pollExceptionStrategy) {
          this.pollExceptionStrategy = pollExceptionStrategy;
      }
  
      public Long getSubscribeConsumerBackoffInterval() {
          return subscribeConsumerBackoffInterval;
      }
  
      public void setSubscribeConsumerBackoffInterval(
              Long subscribeConsumerBackoffInterval) {
          this.subscribeConsumerBackoffInterval = subscribeConsumerBackoffInterval;
      }
  
      public Integer getSubscribeConsumerBackoffMaxAttempts() {
          return subscribeConsumerBackoffMaxAttempts;
      }
  
      public void setSubscribeConsumerBackoffMaxAttempts(
              Integer subscribeConsumerBackoffMaxAttempts) {
          this.subscribeConsumerBackoffMaxAttempts = subscribeConsumerBackoffMaxAttempts;
      }
  
      public Boolean getSubscribeConsumerTopicMustExists() {
          return subscribeConsumerTopicMustExists;
      }
  
      public void setSubscribeConsumerTopicMustExists(
              Boolean subscribeConsumerTopicMustExists) {
          this.subscribeConsumerTopicMustExists = subscribeConsumerTopicMustExists;
      }
  
      public Boolean getBatchWithIndividualHeaders() {
          return batchWithIndividualHeaders;
      }
  
      public void setBatchWithIndividualHeaders(Boolean batchWithIndividualHeaders) {
          this.batchWithIndividualHeaders = batchWithIndividualHeaders;
      }
  
      public Integer getBufferMemorySize() {
          return bufferMemorySize;
      }
  
      public void setBufferMemorySize(Integer bufferMemorySize) {
          this.bufferMemorySize = bufferMemorySize;
      }
  
      public String getCompressionCodec() {
          return compressionCodec;
      }
  
      public void setCompressionCodec(String compressionCodec) {
          this.compressionCodec = compressionCodec;
      }
  
      public Integer getConnectionMaxIdleMs() {
          return connectionMaxIdleMs;
      }
  
      public void setConnectionMaxIdleMs(Integer connectionMaxIdleMs) {
          this.connectionMaxIdleMs = connectionMaxIdleMs;
      }
  
      public Integer getDeliveryTimeoutMs() {
          return deliveryTimeoutMs;
      }
  
      public void setDeliveryTimeoutMs(Integer deliveryTimeoutMs) {
          this.deliveryTimeoutMs = deliveryTimeoutMs;
      }
  
      public Boolean getEnableIdempotence() {
          return enableIdempotence;
      }
  
      public void setEnableIdempotence(Boolean enableIdempotence) {
          this.enableIdempotence = enableIdempotence;
      }
  
      public KafkaHeaderSerializer getHeaderSerializer() {
          return headerSerializer;
      }
  
      public void setHeaderSerializer(KafkaHeaderSerializer headerSerializer) {
          this.headerSerializer = headerSerializer;
      }
  
      public String getKey() {
          return key;
      }
  
      public void setKey(String key) {
          this.key = key;
      }
  
      public String getKeySerializer() {
          return keySerializer;
      }
  
      public void setKeySerializer(String keySerializer) {
          this.keySerializer = keySerializer;
      }
  
      public Boolean getLazyStartProducer() {
          return lazyStartProducer;
      }
  
      public void setLazyStartProducer(Boolean lazyStartProducer) {
          this.lazyStartProducer = lazyStartProducer;
      }
  
      public Integer getLingerMs() {
          return lingerMs;
      }
  
      public void setLingerMs(Integer lingerMs) {
          this.lingerMs = lingerMs;
      }
  
      public Integer getMaxBlockMs() {
          return maxBlockMs;
      }
  
      public void setMaxBlockMs(Integer maxBlockMs) {
          this.maxBlockMs = maxBlockMs;
      }
  
      public Integer getMaxInFlightRequest() {
          return maxInFlightRequest;
      }
  
      public void setMaxInFlightRequest(Integer maxInFlightRequest) {
          this.maxInFlightRequest = maxInFlightRequest;
      }
  
      public Integer getMaxRequestSize() {
          return maxRequestSize;
      }
  
      public void setMaxRequestSize(Integer maxRequestSize) {
          this.maxRequestSize = maxRequestSize;
      }
  
      public Integer getMetadataMaxAgeMs() {
          return metadataMaxAgeMs;
      }
  
      public void setMetadataMaxAgeMs(Integer metadataMaxAgeMs) {
          this.metadataMaxAgeMs = metadataMaxAgeMs;
      }
  
      public String getMetricReporters() {
          return metricReporters;
      }
  
      public void setMetricReporters(String metricReporters) {
          this.metricReporters = metricReporters;
      }
  
      public Integer getMetricsSampleWindowMs() {
          return metricsSampleWindowMs;
      }
  
      public void setMetricsSampleWindowMs(Integer metricsSampleWindowMs) {
          this.metricsSampleWindowMs = metricsSampleWindowMs;
      }
  
      public Integer getNoOfMetricsSample() {
          return noOfMetricsSample;
      }
  
      public void setNoOfMetricsSample(Integer noOfMetricsSample) {
          this.noOfMetricsSample = noOfMetricsSample;
      }
  
      public String getPartitioner() {
          return partitioner;
      }
  
      public void setPartitioner(String partitioner) {
          this.partitioner = partitioner;
      }
  
      public Boolean getPartitionerIgnoreKeys() {
          return partitionerIgnoreKeys;
      }
  
      public void setPartitionerIgnoreKeys(Boolean partitionerIgnoreKeys) {
          this.partitionerIgnoreKeys = partitionerIgnoreKeys;
      }
  
      public Integer getPartitionKey() {
          return partitionKey;
      }
  
      public void setPartitionKey(Integer partitionKey) {
          this.partitionKey = partitionKey;
      }
  
      public Integer getProducerBatchSize() {
          return producerBatchSize;
      }
  
      public void setProducerBatchSize(Integer producerBatchSize) {
          this.producerBatchSize = producerBatchSize;
      }
  
      public Integer getQueueBufferingMaxMessages() {
          return queueBufferingMaxMessages;
      }
  
      public void setQueueBufferingMaxMessages(Integer queueBufferingMaxMessages) {
          this.queueBufferingMaxMessages = queueBufferingMaxMessages;
      }
  
      public Integer getReceiveBufferBytes() {
          return receiveBufferBytes;
      }
  
      public void setReceiveBufferBytes(Integer receiveBufferBytes) {
          this.receiveBufferBytes = receiveBufferBytes;
      }
  
      public Integer getReconnectBackoffMs() {
          return reconnectBackoffMs;
      }
  
      public void setReconnectBackoffMs(Integer reconnectBackoffMs) {
          this.reconnectBackoffMs = reconnectBackoffMs;
      }
  
      public String getRequestRequiredAcks() {
          return requestRequiredAcks;
      }
  
      public void setRequestRequiredAcks(String requestRequiredAcks) {
          this.requestRequiredAcks = requestRequiredAcks;
      }
  
      public Integer getRequestTimeoutMs() {
          return requestTimeoutMs;
      }
  
      public void setRequestTimeoutMs(Integer requestTimeoutMs) {
          this.requestTimeoutMs = requestTimeoutMs;
      }
  
      public Integer getRetries() {
          return retries;
      }
  
      public void setRetries(Integer retries) {
          this.retries = retries;
      }
  
      public Integer getSendBufferBytes() {
          return sendBufferBytes;
      }
  
      public void setSendBufferBytes(Integer sendBufferBytes) {
          this.sendBufferBytes = sendBufferBytes;
      }
  
      public Boolean getTransacted() {
          return transacted;
      }
  
      public void setTransacted(Boolean transacted) {
          this.transacted = transacted;
      }
  
      public String getTransactionalId() {
          return transactionalId;
      }
  
      public void setTransactionalId(String transactionalId) {
          this.transactionalId = transactionalId;
      }
  
      public Boolean getUseIterator() {
          return useIterator;
      }
  
      public void setUseIterator(Boolean useIterator) {
          this.useIterator = useIterator;
      }
  
      public String getValueSerializer() {
          return valueSerializer;
      }
  
      public void setValueSerializer(String valueSerializer) {
          this.valueSerializer = valueSerializer;
      }
  
      public ExecutorService getWorkerPool() {
          return workerPool;
      }
  
      public void setWorkerPool(ExecutorService workerPool) {
          this.workerPool = workerPool;
      }
  
      public Integer getWorkerPoolCoreSize() {
          return workerPoolCoreSize;
      }
  
      public void setWorkerPoolCoreSize(Integer workerPoolCoreSize) {
          this.workerPoolCoreSize = workerPoolCoreSize;
      }
  
      public Integer getWorkerPoolMaxSize() {
          return workerPoolMaxSize;
      }
  
      public void setWorkerPoolMaxSize(Integer workerPoolMaxSize) {
          this.workerPoolMaxSize = workerPoolMaxSize;
      }
  
      public Boolean getRecordMetadata() {
          return recordMetadata;
      }
  
      public void setRecordMetadata(Boolean recordMetadata) {
          this.recordMetadata = recordMetadata;
      }
  
      public Boolean getAutowiredEnabled() {
          return autowiredEnabled;
      }
  
      public void setAutowiredEnabled(Boolean autowiredEnabled) {
          this.autowiredEnabled = autowiredEnabled;
      }
  
      public KafkaClientFactory getKafkaClientFactory() {
          return kafkaClientFactory;
      }
  
      public void setKafkaClientFactory(KafkaClientFactory kafkaClientFactory) {
          this.kafkaClientFactory = kafkaClientFactory;
      }
  
      public Boolean getSynchronous() {
          return synchronous;
      }
  
      public void setSynchronous(Boolean synchronous) {
          this.synchronous = synchronous;
      }
  
      public Boolean getHealthCheckConsumerEnabled() {
          return healthCheckConsumerEnabled;
      }
  
      public void setHealthCheckConsumerEnabled(Boolean healthCheckConsumerEnabled) {
          this.healthCheckConsumerEnabled = healthCheckConsumerEnabled;
      }
  
      public Boolean getHealthCheckProducerEnabled() {
          return healthCheckProducerEnabled;
      }
  
      public void setHealthCheckProducerEnabled(Boolean healthCheckProducerEnabled) {
          this.healthCheckProducerEnabled = healthCheckProducerEnabled;
      }
  
      public String getInterceptorClasses() {
          return interceptorClasses;
      }
  
      public void setInterceptorClasses(String interceptorClasses) {
          this.interceptorClasses = interceptorClasses;
      }
  
      public String getSchemaRegistryURL() {
          return schemaRegistryURL;
      }
  
      public void setSchemaRegistryURL(String schemaRegistryURL) {
          this.schemaRegistryURL = schemaRegistryURL;
      }
  
      public Integer getKerberosBeforeReloginMinTime() {
          return kerberosBeforeReloginMinTime;
      }
  
      public void setKerberosBeforeReloginMinTime(
              Integer kerberosBeforeReloginMinTime) {
          this.kerberosBeforeReloginMinTime = kerberosBeforeReloginMinTime;
      }
  
      public String getKerberosConfigLocation() {
          return kerberosConfigLocation;
      }
  
      public void setKerberosConfigLocation(String kerberosConfigLocation) {
          this.kerberosConfigLocation = kerberosConfigLocation;
      }
  
      public String getKerberosInitCmd() {
          return kerberosInitCmd;
      }
  
      public void setKerberosInitCmd(String kerberosInitCmd) {
          this.kerberosInitCmd = kerberosInitCmd;
      }
  
      public String getKerberosPrincipalToLocalRules() {
          return kerberosPrincipalToLocalRules;
      }
  
      public void setKerberosPrincipalToLocalRules(
              String kerberosPrincipalToLocalRules) {
          this.kerberosPrincipalToLocalRules = kerberosPrincipalToLocalRules;
      }
  
      public Double getKerberosRenewJitter() {
          return kerberosRenewJitter;
      }
  
      public void setKerberosRenewJitter(Double kerberosRenewJitter) {
          this.kerberosRenewJitter = kerberosRenewJitter;
      }
  
      public Double getKerberosRenewWindowFactor() {
          return kerberosRenewWindowFactor;
      }
  
      public void setKerberosRenewWindowFactor(Double kerberosRenewWindowFactor) {
          this.kerberosRenewWindowFactor = kerberosRenewWindowFactor;
      }
  
      public String getSaslJaasConfig() {
          return saslJaasConfig;
      }
  
      public void setSaslJaasConfig(String saslJaasConfig) {
          this.saslJaasConfig = saslJaasConfig;
      }
  
      public String getSaslKerberosServiceName() {
          return saslKerberosServiceName;
      }
  
      public void setSaslKerberosServiceName(String saslKerberosServiceName) {
          this.saslKerberosServiceName = saslKerberosServiceName;
      }
  
      public String getSaslMechanism() {
          return saslMechanism;
      }
  
      public void setSaslMechanism(String saslMechanism) {
          this.saslMechanism = saslMechanism;
      }
  
      public String getSecurityProtocol() {
          return securityProtocol;
      }
  
      public void setSecurityProtocol(String securityProtocol) {
          this.securityProtocol = securityProtocol;
      }
  
      public String getSslCipherSuites() {
          return sslCipherSuites;
      }
  
      public void setSslCipherSuites(String sslCipherSuites) {
          this.sslCipherSuites = sslCipherSuites;
      }
  
      public SSLContextParameters getSslContextParameters() {
          return sslContextParameters;
      }
  
      public void setSslContextParameters(
              SSLContextParameters sslContextParameters) {
          this.sslContextParameters = sslContextParameters;
      }
  
      public String getSslEnabledProtocols() {
          return sslEnabledProtocols;
      }
  
      public void setSslEnabledProtocols(String sslEnabledProtocols) {
          this.sslEnabledProtocols = sslEnabledProtocols;
      }
  
      public String getSslEndpointAlgorithm() {
          return sslEndpointAlgorithm;
      }
  
      public void setSslEndpointAlgorithm(String sslEndpointAlgorithm) {
          this.sslEndpointAlgorithm = sslEndpointAlgorithm;
      }
  
      public String getSslKeymanagerAlgorithm() {
          return sslKeymanagerAlgorithm;
      }
  
      public void setSslKeymanagerAlgorithm(String sslKeymanagerAlgorithm) {
          this.sslKeymanagerAlgorithm = sslKeymanagerAlgorithm;
      }
  
      public String getSslKeyPassword() {
          return sslKeyPassword;
      }
  
      public void setSslKeyPassword(String sslKeyPassword) {
          this.sslKeyPassword = sslKeyPassword;
      }
  
      public String getSslKeystoreLocation() {
          return sslKeystoreLocation;
      }
  
      public void setSslKeystoreLocation(String sslKeystoreLocation) {
          this.sslKeystoreLocation = sslKeystoreLocation;
      }
  
      public String getSslKeystorePassword() {
          return sslKeystorePassword;
      }
  
      public void setSslKeystorePassword(String sslKeystorePassword) {
          this.sslKeystorePassword = sslKeystorePassword;
      }
  
      public String getSslKeystoreType() {
          return sslKeystoreType;
      }
  
      public void setSslKeystoreType(String sslKeystoreType) {
          this.sslKeystoreType = sslKeystoreType;
      }
  
      public String getSslProtocol() {
          return sslProtocol;
      }
  
      public void setSslProtocol(String sslProtocol) {
          this.sslProtocol = sslProtocol;
      }
  
      public String getSslProvider() {
          return sslProvider;
      }
  
      public void setSslProvider(String sslProvider) {
          this.sslProvider = sslProvider;
      }
  
      public String getSslTrustmanagerAlgorithm() {
          return sslTrustmanagerAlgorithm;
      }
  
      public void setSslTrustmanagerAlgorithm(String sslTrustmanagerAlgorithm) {
          this.sslTrustmanagerAlgorithm = sslTrustmanagerAlgorithm;
      }
  
      public String getSslTruststoreLocation() {
          return sslTruststoreLocation;
      }
  
      public void setSslTruststoreLocation(String sslTruststoreLocation) {
          this.sslTruststoreLocation = sslTruststoreLocation;
      }
  
      public String getSslTruststorePassword() {
          return sslTruststorePassword;
      }
  
      public void setSslTruststorePassword(String sslTruststorePassword) {
          this.sslTruststorePassword = sslTruststorePassword;
      }
  
      public String getSslTruststoreType() {
          return sslTruststoreType;
      }
  
      public void setSslTruststoreType(String sslTruststoreType) {
          this.sslTruststoreType = sslTruststoreType;
      }
  
      public Boolean getUseGlobalSslContextParameters() {
          return useGlobalSslContextParameters;
      }
  
      public void setUseGlobalSslContextParameters(
              Boolean useGlobalSslContextParameters) {
          this.useGlobalSslContextParameters = useGlobalSslContextParameters;
      }
  }