java.lang.Object
- com.exoscale.sdk.model.JsonSchemaKafka

@Generated(value="org.openapitools.codegen.languages.JavaClientCodegen",
           comments="Generator version: 7.4.0")
public class JsonSchemaKafka
extends Object

JsonSchemaKafka

Nested Class Summary

Nested Classes
Modifier and Type	Class	Description
`static class`	`JsonSchemaKafka.CompressionTypeEnum`	Specify the final compression type for a given topic.
`static class`	`JsonSchemaKafka.LogMessageTimestampTypeEnum`	Define whether the timestamp in the message is message create time or log append time.

Field Summary

Fields
Modifier and Type	Field	Description
`static String`	`JSON_PROPERTY_AUTO_CREATE_TOPICS_ENABLE`
`static String`	`JSON_PROPERTY_COMPRESSION_TYPE`
`static String`	`JSON_PROPERTY_CONNECTIONS_MAX_IDLE_MS`
`static String`	`JSON_PROPERTY_DEFAULT_REPLICATION_FACTOR`
`static String`	`JSON_PROPERTY_GROUP_INITIAL_REBALANCE_DELAY_MS`
`static String`	`JSON_PROPERTY_GROUP_MAX_SESSION_TIMEOUT_MS`
`static String`	`JSON_PROPERTY_GROUP_MIN_SESSION_TIMEOUT_MS`
`static String`	`JSON_PROPERTY_LOG_CLEANUP_AND_COMPACTION`
`static String`	`JSON_PROPERTY_LOG_FLUSH_INTERVAL_MESSAGES`
`static String`	`JSON_PROPERTY_LOG_FLUSH_INTERVAL_MS`
`static String`	`JSON_PROPERTY_LOG_INDEX_INTERVAL_BYTES`
`static String`	`JSON_PROPERTY_LOG_INDEX_SIZE_MAX_BYTES`
`static String`	`JSON_PROPERTY_LOG_LOCAL_RETENTION_BYTES`
`static String`	`JSON_PROPERTY_LOG_LOCAL_RETENTION_MS`
`static String`	`JSON_PROPERTY_LOG_MESSAGE_DOWNCONVERSION_ENABLE`
`static String`	`JSON_PROPERTY_LOG_MESSAGE_TIMESTAMP_DIFFERENCE_MAX_MS`
`static String`	`JSON_PROPERTY_LOG_MESSAGE_TIMESTAMP_TYPE`
`static String`	`JSON_PROPERTY_LOG_PREALLOCATE`
`static String`	`JSON_PROPERTY_LOG_RETENTION_BYTES`
`static String`	`JSON_PROPERTY_LOG_RETENTION_HOURS`
`static String`	`JSON_PROPERTY_LOG_RETENTION_MS`
`static String`	`JSON_PROPERTY_LOG_ROLL_JITTER_MS`
`static String`	`JSON_PROPERTY_LOG_ROLL_MS`
`static String`	`JSON_PROPERTY_LOG_SEGMENT_BYTES`
`static String`	`JSON_PROPERTY_LOG_SEGMENT_DELETE_DELAY_MS`
`static String`	`JSON_PROPERTY_MAX_CONNECTIONS_PER_IP`
`static String`	`JSON_PROPERTY_MAX_INCREMENTAL_FETCH_SESSION_CACHE_SLOTS`
`static String`	`JSON_PROPERTY_MESSAGE_MAX_BYTES`
`static String`	`JSON_PROPERTY_MIN_INSYNC_REPLICAS`
`static String`	`JSON_PROPERTY_NUM_PARTITIONS`
`static String`	`JSON_PROPERTY_OFFSETS_RETENTION_MINUTES`
`static String`	`JSON_PROPERTY_PRODUCER_PURGATORY_PURGE_INTERVAL_REQUESTS`
`static String`	`JSON_PROPERTY_REPLICA_FETCH_MAX_BYTES`
`static String`	`JSON_PROPERTY_REPLICA_FETCH_RESPONSE_MAX_BYTES`
`static String`	`JSON_PROPERTY_SASL_OAUTHBEARER_EXPECTED_AUDIENCE`
`static String`	`JSON_PROPERTY_SASL_OAUTHBEARER_EXPECTED_ISSUER`
`static String`	`JSON_PROPERTY_SASL_OAUTHBEARER_JWKS_ENDPOINT_URL`
`static String`	`JSON_PROPERTY_SASL_OAUTHBEARER_SUB_CLAIM_NAME`
`static String`	`JSON_PROPERTY_SOCKET_REQUEST_MAX_BYTES`
`static String`	`JSON_PROPERTY_TRANSACTION_PARTITION_VERIFICATION_ENABLE`
`static String`	`JSON_PROPERTY_TRANSACTION_REMOVE_EXPIRED_TRANSACTION_CLEANUP_INTERVAL_MS`
`static String`	`JSON_PROPERTY_TRANSACTION_STATE_LOG_SEGMENT_BYTES`

Constructor Summary

Constructors
Constructor Description

JsonSchemaKafka()

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`JsonSchemaKafka`	`autoCreateTopicsEnable(Boolean autoCreateTopicsEnable)`
`JsonSchemaKafka`	`compressionType(JsonSchemaKafka.CompressionTypeEnum compressionType)`
`JsonSchemaKafka`	`connectionsMaxIdleMs(Integer connectionsMaxIdleMs)`
`JsonSchemaKafka`	`defaultReplicationFactor(Integer defaultReplicationFactor)`
`boolean`	`equals(Object o)`	Return true if this json-schema-kafka object is equal to o.
`Boolean`	`getAutoCreateTopicsEnable()`	Enable auto creation of topics
`JsonSchemaKafka.CompressionTypeEnum`	`getCompressionType()`	Specify the final compression type for a given topic.
`Integer`	`getConnectionsMaxIdleMs()`	Idle connections timeout: the server socket processor threads close the connections that idle for longer than this.
`Integer`	`getDefaultReplicationFactor()`	Replication factor for autocreated topics minimum: 1 maximum: 10
`Integer`	`getGroupInitialRebalanceDelayMs()`	The amount of time, in milliseconds, the group coordinator will wait for more consumers to join a new group before performing the first rebalance.
`Integer`	`getGroupMaxSessionTimeoutMs()`	The maximum allowed session timeout for registered consumers.
`Integer`	`getGroupMinSessionTimeoutMs()`	The minimum allowed session timeout for registered consumers.
`ConfigureLogCleanerForTopicCompaction`	`getLogCleanupAndCompaction()`	Get logCleanupAndCompaction
`Integer`	`getLogFlushIntervalMessages()`	The number of messages accumulated on a log partition before messages are flushed to disk minimum: 1 maximum: 9223372036854775807
`Integer`	`getLogFlushIntervalMs()`	The maximum time in ms that a message in any topic is kept in memory before flushed to disk.
`Integer`	`getLogIndexIntervalBytes()`	The interval with which Kafka adds an entry to the offset index minimum: 0 maximum: 104857600
`Integer`	`getLogIndexSizeMaxBytes()`	The maximum size in bytes of the offset index minimum: 1048576 maximum: 104857600
`Integer`	`getLogLocalRetentionBytes()`	The maximum size of local log segments that can grow for a partition before it gets eligible for deletion.
`Integer`	`getLogLocalRetentionMs()`	The number of milliseconds to keep the local log segments before it gets eligible for deletion.
`Boolean`	`getLogMessageDownconversionEnable()`	This configuration controls whether down-conversion of message formats is enabled to satisfy consume requests.
`Integer`	`getLogMessageTimestampDifferenceMaxMs()`	The maximum difference allowed between the timestamp when a broker receives a message and the timestamp specified in the message minimum: 0 maximum: 9223372036854775807
`JsonSchemaKafka.LogMessageTimestampTypeEnum`	`getLogMessageTimestampType()`	Define whether the timestamp in the message is message create time or log append time.
`Boolean`	`getLogPreallocate()`	Should pre allocate file when create new segment?
`Integer`	`getLogRetentionBytes()`	The maximum size of the log before deleting messages minimum: -1 maximum: 9223372036854775807
`Integer`	`getLogRetentionHours()`	The number of hours to keep a log file before deleting it minimum: -1 maximum: 2147483647
`Integer`	`getLogRetentionMs()`	The number of milliseconds to keep a log file before deleting it (in milliseconds), If not set, the value in log.retention.minutes is used.
`Integer`	`getLogRollJitterMs()`	The maximum jitter to subtract from logRollTimeMillis (in milliseconds).
`Integer`	`getLogRollMs()`	The maximum time before a new log segment is rolled out (in milliseconds).
`Integer`	`getLogSegmentBytes()`	The maximum size of a single log file minimum: 10485760 maximum: 1073741824
`Integer`	`getLogSegmentDeleteDelayMs()`	The amount of time to wait before deleting a file from the filesystem minimum: 0 maximum: 3600000
`Integer`	`getMaxConnectionsPerIp()`	The maximum number of connections allowed from each ip address (defaults to 2147483647).
`Integer`	`getMaxIncrementalFetchSessionCacheSlots()`	The maximum number of incremental fetch sessions that the broker will maintain.
`Integer`	`getMessageMaxBytes()`	The maximum size of message that the server can receive.
`Integer`	`getMinInsyncReplicas()`	When a producer sets acks to 'all' (or '-1'), min.insync.replicas specifies the minimum number of replicas that must acknowledge a write for the write to be considered successful.
`Integer`	`getNumPartitions()`	Number of partitions for autocreated topics minimum: 1 maximum: 1000
`Integer`	`getOffsetsRetentionMinutes()`	Log retention window in minutes for offsets topic minimum: 1 maximum: 2147483647
`Integer`	`getProducerPurgatoryPurgeIntervalRequests()`	The purge interval (in number of requests) of the producer request purgatory(defaults to 1000).
`Integer`	`getReplicaFetchMaxBytes()`	The number of bytes of messages to attempt to fetch for each partition (defaults to 1048576).
`Integer`	`getReplicaFetchResponseMaxBytes()`	Maximum bytes expected for the entire fetch response (defaults to 10485760).
`String`	`getSaslOauthbearerExpectedAudience()`	The (optional) comma-delimited setting for the broker to use to verify that the JWT was issued for one of the expected audiences.
`String`	`getSaslOauthbearerExpectedIssuer()`	Optional setting for the broker to use to verify that the JWT was created by the expected issuer.
`String`	`getSaslOauthbearerJwksEndpointUrl()`	OIDC JWKS endpoint URL.
`String`	`getSaslOauthbearerSubClaimName()`	Name of the scope from which to extract the subject claim from the JWT.
`Integer`	`getSocketRequestMaxBytes()`	The maximum number of bytes in a socket request (defaults to 104857600).
`Boolean`	`getTransactionPartitionVerificationEnable()`	Enable verification that checks that the partition has been added to the transaction before writing transactional records to the partition
`Integer`	`getTransactionRemoveExpiredTransactionCleanupIntervalMs()`	The interval at which to remove transactions that have expired due to transactional.id.expiration.ms passing (defaults to 3600000 (1 hour)).
`Integer`	`getTransactionStateLogSegmentBytes()`	The transaction topic segment bytes should be kept relatively small in order to facilitate faster log compaction and cache loads (defaults to 104857600 (100 mebibytes)).
`JsonSchemaKafka`	`groupInitialRebalanceDelayMs(Integer groupInitialRebalanceDelayMs)`
`JsonSchemaKafka`	`groupMaxSessionTimeoutMs(Integer groupMaxSessionTimeoutMs)`
`JsonSchemaKafka`	`groupMinSessionTimeoutMs(Integer groupMinSessionTimeoutMs)`
`int`	`hashCode()`
`JsonSchemaKafka`	`logCleanupAndCompaction(ConfigureLogCleanerForTopicCompaction logCleanupAndCompaction)`
`JsonSchemaKafka`	`logFlushIntervalMessages(Integer logFlushIntervalMessages)`
`JsonSchemaKafka`	`logFlushIntervalMs(Integer logFlushIntervalMs)`
`JsonSchemaKafka`	`logIndexIntervalBytes(Integer logIndexIntervalBytes)`
`JsonSchemaKafka`	`logIndexSizeMaxBytes(Integer logIndexSizeMaxBytes)`
`JsonSchemaKafka`	`logLocalRetentionBytes(Integer logLocalRetentionBytes)`
`JsonSchemaKafka`	`logLocalRetentionMs(Integer logLocalRetentionMs)`
`JsonSchemaKafka`	`logMessageDownconversionEnable(Boolean logMessageDownconversionEnable)`
`JsonSchemaKafka`	`logMessageTimestampDifferenceMaxMs(Integer logMessageTimestampDifferenceMaxMs)`
`JsonSchemaKafka`	`logMessageTimestampType(JsonSchemaKafka.LogMessageTimestampTypeEnum logMessageTimestampType)`
`JsonSchemaKafka`	`logPreallocate(Boolean logPreallocate)`
`JsonSchemaKafka`	`logRetentionBytes(Integer logRetentionBytes)`
`JsonSchemaKafka`	`logRetentionHours(Integer logRetentionHours)`
`JsonSchemaKafka`	`logRetentionMs(Integer logRetentionMs)`
`JsonSchemaKafka`	`logRollJitterMs(Integer logRollJitterMs)`
`JsonSchemaKafka`	`logRollMs(Integer logRollMs)`
`JsonSchemaKafka`	`logSegmentBytes(Integer logSegmentBytes)`
`JsonSchemaKafka`	`logSegmentDeleteDelayMs(Integer logSegmentDeleteDelayMs)`
`JsonSchemaKafka`	`maxConnectionsPerIp(Integer maxConnectionsPerIp)`
`JsonSchemaKafka`	`maxIncrementalFetchSessionCacheSlots(Integer maxIncrementalFetchSessionCacheSlots)`
`JsonSchemaKafka`	`messageMaxBytes(Integer messageMaxBytes)`
`JsonSchemaKafka`	`minInsyncReplicas(Integer minInsyncReplicas)`
`JsonSchemaKafka`	`numPartitions(Integer numPartitions)`
`JsonSchemaKafka`	`offsetsRetentionMinutes(Integer offsetsRetentionMinutes)`
`JsonSchemaKafka`	`producerPurgatoryPurgeIntervalRequests(Integer producerPurgatoryPurgeIntervalRequests)`
`JsonSchemaKafka`	`replicaFetchMaxBytes(Integer replicaFetchMaxBytes)`
`JsonSchemaKafka`	`replicaFetchResponseMaxBytes(Integer replicaFetchResponseMaxBytes)`
`JsonSchemaKafka`	`saslOauthbearerExpectedAudience(String saslOauthbearerExpectedAudience)`
`JsonSchemaKafka`	`saslOauthbearerExpectedIssuer(String saslOauthbearerExpectedIssuer)`
`JsonSchemaKafka`	`saslOauthbearerJwksEndpointUrl(String saslOauthbearerJwksEndpointUrl)`
`JsonSchemaKafka`	`saslOauthbearerSubClaimName(String saslOauthbearerSubClaimName)`
`void`	`setAutoCreateTopicsEnable(Boolean autoCreateTopicsEnable)`
`void`	`setCompressionType(JsonSchemaKafka.CompressionTypeEnum compressionType)`
`void`	`setConnectionsMaxIdleMs(Integer connectionsMaxIdleMs)`
`void`	`setDefaultReplicationFactor(Integer defaultReplicationFactor)`
`void`	`setGroupInitialRebalanceDelayMs(Integer groupInitialRebalanceDelayMs)`
`void`	`setGroupMaxSessionTimeoutMs(Integer groupMaxSessionTimeoutMs)`
`void`	`setGroupMinSessionTimeoutMs(Integer groupMinSessionTimeoutMs)`
`void`	`setLogCleanupAndCompaction(ConfigureLogCleanerForTopicCompaction logCleanupAndCompaction)`
`void`	`setLogFlushIntervalMessages(Integer logFlushIntervalMessages)`
`void`	`setLogFlushIntervalMs(Integer logFlushIntervalMs)`
`void`	`setLogIndexIntervalBytes(Integer logIndexIntervalBytes)`
`void`	`setLogIndexSizeMaxBytes(Integer logIndexSizeMaxBytes)`
`void`	`setLogLocalRetentionBytes(Integer logLocalRetentionBytes)`
`void`	`setLogLocalRetentionMs(Integer logLocalRetentionMs)`
`void`	`setLogMessageDownconversionEnable(Boolean logMessageDownconversionEnable)`
`void`	`setLogMessageTimestampDifferenceMaxMs(Integer logMessageTimestampDifferenceMaxMs)`
`void`	`setLogMessageTimestampType(JsonSchemaKafka.LogMessageTimestampTypeEnum logMessageTimestampType)`
`void`	`setLogPreallocate(Boolean logPreallocate)`
`void`	`setLogRetentionBytes(Integer logRetentionBytes)`
`void`	`setLogRetentionHours(Integer logRetentionHours)`
`void`	`setLogRetentionMs(Integer logRetentionMs)`
`void`	`setLogRollJitterMs(Integer logRollJitterMs)`
`void`	`setLogRollMs(Integer logRollMs)`
`void`	`setLogSegmentBytes(Integer logSegmentBytes)`
`void`	`setLogSegmentDeleteDelayMs(Integer logSegmentDeleteDelayMs)`
`void`	`setMaxConnectionsPerIp(Integer maxConnectionsPerIp)`
`void`	`setMaxIncrementalFetchSessionCacheSlots(Integer maxIncrementalFetchSessionCacheSlots)`
`void`	`setMessageMaxBytes(Integer messageMaxBytes)`
`void`	`setMinInsyncReplicas(Integer minInsyncReplicas)`
`void`	`setNumPartitions(Integer numPartitions)`
`void`	`setOffsetsRetentionMinutes(Integer offsetsRetentionMinutes)`
`void`	`setProducerPurgatoryPurgeIntervalRequests(Integer producerPurgatoryPurgeIntervalRequests)`
`void`	`setReplicaFetchMaxBytes(Integer replicaFetchMaxBytes)`
`void`	`setReplicaFetchResponseMaxBytes(Integer replicaFetchResponseMaxBytes)`
`void`	`setSaslOauthbearerExpectedAudience(String saslOauthbearerExpectedAudience)`
`void`	`setSaslOauthbearerExpectedIssuer(String saslOauthbearerExpectedIssuer)`
`void`	`setSaslOauthbearerJwksEndpointUrl(String saslOauthbearerJwksEndpointUrl)`
`void`	`setSaslOauthbearerSubClaimName(String saslOauthbearerSubClaimName)`
`void`	`setSocketRequestMaxBytes(Integer socketRequestMaxBytes)`
`void`	`setTransactionPartitionVerificationEnable(Boolean transactionPartitionVerificationEnable)`
`void`	`setTransactionRemoveExpiredTransactionCleanupIntervalMs(Integer transactionRemoveExpiredTransactionCleanupIntervalMs)`
`void`	`setTransactionStateLogSegmentBytes(Integer transactionStateLogSegmentBytes)`
`JsonSchemaKafka`	`socketRequestMaxBytes(Integer socketRequestMaxBytes)`
`String`	`toString()`
`String`	`toUrlQueryString()`	Convert the instance into URL query string.
`String`	`toUrlQueryString(String prefix)`	Convert the instance into URL query string.
`JsonSchemaKafka`	`transactionPartitionVerificationEnable(Boolean transactionPartitionVerificationEnable)`
`JsonSchemaKafka`	`transactionRemoveExpiredTransactionCleanupIntervalMs(Integer transactionRemoveExpiredTransactionCleanupIntervalMs)`
`JsonSchemaKafka`	`transactionStateLogSegmentBytes(Integer transactionStateLogSegmentBytes)`

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

- Field Detail
  - JSON_PROPERTY_SASL_OAUTHBEARER_EXPECTED_AUDIENCE
```
public static final String JSON_PROPERTY_SASL_OAUTHBEARER_EXPECTED_AUDIENCE
```
    See Also:
    
    Constant Field Values
  - JSON_PROPERTY_GROUP_MAX_SESSION_TIMEOUT_MS
```
public static final String JSON_PROPERTY_GROUP_MAX_SESSION_TIMEOUT_MS
```
    See Also:
    
    Constant Field Values
  - JSON_PROPERTY_LOG_FLUSH_INTERVAL_MESSAGES
```
public static final String JSON_PROPERTY_LOG_FLUSH_INTERVAL_MESSAGES
```
    See Also:
    
    Constant Field Values
  - JSON_PROPERTY_SASL_OAUTHBEARER_JWKS_ENDPOINT_URL
```
public static final String JSON_PROPERTY_SASL_OAUTHBEARER_JWKS_ENDPOINT_URL
```
    See Also:
    
    Constant Field Values
  - JSON_PROPERTY_MAX_CONNECTIONS_PER_IP
```
public static final String JSON_PROPERTY_MAX_CONNECTIONS_PER_IP
```
    See Also:
    
    Constant Field Values
  - JSON_PROPERTY_SASL_OAUTHBEARER_EXPECTED_ISSUER
```
public static final String JSON_PROPERTY_SASL_OAUTHBEARER_EXPECTED_ISSUER
```
    See Also:
    
    Constant Field Values
  - JSON_PROPERTY_LOG_INDEX_SIZE_MAX_BYTES
```
public static final String JSON_PROPERTY_LOG_INDEX_SIZE_MAX_BYTES
```
    See Also:
    
    Constant Field Values
  - JSON_PROPERTY_AUTO_CREATE_TOPICS_ENABLE
```
public static final String JSON_PROPERTY_AUTO_CREATE_TOPICS_ENABLE
```
    See Also:
    
    Constant Field Values
  - JSON_PROPERTY_LOG_INDEX_INTERVAL_BYTES
```
public static final String JSON_PROPERTY_LOG_INDEX_INTERVAL_BYTES
```
    See Also:
    
    Constant Field Values
  - JSON_PROPERTY_REPLICA_FETCH_MAX_BYTES
```
public static final String JSON_PROPERTY_REPLICA_FETCH_MAX_BYTES
```
    See Also:
    
    Constant Field Values
  - JSON_PROPERTY_NUM_PARTITIONS
```
public static final String JSON_PROPERTY_NUM_PARTITIONS
```
    See Also:
    
    Constant Field Values
  - JSON_PROPERTY_TRANSACTION_STATE_LOG_SEGMENT_BYTES
```
public static final String JSON_PROPERTY_TRANSACTION_STATE_LOG_SEGMENT_BYTES
```
    See Also:
    
    Constant Field Values
  - JSON_PROPERTY_REPLICA_FETCH_RESPONSE_MAX_BYTES
```
public static final String JSON_PROPERTY_REPLICA_FETCH_RESPONSE_MAX_BYTES
```
    See Also:
    
    Constant Field Values
  - JSON_PROPERTY_LOG_MESSAGE_TIMESTAMP_TYPE
```
public static final String JSON_PROPERTY_LOG_MESSAGE_TIMESTAMP_TYPE
```
    See Also:
    
    Constant Field Values
  - JSON_PROPERTY_CONNECTIONS_MAX_IDLE_MS
```
public static final String JSON_PROPERTY_CONNECTIONS_MAX_IDLE_MS
```
    See Also:
    
    Constant Field Values
  - JSON_PROPERTY_LOG_FLUSH_INTERVAL_MS
```
public static final String JSON_PROPERTY_LOG_FLUSH_INTERVAL_MS
```
    See Also:
    
    Constant Field Values
  - JSON_PROPERTY_LOG_PREALLOCATE
```
public static final String JSON_PROPERTY_LOG_PREALLOCATE
```
    See Also:
    
    Constant Field Values
  - JSON_PROPERTY_LOG_SEGMENT_DELETE_DELAY_MS
```
public static final String JSON_PROPERTY_LOG_SEGMENT_DELETE_DELAY_MS
```
    See Also:
    
    Constant Field Values
  - JSON_PROPERTY_MESSAGE_MAX_BYTES
```
public static final String JSON_PROPERTY_MESSAGE_MAX_BYTES
```
    See Also:
    
    Constant Field Values
  - JSON_PROPERTY_GROUP_INITIAL_REBALANCE_DELAY_MS
```
public static final String JSON_PROPERTY_GROUP_INITIAL_REBALANCE_DELAY_MS
```
    See Also:
    
    Constant Field Values
  - JSON_PROPERTY_LOG_LOCAL_RETENTION_BYTES
```
public static final String JSON_PROPERTY_LOG_LOCAL_RETENTION_BYTES
```
    See Also:
    
    Constant Field Values
  - JSON_PROPERTY_LOG_ROLL_JITTER_MS
```
public static final String JSON_PROPERTY_LOG_ROLL_JITTER_MS
```
    See Also:
    
    Constant Field Values
  - JSON_PROPERTY_TRANSACTION_REMOVE_EXPIRED_TRANSACTION_CLEANUP_INTERVAL_MS
```
public static final String JSON_PROPERTY_TRANSACTION_REMOVE_EXPIRED_TRANSACTION_CLEANUP_INTERVAL_MS
```
    See Also:
    
    Constant Field Values
  - JSON_PROPERTY_TRANSACTION_PARTITION_VERIFICATION_ENABLE
```
public static final String JSON_PROPERTY_TRANSACTION_PARTITION_VERIFICATION_ENABLE
```
    See Also:
    
    Constant Field Values
  - JSON_PROPERTY_DEFAULT_REPLICATION_FACTOR
```
public static final String JSON_PROPERTY_DEFAULT_REPLICATION_FACTOR
```
    See Also:
    
    Constant Field Values
  - JSON_PROPERTY_LOG_ROLL_MS
```
public static final String JSON_PROPERTY_LOG_ROLL_MS
```
    See Also:
    
    Constant Field Values
  - JSON_PROPERTY_PRODUCER_PURGATORY_PURGE_INTERVAL_REQUESTS
```
public static final String JSON_PROPERTY_PRODUCER_PURGATORY_PURGE_INTERVAL_REQUESTS
```
    See Also:
    
    Constant Field Values
  - JSON_PROPERTY_LOG_RETENTION_BYTES
```
public static final String JSON_PROPERTY_LOG_RETENTION_BYTES
```
    See Also:
    
    Constant Field Values
  - JSON_PROPERTY_MIN_INSYNC_REPLICAS
```
public static final String JSON_PROPERTY_MIN_INSYNC_REPLICAS
```
    See Also:
    
    Constant Field Values
  - JSON_PROPERTY_COMPRESSION_TYPE
```
public static final String JSON_PROPERTY_COMPRESSION_TYPE
```
    See Also:
    
    Constant Field Values
  - JSON_PROPERTY_LOG_MESSAGE_TIMESTAMP_DIFFERENCE_MAX_MS
```
public static final String JSON_PROPERTY_LOG_MESSAGE_TIMESTAMP_DIFFERENCE_MAX_MS
```
    See Also:
    
    Constant Field Values
  - JSON_PROPERTY_LOG_LOCAL_RETENTION_MS
```
public static final String JSON_PROPERTY_LOG_LOCAL_RETENTION_MS
```
    See Also:
    
    Constant Field Values
  - JSON_PROPERTY_LOG_MESSAGE_DOWNCONVERSION_ENABLE
```
public static final String JSON_PROPERTY_LOG_MESSAGE_DOWNCONVERSION_ENABLE
```
    See Also:
    
    Constant Field Values
  - JSON_PROPERTY_SASL_OAUTHBEARER_SUB_CLAIM_NAME
```
public static final String JSON_PROPERTY_SASL_OAUTHBEARER_SUB_CLAIM_NAME
```
    See Also:
    
    Constant Field Values
  - JSON_PROPERTY_MAX_INCREMENTAL_FETCH_SESSION_CACHE_SLOTS
```
public static final String JSON_PROPERTY_MAX_INCREMENTAL_FETCH_SESSION_CACHE_SLOTS
```
    See Also:
    
    Constant Field Values
  - JSON_PROPERTY_LOG_RETENTION_HOURS
```
public static final String JSON_PROPERTY_LOG_RETENTION_HOURS
```
    See Also:
    
    Constant Field Values
  - JSON_PROPERTY_GROUP_MIN_SESSION_TIMEOUT_MS
```
public static final String JSON_PROPERTY_GROUP_MIN_SESSION_TIMEOUT_MS
```
    See Also:
    
    Constant Field Values
  - JSON_PROPERTY_SOCKET_REQUEST_MAX_BYTES
```
public static final String JSON_PROPERTY_SOCKET_REQUEST_MAX_BYTES
```
    See Also:
    
    Constant Field Values
  - JSON_PROPERTY_LOG_SEGMENT_BYTES
```
public static final String JSON_PROPERTY_LOG_SEGMENT_BYTES
```
    See Also:
    
    Constant Field Values
  - JSON_PROPERTY_LOG_CLEANUP_AND_COMPACTION
```
public static final String JSON_PROPERTY_LOG_CLEANUP_AND_COMPACTION
```
    See Also:
    
    Constant Field Values
  - JSON_PROPERTY_OFFSETS_RETENTION_MINUTES
```
public static final String JSON_PROPERTY_OFFSETS_RETENTION_MINUTES
```
    See Also:
    
    Constant Field Values
  - JSON_PROPERTY_LOG_RETENTION_MS
```
public static final String JSON_PROPERTY_LOG_RETENTION_MS
```
    See Also:
    
    Constant Field Values
- Constructor Detail
  - JsonSchemaKafka
```
public JsonSchemaKafka()
```
- Method Detail
  - saslOauthbearerExpectedAudience
```
public JsonSchemaKafka saslOauthbearerExpectedAudience(String saslOauthbearerExpectedAudience)
```
  - getSaslOauthbearerExpectedAudience
```
@Nullable
public String getSaslOauthbearerExpectedAudience()
```
    The (optional) comma-delimited setting for the broker to use to verify that the JWT was issued for one of the expected audiences.
    
    Returns:
    
    saslOauthbearerExpectedAudience
  - setSaslOauthbearerExpectedAudience
```
public void setSaslOauthbearerExpectedAudience(String saslOauthbearerExpectedAudience)
```
  - groupMaxSessionTimeoutMs
```
public JsonSchemaKafka groupMaxSessionTimeoutMs(Integer groupMaxSessionTimeoutMs)
```
  - getGroupMaxSessionTimeoutMs
```
@Nullable
public Integer getGroupMaxSessionTimeoutMs()
```
    The maximum allowed session timeout for registered consumers. Longer timeouts give consumers more time to process messages in between heartbeats at the cost of a longer time to detect failures. minimum: 0 maximum: 1800000
    
    Returns:
    
    groupMaxSessionTimeoutMs
  - setGroupMaxSessionTimeoutMs
```
public void setGroupMaxSessionTimeoutMs(Integer groupMaxSessionTimeoutMs)
```
  - logFlushIntervalMessages
```
public JsonSchemaKafka logFlushIntervalMessages(Integer logFlushIntervalMessages)
```
  - getLogFlushIntervalMessages
```
@Nullable
public Integer getLogFlushIntervalMessages()
```
    The number of messages accumulated on a log partition before messages are flushed to disk minimum: 1 maximum: 9223372036854775807
    
    Returns:
    
    logFlushIntervalMessages
  - setLogFlushIntervalMessages
```
public void setLogFlushIntervalMessages(Integer logFlushIntervalMessages)
```
  - saslOauthbearerJwksEndpointUrl
```
public JsonSchemaKafka saslOauthbearerJwksEndpointUrl(String saslOauthbearerJwksEndpointUrl)
```
  - getSaslOauthbearerJwksEndpointUrl
```
@Nullable
public String getSaslOauthbearerJwksEndpointUrl()
```
    OIDC JWKS endpoint URL. By setting this the SASL SSL OAuth2/OIDC authentication is enabled. See also other options for SASL OAuth2/OIDC.
    
    Returns:
    
    saslOauthbearerJwksEndpointUrl
  - setSaslOauthbearerJwksEndpointUrl
```
public void setSaslOauthbearerJwksEndpointUrl(String saslOauthbearerJwksEndpointUrl)
```
  - maxConnectionsPerIp
```
public JsonSchemaKafka maxConnectionsPerIp(Integer maxConnectionsPerIp)
```
  - getMaxConnectionsPerIp
```
@Nullable
public Integer getMaxConnectionsPerIp()
```
    The maximum number of connections allowed from each ip address (defaults to 2147483647). minimum: 256 maximum: 2147483647
    
    Returns:
    
    maxConnectionsPerIp
  - setMaxConnectionsPerIp
```
public void setMaxConnectionsPerIp(Integer maxConnectionsPerIp)
```
  - saslOauthbearerExpectedIssuer
```
public JsonSchemaKafka saslOauthbearerExpectedIssuer(String saslOauthbearerExpectedIssuer)
```
  - getSaslOauthbearerExpectedIssuer
```
@Nullable
public String getSaslOauthbearerExpectedIssuer()
```
    Optional setting for the broker to use to verify that the JWT was created by the expected issuer.
    
    Returns:
    
    saslOauthbearerExpectedIssuer
  - setSaslOauthbearerExpectedIssuer
```
public void setSaslOauthbearerExpectedIssuer(String saslOauthbearerExpectedIssuer)
```
  - logIndexSizeMaxBytes
```
public JsonSchemaKafka logIndexSizeMaxBytes(Integer logIndexSizeMaxBytes)
```
  - getLogIndexSizeMaxBytes
```
@Nullable
public Integer getLogIndexSizeMaxBytes()
```
    The maximum size in bytes of the offset index minimum: 1048576 maximum: 104857600
    
    Returns:
    
    logIndexSizeMaxBytes
  - setLogIndexSizeMaxBytes
```
public void setLogIndexSizeMaxBytes(Integer logIndexSizeMaxBytes)
```
  - autoCreateTopicsEnable
```
public JsonSchemaKafka autoCreateTopicsEnable(Boolean autoCreateTopicsEnable)
```
  - getAutoCreateTopicsEnable
```
@Nullable
public Boolean getAutoCreateTopicsEnable()
```
    Enable auto creation of topics
    
    Returns:
    
    autoCreateTopicsEnable
  - setAutoCreateTopicsEnable
```
public void setAutoCreateTopicsEnable(Boolean autoCreateTopicsEnable)
```
  - logIndexIntervalBytes
```
public JsonSchemaKafka logIndexIntervalBytes(Integer logIndexIntervalBytes)
```
  - getLogIndexIntervalBytes
```
@Nullable
public Integer getLogIndexIntervalBytes()
```
    The interval with which Kafka adds an entry to the offset index minimum: 0 maximum: 104857600
    
    Returns:
    
    logIndexIntervalBytes
  - setLogIndexIntervalBytes
```
public void setLogIndexIntervalBytes(Integer logIndexIntervalBytes)
```
  - replicaFetchMaxBytes
```
public JsonSchemaKafka replicaFetchMaxBytes(Integer replicaFetchMaxBytes)
```
  - getReplicaFetchMaxBytes
```
@Nullable
public Integer getReplicaFetchMaxBytes()
```
    The number of bytes of messages to attempt to fetch for each partition (defaults to 1048576). This is not an absolute maximum, if the first record batch in the first non-empty partition of the fetch is larger than this value, the record batch will still be returned to ensure that progress can be made. minimum: 1048576 maximum: 104857600
    
    Returns:
    
    replicaFetchMaxBytes
  - setReplicaFetchMaxBytes
```
public void setReplicaFetchMaxBytes(Integer replicaFetchMaxBytes)
```
  - numPartitions
```
public JsonSchemaKafka numPartitions(Integer numPartitions)
```
  - getNumPartitions
```
@Nullable
public Integer getNumPartitions()
```
    Number of partitions for autocreated topics minimum: 1 maximum: 1000
    
    Returns:
    
    numPartitions
  - setNumPartitions
```
public void setNumPartitions(Integer numPartitions)
```
  - transactionStateLogSegmentBytes
```
public JsonSchemaKafka transactionStateLogSegmentBytes(Integer transactionStateLogSegmentBytes)
```
  - getTransactionStateLogSegmentBytes
```
@Nullable
public Integer getTransactionStateLogSegmentBytes()
```
    The transaction topic segment bytes should be kept relatively small in order to facilitate faster log compaction and cache loads (defaults to 104857600 (100 mebibytes)). minimum: 1048576 maximum: 2147483647
    
    Returns:
    
    transactionStateLogSegmentBytes
  - setTransactionStateLogSegmentBytes
```
public void setTransactionStateLogSegmentBytes(Integer transactionStateLogSegmentBytes)
```
  - replicaFetchResponseMaxBytes
```
public JsonSchemaKafka replicaFetchResponseMaxBytes(Integer replicaFetchResponseMaxBytes)
```
  - getReplicaFetchResponseMaxBytes
```
@Nullable
public Integer getReplicaFetchResponseMaxBytes()
```
    Maximum bytes expected for the entire fetch response (defaults to 10485760). Records are fetched in batches, and if the first record batch in the first non-empty partition of the fetch is larger than this value, the record batch will still be returned to ensure that progress can be made. As such, this is not an absolute maximum. minimum: 10485760 maximum: 1048576000
    
    Returns:
    
    replicaFetchResponseMaxBytes
  - setReplicaFetchResponseMaxBytes
```
public void setReplicaFetchResponseMaxBytes(Integer replicaFetchResponseMaxBytes)
```
  - logMessageTimestampType
```
public JsonSchemaKafka logMessageTimestampType(JsonSchemaKafka.LogMessageTimestampTypeEnum logMessageTimestampType)
```
  - getLogMessageTimestampType
```
@Nullable
public JsonSchemaKafka.LogMessageTimestampTypeEnum getLogMessageTimestampType()
```
    Define whether the timestamp in the message is message create time or log append time.
    
    Returns:
    
    logMessageTimestampType
  - setLogMessageTimestampType
```
public void setLogMessageTimestampType(JsonSchemaKafka.LogMessageTimestampTypeEnum logMessageTimestampType)
```
  - connectionsMaxIdleMs
```
public JsonSchemaKafka connectionsMaxIdleMs(Integer connectionsMaxIdleMs)
```
  - getConnectionsMaxIdleMs
```
@Nullable
public Integer getConnectionsMaxIdleMs()
```
    Idle connections timeout: the server socket processor threads close the connections that idle for longer than this. minimum: 1000 maximum: 3600000
    
    Returns:
    
    connectionsMaxIdleMs
  - setConnectionsMaxIdleMs
```
public void setConnectionsMaxIdleMs(Integer connectionsMaxIdleMs)
```
  - logFlushIntervalMs
```
public JsonSchemaKafka logFlushIntervalMs(Integer logFlushIntervalMs)
```
  - getLogFlushIntervalMs
```
@Nullable
public Integer getLogFlushIntervalMs()
```
    The maximum time in ms that a message in any topic is kept in memory before flushed to disk. If not set, the value in log.flush.scheduler.interval.ms is used minimum: 0 maximum: 9223372036854775807
    
    Returns:
    
    logFlushIntervalMs
  - setLogFlushIntervalMs
```
public void setLogFlushIntervalMs(Integer logFlushIntervalMs)
```
  - logPreallocate
```
public JsonSchemaKafka logPreallocate(Boolean logPreallocate)
```
  - getLogPreallocate
```
@Nullable
public Boolean getLogPreallocate()
```
    Should pre allocate file when create new segment?
    
    Returns:
    
    logPreallocate
  - setLogPreallocate
```
public void setLogPreallocate(Boolean logPreallocate)
```
  - logSegmentDeleteDelayMs
```
public JsonSchemaKafka logSegmentDeleteDelayMs(Integer logSegmentDeleteDelayMs)
```
  - getLogSegmentDeleteDelayMs
```
@Nullable
public Integer getLogSegmentDeleteDelayMs()
```
    The amount of time to wait before deleting a file from the filesystem minimum: 0 maximum: 3600000
    
    Returns:
    
    logSegmentDeleteDelayMs
  - setLogSegmentDeleteDelayMs
```
public void setLogSegmentDeleteDelayMs(Integer logSegmentDeleteDelayMs)
```
  - messageMaxBytes
```
public JsonSchemaKafka messageMaxBytes(Integer messageMaxBytes)
```
  - getMessageMaxBytes
```
@Nullable
public Integer getMessageMaxBytes()
```
    The maximum size of message that the server can receive. minimum: 0 maximum: 100001200
    
    Returns:
    
    messageMaxBytes
  - setMessageMaxBytes
```
public void setMessageMaxBytes(Integer messageMaxBytes)
```
  - groupInitialRebalanceDelayMs
```
public JsonSchemaKafka groupInitialRebalanceDelayMs(Integer groupInitialRebalanceDelayMs)
```
  - getGroupInitialRebalanceDelayMs
```
@Nullable
public Integer getGroupInitialRebalanceDelayMs()
```
    The amount of time, in milliseconds, the group coordinator will wait for more consumers to join a new group before performing the first rebalance. A longer delay means potentially fewer rebalances, but increases the time until processing begins. The default value for this is 3 seconds. During development and testing it might be desirable to set this to 0 in order to not delay test execution time. minimum: 0 maximum: 300000
    
    Returns:
    
    groupInitialRebalanceDelayMs
  - setGroupInitialRebalanceDelayMs
```
public void setGroupInitialRebalanceDelayMs(Integer groupInitialRebalanceDelayMs)
```
  - logLocalRetentionBytes
```
public JsonSchemaKafka logLocalRetentionBytes(Integer logLocalRetentionBytes)
```
  - getLogLocalRetentionBytes
```
@Nullable
public Integer getLogLocalRetentionBytes()
```
    The maximum size of local log segments that can grow for a partition before it gets eligible for deletion. If set to -2, the value of log.retention.bytes is used. The effective value should always be less than or equal to log.retention.bytes value. minimum: -2 maximum: 9223372036854775807
    
    Returns:
    
    logLocalRetentionBytes
  - setLogLocalRetentionBytes
```
public void setLogLocalRetentionBytes(Integer logLocalRetentionBytes)
```
  - logRollJitterMs
```
public JsonSchemaKafka logRollJitterMs(Integer logRollJitterMs)
```
  - getLogRollJitterMs
```
@Nullable
public Integer getLogRollJitterMs()
```
    The maximum jitter to subtract from logRollTimeMillis (in milliseconds). If not set, the value in log.roll.jitter.hours is used minimum: 0 maximum: 9223372036854775807
    
    Returns:
    
    logRollJitterMs
  - setLogRollJitterMs
```
public void setLogRollJitterMs(Integer logRollJitterMs)
```
  - transactionRemoveExpiredTransactionCleanupIntervalMs
```
public JsonSchemaKafka transactionRemoveExpiredTransactionCleanupIntervalMs(Integer transactionRemoveExpiredTransactionCleanupIntervalMs)
```
  - getTransactionRemoveExpiredTransactionCleanupIntervalMs
```
@Nullable
public Integer getTransactionRemoveExpiredTransactionCleanupIntervalMs()
```
    The interval at which to remove transactions that have expired due to transactional.id.expiration.ms passing (defaults to 3600000 (1 hour)). minimum: 600000 maximum: 3600000
    
    Returns:
    
    transactionRemoveExpiredTransactionCleanupIntervalMs
  - setTransactionRemoveExpiredTransactionCleanupIntervalMs
```
public void setTransactionRemoveExpiredTransactionCleanupIntervalMs(Integer transactionRemoveExpiredTransactionCleanupIntervalMs)
```
  - transactionPartitionVerificationEnable
```
public JsonSchemaKafka transactionPartitionVerificationEnable(Boolean transactionPartitionVerificationEnable)
```
  - getTransactionPartitionVerificationEnable
```
@Nullable
public Boolean getTransactionPartitionVerificationEnable()
```
    Enable verification that checks that the partition has been added to the transaction before writing transactional records to the partition
    
    Returns:
    
    transactionPartitionVerificationEnable
  - setTransactionPartitionVerificationEnable
```
public void setTransactionPartitionVerificationEnable(Boolean transactionPartitionVerificationEnable)
```
  - defaultReplicationFactor
```
public JsonSchemaKafka defaultReplicationFactor(Integer defaultReplicationFactor)
```
  - getDefaultReplicationFactor
```
@Nullable
public Integer getDefaultReplicationFactor()
```
    Replication factor for autocreated topics minimum: 1 maximum: 10
    
    Returns:
    
    defaultReplicationFactor
  - setDefaultReplicationFactor
```
public void setDefaultReplicationFactor(Integer defaultReplicationFactor)
```
  - logRollMs
```
public JsonSchemaKafka logRollMs(Integer logRollMs)
```
  - getLogRollMs
```
@Nullable
public Integer getLogRollMs()
```
    The maximum time before a new log segment is rolled out (in milliseconds). minimum: 1 maximum: 9223372036854775807
    
    Returns:
    
    logRollMs
  - setLogRollMs
```
public void setLogRollMs(Integer logRollMs)
```
  - producerPurgatoryPurgeIntervalRequests
```
public JsonSchemaKafka producerPurgatoryPurgeIntervalRequests(Integer producerPurgatoryPurgeIntervalRequests)
```
  - getProducerPurgatoryPurgeIntervalRequests
```
@Nullable
public Integer getProducerPurgatoryPurgeIntervalRequests()
```
    The purge interval (in number of requests) of the producer request purgatory(defaults to 1000). minimum: 10 maximum: 10000
    
    Returns:
    
    producerPurgatoryPurgeIntervalRequests
  - setProducerPurgatoryPurgeIntervalRequests
```
public void setProducerPurgatoryPurgeIntervalRequests(Integer producerPurgatoryPurgeIntervalRequests)
```
  - logRetentionBytes
```
public JsonSchemaKafka logRetentionBytes(Integer logRetentionBytes)
```
  - getLogRetentionBytes
```
@Nullable
public Integer getLogRetentionBytes()
```
    The maximum size of the log before deleting messages minimum: -1 maximum: 9223372036854775807
    
    Returns:
    
    logRetentionBytes
  - setLogRetentionBytes
```
public void setLogRetentionBytes(Integer logRetentionBytes)
```
  - minInsyncReplicas
```
public JsonSchemaKafka minInsyncReplicas(Integer minInsyncReplicas)
```
  - getMinInsyncReplicas
```
@Nullable
public Integer getMinInsyncReplicas()
```
    When a producer sets acks to 'all' (or '-1'), min.insync.replicas specifies the minimum number of replicas that must acknowledge a write for the write to be considered successful. minimum: 1 maximum: 7
    
    Returns:
    
    minInsyncReplicas
  - setMinInsyncReplicas
```
public void setMinInsyncReplicas(Integer minInsyncReplicas)
```
  - compressionType
```
public JsonSchemaKafka compressionType(JsonSchemaKafka.CompressionTypeEnum compressionType)
```
  - getCompressionType
```
@Nullable
public JsonSchemaKafka.CompressionTypeEnum getCompressionType()
```
    Specify the final compression type for a given topic. This configuration accepts the standard compression codecs ('gzip', 'snappy', 'lz4', 'zstd'). It additionally accepts 'uncompressed' which is equivalent to no compression; and 'producer' which means retain the original compression codec set by the producer.
    
    Returns:
    
    compressionType
  - setCompressionType
```
public void setCompressionType(JsonSchemaKafka.CompressionTypeEnum compressionType)
```
  - logMessageTimestampDifferenceMaxMs
```
public JsonSchemaKafka logMessageTimestampDifferenceMaxMs(Integer logMessageTimestampDifferenceMaxMs)
```
  - getLogMessageTimestampDifferenceMaxMs
```
@Nullable
public Integer getLogMessageTimestampDifferenceMaxMs()
```
    The maximum difference allowed between the timestamp when a broker receives a message and the timestamp specified in the message minimum: 0 maximum: 9223372036854775807
    
    Returns:
    
    logMessageTimestampDifferenceMaxMs
  - setLogMessageTimestampDifferenceMaxMs
```
public void setLogMessageTimestampDifferenceMaxMs(Integer logMessageTimestampDifferenceMaxMs)
```
  - logLocalRetentionMs
```
public JsonSchemaKafka logLocalRetentionMs(Integer logLocalRetentionMs)
```
  - getLogLocalRetentionMs
```
@Nullable
public Integer getLogLocalRetentionMs()
```
    The number of milliseconds to keep the local log segments before it gets eligible for deletion. If set to -2, the value of log.retention.ms is used. The effective value should always be less than or equal to log.retention.ms value. minimum: -2 maximum: 9223372036854775807
    
    Returns:
    
    logLocalRetentionMs
  - setLogLocalRetentionMs
```
public void setLogLocalRetentionMs(Integer logLocalRetentionMs)
```
  - logMessageDownconversionEnable
```
public JsonSchemaKafka logMessageDownconversionEnable(Boolean logMessageDownconversionEnable)
```
  - getLogMessageDownconversionEnable
```
@Nullable
public Boolean getLogMessageDownconversionEnable()
```
    This configuration controls whether down-conversion of message formats is enabled to satisfy consume requests.
    
    Returns:
    
    logMessageDownconversionEnable
  - setLogMessageDownconversionEnable
```
public void setLogMessageDownconversionEnable(Boolean logMessageDownconversionEnable)
```
  - saslOauthbearerSubClaimName
```
public JsonSchemaKafka saslOauthbearerSubClaimName(String saslOauthbearerSubClaimName)
```
  - getSaslOauthbearerSubClaimName
```
@Nullable
public String getSaslOauthbearerSubClaimName()
```
    Name of the scope from which to extract the subject claim from the JWT. Defaults to sub.
    
    Returns:
    
    saslOauthbearerSubClaimName
  - setSaslOauthbearerSubClaimName
```
public void setSaslOauthbearerSubClaimName(String saslOauthbearerSubClaimName)
```
  - maxIncrementalFetchSessionCacheSlots
```
public JsonSchemaKafka maxIncrementalFetchSessionCacheSlots(Integer maxIncrementalFetchSessionCacheSlots)
```
  - getMaxIncrementalFetchSessionCacheSlots
```
@Nullable
public Integer getMaxIncrementalFetchSessionCacheSlots()
```
    The maximum number of incremental fetch sessions that the broker will maintain. minimum: 1000 maximum: 10000
    
    Returns:
    
    maxIncrementalFetchSessionCacheSlots
  - setMaxIncrementalFetchSessionCacheSlots
```
public void setMaxIncrementalFetchSessionCacheSlots(Integer maxIncrementalFetchSessionCacheSlots)
```
  - logRetentionHours
```
public JsonSchemaKafka logRetentionHours(Integer logRetentionHours)
```
  - getLogRetentionHours
```
@Nullable
public Integer getLogRetentionHours()
```
    The number of hours to keep a log file before deleting it minimum: -1 maximum: 2147483647
    
    Returns:
    
    logRetentionHours
  - setLogRetentionHours
```
public void setLogRetentionHours(Integer logRetentionHours)
```
  - groupMinSessionTimeoutMs
```
public JsonSchemaKafka groupMinSessionTimeoutMs(Integer groupMinSessionTimeoutMs)
```
  - getGroupMinSessionTimeoutMs
```
@Nullable
public Integer getGroupMinSessionTimeoutMs()
```
    The minimum allowed session timeout for registered consumers. Longer timeouts give consumers more time to process messages in between heartbeats at the cost of a longer time to detect failures. minimum: 0 maximum: 60000
    
    Returns:
    
    groupMinSessionTimeoutMs
  - setGroupMinSessionTimeoutMs
```
public void setGroupMinSessionTimeoutMs(Integer groupMinSessionTimeoutMs)
```
  - socketRequestMaxBytes
```
public JsonSchemaKafka socketRequestMaxBytes(Integer socketRequestMaxBytes)
```
  - getSocketRequestMaxBytes
```
@Nullable
public Integer getSocketRequestMaxBytes()
```
    The maximum number of bytes in a socket request (defaults to 104857600). minimum: 10485760 maximum: 209715200
    
    Returns:
    
    socketRequestMaxBytes
  - setSocketRequestMaxBytes
```
public void setSocketRequestMaxBytes(Integer socketRequestMaxBytes)
```
  - logSegmentBytes
```
public JsonSchemaKafka logSegmentBytes(Integer logSegmentBytes)
```
  - getLogSegmentBytes
```
@Nullable
public Integer getLogSegmentBytes()
```
    The maximum size of a single log file minimum: 10485760 maximum: 1073741824
    
    Returns:
    
    logSegmentBytes
  - setLogSegmentBytes
```
public void setLogSegmentBytes(Integer logSegmentBytes)
```
  - logCleanupAndCompaction
```
public JsonSchemaKafka logCleanupAndCompaction(ConfigureLogCleanerForTopicCompaction logCleanupAndCompaction)
```
  - getLogCleanupAndCompaction
```
@Nullable
public ConfigureLogCleanerForTopicCompaction getLogCleanupAndCompaction()
```
    Get logCleanupAndCompaction
    
    Returns:
    
    logCleanupAndCompaction
  - setLogCleanupAndCompaction
```
public void setLogCleanupAndCompaction(ConfigureLogCleanerForTopicCompaction logCleanupAndCompaction)
```
  - offsetsRetentionMinutes
```
public JsonSchemaKafka offsetsRetentionMinutes(Integer offsetsRetentionMinutes)
```
  - getOffsetsRetentionMinutes
```
@Nullable
public Integer getOffsetsRetentionMinutes()
```
    Log retention window in minutes for offsets topic minimum: 1 maximum: 2147483647
    
    Returns:
    
    offsetsRetentionMinutes
  - setOffsetsRetentionMinutes
```
public void setOffsetsRetentionMinutes(Integer offsetsRetentionMinutes)
```
  - logRetentionMs
```
public JsonSchemaKafka logRetentionMs(Integer logRetentionMs)
```
  - getLogRetentionMs
```
@Nullable
public Integer getLogRetentionMs()
```
    The number of milliseconds to keep a log file before deleting it (in milliseconds), If not set, the value in log.retention.minutes is used. If set to -1, no time limit is applied. minimum: -1 maximum: 9223372036854775807
    
    Returns:
    
    logRetentionMs
  - setLogRetentionMs
```
public void setLogRetentionMs(Integer logRetentionMs)
```
  - equals
```
public boolean equals(Object o)
```
    Return true if this json-schema-kafka object is equal to o.
    
    Overrides:
    
    equals in class Object
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - toUrlQueryString
```
public String toUrlQueryString()
```
    Convert the instance into URL query string.
    
    Returns:
    
    URL query string
  - toUrlQueryString
```
public String toUrlQueryString(String prefix)
```
    Convert the instance into URL query string.
    
    Parameters:
    
    prefix - prefix of the query string
    
    Returns:
    
    URL query string

Class JsonSchemaKafka

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

JSON_PROPERTY_SASL_OAUTHBEARER_EXPECTED_AUDIENCE

JSON_PROPERTY_GROUP_MAX_SESSION_TIMEOUT_MS

JSON_PROPERTY_LOG_FLUSH_INTERVAL_MESSAGES

JSON_PROPERTY_SASL_OAUTHBEARER_JWKS_ENDPOINT_URL

JSON_PROPERTY_MAX_CONNECTIONS_PER_IP

JSON_PROPERTY_SASL_OAUTHBEARER_EXPECTED_ISSUER

JSON_PROPERTY_LOG_INDEX_SIZE_MAX_BYTES

JSON_PROPERTY_AUTO_CREATE_TOPICS_ENABLE

JSON_PROPERTY_LOG_INDEX_INTERVAL_BYTES

JSON_PROPERTY_REPLICA_FETCH_MAX_BYTES

JSON_PROPERTY_NUM_PARTITIONS

JSON_PROPERTY_TRANSACTION_STATE_LOG_SEGMENT_BYTES

JSON_PROPERTY_REPLICA_FETCH_RESPONSE_MAX_BYTES

JSON_PROPERTY_LOG_MESSAGE_TIMESTAMP_TYPE

JSON_PROPERTY_CONNECTIONS_MAX_IDLE_MS

JSON_PROPERTY_LOG_FLUSH_INTERVAL_MS

JSON_PROPERTY_LOG_PREALLOCATE

JSON_PROPERTY_LOG_SEGMENT_DELETE_DELAY_MS

JSON_PROPERTY_MESSAGE_MAX_BYTES

JSON_PROPERTY_GROUP_INITIAL_REBALANCE_DELAY_MS

JSON_PROPERTY_LOG_LOCAL_RETENTION_BYTES

JSON_PROPERTY_LOG_ROLL_JITTER_MS

JSON_PROPERTY_TRANSACTION_REMOVE_EXPIRED_TRANSACTION_CLEANUP_INTERVAL_MS

JSON_PROPERTY_TRANSACTION_PARTITION_VERIFICATION_ENABLE

JSON_PROPERTY_DEFAULT_REPLICATION_FACTOR

JSON_PROPERTY_LOG_ROLL_MS

JSON_PROPERTY_PRODUCER_PURGATORY_PURGE_INTERVAL_REQUESTS

JSON_PROPERTY_LOG_RETENTION_BYTES

JSON_PROPERTY_MIN_INSYNC_REPLICAS

JSON_PROPERTY_COMPRESSION_TYPE

JSON_PROPERTY_LOG_MESSAGE_TIMESTAMP_DIFFERENCE_MAX_MS

JSON_PROPERTY_LOG_LOCAL_RETENTION_MS

JSON_PROPERTY_LOG_MESSAGE_DOWNCONVERSION_ENABLE

JSON_PROPERTY_SASL_OAUTHBEARER_SUB_CLAIM_NAME

JSON_PROPERTY_MAX_INCREMENTAL_FETCH_SESSION_CACHE_SLOTS

JSON_PROPERTY_LOG_RETENTION_HOURS

JSON_PROPERTY_GROUP_MIN_SESSION_TIMEOUT_MS

JSON_PROPERTY_SOCKET_REQUEST_MAX_BYTES

JSON_PROPERTY_LOG_SEGMENT_BYTES

JSON_PROPERTY_LOG_CLEANUP_AND_COMPACTION

JSON_PROPERTY_OFFSETS_RETENTION_MINUTES

JSON_PROPERTY_LOG_RETENTION_MS

Constructor Detail

JsonSchemaKafka

Method Detail

saslOauthbearerExpectedAudience

getSaslOauthbearerExpectedAudience

setSaslOauthbearerExpectedAudience

groupMaxSessionTimeoutMs

getGroupMaxSessionTimeoutMs

setGroupMaxSessionTimeoutMs

logFlushIntervalMessages

getLogFlushIntervalMessages

setLogFlushIntervalMessages

saslOauthbearerJwksEndpointUrl

getSaslOauthbearerJwksEndpointUrl

setSaslOauthbearerJwksEndpointUrl

maxConnectionsPerIp

getMaxConnectionsPerIp

setMaxConnectionsPerIp

saslOauthbearerExpectedIssuer

getSaslOauthbearerExpectedIssuer

setSaslOauthbearerExpectedIssuer

logIndexSizeMaxBytes

getLogIndexSizeMaxBytes

setLogIndexSizeMaxBytes

autoCreateTopicsEnable

getAutoCreateTopicsEnable

setAutoCreateTopicsEnable

logIndexIntervalBytes

getLogIndexIntervalBytes

setLogIndexIntervalBytes

replicaFetchMaxBytes