<!DOCTYPE HTML>
<html lang="en">
<head>
<!-- Generated by javadoc (17) -->
<title>Constant Field Values (kafka 3.3.2 API)</title>
<meta name="viewport" content="width=device-width, initial-scale=1">
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<meta name="description" content="summary of constants">
<meta name="generator" content="javadoc/ConstantsSummaryWriterImpl">
<link rel="stylesheet" type="text/css" href="stylesheet.css" title="Style">
<link rel="stylesheet" type="text/css" href="script-dir/jquery-ui.min.css" title="Style">
<link rel="stylesheet" type="text/css" href="jquery-ui.overrides.css" title="Style">
<script type="text/javascript" src="script.js"></script>
<script type="text/javascript" src="script-dir/jquery-3.5.1.min.js"></script>
<script type="text/javascript" src="script-dir/jquery-ui.min.js"></script>
</head>
<body class="constants-summary-page">
<script type="text/javascript">var pathtoroot = "./";
loadScripts(document, 'script');</script>
<noscript>
<div>JavaScript is disabled on your browser.</div>
</noscript>
<div class="flex-box">
<header role="banner" class="flex-header">
<nav role="navigation">
<!-- ========= START OF TOP NAVBAR ======= -->
<div class="top-nav" id="navbar-top">
<div class="skip-nav"><a href="#skip-navbar-top" title="Skip navigation links">Skip navigation links</a></div>
<ul id="navbar-top-firstrow" class="nav-list" title="Navigation">
<li><a href="index.html">Overview</a></li>
<li>Package</li>
<li>Class</li>
<li><a href="overview-tree.html">Tree</a></li>
<li><a href="deprecated-list.html">Deprecated</a></li>
<li><a href="index-all.html">Index</a></li>
<li><a href="help-doc.html#constant-values">Help</a></li>
</ul>
</div>
<div class="sub-nav">
<div class="nav-list-search"><label for="search-input">SEARCH:</label>
<input type="text" id="search-input" value="search" disabled="disabled">
<input type="reset" id="reset-button" value="reset" disabled="disabled">
</div>
</div>
<!-- ========= END OF TOP NAVBAR ========= -->
<span class="skip-nav" id="skip-navbar-top"></span></nav>
</header>
<div class="flex-content">
<main role="main">
<div class="header">
<h1 title="Constant Field Values" class="title">Constant Field Values</h1>
<section class="packages">
<h2 title="Contents">Contents</h2>
<ul>
<li><a href="#org.apache">org.apache.*</a></li>
</ul>
</section>
</div>
<section class="constants-summary" id="org.apache.kafka.clients.admin">
<h2 title="org.apache">org.apache.*</h2>
<ul class="block-list">
<li>
<div class="caption"><span>org.apache.kafka.clients.admin.<a href="org/apache/kafka/clients/admin/AdminClientConfig.html" title="class in org.apache.kafka.clients.admin">AdminClientConfig</a></span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Constant Field</div>
<div class="table-header col-last">Value</div>
<div class="col-first even-row-color"><code id="org.apache.kafka.clients.admin.AdminClientConfig.BOOTSTRAP_SERVERS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/clients/admin/AdminClientConfig.html#BOOTSTRAP_SERVERS_CONFIG">BOOTSTRAP_SERVERS_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"bootstrap.servers"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.clients.admin.AdminClientConfig.CLIENT_DNS_LOOKUP_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/clients/admin/AdminClientConfig.html#CLIENT_DNS_LOOKUP_CONFIG">CLIENT_DNS_LOOKUP_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"client.dns.lookup"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.clients.admin.AdminClientConfig.CLIENT_ID_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/clients/admin/AdminClientConfig.html#CLIENT_ID_CONFIG">CLIENT_ID_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"client.id"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.clients.admin.AdminClientConfig.CONNECTIONS_MAX_IDLE_MS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/clients/admin/AdminClientConfig.html#CONNECTIONS_MAX_IDLE_MS_CONFIG">CONNECTIONS_MAX_IDLE_MS_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"connections.max.idle.ms"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.clients.admin.AdminClientConfig.DEFAULT_API_TIMEOUT_MS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/clients/admin/AdminClientConfig.html#DEFAULT_API_TIMEOUT_MS_CONFIG">DEFAULT_API_TIMEOUT_MS_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"default.api.timeout.ms"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.clients.admin.AdminClientConfig.DEFAULT_SECURITY_PROTOCOL">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/clients/admin/AdminClientConfig.html#DEFAULT_SECURITY_PROTOCOL">DEFAULT_SECURITY_PROTOCOL</a></code></div>
<div class="col-last odd-row-color"><code>"PLAINTEXT"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.clients.admin.AdminClientConfig.METADATA_MAX_AGE_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/clients/admin/AdminClientConfig.html#METADATA_MAX_AGE_CONFIG">METADATA_MAX_AGE_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"metadata.max.age.ms"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.clients.admin.AdminClientConfig.METRIC_REPORTER_CLASSES_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/clients/admin/AdminClientConfig.html#METRIC_REPORTER_CLASSES_CONFIG">METRIC_REPORTER_CLASSES_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"metric.reporters"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.clients.admin.AdminClientConfig.METRICS_NUM_SAMPLES_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/clients/admin/AdminClientConfig.html#METRICS_NUM_SAMPLES_CONFIG">METRICS_NUM_SAMPLES_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"metrics.num.samples"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.clients.admin.AdminClientConfig.METRICS_RECORDING_LEVEL_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/clients/admin/AdminClientConfig.html#METRICS_RECORDING_LEVEL_CONFIG">METRICS_RECORDING_LEVEL_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"metrics.recording.level"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.clients.admin.AdminClientConfig.METRICS_SAMPLE_WINDOW_MS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/clients/admin/AdminClientConfig.html#METRICS_SAMPLE_WINDOW_MS_CONFIG">METRICS_SAMPLE_WINDOW_MS_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"metrics.sample.window.ms"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.clients.admin.AdminClientConfig.RECEIVE_BUFFER_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/clients/admin/AdminClientConfig.html#RECEIVE_BUFFER_CONFIG">RECEIVE_BUFFER_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"receive.buffer.bytes"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.clients.admin.AdminClientConfig.RECONNECT_BACKOFF_MAX_MS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/clients/admin/AdminClientConfig.html#RECONNECT_BACKOFF_MAX_MS_CONFIG">RECONNECT_BACKOFF_MAX_MS_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"reconnect.backoff.max.ms"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.clients.admin.AdminClientConfig.RECONNECT_BACKOFF_MS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/clients/admin/AdminClientConfig.html#RECONNECT_BACKOFF_MS_CONFIG">RECONNECT_BACKOFF_MS_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"reconnect.backoff.ms"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.clients.admin.AdminClientConfig.REQUEST_TIMEOUT_MS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/clients/admin/AdminClientConfig.html#REQUEST_TIMEOUT_MS_CONFIG">REQUEST_TIMEOUT_MS_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"request.timeout.ms"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.clients.admin.AdminClientConfig.RETRIES_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/clients/admin/AdminClientConfig.html#RETRIES_CONFIG">RETRIES_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"retries"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.clients.admin.AdminClientConfig.RETRY_BACKOFF_MS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/clients/admin/AdminClientConfig.html#RETRY_BACKOFF_MS_CONFIG">RETRY_BACKOFF_MS_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"retry.backoff.ms"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.clients.admin.AdminClientConfig.SECURITY_PROTOCOL_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/clients/admin/AdminClientConfig.html#SECURITY_PROTOCOL_CONFIG">SECURITY_PROTOCOL_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"security.protocol"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.clients.admin.AdminClientConfig.SECURITY_PROVIDERS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/clients/admin/AdminClientConfig.html#SECURITY_PROVIDERS_CONFIG">SECURITY_PROVIDERS_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"security.providers"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.clients.admin.AdminClientConfig.SEND_BUFFER_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/clients/admin/AdminClientConfig.html#SEND_BUFFER_CONFIG">SEND_BUFFER_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"send.buffer.bytes"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.clients.admin.AdminClientConfig.SOCKET_CONNECTION_SETUP_TIMEOUT_MAX_MS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/clients/admin/AdminClientConfig.html#SOCKET_CONNECTION_SETUP_TIMEOUT_MAX_MS_CONFIG">SOCKET_CONNECTION_SETUP_TIMEOUT_MAX_MS_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"socket.connection.setup.timeout.max.ms"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.clients.admin.AdminClientConfig.SOCKET_CONNECTION_SETUP_TIMEOUT_MS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/clients/admin/AdminClientConfig.html#SOCKET_CONNECTION_SETUP_TIMEOUT_MS_CONFIG">SOCKET_CONNECTION_SETUP_TIMEOUT_MS_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"socket.connection.setup.timeout.ms"</code></div>
</div>
</li>
</ul>
<ul class="block-list">
<li>
<div class="caption"><span>org.apache.kafka.clients.consumer.<a href="org/apache/kafka/clients/consumer/ConsumerConfig.html" title="class in org.apache.kafka.clients.consumer">ConsumerConfig</a></span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Constant Field</div>
<div class="table-header col-last">Value</div>
<div class="col-first even-row-color"><code id="org.apache.kafka.clients.consumer.ConsumerConfig.ALLOW_AUTO_CREATE_TOPICS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/clients/consumer/ConsumerConfig.html#ALLOW_AUTO_CREATE_TOPICS_CONFIG">ALLOW_AUTO_CREATE_TOPICS_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"allow.auto.create.topics"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.clients.consumer.ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/clients/consumer/ConsumerConfig.html#AUTO_COMMIT_INTERVAL_MS_CONFIG">AUTO_COMMIT_INTERVAL_MS_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"auto.commit.interval.ms"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.clients.consumer.ConsumerConfig.AUTO_OFFSET_RESET_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/clients/consumer/ConsumerConfig.html#AUTO_OFFSET_RESET_CONFIG">AUTO_OFFSET_RESET_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"auto.offset.reset"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.clients.consumer.ConsumerConfig.AUTO_OFFSET_RESET_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/clients/consumer/ConsumerConfig.html#AUTO_OFFSET_RESET_DOC">AUTO_OFFSET_RESET_DOC</a></code></div>
<div class="col-last odd-row-color"><code>"What to do when there is no initial offset in Kafka or if the current offset does not exist any more on the server (e.g. because that data has been deleted): &lt;ul&gt;&lt;li&gt;earliest: automatically reset the offset to the earliest offset&lt;li&gt;latest: automatically reset the offset to the latest offset&lt;/li&gt;&lt;li&gt;none: throw exception to the consumer if no previous offset is found for the consumer\'s group&lt;/li&gt;&lt;li&gt;anything else: throw exception to the consumer.&lt;/li&gt;&lt;/ul&gt;"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.clients.consumer.ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/clients/consumer/ConsumerConfig.html#BOOTSTRAP_SERVERS_CONFIG">BOOTSTRAP_SERVERS_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"bootstrap.servers"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.clients.consumer.ConsumerConfig.CHECK_CRCS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/clients/consumer/ConsumerConfig.html#CHECK_CRCS_CONFIG">CHECK_CRCS_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"check.crcs"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.clients.consumer.ConsumerConfig.CLIENT_DNS_LOOKUP_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/clients/consumer/ConsumerConfig.html#CLIENT_DNS_LOOKUP_CONFIG">CLIENT_DNS_LOOKUP_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"client.dns.lookup"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.clients.consumer.ConsumerConfig.CLIENT_ID_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/clients/consumer/ConsumerConfig.html#CLIENT_ID_CONFIG">CLIENT_ID_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"client.id"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.clients.consumer.ConsumerConfig.CLIENT_RACK_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/clients/consumer/ConsumerConfig.html#CLIENT_RACK_CONFIG">CLIENT_RACK_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"client.rack"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.clients.consumer.ConsumerConfig.CONNECTIONS_MAX_IDLE_MS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/clients/consumer/ConsumerConfig.html#CONNECTIONS_MAX_IDLE_MS_CONFIG">CONNECTIONS_MAX_IDLE_MS_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"connections.max.idle.ms"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.clients.consumer.ConsumerConfig.DEFAULT_ALLOW_AUTO_CREATE_TOPICS">public&nbsp;static&nbsp;final&nbsp;boolean</code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/clients/consumer/ConsumerConfig.html#DEFAULT_ALLOW_AUTO_CREATE_TOPICS">DEFAULT_ALLOW_AUTO_CREATE_TOPICS</a></code></div>
<div class="col-last even-row-color"><code>true</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.clients.consumer.ConsumerConfig.DEFAULT_API_TIMEOUT_MS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/clients/consumer/ConsumerConfig.html#DEFAULT_API_TIMEOUT_MS_CONFIG">DEFAULT_API_TIMEOUT_MS_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"default.api.timeout.ms"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.clients.consumer.ConsumerConfig.DEFAULT_EXCLUDE_INTERNAL_TOPICS">public&nbsp;static&nbsp;final&nbsp;boolean</code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/clients/consumer/ConsumerConfig.html#DEFAULT_EXCLUDE_INTERNAL_TOPICS">DEFAULT_EXCLUDE_INTERNAL_TOPICS</a></code></div>
<div class="col-last even-row-color"><code>true</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.clients.consumer.ConsumerConfig.DEFAULT_FETCH_MAX_BYTES">public&nbsp;static&nbsp;final&nbsp;int</code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/clients/consumer/ConsumerConfig.html#DEFAULT_FETCH_MAX_BYTES">DEFAULT_FETCH_MAX_BYTES</a></code></div>
<div class="col-last odd-row-color"><code>52428800</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.clients.consumer.ConsumerConfig.DEFAULT_MAX_PARTITION_FETCH_BYTES">public&nbsp;static&nbsp;final&nbsp;int</code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/clients/consumer/ConsumerConfig.html#DEFAULT_MAX_PARTITION_FETCH_BYTES">DEFAULT_MAX_PARTITION_FETCH_BYTES</a></code></div>
<div class="col-last even-row-color"><code>1048576</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.clients.consumer.ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/clients/consumer/ConsumerConfig.html#ENABLE_AUTO_COMMIT_CONFIG">ENABLE_AUTO_COMMIT_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"enable.auto.commit"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.clients.consumer.ConsumerConfig.EXCLUDE_INTERNAL_TOPICS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/clients/consumer/ConsumerConfig.html#EXCLUDE_INTERNAL_TOPICS_CONFIG">EXCLUDE_INTERNAL_TOPICS_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"exclude.internal.topics"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.clients.consumer.ConsumerConfig.FETCH_MAX_BYTES_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/clients/consumer/ConsumerConfig.html#FETCH_MAX_BYTES_CONFIG">FETCH_MAX_BYTES_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"fetch.max.bytes"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.clients.consumer.ConsumerConfig.FETCH_MAX_WAIT_MS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/clients/consumer/ConsumerConfig.html#FETCH_MAX_WAIT_MS_CONFIG">FETCH_MAX_WAIT_MS_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"fetch.max.wait.ms"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.clients.consumer.ConsumerConfig.FETCH_MIN_BYTES_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/clients/consumer/ConsumerConfig.html#FETCH_MIN_BYTES_CONFIG">FETCH_MIN_BYTES_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"fetch.min.bytes"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.clients.consumer.ConsumerConfig.GROUP_ID_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/clients/consumer/ConsumerConfig.html#GROUP_ID_CONFIG">GROUP_ID_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"group.id"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.clients.consumer.ConsumerConfig.GROUP_INSTANCE_ID_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/clients/consumer/ConsumerConfig.html#GROUP_INSTANCE_ID_CONFIG">GROUP_INSTANCE_ID_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"group.instance.id"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.clients.consumer.ConsumerConfig.HEARTBEAT_INTERVAL_MS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/clients/consumer/ConsumerConfig.html#HEARTBEAT_INTERVAL_MS_CONFIG">HEARTBEAT_INTERVAL_MS_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"heartbeat.interval.ms"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.clients.consumer.ConsumerConfig.INTERCEPTOR_CLASSES_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/clients/consumer/ConsumerConfig.html#INTERCEPTOR_CLASSES_CONFIG">INTERCEPTOR_CLASSES_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"interceptor.classes"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.clients.consumer.ConsumerConfig.INTERCEPTOR_CLASSES_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/clients/consumer/ConsumerConfig.html#INTERCEPTOR_CLASSES_DOC">INTERCEPTOR_CLASSES_DOC</a></code></div>
<div class="col-last even-row-color"><code>"A list of classes to use as interceptors. Implementing the &lt;code&gt;org.apache.kafka.clients.consumer.ConsumerInterceptor&lt;/code&gt; interface allows you to intercept (and possibly mutate) records received by the consumer. By default, there are no interceptors."</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.clients.consumer.ConsumerConfig.ISOLATION_LEVEL_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/clients/consumer/ConsumerConfig.html#ISOLATION_LEVEL_CONFIG">ISOLATION_LEVEL_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"isolation.level"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.clients.consumer.ConsumerConfig.ISOLATION_LEVEL_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/clients/consumer/ConsumerConfig.html#ISOLATION_LEVEL_DOC">ISOLATION_LEVEL_DOC</a></code></div>
<div class="col-last even-row-color"><code>"Controls how to read messages written transactionally. If set to &lt;code&gt;read_committed&lt;/code&gt;, consumer.poll() will only return transactional messages which have been committed. If set to &lt;code&gt;read_uncommitted&lt;/code&gt; (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. &lt;p&gt;Messages will always be returned in offset order. Hence, in  &lt;code&gt;read_committed&lt;/code&gt; 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, &lt;code&gt;read_committed&lt;/code&gt; consumers will not be able to read up to the high watermark when there are in flight transactions.&lt;/p&gt;&lt;p&gt; Further, when in &lt;code&gt;read_committed&lt;/code&gt; the seekToEnd method will return the LSO&lt;/p&gt;"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.clients.consumer.ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/clients/consumer/ConsumerConfig.html#KEY_DESERIALIZER_CLASS_CONFIG">KEY_DESERIALIZER_CLASS_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"key.deserializer"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.clients.consumer.ConsumerConfig.KEY_DESERIALIZER_CLASS_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/clients/consumer/ConsumerConfig.html#KEY_DESERIALIZER_CLASS_DOC">KEY_DESERIALIZER_CLASS_DOC</a></code></div>
<div class="col-last even-row-color"><code>"Deserializer class for key that implements the &lt;code&gt;org.apache.kafka.common.serialization.Deserializer&lt;/code&gt; interface."</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.clients.consumer.ConsumerConfig.MAX_PARTITION_FETCH_BYTES_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/clients/consumer/ConsumerConfig.html#MAX_PARTITION_FETCH_BYTES_CONFIG">MAX_PARTITION_FETCH_BYTES_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"max.partition.fetch.bytes"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.clients.consumer.ConsumerConfig.MAX_POLL_INTERVAL_MS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/clients/consumer/ConsumerConfig.html#MAX_POLL_INTERVAL_MS_CONFIG">MAX_POLL_INTERVAL_MS_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"max.poll.interval.ms"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.clients.consumer.ConsumerConfig.MAX_POLL_RECORDS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/clients/consumer/ConsumerConfig.html#MAX_POLL_RECORDS_CONFIG">MAX_POLL_RECORDS_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"max.poll.records"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.clients.consumer.ConsumerConfig.METADATA_MAX_AGE_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/clients/consumer/ConsumerConfig.html#METADATA_MAX_AGE_CONFIG">METADATA_MAX_AGE_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"metadata.max.age.ms"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.clients.consumer.ConsumerConfig.METRIC_REPORTER_CLASSES_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/clients/consumer/ConsumerConfig.html#METRIC_REPORTER_CLASSES_CONFIG">METRIC_REPORTER_CLASSES_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"metric.reporters"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.clients.consumer.ConsumerConfig.METRICS_NUM_SAMPLES_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/clients/consumer/ConsumerConfig.html#METRICS_NUM_SAMPLES_CONFIG">METRICS_NUM_SAMPLES_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"metrics.num.samples"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.clients.consumer.ConsumerConfig.METRICS_RECORDING_LEVEL_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/clients/consumer/ConsumerConfig.html#METRICS_RECORDING_LEVEL_CONFIG">METRICS_RECORDING_LEVEL_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"metrics.recording.level"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.clients.consumer.ConsumerConfig.METRICS_SAMPLE_WINDOW_MS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/clients/consumer/ConsumerConfig.html#METRICS_SAMPLE_WINDOW_MS_CONFIG">METRICS_SAMPLE_WINDOW_MS_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"metrics.sample.window.ms"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.clients.consumer.ConsumerConfig.PARTITION_ASSIGNMENT_STRATEGY_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/clients/consumer/ConsumerConfig.html#PARTITION_ASSIGNMENT_STRATEGY_CONFIG">PARTITION_ASSIGNMENT_STRATEGY_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"partition.assignment.strategy"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.clients.consumer.ConsumerConfig.RECEIVE_BUFFER_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/clients/consumer/ConsumerConfig.html#RECEIVE_BUFFER_CONFIG">RECEIVE_BUFFER_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"receive.buffer.bytes"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.clients.consumer.ConsumerConfig.RECONNECT_BACKOFF_MAX_MS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/clients/consumer/ConsumerConfig.html#RECONNECT_BACKOFF_MAX_MS_CONFIG">RECONNECT_BACKOFF_MAX_MS_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"reconnect.backoff.max.ms"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.clients.consumer.ConsumerConfig.RECONNECT_BACKOFF_MS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/clients/consumer/ConsumerConfig.html#RECONNECT_BACKOFF_MS_CONFIG">RECONNECT_BACKOFF_MS_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"reconnect.backoff.ms"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.clients.consumer.ConsumerConfig.REQUEST_TIMEOUT_MS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/clients/consumer/ConsumerConfig.html#REQUEST_TIMEOUT_MS_CONFIG">REQUEST_TIMEOUT_MS_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"request.timeout.ms"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.clients.consumer.ConsumerConfig.RETRY_BACKOFF_MS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/clients/consumer/ConsumerConfig.html#RETRY_BACKOFF_MS_CONFIG">RETRY_BACKOFF_MS_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"retry.backoff.ms"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.clients.consumer.ConsumerConfig.SECURITY_PROVIDERS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/clients/consumer/ConsumerConfig.html#SECURITY_PROVIDERS_CONFIG">SECURITY_PROVIDERS_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"security.providers"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.clients.consumer.ConsumerConfig.SEND_BUFFER_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/clients/consumer/ConsumerConfig.html#SEND_BUFFER_CONFIG">SEND_BUFFER_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"send.buffer.bytes"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.clients.consumer.ConsumerConfig.SESSION_TIMEOUT_MS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/clients/consumer/ConsumerConfig.html#SESSION_TIMEOUT_MS_CONFIG">SESSION_TIMEOUT_MS_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"session.timeout.ms"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.clients.consumer.ConsumerConfig.SOCKET_CONNECTION_SETUP_TIMEOUT_MAX_MS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/clients/consumer/ConsumerConfig.html#SOCKET_CONNECTION_SETUP_TIMEOUT_MAX_MS_CONFIG">SOCKET_CONNECTION_SETUP_TIMEOUT_MAX_MS_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"socket.connection.setup.timeout.max.ms"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.clients.consumer.ConsumerConfig.SOCKET_CONNECTION_SETUP_TIMEOUT_MS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/clients/consumer/ConsumerConfig.html#SOCKET_CONNECTION_SETUP_TIMEOUT_MS_CONFIG">SOCKET_CONNECTION_SETUP_TIMEOUT_MS_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"socket.connection.setup.timeout.ms"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.clients.consumer.ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/clients/consumer/ConsumerConfig.html#VALUE_DESERIALIZER_CLASS_CONFIG">VALUE_DESERIALIZER_CLASS_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"value.deserializer"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.clients.consumer.ConsumerConfig.VALUE_DESERIALIZER_CLASS_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/clients/consumer/ConsumerConfig.html#VALUE_DESERIALIZER_CLASS_DOC">VALUE_DESERIALIZER_CLASS_DOC</a></code></div>
<div class="col-last odd-row-color"><code>"Deserializer class for value that implements the &lt;code&gt;org.apache.kafka.common.serialization.Deserializer&lt;/code&gt; interface."</code></div>
</div>
</li>
<li>
<div class="caption"><span>org.apache.kafka.clients.consumer.<a href="org/apache/kafka/clients/consumer/ConsumerRecord.html" title="class in org.apache.kafka.clients.consumer">ConsumerRecord</a>&lt;<a href="org/apache/kafka/clients/consumer/ConsumerRecord.html" title="type parameter in ConsumerRecord">K</a>,<wbr><a href="org/apache/kafka/clients/consumer/ConsumerRecord.html" title="type parameter in ConsumerRecord">V</a>&gt;</span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Constant Field</div>
<div class="table-header col-last">Value</div>
<div class="col-first even-row-color"><code id="org.apache.kafka.clients.consumer.ConsumerRecord.NO_TIMESTAMP">public&nbsp;static&nbsp;final&nbsp;long</code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/clients/consumer/ConsumerRecord.html#NO_TIMESTAMP">NO_TIMESTAMP</a></code></div>
<div class="col-last even-row-color"><code>-1L</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.clients.consumer.ConsumerRecord.NULL_CHECKSUM">public&nbsp;static&nbsp;final&nbsp;int</code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/clients/consumer/ConsumerRecord.html#NULL_CHECKSUM">NULL_CHECKSUM</a></code></div>
<div class="col-last odd-row-color"><code>-1</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.clients.consumer.ConsumerRecord.NULL_SIZE">public&nbsp;static&nbsp;final&nbsp;int</code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/clients/consumer/ConsumerRecord.html#NULL_SIZE">NULL_SIZE</a></code></div>
<div class="col-last even-row-color"><code>-1</code></div>
</div>
</li>
<li>
<div class="caption"><span>org.apache.kafka.clients.consumer.<a href="org/apache/kafka/clients/consumer/CooperativeStickyAssignor.html" title="class in org.apache.kafka.clients.consumer">CooperativeStickyAssignor</a></span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Constant Field</div>
<div class="table-header col-last">Value</div>
<div class="col-first even-row-color"><code id="org.apache.kafka.clients.consumer.CooperativeStickyAssignor.COOPERATIVE_STICKY_ASSIGNOR_NAME">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/clients/consumer/CooperativeStickyAssignor.html#COOPERATIVE_STICKY_ASSIGNOR_NAME">COOPERATIVE_STICKY_ASSIGNOR_NAME</a></code></div>
<div class="col-last even-row-color"><code>"cooperative-sticky"</code></div>
</div>
</li>
<li>
<div class="caption"><span>org.apache.kafka.clients.consumer.<a href="org/apache/kafka/clients/consumer/RangeAssignor.html" title="class in org.apache.kafka.clients.consumer">RangeAssignor</a></span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Constant Field</div>
<div class="table-header col-last">Value</div>
<div class="col-first even-row-color"><code id="org.apache.kafka.clients.consumer.RangeAssignor.RANGE_ASSIGNOR_NAME">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/clients/consumer/RangeAssignor.html#RANGE_ASSIGNOR_NAME">RANGE_ASSIGNOR_NAME</a></code></div>
<div class="col-last even-row-color"><code>"range"</code></div>
</div>
</li>
<li>
<div class="caption"><span>org.apache.kafka.clients.consumer.<a href="org/apache/kafka/clients/consumer/RoundRobinAssignor.html" title="class in org.apache.kafka.clients.consumer">RoundRobinAssignor</a></span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Constant Field</div>
<div class="table-header col-last">Value</div>
<div class="col-first even-row-color"><code id="org.apache.kafka.clients.consumer.RoundRobinAssignor.ROUNDROBIN_ASSIGNOR_NAME">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/clients/consumer/RoundRobinAssignor.html#ROUNDROBIN_ASSIGNOR_NAME">ROUNDROBIN_ASSIGNOR_NAME</a></code></div>
<div class="col-last even-row-color"><code>"roundrobin"</code></div>
</div>
</li>
<li>
<div class="caption"><span>org.apache.kafka.clients.consumer.<a href="org/apache/kafka/clients/consumer/StickyAssignor.html" title="class in org.apache.kafka.clients.consumer">StickyAssignor</a></span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Constant Field</div>
<div class="table-header col-last">Value</div>
<div class="col-first even-row-color"><code id="org.apache.kafka.clients.consumer.StickyAssignor.STICKY_ASSIGNOR_NAME">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/clients/consumer/StickyAssignor.html#STICKY_ASSIGNOR_NAME">STICKY_ASSIGNOR_NAME</a></code></div>
<div class="col-last even-row-color"><code>"sticky"</code></div>
</div>
</li>
</ul>
<ul class="block-list">
<li>
<div class="caption"><span>org.apache.kafka.clients.producer.<a href="org/apache/kafka/clients/producer/KafkaProducer.html" title="class in org.apache.kafka.clients.producer">KafkaProducer</a>&lt;<a href="org/apache/kafka/clients/producer/KafkaProducer.html" title="type parameter in KafkaProducer">K</a>,<wbr><a href="org/apache/kafka/clients/producer/KafkaProducer.html" title="type parameter in KafkaProducer">V</a>&gt;</span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Constant Field</div>
<div class="table-header col-last">Value</div>
<div class="col-first even-row-color"><code id="org.apache.kafka.clients.producer.KafkaProducer.NETWORK_THREAD_PREFIX">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/clients/producer/KafkaProducer.html#NETWORK_THREAD_PREFIX">NETWORK_THREAD_PREFIX</a></code></div>
<div class="col-last even-row-color"><code>"kafka-producer-network-thread"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.clients.producer.KafkaProducer.PRODUCER_METRIC_GROUP_NAME">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/clients/producer/KafkaProducer.html#PRODUCER_METRIC_GROUP_NAME">PRODUCER_METRIC_GROUP_NAME</a></code></div>
<div class="col-last odd-row-color"><code>"producer-metrics"</code></div>
</div>
</li>
<li>
<div class="caption"><span>org.apache.kafka.clients.producer.<a href="org/apache/kafka/clients/producer/ProducerConfig.html" title="class in org.apache.kafka.clients.producer">ProducerConfig</a></span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Constant Field</div>
<div class="table-header col-last">Value</div>
<div class="col-first even-row-color"><code id="org.apache.kafka.clients.producer.ProducerConfig.ACKS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/clients/producer/ProducerConfig.html#ACKS_CONFIG">ACKS_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"acks"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.clients.producer.ProducerConfig.BATCH_SIZE_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/clients/producer/ProducerConfig.html#BATCH_SIZE_CONFIG">BATCH_SIZE_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"batch.size"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.clients.producer.ProducerConfig.BOOTSTRAP_SERVERS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/clients/producer/ProducerConfig.html#BOOTSTRAP_SERVERS_CONFIG">BOOTSTRAP_SERVERS_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"bootstrap.servers"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.clients.producer.ProducerConfig.BUFFER_MEMORY_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/clients/producer/ProducerConfig.html#BUFFER_MEMORY_CONFIG">BUFFER_MEMORY_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"buffer.memory"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.clients.producer.ProducerConfig.CLIENT_DNS_LOOKUP_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/clients/producer/ProducerConfig.html#CLIENT_DNS_LOOKUP_CONFIG">CLIENT_DNS_LOOKUP_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"client.dns.lookup"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.clients.producer.ProducerConfig.CLIENT_ID_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/clients/producer/ProducerConfig.html#CLIENT_ID_CONFIG">CLIENT_ID_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"client.id"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.clients.producer.ProducerConfig.COMPRESSION_TYPE_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/clients/producer/ProducerConfig.html#COMPRESSION_TYPE_CONFIG">COMPRESSION_TYPE_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"compression.type"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.clients.producer.ProducerConfig.CONNECTIONS_MAX_IDLE_MS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/clients/producer/ProducerConfig.html#CONNECTIONS_MAX_IDLE_MS_CONFIG">CONNECTIONS_MAX_IDLE_MS_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"connections.max.idle.ms"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.clients.producer.ProducerConfig.DELIVERY_TIMEOUT_MS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/clients/producer/ProducerConfig.html#DELIVERY_TIMEOUT_MS_CONFIG">DELIVERY_TIMEOUT_MS_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"delivery.timeout.ms"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.clients.producer.ProducerConfig.ENABLE_IDEMPOTENCE_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/clients/producer/ProducerConfig.html#ENABLE_IDEMPOTENCE_CONFIG">ENABLE_IDEMPOTENCE_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"enable.idempotence"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.clients.producer.ProducerConfig.ENABLE_IDEMPOTENCE_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/clients/producer/ProducerConfig.html#ENABLE_IDEMPOTENCE_DOC">ENABLE_IDEMPOTENCE_DOC</a></code></div>
<div class="col-last even-row-color"><code>"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 &lt;code&gt;max.in.flight.requests.per.connection&lt;/code&gt; to be less than or equal to 5 (with message ordering preserved for any allowable value), &lt;code&gt;retries&lt;/code&gt; to be greater than 0, and &lt;code&gt;acks&lt;/code&gt; must be \'all\'. &lt;p&gt;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 &lt;code&gt;ConfigException&lt;/code&gt; is thrown."</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.clients.producer.ProducerConfig.INTERCEPTOR_CLASSES_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/clients/producer/ProducerConfig.html#INTERCEPTOR_CLASSES_CONFIG">INTERCEPTOR_CLASSES_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"interceptor.classes"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.clients.producer.ProducerConfig.INTERCEPTOR_CLASSES_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/clients/producer/ProducerConfig.html#INTERCEPTOR_CLASSES_DOC">INTERCEPTOR_CLASSES_DOC</a></code></div>
<div class="col-last even-row-color"><code>"A list of classes to use as interceptors. Implementing the &lt;code&gt;org.apache.kafka.clients.producer.ProducerInterceptor&lt;/code&gt; interface allows you to intercept (and possibly mutate) the records received by the producer before they are published to the Kafka cluster. By default, there are no interceptors."</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.clients.producer.ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/clients/producer/ProducerConfig.html#KEY_SERIALIZER_CLASS_CONFIG">KEY_SERIALIZER_CLASS_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"key.serializer"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.clients.producer.ProducerConfig.KEY_SERIALIZER_CLASS_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/clients/producer/ProducerConfig.html#KEY_SERIALIZER_CLASS_DOC">KEY_SERIALIZER_CLASS_DOC</a></code></div>
<div class="col-last even-row-color"><code>"Serializer class for key that implements the &lt;code&gt;org.apache.kafka.common.serialization.Serializer&lt;/code&gt; interface."</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.clients.producer.ProducerConfig.LINGER_MS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/clients/producer/ProducerConfig.html#LINGER_MS_CONFIG">LINGER_MS_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"linger.ms"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.clients.producer.ProducerConfig.MAX_BLOCK_MS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/clients/producer/ProducerConfig.html#MAX_BLOCK_MS_CONFIG">MAX_BLOCK_MS_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"max.block.ms"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.clients.producer.ProducerConfig.MAX_IN_FLIGHT_REQUESTS_PER_CONNECTION">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/clients/producer/ProducerConfig.html#MAX_IN_FLIGHT_REQUESTS_PER_CONNECTION">MAX_IN_FLIGHT_REQUESTS_PER_CONNECTION</a></code></div>
<div class="col-last odd-row-color"><code>"max.in.flight.requests.per.connection"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.clients.producer.ProducerConfig.MAX_REQUEST_SIZE_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/clients/producer/ProducerConfig.html#MAX_REQUEST_SIZE_CONFIG">MAX_REQUEST_SIZE_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"max.request.size"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.clients.producer.ProducerConfig.METADATA_MAX_AGE_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/clients/producer/ProducerConfig.html#METADATA_MAX_AGE_CONFIG">METADATA_MAX_AGE_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"metadata.max.age.ms"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.clients.producer.ProducerConfig.METADATA_MAX_IDLE_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/clients/producer/ProducerConfig.html#METADATA_MAX_IDLE_CONFIG">METADATA_MAX_IDLE_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"metadata.max.idle.ms"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.clients.producer.ProducerConfig.METRIC_REPORTER_CLASSES_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/clients/producer/ProducerConfig.html#METRIC_REPORTER_CLASSES_CONFIG">METRIC_REPORTER_CLASSES_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"metric.reporters"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.clients.producer.ProducerConfig.METRICS_NUM_SAMPLES_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/clients/producer/ProducerConfig.html#METRICS_NUM_SAMPLES_CONFIG">METRICS_NUM_SAMPLES_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"metrics.num.samples"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.clients.producer.ProducerConfig.METRICS_RECORDING_LEVEL_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/clients/producer/ProducerConfig.html#METRICS_RECORDING_LEVEL_CONFIG">METRICS_RECORDING_LEVEL_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"metrics.recording.level"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.clients.producer.ProducerConfig.METRICS_SAMPLE_WINDOW_MS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/clients/producer/ProducerConfig.html#METRICS_SAMPLE_WINDOW_MS_CONFIG">METRICS_SAMPLE_WINDOW_MS_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"metrics.sample.window.ms"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.clients.producer.ProducerConfig.PARTITIONER_ADPATIVE_PARTITIONING_ENABLE_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/clients/producer/ProducerConfig.html#PARTITIONER_ADPATIVE_PARTITIONING_ENABLE_CONFIG">PARTITIONER_ADPATIVE_PARTITIONING_ENABLE_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"partitioner.adaptive.partitioning.enable"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.clients.producer.ProducerConfig.PARTITIONER_AVAILABILITY_TIMEOUT_MS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/clients/producer/ProducerConfig.html#PARTITIONER_AVAILABILITY_TIMEOUT_MS_CONFIG">PARTITIONER_AVAILABILITY_TIMEOUT_MS_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"partitioner.availability.timeout.ms"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.clients.producer.ProducerConfig.PARTITIONER_CLASS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/clients/producer/ProducerConfig.html#PARTITIONER_CLASS_CONFIG">PARTITIONER_CLASS_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"partitioner.class"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.clients.producer.ProducerConfig.PARTITIONER_IGNORE_KEYS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/clients/producer/ProducerConfig.html#PARTITIONER_IGNORE_KEYS_CONFIG">PARTITIONER_IGNORE_KEYS_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"partitioner.ignore.keys"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.clients.producer.ProducerConfig.RECEIVE_BUFFER_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/clients/producer/ProducerConfig.html#RECEIVE_BUFFER_CONFIG">RECEIVE_BUFFER_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"receive.buffer.bytes"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.clients.producer.ProducerConfig.RECONNECT_BACKOFF_MAX_MS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/clients/producer/ProducerConfig.html#RECONNECT_BACKOFF_MAX_MS_CONFIG">RECONNECT_BACKOFF_MAX_MS_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"reconnect.backoff.max.ms"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.clients.producer.ProducerConfig.RECONNECT_BACKOFF_MS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/clients/producer/ProducerConfig.html#RECONNECT_BACKOFF_MS_CONFIG">RECONNECT_BACKOFF_MS_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"reconnect.backoff.ms"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.clients.producer.ProducerConfig.REQUEST_TIMEOUT_MS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/clients/producer/ProducerConfig.html#REQUEST_TIMEOUT_MS_CONFIG">REQUEST_TIMEOUT_MS_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"request.timeout.ms"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.clients.producer.ProducerConfig.RETRIES_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/clients/producer/ProducerConfig.html#RETRIES_CONFIG">RETRIES_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"retries"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.clients.producer.ProducerConfig.RETRY_BACKOFF_MS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/clients/producer/ProducerConfig.html#RETRY_BACKOFF_MS_CONFIG">RETRY_BACKOFF_MS_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"retry.backoff.ms"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.clients.producer.ProducerConfig.SECURITY_PROVIDERS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/clients/producer/ProducerConfig.html#SECURITY_PROVIDERS_CONFIG">SECURITY_PROVIDERS_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"security.providers"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.clients.producer.ProducerConfig.SEND_BUFFER_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/clients/producer/ProducerConfig.html#SEND_BUFFER_CONFIG">SEND_BUFFER_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"send.buffer.bytes"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.clients.producer.ProducerConfig.SOCKET_CONNECTION_SETUP_TIMEOUT_MAX_MS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/clients/producer/ProducerConfig.html#SOCKET_CONNECTION_SETUP_TIMEOUT_MAX_MS_CONFIG">SOCKET_CONNECTION_SETUP_TIMEOUT_MAX_MS_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"socket.connection.setup.timeout.max.ms"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.clients.producer.ProducerConfig.SOCKET_CONNECTION_SETUP_TIMEOUT_MS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/clients/producer/ProducerConfig.html#SOCKET_CONNECTION_SETUP_TIMEOUT_MS_CONFIG">SOCKET_CONNECTION_SETUP_TIMEOUT_MS_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"socket.connection.setup.timeout.ms"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.clients.producer.ProducerConfig.TRANSACTION_TIMEOUT_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/clients/producer/ProducerConfig.html#TRANSACTION_TIMEOUT_CONFIG">TRANSACTION_TIMEOUT_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"transaction.timeout.ms"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.clients.producer.ProducerConfig.TRANSACTION_TIMEOUT_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/clients/producer/ProducerConfig.html#TRANSACTION_TIMEOUT_DOC">TRANSACTION_TIMEOUT_DOC</a></code></div>
<div class="col-last even-row-color"><code>"The maximum amount of time in ms that the transaction coordinator will wait for a transaction status update from the producer before proactively aborting the ongoing transaction.If this value is larger than the transaction.max.timeout.ms setting in the broker, the request will fail with a &lt;code&gt;InvalidTxnTimeoutException&lt;/code&gt; error."</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.clients.producer.ProducerConfig.TRANSACTIONAL_ID_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/clients/producer/ProducerConfig.html#TRANSACTIONAL_ID_CONFIG">TRANSACTIONAL_ID_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"transactional.id"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.clients.producer.ProducerConfig.TRANSACTIONAL_ID_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/clients/producer/ProducerConfig.html#TRANSACTIONAL_ID_DOC">TRANSACTIONAL_ID_DOC</a></code></div>
<div class="col-last even-row-color"><code>"The TransactionalId to use for transactional delivery. This enables reliability semantics which span multiple producer sessions since it allows the client to guarantee that transactions using the same TransactionalId have been completed prior to starting any new transactions. If no TransactionalId is provided, then the producer is limited to idempotent delivery. If a TransactionalId is configured, &lt;code&gt;enable.idempotence&lt;/code&gt; is implied. By default the TransactionId is not configured, which means transactions cannot be used. Note that, by default, transactions require a cluster of at least three brokers which is the recommended setting for production; for development you can change this, by adjusting broker setting &lt;code&gt;transaction.state.log.replication.factor&lt;/code&gt;."</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.clients.producer.ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/clients/producer/ProducerConfig.html#VALUE_SERIALIZER_CLASS_CONFIG">VALUE_SERIALIZER_CLASS_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"value.serializer"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.clients.producer.ProducerConfig.VALUE_SERIALIZER_CLASS_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/clients/producer/ProducerConfig.html#VALUE_SERIALIZER_CLASS_DOC">VALUE_SERIALIZER_CLASS_DOC</a></code></div>
<div class="col-last even-row-color"><code>"Serializer class for value that implements the &lt;code&gt;org.apache.kafka.common.serialization.Serializer&lt;/code&gt; interface."</code></div>
</div>
</li>
<li>
<div class="caption"><span>org.apache.kafka.clients.producer.<a href="org/apache/kafka/clients/producer/RecordMetadata.html" title="class in org.apache.kafka.clients.producer">RecordMetadata</a></span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Constant Field</div>
<div class="table-header col-last">Value</div>
<div class="col-first even-row-color"><code id="org.apache.kafka.clients.producer.RecordMetadata.UNKNOWN_PARTITION">public&nbsp;static&nbsp;final&nbsp;int</code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/clients/producer/RecordMetadata.html#UNKNOWN_PARTITION">UNKNOWN_PARTITION</a></code></div>
<div class="col-last even-row-color"><code>-1</code></div>
</div>
</li>
</ul>
<ul class="block-list">
<li>
<div class="caption"><span>org.apache.kafka.common.config.<a href="org/apache/kafka/common/config/AbstractConfig.html" title="class in org.apache.kafka.common.config">AbstractConfig</a></span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Constant Field</div>
<div class="table-header col-last">Value</div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.AbstractConfig.CONFIG_PROVIDERS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/AbstractConfig.html#CONFIG_PROVIDERS_CONFIG">CONFIG_PROVIDERS_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"config.providers"</code></div>
</div>
</li>
<li>
<div class="caption"><span>org.apache.kafka.common.config.<a href="org/apache/kafka/common/config/LogLevelConfig.html" title="class in org.apache.kafka.common.config">LogLevelConfig</a></span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Constant Field</div>
<div class="table-header col-last">Value</div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.LogLevelConfig.DEBUG_LOG_LEVEL">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/LogLevelConfig.html#DEBUG_LOG_LEVEL">DEBUG_LOG_LEVEL</a></code></div>
<div class="col-last even-row-color"><code>"DEBUG"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.LogLevelConfig.ERROR_LOG_LEVEL">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/LogLevelConfig.html#ERROR_LOG_LEVEL">ERROR_LOG_LEVEL</a></code></div>
<div class="col-last odd-row-color"><code>"ERROR"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.LogLevelConfig.FATAL_LOG_LEVEL">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/LogLevelConfig.html#FATAL_LOG_LEVEL">FATAL_LOG_LEVEL</a></code></div>
<div class="col-last even-row-color"><code>"FATAL"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.LogLevelConfig.INFO_LOG_LEVEL">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/LogLevelConfig.html#INFO_LOG_LEVEL">INFO_LOG_LEVEL</a></code></div>
<div class="col-last odd-row-color"><code>"INFO"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.LogLevelConfig.TRACE_LOG_LEVEL">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/LogLevelConfig.html#TRACE_LOG_LEVEL">TRACE_LOG_LEVEL</a></code></div>
<div class="col-last even-row-color"><code>"TRACE"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.LogLevelConfig.WARN_LOG_LEVEL">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/LogLevelConfig.html#WARN_LOG_LEVEL">WARN_LOG_LEVEL</a></code></div>
<div class="col-last odd-row-color"><code>"WARN"</code></div>
</div>
</li>
<li>
<div class="caption"><span>org.apache.kafka.common.config.<a href="org/apache/kafka/common/config/SaslConfigs.html" title="class in org.apache.kafka.common.config">SaslConfigs</a></span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Constant Field</div>
<div class="table-header col-last">Value</div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.SaslConfigs.DEFAULT_KERBEROS_KINIT_CMD">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/SaslConfigs.html#DEFAULT_KERBEROS_KINIT_CMD">DEFAULT_KERBEROS_KINIT_CMD</a></code></div>
<div class="col-last even-row-color"><code>"/usr/bin/kinit"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.SaslConfigs.DEFAULT_KERBEROS_MIN_TIME_BEFORE_RELOGIN">public&nbsp;static&nbsp;final&nbsp;long</code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/SaslConfigs.html#DEFAULT_KERBEROS_MIN_TIME_BEFORE_RELOGIN">DEFAULT_KERBEROS_MIN_TIME_BEFORE_RELOGIN</a></code></div>
<div class="col-last odd-row-color"><code>60000L</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.SaslConfigs.DEFAULT_KERBEROS_TICKET_RENEW_JITTER">public&nbsp;static&nbsp;final&nbsp;double</code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/SaslConfigs.html#DEFAULT_KERBEROS_TICKET_RENEW_JITTER">DEFAULT_KERBEROS_TICKET_RENEW_JITTER</a></code></div>
<div class="col-last even-row-color"><code>0.05</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.SaslConfigs.DEFAULT_KERBEROS_TICKET_RENEW_WINDOW_FACTOR">public&nbsp;static&nbsp;final&nbsp;double</code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/SaslConfigs.html#DEFAULT_KERBEROS_TICKET_RENEW_WINDOW_FACTOR">DEFAULT_KERBEROS_TICKET_RENEW_WINDOW_FACTOR</a></code></div>
<div class="col-last odd-row-color"><code>0.8</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.SaslConfigs.DEFAULT_LOGIN_REFRESH_BUFFER_SECONDS">public&nbsp;static&nbsp;final&nbsp;short</code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/SaslConfigs.html#DEFAULT_LOGIN_REFRESH_BUFFER_SECONDS">DEFAULT_LOGIN_REFRESH_BUFFER_SECONDS</a></code></div>
<div class="col-last even-row-color"><code>300</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.SaslConfigs.DEFAULT_LOGIN_REFRESH_MIN_PERIOD_SECONDS">public&nbsp;static&nbsp;final&nbsp;short</code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/SaslConfigs.html#DEFAULT_LOGIN_REFRESH_MIN_PERIOD_SECONDS">DEFAULT_LOGIN_REFRESH_MIN_PERIOD_SECONDS</a></code></div>
<div class="col-last odd-row-color"><code>60</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.SaslConfigs.DEFAULT_LOGIN_REFRESH_WINDOW_FACTOR">public&nbsp;static&nbsp;final&nbsp;double</code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/SaslConfigs.html#DEFAULT_LOGIN_REFRESH_WINDOW_FACTOR">DEFAULT_LOGIN_REFRESH_WINDOW_FACTOR</a></code></div>
<div class="col-last even-row-color"><code>0.8</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.SaslConfigs.DEFAULT_LOGIN_REFRESH_WINDOW_JITTER">public&nbsp;static&nbsp;final&nbsp;double</code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/SaslConfigs.html#DEFAULT_LOGIN_REFRESH_WINDOW_JITTER">DEFAULT_LOGIN_REFRESH_WINDOW_JITTER</a></code></div>
<div class="col-last odd-row-color"><code>0.05</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.SaslConfigs.DEFAULT_SASL_LOGIN_RETRY_BACKOFF_MAX_MS">public&nbsp;static&nbsp;final&nbsp;long</code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/SaslConfigs.html#DEFAULT_SASL_LOGIN_RETRY_BACKOFF_MAX_MS">DEFAULT_SASL_LOGIN_RETRY_BACKOFF_MAX_MS</a></code></div>
<div class="col-last even-row-color"><code>10000L</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.SaslConfigs.DEFAULT_SASL_LOGIN_RETRY_BACKOFF_MS">public&nbsp;static&nbsp;final&nbsp;long</code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/SaslConfigs.html#DEFAULT_SASL_LOGIN_RETRY_BACKOFF_MS">DEFAULT_SASL_LOGIN_RETRY_BACKOFF_MS</a></code></div>
<div class="col-last odd-row-color"><code>100L</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.SaslConfigs.DEFAULT_SASL_MECHANISM">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/SaslConfigs.html#DEFAULT_SASL_MECHANISM">DEFAULT_SASL_MECHANISM</a></code></div>
<div class="col-last even-row-color"><code>"GSSAPI"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.SaslConfigs.DEFAULT_SASL_OAUTHBEARER_CLOCK_SKEW_SECONDS">public&nbsp;static&nbsp;final&nbsp;int</code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/SaslConfigs.html#DEFAULT_SASL_OAUTHBEARER_CLOCK_SKEW_SECONDS">DEFAULT_SASL_OAUTHBEARER_CLOCK_SKEW_SECONDS</a></code></div>
<div class="col-last odd-row-color"><code>30</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.SaslConfigs.DEFAULT_SASL_OAUTHBEARER_JWKS_ENDPOINT_REFRESH_MS">public&nbsp;static&nbsp;final&nbsp;long</code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/SaslConfigs.html#DEFAULT_SASL_OAUTHBEARER_JWKS_ENDPOINT_REFRESH_MS">DEFAULT_SASL_OAUTHBEARER_JWKS_ENDPOINT_REFRESH_MS</a></code></div>
<div class="col-last even-row-color"><code>3600000L</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.SaslConfigs.DEFAULT_SASL_OAUTHBEARER_JWKS_ENDPOINT_RETRY_BACKOFF_MAX_MS">public&nbsp;static&nbsp;final&nbsp;long</code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/SaslConfigs.html#DEFAULT_SASL_OAUTHBEARER_JWKS_ENDPOINT_RETRY_BACKOFF_MAX_MS">DEFAULT_SASL_OAUTHBEARER_JWKS_ENDPOINT_RETRY_BACKOFF_MAX_MS</a></code></div>
<div class="col-last odd-row-color"><code>10000L</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.SaslConfigs.DEFAULT_SASL_OAUTHBEARER_JWKS_ENDPOINT_RETRY_BACKOFF_MS">public&nbsp;static&nbsp;final&nbsp;long</code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/SaslConfigs.html#DEFAULT_SASL_OAUTHBEARER_JWKS_ENDPOINT_RETRY_BACKOFF_MS">DEFAULT_SASL_OAUTHBEARER_JWKS_ENDPOINT_RETRY_BACKOFF_MS</a></code></div>
<div class="col-last even-row-color"><code>100L</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.SaslConfigs.DEFAULT_SASL_OAUTHBEARER_SCOPE_CLAIM_NAME">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/SaslConfigs.html#DEFAULT_SASL_OAUTHBEARER_SCOPE_CLAIM_NAME">DEFAULT_SASL_OAUTHBEARER_SCOPE_CLAIM_NAME</a></code></div>
<div class="col-last odd-row-color"><code>"scope"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.SaslConfigs.DEFAULT_SASL_OAUTHBEARER_SUB_CLAIM_NAME">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/SaslConfigs.html#DEFAULT_SASL_OAUTHBEARER_SUB_CLAIM_NAME">DEFAULT_SASL_OAUTHBEARER_SUB_CLAIM_NAME</a></code></div>
<div class="col-last even-row-color"><code>"sub"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.SaslConfigs.GSSAPI_MECHANISM">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/SaslConfigs.html#GSSAPI_MECHANISM">GSSAPI_MECHANISM</a></code></div>
<div class="col-last odd-row-color"><code>"GSSAPI"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.SaslConfigs.SASL_CLIENT_CALLBACK_HANDLER_CLASS">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/SaslConfigs.html#SASL_CLIENT_CALLBACK_HANDLER_CLASS">SASL_CLIENT_CALLBACK_HANDLER_CLASS</a></code></div>
<div class="col-last even-row-color"><code>"sasl.client.callback.handler.class"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.SaslConfigs.SASL_CLIENT_CALLBACK_HANDLER_CLASS_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/SaslConfigs.html#SASL_CLIENT_CALLBACK_HANDLER_CLASS_DOC">SASL_CLIENT_CALLBACK_HANDLER_CLASS_DOC</a></code></div>
<div class="col-last odd-row-color"><code>"The fully qualified name of a SASL client callback handler class that implements the AuthenticateCallbackHandler interface."</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.SaslConfigs.SASL_JAAS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/SaslConfigs.html#SASL_JAAS_CONFIG">SASL_JAAS_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"sasl.jaas.config"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.SaslConfigs.SASL_JAAS_CONFIG_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/SaslConfigs.html#SASL_JAAS_CONFIG_DOC">SASL_JAAS_CONFIG_DOC</a></code></div>
<div class="col-last odd-row-color"><code>"JAAS login context parameters for SASL connections in the format used by JAAS configuration files. JAAS configuration file format is described &lt;a href=\"http://docs.oracle.com/javase/8/docs/technotes/guides/security/jgss/tutorials/LoginConfigFile.html\"&gt;here&lt;/a&gt;. The format for the value is: &lt;code&gt;loginModuleClass controlFlag (optionName=optionValue)*;&lt;/code&gt;. For brokers, the config must be prefixed with listener prefix and SASL mechanism name in lower-case. For example, listener.name.sasl_ssl.scram-sha-256.sasl.jaas.config=com.example.ScramLoginModule required;"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.SaslConfigs.SASL_KERBEROS_KINIT_CMD">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/SaslConfigs.html#SASL_KERBEROS_KINIT_CMD">SASL_KERBEROS_KINIT_CMD</a></code></div>
<div class="col-last even-row-color"><code>"sasl.kerberos.kinit.cmd"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.SaslConfigs.SASL_KERBEROS_KINIT_CMD_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/SaslConfigs.html#SASL_KERBEROS_KINIT_CMD_DOC">SASL_KERBEROS_KINIT_CMD_DOC</a></code></div>
<div class="col-last odd-row-color"><code>"Kerberos kinit command path."</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.SaslConfigs.SASL_KERBEROS_MIN_TIME_BEFORE_RELOGIN">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/SaslConfigs.html#SASL_KERBEROS_MIN_TIME_BEFORE_RELOGIN">SASL_KERBEROS_MIN_TIME_BEFORE_RELOGIN</a></code></div>
<div class="col-last even-row-color"><code>"sasl.kerberos.min.time.before.relogin"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.SaslConfigs.SASL_KERBEROS_MIN_TIME_BEFORE_RELOGIN_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/SaslConfigs.html#SASL_KERBEROS_MIN_TIME_BEFORE_RELOGIN_DOC">SASL_KERBEROS_MIN_TIME_BEFORE_RELOGIN_DOC</a></code></div>
<div class="col-last odd-row-color"><code>"Login thread sleep time between refresh attempts."</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.SaslConfigs.SASL_KERBEROS_SERVICE_NAME">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/SaslConfigs.html#SASL_KERBEROS_SERVICE_NAME">SASL_KERBEROS_SERVICE_NAME</a></code></div>
<div class="col-last even-row-color"><code>"sasl.kerberos.service.name"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.SaslConfigs.SASL_KERBEROS_SERVICE_NAME_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/SaslConfigs.html#SASL_KERBEROS_SERVICE_NAME_DOC">SASL_KERBEROS_SERVICE_NAME_DOC</a></code></div>
<div class="col-last odd-row-color"><code>"The Kerberos principal name that Kafka runs as. This can be defined either in Kafka\'s JAAS config or in Kafka\'s config."</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.SaslConfigs.SASL_KERBEROS_TICKET_RENEW_JITTER">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/SaslConfigs.html#SASL_KERBEROS_TICKET_RENEW_JITTER">SASL_KERBEROS_TICKET_RENEW_JITTER</a></code></div>
<div class="col-last even-row-color"><code>"sasl.kerberos.ticket.renew.jitter"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.SaslConfigs.SASL_KERBEROS_TICKET_RENEW_JITTER_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/SaslConfigs.html#SASL_KERBEROS_TICKET_RENEW_JITTER_DOC">SASL_KERBEROS_TICKET_RENEW_JITTER_DOC</a></code></div>
<div class="col-last odd-row-color"><code>"Percentage of random jitter added to the renewal time."</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.SaslConfigs.SASL_KERBEROS_TICKET_RENEW_WINDOW_FACTOR">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/SaslConfigs.html#SASL_KERBEROS_TICKET_RENEW_WINDOW_FACTOR">SASL_KERBEROS_TICKET_RENEW_WINDOW_FACTOR</a></code></div>
<div class="col-last even-row-color"><code>"sasl.kerberos.ticket.renew.window.factor"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.SaslConfigs.SASL_KERBEROS_TICKET_RENEW_WINDOW_FACTOR_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/SaslConfigs.html#SASL_KERBEROS_TICKET_RENEW_WINDOW_FACTOR_DOC">SASL_KERBEROS_TICKET_RENEW_WINDOW_FACTOR_DOC</a></code></div>
<div class="col-last odd-row-color"><code>"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."</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.SaslConfigs.SASL_LOGIN_CALLBACK_HANDLER_CLASS">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/SaslConfigs.html#SASL_LOGIN_CALLBACK_HANDLER_CLASS">SASL_LOGIN_CALLBACK_HANDLER_CLASS</a></code></div>
<div class="col-last even-row-color"><code>"sasl.login.callback.handler.class"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.SaslConfigs.SASL_LOGIN_CALLBACK_HANDLER_CLASS_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/SaslConfigs.html#SASL_LOGIN_CALLBACK_HANDLER_CLASS_DOC">SASL_LOGIN_CALLBACK_HANDLER_CLASS_DOC</a></code></div>
<div class="col-last odd-row-color"><code>"The fully qualified name of a SASL login callback handler class that implements the AuthenticateCallbackHandler interface. For brokers, login callback handler config must be prefixed with listener prefix and SASL mechanism name in lower-case. For example, listener.name.sasl_ssl.scram-sha-256.sasl.login.callback.handler.class=com.example.CustomScramLoginCallbackHandler"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.SaslConfigs.SASL_LOGIN_CLASS">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/SaslConfigs.html#SASL_LOGIN_CLASS">SASL_LOGIN_CLASS</a></code></div>
<div class="col-last even-row-color"><code>"sasl.login.class"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.SaslConfigs.SASL_LOGIN_CLASS_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/SaslConfigs.html#SASL_LOGIN_CLASS_DOC">SASL_LOGIN_CLASS_DOC</a></code></div>
<div class="col-last odd-row-color"><code>"The fully qualified name of a class that implements the Login interface. For brokers, login config must be prefixed with listener prefix and SASL mechanism name in lower-case. For example, listener.name.sasl_ssl.scram-sha-256.sasl.login.class=com.example.CustomScramLogin"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.SaslConfigs.SASL_LOGIN_CONNECT_TIMEOUT_MS">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/SaslConfigs.html#SASL_LOGIN_CONNECT_TIMEOUT_MS">SASL_LOGIN_CONNECT_TIMEOUT_MS</a></code></div>
<div class="col-last even-row-color"><code>"sasl.login.connect.timeout.ms"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.SaslConfigs.SASL_LOGIN_CONNECT_TIMEOUT_MS_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/SaslConfigs.html#SASL_LOGIN_CONNECT_TIMEOUT_MS_DOC">SASL_LOGIN_CONNECT_TIMEOUT_MS_DOC</a></code></div>
<div class="col-last odd-row-color"><code>"The (optional) value in milliseconds for the external authentication provider connection timeout. Currently applies only to OAUTHBEARER."</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.SaslConfigs.SASL_LOGIN_READ_TIMEOUT_MS">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/SaslConfigs.html#SASL_LOGIN_READ_TIMEOUT_MS">SASL_LOGIN_READ_TIMEOUT_MS</a></code></div>
<div class="col-last even-row-color"><code>"sasl.login.read.timeout.ms"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.SaslConfigs.SASL_LOGIN_READ_TIMEOUT_MS_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/SaslConfigs.html#SASL_LOGIN_READ_TIMEOUT_MS_DOC">SASL_LOGIN_READ_TIMEOUT_MS_DOC</a></code></div>
<div class="col-last odd-row-color"><code>"The (optional) value in milliseconds for the external authentication provider read timeout. Currently applies only to OAUTHBEARER."</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.SaslConfigs.SASL_LOGIN_REFRESH_BUFFER_SECONDS">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/SaslConfigs.html#SASL_LOGIN_REFRESH_BUFFER_SECONDS">SASL_LOGIN_REFRESH_BUFFER_SECONDS</a></code></div>
<div class="col-last even-row-color"><code>"sasl.login.refresh.buffer.seconds"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.SaslConfigs.SASL_LOGIN_REFRESH_BUFFER_SECONDS_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/SaslConfigs.html#SASL_LOGIN_REFRESH_BUFFER_SECONDS_DOC">SASL_LOGIN_REFRESH_BUFFER_SECONDS_DOC</a></code></div>
<div class="col-last odd-row-color"><code>"The amount of buffer time before credential expiration to maintain when refreshing a credential, in seconds. If a refresh would otherwise occur closer to expiration than the number of buffer seconds then the refresh will be moved up to maintain as much of the buffer time as possible. Legal values are between 0 and 3600 (1 hour); a default value of  300 (5 minutes) is used if no value is specified. This value and sasl.login.refresh.min.period.seconds are both ignored if their sum exceeds the remaining lifetime of a credential. Currently applies only to OAUTHBEARER."</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.SaslConfigs.SASL_LOGIN_REFRESH_MIN_PERIOD_SECONDS">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/SaslConfigs.html#SASL_LOGIN_REFRESH_MIN_PERIOD_SECONDS">SASL_LOGIN_REFRESH_MIN_PERIOD_SECONDS</a></code></div>
<div class="col-last even-row-color"><code>"sasl.login.refresh.min.period.seconds"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.SaslConfigs.SASL_LOGIN_REFRESH_MIN_PERIOD_SECONDS_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/SaslConfigs.html#SASL_LOGIN_REFRESH_MIN_PERIOD_SECONDS_DOC">SASL_LOGIN_REFRESH_MIN_PERIOD_SECONDS_DOC</a></code></div>
<div class="col-last odd-row-color"><code>"The desired minimum time for the login refresh thread to wait before refreshing a credential, in seconds. Legal values are between 0 and 900 (15 minutes); a default value of 60 (1 minute) is used if no value is specified.  This value and  sasl.login.refresh.buffer.seconds are both ignored if their sum exceeds the remaining lifetime of a credential. Currently applies only to OAUTHBEARER."</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.SaslConfigs.SASL_LOGIN_REFRESH_WINDOW_FACTOR">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/SaslConfigs.html#SASL_LOGIN_REFRESH_WINDOW_FACTOR">SASL_LOGIN_REFRESH_WINDOW_FACTOR</a></code></div>
<div class="col-last even-row-color"><code>"sasl.login.refresh.window.factor"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.SaslConfigs.SASL_LOGIN_REFRESH_WINDOW_FACTOR_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/SaslConfigs.html#SASL_LOGIN_REFRESH_WINDOW_FACTOR_DOC">SASL_LOGIN_REFRESH_WINDOW_FACTOR_DOC</a></code></div>
<div class="col-last odd-row-color"><code>"Login refresh thread will sleep until the specified window factor relative to the credential\'s lifetime has been reached, at which time it will try to refresh the credential. Legal values are between 0.5 (50%) and 1.0 (100%) inclusive; a default value of 0.8 (80%) is used if no value is specified. Currently applies only to OAUTHBEARER."</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.SaslConfigs.SASL_LOGIN_REFRESH_WINDOW_JITTER">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/SaslConfigs.html#SASL_LOGIN_REFRESH_WINDOW_JITTER">SASL_LOGIN_REFRESH_WINDOW_JITTER</a></code></div>
<div class="col-last even-row-color"><code>"sasl.login.refresh.window.jitter"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.SaslConfigs.SASL_LOGIN_REFRESH_WINDOW_JITTER_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/SaslConfigs.html#SASL_LOGIN_REFRESH_WINDOW_JITTER_DOC">SASL_LOGIN_REFRESH_WINDOW_JITTER_DOC</a></code></div>
<div class="col-last odd-row-color"><code>"The maximum amount of random jitter relative to the credential\'s lifetime that is added to the login refresh thread\'s sleep time. Legal values are between 0 and 0.25 (25%) inclusive; a default value of 0.05 (5%) is used if no value is specified. Currently applies only to OAUTHBEARER."</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.SaslConfigs.SASL_LOGIN_RETRY_BACKOFF_MAX_MS">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/SaslConfigs.html#SASL_LOGIN_RETRY_BACKOFF_MAX_MS">SASL_LOGIN_RETRY_BACKOFF_MAX_MS</a></code></div>
<div class="col-last even-row-color"><code>"sasl.login.retry.backoff.max.ms"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.SaslConfigs.SASL_LOGIN_RETRY_BACKOFF_MAX_MS_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/SaslConfigs.html#SASL_LOGIN_RETRY_BACKOFF_MAX_MS_DOC">SASL_LOGIN_RETRY_BACKOFF_MAX_MS_DOC</a></code></div>
<div class="col-last odd-row-color"><code>"The (optional) value in milliseconds for the maximum wait between login attempts to the external authentication provider. Login uses an exponential backoff algorithm with an initial wait based on the sasl.login.retry.backoff.ms setting and will double in wait length between attempts up to a maximum wait length specified by the sasl.login.retry.backoff.max.ms setting. Currently applies only to OAUTHBEARER."</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.SaslConfigs.SASL_LOGIN_RETRY_BACKOFF_MS">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/SaslConfigs.html#SASL_LOGIN_RETRY_BACKOFF_MS">SASL_LOGIN_RETRY_BACKOFF_MS</a></code></div>
<div class="col-last even-row-color"><code>"sasl.login.retry.backoff.ms"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.SaslConfigs.SASL_LOGIN_RETRY_BACKOFF_MS_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/SaslConfigs.html#SASL_LOGIN_RETRY_BACKOFF_MS_DOC">SASL_LOGIN_RETRY_BACKOFF_MS_DOC</a></code></div>
<div class="col-last odd-row-color"><code>"The (optional) value in milliseconds for the initial wait between login attempts to the external authentication provider. Login uses an exponential backoff algorithm with an initial wait based on the sasl.login.retry.backoff.ms setting and will double in wait length between attempts up to a maximum wait length specified by the sasl.login.retry.backoff.max.ms setting. Currently applies only to OAUTHBEARER."</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.SaslConfigs.SASL_MECHANISM">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/SaslConfigs.html#SASL_MECHANISM">SASL_MECHANISM</a></code></div>
<div class="col-last even-row-color"><code>"sasl.mechanism"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.SaslConfigs.SASL_MECHANISM_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/SaslConfigs.html#SASL_MECHANISM_DOC">SASL_MECHANISM_DOC</a></code></div>
<div class="col-last odd-row-color"><code>"SASL mechanism used for client connections. This may be any mechanism for which a security provider is available. GSSAPI is the default mechanism."</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.SaslConfigs.SASL_OAUTHBEARER_CLOCK_SKEW_SECONDS">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/SaslConfigs.html#SASL_OAUTHBEARER_CLOCK_SKEW_SECONDS">SASL_OAUTHBEARER_CLOCK_SKEW_SECONDS</a></code></div>
<div class="col-last even-row-color"><code>"sasl.oauthbearer.clock.skew.seconds"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.SaslConfigs.SASL_OAUTHBEARER_CLOCK_SKEW_SECONDS_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/SaslConfigs.html#SASL_OAUTHBEARER_CLOCK_SKEW_SECONDS_DOC">SASL_OAUTHBEARER_CLOCK_SKEW_SECONDS_DOC</a></code></div>
<div class="col-last odd-row-color"><code>"The (optional) value in seconds to allow for differences between the time of the OAuth/OIDC identity provider and the broker."</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.SaslConfigs.SASL_OAUTHBEARER_EXPECTED_AUDIENCE">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/SaslConfigs.html#SASL_OAUTHBEARER_EXPECTED_AUDIENCE">SASL_OAUTHBEARER_EXPECTED_AUDIENCE</a></code></div>
<div class="col-last even-row-color"><code>"sasl.oauthbearer.expected.audience"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.SaslConfigs.SASL_OAUTHBEARER_EXPECTED_AUDIENCE_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/SaslConfigs.html#SASL_OAUTHBEARER_EXPECTED_AUDIENCE_DOC">SASL_OAUTHBEARER_EXPECTED_AUDIENCE_DOC</a></code></div>
<div class="col-last odd-row-color"><code>"The (optional) comma-delimited setting for the broker to use to verify that the JWT was issued for one of the expected audiences. The JWT will be inspected for the standard OAuth \"aud\" claim and if this value is set, the broker will match the value from JWT\'s \"aud\" claim  to see if there is an exact match. If there is no match, the broker will reject the JWT and authentication will fail."</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.SaslConfigs.SASL_OAUTHBEARER_EXPECTED_ISSUER">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/SaslConfigs.html#SASL_OAUTHBEARER_EXPECTED_ISSUER">SASL_OAUTHBEARER_EXPECTED_ISSUER</a></code></div>
<div class="col-last even-row-color"><code>"sasl.oauthbearer.expected.issuer"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.SaslConfigs.SASL_OAUTHBEARER_EXPECTED_ISSUER_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/SaslConfigs.html#SASL_OAUTHBEARER_EXPECTED_ISSUER_DOC">SASL_OAUTHBEARER_EXPECTED_ISSUER_DOC</a></code></div>
<div class="col-last odd-row-color"><code>"The (optional) setting for the broker to use to verify that the JWT was created by the expected issuer. The JWT will be inspected for the standard OAuth \"iss\" claim and if this value is set, the broker will match it exactly against what is in the JWT\'s \"iss\" claim. If there is no match, the broker will reject the JWT and authentication will fail."</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.SaslConfigs.SASL_OAUTHBEARER_JWKS_ENDPOINT_REFRESH_MS">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/SaslConfigs.html#SASL_OAUTHBEARER_JWKS_ENDPOINT_REFRESH_MS">SASL_OAUTHBEARER_JWKS_ENDPOINT_REFRESH_MS</a></code></div>
<div class="col-last even-row-color"><code>"sasl.oauthbearer.jwks.endpoint.refresh.ms"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.SaslConfigs.SASL_OAUTHBEARER_JWKS_ENDPOINT_REFRESH_MS_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/SaslConfigs.html#SASL_OAUTHBEARER_JWKS_ENDPOINT_REFRESH_MS_DOC">SASL_OAUTHBEARER_JWKS_ENDPOINT_REFRESH_MS_DOC</a></code></div>
<div class="col-last odd-row-color"><code>"The (optional) value in milliseconds for the broker to wait between refreshing its JWKS (JSON Web Key Set) cache that contains the keys to verify the signature of the JWT."</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.SaslConfigs.SASL_OAUTHBEARER_JWKS_ENDPOINT_RETRY_BACKOFF_MAX_MS">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/SaslConfigs.html#SASL_OAUTHBEARER_JWKS_ENDPOINT_RETRY_BACKOFF_MAX_MS">SASL_OAUTHBEARER_JWKS_ENDPOINT_RETRY_BACKOFF_MAX_MS</a></code></div>
<div class="col-last even-row-color"><code>"sasl.oauthbearer.jwks.endpoint.retry.backoff.max.ms"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.SaslConfigs.SASL_OAUTHBEARER_JWKS_ENDPOINT_RETRY_BACKOFF_MAX_MS_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/SaslConfigs.html#SASL_OAUTHBEARER_JWKS_ENDPOINT_RETRY_BACKOFF_MAX_MS_DOC">SASL_OAUTHBEARER_JWKS_ENDPOINT_RETRY_BACKOFF_MAX_MS_DOC</a></code></div>
<div class="col-last odd-row-color"><code>"The (optional) value in milliseconds for the maximum wait between attempts to retrieve the JWKS (JSON Web Key Set) from the external authentication provider. JWKS retrieval uses an exponential backoff algorithm with an initial wait based on the sasl.oauthbearer.jwks.endpoint.retry.backoff.ms setting and will double in wait length between attempts up to a maximum wait length specified by the sasl.oauthbearer.jwks.endpoint.retry.backoff.max.ms setting."</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.SaslConfigs.SASL_OAUTHBEARER_JWKS_ENDPOINT_RETRY_BACKOFF_MS">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/SaslConfigs.html#SASL_OAUTHBEARER_JWKS_ENDPOINT_RETRY_BACKOFF_MS">SASL_OAUTHBEARER_JWKS_ENDPOINT_RETRY_BACKOFF_MS</a></code></div>
<div class="col-last even-row-color"><code>"sasl.oauthbearer.jwks.endpoint.retry.backoff.ms"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.SaslConfigs.SASL_OAUTHBEARER_JWKS_ENDPOINT_RETRY_BACKOFF_MS_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/SaslConfigs.html#SASL_OAUTHBEARER_JWKS_ENDPOINT_RETRY_BACKOFF_MS_DOC">SASL_OAUTHBEARER_JWKS_ENDPOINT_RETRY_BACKOFF_MS_DOC</a></code></div>
<div class="col-last odd-row-color"><code>"The (optional) value in milliseconds for the initial wait between JWKS (JSON Web Key Set) retrieval attempts from the external authentication provider. JWKS retrieval uses an exponential backoff algorithm with an initial wait based on the sasl.oauthbearer.jwks.endpoint.retry.backoff.ms setting and will double in wait length between attempts up to a maximum wait length specified by the sasl.oauthbearer.jwks.endpoint.retry.backoff.max.ms setting."</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.SaslConfigs.SASL_OAUTHBEARER_JWKS_ENDPOINT_URL">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/SaslConfigs.html#SASL_OAUTHBEARER_JWKS_ENDPOINT_URL">SASL_OAUTHBEARER_JWKS_ENDPOINT_URL</a></code></div>
<div class="col-last even-row-color"><code>"sasl.oauthbearer.jwks.endpoint.url"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.SaslConfigs.SASL_OAUTHBEARER_JWKS_ENDPOINT_URL_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/SaslConfigs.html#SASL_OAUTHBEARER_JWKS_ENDPOINT_URL_DOC">SASL_OAUTHBEARER_JWKS_ENDPOINT_URL_DOC</a></code></div>
<div class="col-last odd-row-color"><code>"The OAuth/OIDC provider URL from which the provider\'s &lt;a href=\"https://datatracker.ietf.org/doc/html/rfc7517#section-5\"&gt;JWKS (JSON Web Key Set)&lt;/a&gt; can be retrieved. The URL can be HTTP(S)-based or file-based. If the URL is HTTP(S)-based, the JWKS data will be retrieved from the OAuth/OIDC provider via the configured URL on broker startup. All then-current keys will be cached on the broker for incoming requests. If an authentication request is received for a JWT that includes a \"kid\" header claim value that isn\'t yet in the cache, the JWKS endpoint will be queried again on demand. However, the broker polls the URL every sasl.oauthbearer.jwks.endpoint.refresh.ms milliseconds to refresh the cache with any forthcoming keys before any JWT requests that include them are received. If the URL is file-based, the broker will load the JWKS file from a configured location on startup. In the event that the JWT includes a \"kid\" header value that isn\'t in the JWKS file, the broker will reject the JWT and authentication will fail."</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.SaslConfigs.SASL_OAUTHBEARER_SCOPE_CLAIM_NAME">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/SaslConfigs.html#SASL_OAUTHBEARER_SCOPE_CLAIM_NAME">SASL_OAUTHBEARER_SCOPE_CLAIM_NAME</a></code></div>
<div class="col-last even-row-color"><code>"sasl.oauthbearer.scope.claim.name"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.SaslConfigs.SASL_OAUTHBEARER_SCOPE_CLAIM_NAME_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/SaslConfigs.html#SASL_OAUTHBEARER_SCOPE_CLAIM_NAME_DOC">SASL_OAUTHBEARER_SCOPE_CLAIM_NAME_DOC</a></code></div>
<div class="col-last odd-row-color"><code>"The OAuth claim for the scope is often named \"scope\", but this (optional) setting can provide a different name to use for the scope included in the JWT payload\'s claims if the OAuth/OIDC provider uses a different name for that claim."</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.SaslConfigs.SASL_OAUTHBEARER_SUB_CLAIM_NAME">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/SaslConfigs.html#SASL_OAUTHBEARER_SUB_CLAIM_NAME">SASL_OAUTHBEARER_SUB_CLAIM_NAME</a></code></div>
<div class="col-last even-row-color"><code>"sasl.oauthbearer.sub.claim.name"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.SaslConfigs.SASL_OAUTHBEARER_SUB_CLAIM_NAME_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/SaslConfigs.html#SASL_OAUTHBEARER_SUB_CLAIM_NAME_DOC">SASL_OAUTHBEARER_SUB_CLAIM_NAME_DOC</a></code></div>
<div class="col-last odd-row-color"><code>"The OAuth claim for the subject is often named \"sub\", but this (optional) setting can provide a different name to use for the subject included in the JWT payload\'s claims if the OAuth/OIDC provider uses a different name for that claim."</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.SaslConfigs.SASL_OAUTHBEARER_TOKEN_ENDPOINT_URL">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/SaslConfigs.html#SASL_OAUTHBEARER_TOKEN_ENDPOINT_URL">SASL_OAUTHBEARER_TOKEN_ENDPOINT_URL</a></code></div>
<div class="col-last even-row-color"><code>"sasl.oauthbearer.token.endpoint.url"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.SaslConfigs.SASL_OAUTHBEARER_TOKEN_ENDPOINT_URL_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/SaslConfigs.html#SASL_OAUTHBEARER_TOKEN_ENDPOINT_URL_DOC">SASL_OAUTHBEARER_TOKEN_ENDPOINT_URL_DOC</a></code></div>
<div class="col-last odd-row-color"><code>"The URL for the OAuth/OIDC identity provider. If the URL is HTTP(S)-based, it is the issuer\'s token endpoint URL to which requests will be made to login based on the configuration in sasl.jaas.config. If the URL is file-based, it specifies a file containing an access token (in JWT serialized form) issued by the OAuth/OIDC identity provider to use for authorization."</code></div>
</div>
</li>
<li>
<div class="caption"><span>org.apache.kafka.common.config.<a href="org/apache/kafka/common/config/SecurityConfig.html" title="class in org.apache.kafka.common.config">SecurityConfig</a></span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Constant Field</div>
<div class="table-header col-last">Value</div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.SecurityConfig.SECURITY_PROVIDERS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/SecurityConfig.html#SECURITY_PROVIDERS_CONFIG">SECURITY_PROVIDERS_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"security.providers"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.SecurityConfig.SECURITY_PROVIDERS_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/SecurityConfig.html#SECURITY_PROVIDERS_DOC">SECURITY_PROVIDERS_DOC</a></code></div>
<div class="col-last odd-row-color"><code>"A list of configurable creator classes each returning a provider implementing security algorithms. These classes should implement the &lt;code&gt;org.apache.kafka.common.security.auth.SecurityProviderCreator&lt;/code&gt; interface."</code></div>
</div>
</li>
<li>
<div class="caption"><span>org.apache.kafka.common.config.<a href="org/apache/kafka/common/config/SslConfigs.html" title="class in org.apache.kafka.common.config">SslConfigs</a></span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Constant Field</div>
<div class="table-header col-last">Value</div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.SslConfigs.DEFAULT_SSL_ENDPOINT_IDENTIFICATION_ALGORITHM">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/SslConfigs.html#DEFAULT_SSL_ENDPOINT_IDENTIFICATION_ALGORITHM">DEFAULT_SSL_ENDPOINT_IDENTIFICATION_ALGORITHM</a></code></div>
<div class="col-last even-row-color"><code>"https"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.SslConfigs.DEFAULT_SSL_KEYSTORE_TYPE">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/SslConfigs.html#DEFAULT_SSL_KEYSTORE_TYPE">DEFAULT_SSL_KEYSTORE_TYPE</a></code></div>
<div class="col-last odd-row-color"><code>"JKS"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.SslConfigs.DEFAULT_SSL_TRUSTSTORE_TYPE">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/SslConfigs.html#DEFAULT_SSL_TRUSTSTORE_TYPE">DEFAULT_SSL_TRUSTSTORE_TYPE</a></code></div>
<div class="col-last even-row-color"><code>"JKS"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.SslConfigs.SSL_CIPHER_SUITES_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/SslConfigs.html#SSL_CIPHER_SUITES_CONFIG">SSL_CIPHER_SUITES_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"ssl.cipher.suites"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.SslConfigs.SSL_CIPHER_SUITES_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/SslConfigs.html#SSL_CIPHER_SUITES_DOC">SSL_CIPHER_SUITES_DOC</a></code></div>
<div class="col-last even-row-color"><code>"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."</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.SslConfigs.SSL_ENABLED_PROTOCOLS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/SslConfigs.html#SSL_ENABLED_PROTOCOLS_CONFIG">SSL_ENABLED_PROTOCOLS_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"ssl.enabled.protocols"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.SslConfigs.SSL_ENABLED_PROTOCOLS_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/SslConfigs.html#SSL_ENABLED_PROTOCOLS_DOC">SSL_ENABLED_PROTOCOLS_DOC</a></code></div>
<div class="col-last even-row-color"><code>"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 `ssl.protocol`."</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.SslConfigs.SSL_ENDPOINT_IDENTIFICATION_ALGORITHM_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/SslConfigs.html#SSL_ENDPOINT_IDENTIFICATION_ALGORITHM_CONFIG">SSL_ENDPOINT_IDENTIFICATION_ALGORITHM_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"ssl.endpoint.identification.algorithm"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.SslConfigs.SSL_ENDPOINT_IDENTIFICATION_ALGORITHM_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/SslConfigs.html#SSL_ENDPOINT_IDENTIFICATION_ALGORITHM_DOC">SSL_ENDPOINT_IDENTIFICATION_ALGORITHM_DOC</a></code></div>
<div class="col-last even-row-color"><code>"The endpoint identification algorithm to validate server hostname using server certificate. "</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.SslConfigs.SSL_ENGINE_FACTORY_CLASS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/SslConfigs.html#SSL_ENGINE_FACTORY_CLASS_CONFIG">SSL_ENGINE_FACTORY_CLASS_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"ssl.engine.factory.class"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.SslConfigs.SSL_ENGINE_FACTORY_CLASS_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/SslConfigs.html#SSL_ENGINE_FACTORY_CLASS_DOC">SSL_ENGINE_FACTORY_CLASS_DOC</a></code></div>
<div class="col-last even-row-color"><code>"The class of type org.apache.kafka.common.security.auth.SslEngineFactory to provide SSLEngine objects. Default value is org.apache.kafka.common.security.ssl.DefaultSslEngineFactory"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.SslConfigs.SSL_KEY_PASSWORD_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/SslConfigs.html#SSL_KEY_PASSWORD_CONFIG">SSL_KEY_PASSWORD_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"ssl.key.password"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.SslConfigs.SSL_KEY_PASSWORD_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/SslConfigs.html#SSL_KEY_PASSWORD_DOC">SSL_KEY_PASSWORD_DOC</a></code></div>
<div class="col-last even-row-color"><code>"The password of the private key in the key store file or the PEM key specified in `ssl.keystore.key\'."</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.SslConfigs.SSL_KEYMANAGER_ALGORITHM_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/SslConfigs.html#SSL_KEYMANAGER_ALGORITHM_CONFIG">SSL_KEYMANAGER_ALGORITHM_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"ssl.keymanager.algorithm"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.SslConfigs.SSL_KEYMANAGER_ALGORITHM_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/SslConfigs.html#SSL_KEYMANAGER_ALGORITHM_DOC">SSL_KEYMANAGER_ALGORITHM_DOC</a></code></div>
<div class="col-last even-row-color"><code>"The algorithm used by key manager factory for SSL connections. Default value is the key manager factory algorithm configured for the Java Virtual Machine."</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.SslConfigs.SSL_KEYSTORE_CERTIFICATE_CHAIN_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/SslConfigs.html#SSL_KEYSTORE_CERTIFICATE_CHAIN_CONFIG">SSL_KEYSTORE_CERTIFICATE_CHAIN_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"ssl.keystore.certificate.chain"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.SslConfigs.SSL_KEYSTORE_CERTIFICATE_CHAIN_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/SslConfigs.html#SSL_KEYSTORE_CERTIFICATE_CHAIN_DOC">SSL_KEYSTORE_CERTIFICATE_CHAIN_DOC</a></code></div>
<div class="col-last even-row-color"><code>"Certificate chain in the format specified by \'ssl.keystore.type\'. Default SSL engine factory supports only PEM format with a list of X.509 certificates"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.SslConfigs.SSL_KEYSTORE_KEY_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/SslConfigs.html#SSL_KEYSTORE_KEY_CONFIG">SSL_KEYSTORE_KEY_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"ssl.keystore.key"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.SslConfigs.SSL_KEYSTORE_KEY_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/SslConfigs.html#SSL_KEYSTORE_KEY_DOC">SSL_KEYSTORE_KEY_DOC</a></code></div>
<div class="col-last even-row-color"><code>"Private key in the format specified by \'ssl.keystore.type\'. Default SSL engine factory supports only PEM format with PKCS#8 keys. If the key is encrypted, key password must be specified using \'ssl.key.password\'"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.SslConfigs.SSL_KEYSTORE_LOCATION_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/SslConfigs.html#SSL_KEYSTORE_LOCATION_CONFIG">SSL_KEYSTORE_LOCATION_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"ssl.keystore.location"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.SslConfigs.SSL_KEYSTORE_LOCATION_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/SslConfigs.html#SSL_KEYSTORE_LOCATION_DOC">SSL_KEYSTORE_LOCATION_DOC</a></code></div>
<div class="col-last even-row-color"><code>"The location of the key store file. This is optional for client and can be used for two-way authentication for client."</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.SslConfigs.SSL_KEYSTORE_PASSWORD_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/SslConfigs.html#SSL_KEYSTORE_PASSWORD_CONFIG">SSL_KEYSTORE_PASSWORD_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"ssl.keystore.password"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.SslConfigs.SSL_KEYSTORE_PASSWORD_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/SslConfigs.html#SSL_KEYSTORE_PASSWORD_DOC">SSL_KEYSTORE_PASSWORD_DOC</a></code></div>
<div class="col-last even-row-color"><code>"The store password for the key store file. This is optional for client and only needed if \'ssl.keystore.location\' is configured. Key store password is not supported for PEM format."</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.SslConfigs.SSL_KEYSTORE_TYPE_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/SslConfigs.html#SSL_KEYSTORE_TYPE_CONFIG">SSL_KEYSTORE_TYPE_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"ssl.keystore.type"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.SslConfigs.SSL_KEYSTORE_TYPE_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/SslConfigs.html#SSL_KEYSTORE_TYPE_DOC">SSL_KEYSTORE_TYPE_DOC</a></code></div>
<div class="col-last even-row-color"><code>"The file format of the key store file. This is optional for client. The values currently supported by the default `ssl.engine.factory.class` are [JKS, PKCS12, PEM]."</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.SslConfigs.SSL_PROTOCOL_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/SslConfigs.html#SSL_PROTOCOL_CONFIG">SSL_PROTOCOL_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"ssl.protocol"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.SslConfigs.SSL_PROTOCOL_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/SslConfigs.html#SSL_PROTOCOL_DOC">SSL_PROTOCOL_DOC</a></code></div>
<div class="col-last even-row-color"><code>"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 \'ssl.enabled.protocols\', 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 ssl.enabled.protocols and the server only supports \'TLSv1.3\'."</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.SslConfigs.SSL_PROVIDER_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/SslConfigs.html#SSL_PROVIDER_CONFIG">SSL_PROVIDER_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"ssl.provider"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.SslConfigs.SSL_PROVIDER_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/SslConfigs.html#SSL_PROVIDER_DOC">SSL_PROVIDER_DOC</a></code></div>
<div class="col-last even-row-color"><code>"The name of the security provider used for SSL connections. Default value is the default security provider of the JVM."</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.SslConfigs.SSL_SECURE_RANDOM_IMPLEMENTATION_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/SslConfigs.html#SSL_SECURE_RANDOM_IMPLEMENTATION_CONFIG">SSL_SECURE_RANDOM_IMPLEMENTATION_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"ssl.secure.random.implementation"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.SslConfigs.SSL_SECURE_RANDOM_IMPLEMENTATION_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/SslConfigs.html#SSL_SECURE_RANDOM_IMPLEMENTATION_DOC">SSL_SECURE_RANDOM_IMPLEMENTATION_DOC</a></code></div>
<div class="col-last even-row-color"><code>"The SecureRandom PRNG implementation to use for SSL cryptography operations. "</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.SslConfigs.SSL_TRUSTMANAGER_ALGORITHM_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/SslConfigs.html#SSL_TRUSTMANAGER_ALGORITHM_CONFIG">SSL_TRUSTMANAGER_ALGORITHM_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"ssl.trustmanager.algorithm"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.SslConfigs.SSL_TRUSTMANAGER_ALGORITHM_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/SslConfigs.html#SSL_TRUSTMANAGER_ALGORITHM_DOC">SSL_TRUSTMANAGER_ALGORITHM_DOC</a></code></div>
<div class="col-last even-row-color"><code>"The algorithm used by trust manager factory for SSL connections. Default value is the trust manager factory algorithm configured for the Java Virtual Machine."</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.SslConfigs.SSL_TRUSTSTORE_CERTIFICATES_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/SslConfigs.html#SSL_TRUSTSTORE_CERTIFICATES_CONFIG">SSL_TRUSTSTORE_CERTIFICATES_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"ssl.truststore.certificates"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.SslConfigs.SSL_TRUSTSTORE_CERTIFICATES_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/SslConfigs.html#SSL_TRUSTSTORE_CERTIFICATES_DOC">SSL_TRUSTSTORE_CERTIFICATES_DOC</a></code></div>
<div class="col-last even-row-color"><code>"Trusted certificates in the format specified by \'ssl.truststore.type\'. Default SSL engine factory supports only PEM format with X.509 certificates."</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.SslConfigs.SSL_TRUSTSTORE_LOCATION_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/SslConfigs.html#SSL_TRUSTSTORE_LOCATION_CONFIG">SSL_TRUSTSTORE_LOCATION_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"ssl.truststore.location"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.SslConfigs.SSL_TRUSTSTORE_LOCATION_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/SslConfigs.html#SSL_TRUSTSTORE_LOCATION_DOC">SSL_TRUSTSTORE_LOCATION_DOC</a></code></div>
<div class="col-last even-row-color"><code>"The location of the trust store file."</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.SslConfigs.SSL_TRUSTSTORE_PASSWORD_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/SslConfigs.html#SSL_TRUSTSTORE_PASSWORD_CONFIG">SSL_TRUSTSTORE_PASSWORD_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"ssl.truststore.password"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.SslConfigs.SSL_TRUSTSTORE_PASSWORD_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/SslConfigs.html#SSL_TRUSTSTORE_PASSWORD_DOC">SSL_TRUSTSTORE_PASSWORD_DOC</a></code></div>
<div class="col-last even-row-color"><code>"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."</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.SslConfigs.SSL_TRUSTSTORE_TYPE_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/SslConfigs.html#SSL_TRUSTSTORE_TYPE_CONFIG">SSL_TRUSTSTORE_TYPE_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"ssl.truststore.type"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.SslConfigs.SSL_TRUSTSTORE_TYPE_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/SslConfigs.html#SSL_TRUSTSTORE_TYPE_DOC">SSL_TRUSTSTORE_TYPE_DOC</a></code></div>
<div class="col-last even-row-color"><code>"The file format of the trust store file. The values currently supported by the default `ssl.engine.factory.class` are [JKS, PKCS12, PEM]."</code></div>
</div>
</li>
<li>
<div class="caption"><span>org.apache.kafka.common.config.<a href="org/apache/kafka/common/config/TopicConfig.html" title="class in org.apache.kafka.common.config">TopicConfig</a></span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Constant Field</div>
<div class="table-header col-last">Value</div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.TopicConfig.CLEANUP_POLICY_COMPACT">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/TopicConfig.html#CLEANUP_POLICY_COMPACT">CLEANUP_POLICY_COMPACT</a></code></div>
<div class="col-last even-row-color"><code>"compact"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.TopicConfig.CLEANUP_POLICY_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/TopicConfig.html#CLEANUP_POLICY_CONFIG">CLEANUP_POLICY_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"cleanup.policy"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.TopicConfig.CLEANUP_POLICY_DELETE">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/TopicConfig.html#CLEANUP_POLICY_DELETE">CLEANUP_POLICY_DELETE</a></code></div>
<div class="col-last even-row-color"><code>"delete"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.TopicConfig.CLEANUP_POLICY_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/TopicConfig.html#CLEANUP_POLICY_DOC">CLEANUP_POLICY_DOC</a></code></div>
<div class="col-last odd-row-color"><code>"This config designates the retention policy to use on log segments. The \"delete\" policy (which is the default) will discard old segments when their retention time or size limit has been reached. The \"compact\" policy will enable &lt;a href=\"#compaction\"&gt;log compaction&lt;/a&gt;, which retains the latest value for each key. It is also possible to specify both policies in a comma-separated list (e.g. \"delete,compact\"). In this case, old segments will be discarded per the retention time and size configuration, while retained segments will be compacted."</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.TopicConfig.COMPRESSION_TYPE_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/TopicConfig.html#COMPRESSION_TYPE_CONFIG">COMPRESSION_TYPE_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"compression.type"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.TopicConfig.COMPRESSION_TYPE_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/TopicConfig.html#COMPRESSION_TYPE_DOC">COMPRESSION_TYPE_DOC</a></code></div>
<div class="col-last odd-row-color"><code>"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."</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.TopicConfig.DELETE_RETENTION_MS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/TopicConfig.html#DELETE_RETENTION_MS_CONFIG">DELETE_RETENTION_MS_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"delete.retention.ms"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.TopicConfig.DELETE_RETENTION_MS_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/TopicConfig.html#DELETE_RETENTION_MS_DOC">DELETE_RETENTION_MS_DOC</a></code></div>
<div class="col-last odd-row-color"><code>"The amount of time to retain delete tombstone markers for &lt;a href=\"#compaction\"&gt;log compacted&lt;/a&gt; topics. This setting also gives a bound on the time in which a consumer must complete a read if they begin from offset 0 to ensure that they get a valid snapshot of the final stage (otherwise delete tombstones may be collected before they complete their scan)."</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.TopicConfig.FILE_DELETE_DELAY_MS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/TopicConfig.html#FILE_DELETE_DELAY_MS_CONFIG">FILE_DELETE_DELAY_MS_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"file.delete.delay.ms"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.TopicConfig.FILE_DELETE_DELAY_MS_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/TopicConfig.html#FILE_DELETE_DELAY_MS_DOC">FILE_DELETE_DELAY_MS_DOC</a></code></div>
<div class="col-last odd-row-color"><code>"The time to wait before deleting a file from the filesystem"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.TopicConfig.FLUSH_MESSAGES_INTERVAL_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/TopicConfig.html#FLUSH_MESSAGES_INTERVAL_CONFIG">FLUSH_MESSAGES_INTERVAL_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"flush.messages"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.TopicConfig.FLUSH_MESSAGES_INTERVAL_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/TopicConfig.html#FLUSH_MESSAGES_INTERVAL_DOC">FLUSH_MESSAGES_INTERVAL_DOC</a></code></div>
<div class="col-last odd-row-color"><code>"This setting allows specifying an interval at which we will force an fsync of data written to the log. For example if this was set to 1 we would fsync after every message; if it were 5 we would fsync after every five messages. In general we recommend you not set this and use replication for durability and allow the operating system\'s background flush capabilities as it is more efficient. This setting can be overridden on a per-topic basis (see &lt;a href=\"#topicconfigs\"&gt;the per-topic configuration section&lt;/a&gt;)."</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.TopicConfig.FLUSH_MS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/TopicConfig.html#FLUSH_MS_CONFIG">FLUSH_MS_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"flush.ms"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.TopicConfig.FLUSH_MS_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/TopicConfig.html#FLUSH_MS_DOC">FLUSH_MS_DOC</a></code></div>
<div class="col-last odd-row-color"><code>"This setting allows specifying a time interval at which we will force an fsync of data written to the log. For example if this was set to 1000 we would fsync after 1000 ms had passed. In general we recommend you not set this and use replication for durability and allow the operating system\'s background flush capabilities as it is more efficient."</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.TopicConfig.INDEX_INTERVAL_BYTES_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/TopicConfig.html#INDEX_INTERVAL_BYTES_CONFIG">INDEX_INTERVAL_BYTES_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"index.interval.bytes"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.TopicConfig.INDEX_INTERVAL_BYTES_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/TopicConfig.html#INDEX_INTERVAL_BYTES_DOC">INDEX_INTERVAL_BYTES_DOC</a></code></div>
<div class="col-last odd-row-color"><code>"This setting controls how frequently Kafka adds an index entry to its offset index. The default setting ensures that we index a message roughly every 4096 bytes. More indexing allows reads to jump closer to the exact position in the log but makes the index larger. You probably don\'t need to change this."</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.TopicConfig.LOCAL_LOG_RETENTION_BYTES_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/TopicConfig.html#LOCAL_LOG_RETENTION_BYTES_CONFIG">LOCAL_LOG_RETENTION_BYTES_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"local.retention.bytes"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.TopicConfig.LOCAL_LOG_RETENTION_BYTES_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/TopicConfig.html#LOCAL_LOG_RETENTION_BYTES_DOC">LOCAL_LOG_RETENTION_BYTES_DOC</a></code></div>
<div class="col-last odd-row-color"><code>"The maximum size of local log segments that can grow for a partition before it deletes the old segments. Default value is -2, it represents `retention.bytes` value to be used. The effective value should always be less than or equal to `retention.bytes` value."</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.TopicConfig.LOCAL_LOG_RETENTION_MS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/TopicConfig.html#LOCAL_LOG_RETENTION_MS_CONFIG">LOCAL_LOG_RETENTION_MS_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"local.retention.ms"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.TopicConfig.LOCAL_LOG_RETENTION_MS_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/TopicConfig.html#LOCAL_LOG_RETENTION_MS_DOC">LOCAL_LOG_RETENTION_MS_DOC</a></code></div>
<div class="col-last odd-row-color"><code>"The number of milli seconds to keep the local log segment before it gets deleted. Default value is -2, it represents `retention.ms` value is to be used. The effective value should always be less than or equal to `retention.ms` value."</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.TopicConfig.MAX_COMPACTION_LAG_MS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/TopicConfig.html#MAX_COMPACTION_LAG_MS_CONFIG">MAX_COMPACTION_LAG_MS_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"max.compaction.lag.ms"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.TopicConfig.MAX_COMPACTION_LAG_MS_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/TopicConfig.html#MAX_COMPACTION_LAG_MS_DOC">MAX_COMPACTION_LAG_MS_DOC</a></code></div>
<div class="col-last odd-row-color"><code>"The maximum time a message will remain ineligible for compaction in the log. Only applicable for logs that are being compacted."</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.TopicConfig.MAX_MESSAGE_BYTES_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/TopicConfig.html#MAX_MESSAGE_BYTES_CONFIG">MAX_MESSAGE_BYTES_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"max.message.bytes"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.TopicConfig.MAX_MESSAGE_BYTES_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/TopicConfig.html#MAX_MESSAGE_BYTES_DOC">MAX_MESSAGE_BYTES_DOC</a></code></div>
<div class="col-last odd-row-color"><code>"The largest record batch size allowed by Kafka (after compression if compression is enabled). If this is increased and there are consumers older than 0.10.2, the consumers\' fetch size must also be increased so that they can fetch record batches this large. In the latest message format version, records are always grouped into batches for efficiency. In previous message format versions, uncompressed records are not grouped into batches and this limit only applies to a single record in that case."</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.TopicConfig.MESSAGE_DOWNCONVERSION_ENABLE_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/TopicConfig.html#MESSAGE_DOWNCONVERSION_ENABLE_CONFIG">MESSAGE_DOWNCONVERSION_ENABLE_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"message.downconversion.enable"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.TopicConfig.MESSAGE_DOWNCONVERSION_ENABLE_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/TopicConfig.html#MESSAGE_DOWNCONVERSION_ENABLE_DOC">MESSAGE_DOWNCONVERSION_ENABLE_DOC</a></code></div>
<div class="col-last odd-row-color"><code>"This configuration controls whether down-conversion of message formats is enabled to satisfy consume requests. When set to &lt;code&gt;false&lt;/code&gt;, broker will not perform down-conversion for consumers expecting an older message format. The broker responds with &lt;code&gt;UNSUPPORTED_VERSION&lt;/code&gt; error for consume requests from such older clients. This configurationdoes not apply to any message format conversion that might be required for replication to followers."</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.TopicConfig.MESSAGE_FORMAT_VERSION_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/TopicConfig.html#MESSAGE_FORMAT_VERSION_CONFIG">MESSAGE_FORMAT_VERSION_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"message.format.version"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.TopicConfig.MESSAGE_FORMAT_VERSION_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/TopicConfig.html#MESSAGE_FORMAT_VERSION_DOC">MESSAGE_FORMAT_VERSION_DOC</a></code></div>
<div class="col-last odd-row-color"><code>"[DEPRECATED] Specify the message format version the broker will use to append messages to the logs. The value of this config is always assumed to be `3.0` if `inter.broker.protocol.version` is 3.0 or higher (the actual config value is ignored). Otherwise, the value should be a valid ApiVersion. Some examples are: 0.10.0, 1.1, 2.8, 3.0. By setting a particular message format version, the user is certifying that all the existing messages on disk are smaller or equal than the specified version. Setting this value incorrectly will cause consumers with older versions to break as they will receive messages with a format that they don\'t understand."</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.TopicConfig.MESSAGE_TIMESTAMP_DIFFERENCE_MAX_MS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/TopicConfig.html#MESSAGE_TIMESTAMP_DIFFERENCE_MAX_MS_CONFIG">MESSAGE_TIMESTAMP_DIFFERENCE_MAX_MS_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"message.timestamp.difference.max.ms"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.TopicConfig.MESSAGE_TIMESTAMP_DIFFERENCE_MAX_MS_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/TopicConfig.html#MESSAGE_TIMESTAMP_DIFFERENCE_MAX_MS_DOC">MESSAGE_TIMESTAMP_DIFFERENCE_MAX_MS_DOC</a></code></div>
<div class="col-last odd-row-color"><code>"The maximum difference allowed between the timestamp when a broker receives a message and the timestamp specified in the message. If message.timestamp.type=CreateTime, a message will be rejected if the difference in timestamp exceeds this threshold. This configuration is ignored if message.timestamp.type=LogAppendTime."</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.TopicConfig.MESSAGE_TIMESTAMP_TYPE_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/TopicConfig.html#MESSAGE_TIMESTAMP_TYPE_CONFIG">MESSAGE_TIMESTAMP_TYPE_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"message.timestamp.type"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.TopicConfig.MESSAGE_TIMESTAMP_TYPE_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/TopicConfig.html#MESSAGE_TIMESTAMP_TYPE_DOC">MESSAGE_TIMESTAMP_TYPE_DOC</a></code></div>
<div class="col-last odd-row-color"><code>"Define whether the timestamp in the message is message create time or log append time. The value should be either `CreateTime` or `LogAppendTime`"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.TopicConfig.MIN_CLEANABLE_DIRTY_RATIO_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/TopicConfig.html#MIN_CLEANABLE_DIRTY_RATIO_CONFIG">MIN_CLEANABLE_DIRTY_RATIO_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"min.cleanable.dirty.ratio"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.TopicConfig.MIN_CLEANABLE_DIRTY_RATIO_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/TopicConfig.html#MIN_CLEANABLE_DIRTY_RATIO_DOC">MIN_CLEANABLE_DIRTY_RATIO_DOC</a></code></div>
<div class="col-last odd-row-color"><code>"This configuration controls how frequently the log compactor will attempt to clean the log (assuming &lt;a href=\"#compaction\"&gt;log compaction&lt;/a&gt; is enabled). By default we will avoid cleaning a log where more than 50% of the log has been compacted. This ratio bounds the maximum space wasted in the log by duplicates (at 50% at most 50% of the log could be duplicates). A higher ratio will mean fewer, more efficient cleanings but will mean more wasted space in the log. If the max.compaction.lag.ms or the min.compaction.lag.ms configurations are also specified, then the log compactor considers the log to be eligible for compaction as soon as either: (i) the dirty ratio threshold has been met and the log has had dirty (uncompacted) records for at least the min.compaction.lag.ms duration, or (ii) if the log has had dirty (uncompacted) records for at most the max.compaction.lag.ms period."</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.TopicConfig.MIN_COMPACTION_LAG_MS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/TopicConfig.html#MIN_COMPACTION_LAG_MS_CONFIG">MIN_COMPACTION_LAG_MS_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"min.compaction.lag.ms"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.TopicConfig.MIN_COMPACTION_LAG_MS_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/TopicConfig.html#MIN_COMPACTION_LAG_MS_DOC">MIN_COMPACTION_LAG_MS_DOC</a></code></div>
<div class="col-last odd-row-color"><code>"The minimum time a message will remain uncompacted in the log. Only applicable for logs that are being compacted."</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.TopicConfig.MIN_IN_SYNC_REPLICAS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/TopicConfig.html#MIN_IN_SYNC_REPLICAS_CONFIG">MIN_IN_SYNC_REPLICAS_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"min.insync.replicas"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.TopicConfig.MIN_IN_SYNC_REPLICAS_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/TopicConfig.html#MIN_IN_SYNC_REPLICAS_DOC">MIN_IN_SYNC_REPLICAS_DOC</a></code></div>
<div class="col-last odd-row-color"><code>"When a producer sets acks to \"all\" (or \"-1\"), this configuration specifies the minimum number of replicas that must acknowledge a write for the write to be considered successful. If this minimum cannot be met, then the producer will raise an exception (either NotEnoughReplicas or NotEnoughReplicasAfterAppend).&lt;br&gt;When used together, &lt;code&gt;min.insync.replicas&lt;/code&gt; and &lt;code&gt;acks&lt;/code&gt; allow you to enforce greater durability guarantees. A typical scenario would be to create a topic with a replication factor of 3, set &lt;code&gt;min.insync.replicas&lt;/code&gt; to 2, and produce with &lt;code&gt;acks&lt;/code&gt; of \"all\". This will ensure that the producer raises an exception if a majority of replicas do not receive a write."</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.TopicConfig.PREALLOCATE_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/TopicConfig.html#PREALLOCATE_CONFIG">PREALLOCATE_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"preallocate"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.TopicConfig.PREALLOCATE_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/TopicConfig.html#PREALLOCATE_DOC">PREALLOCATE_DOC</a></code></div>
<div class="col-last odd-row-color"><code>"True if we should preallocate the file on disk when creating a new log segment."</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.TopicConfig.REMOTE_LOG_STORAGE_ENABLE_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/TopicConfig.html#REMOTE_LOG_STORAGE_ENABLE_CONFIG">REMOTE_LOG_STORAGE_ENABLE_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"remote.storage.enable"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.TopicConfig.REMOTE_LOG_STORAGE_ENABLE_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/TopicConfig.html#REMOTE_LOG_STORAGE_ENABLE_DOC">REMOTE_LOG_STORAGE_ENABLE_DOC</a></code></div>
<div class="col-last odd-row-color"><code>"To enable tier storage for a topic, set `remote.storage.enable` as true. You can not disable this config once it is enabled. It will be provided in future versions."</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.TopicConfig.RETENTION_BYTES_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/TopicConfig.html#RETENTION_BYTES_CONFIG">RETENTION_BYTES_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"retention.bytes"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.TopicConfig.RETENTION_BYTES_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/TopicConfig.html#RETENTION_BYTES_DOC">RETENTION_BYTES_DOC</a></code></div>
<div class="col-last odd-row-color"><code>"This configuration controls the maximum size a partition (which consists of log segments) can grow to before we will discard old log segments to free up space if we are using the \"delete\" retention policy. By default there is no size limit only a time limit. Since this limit is enforced at the partition level, multiply it by the number of partitions to compute the topic retention in bytes."</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.TopicConfig.RETENTION_MS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/TopicConfig.html#RETENTION_MS_CONFIG">RETENTION_MS_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"retention.ms"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.TopicConfig.RETENTION_MS_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/TopicConfig.html#RETENTION_MS_DOC">RETENTION_MS_DOC</a></code></div>
<div class="col-last odd-row-color"><code>"This configuration controls the maximum time we will retain a log before we will discard old log segments to free up space if we are using the \"delete\" retention policy. This represents an SLA on how soon consumers must read their data. If set to -1, no time limit is applied."</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.TopicConfig.SEGMENT_BYTES_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/TopicConfig.html#SEGMENT_BYTES_CONFIG">SEGMENT_BYTES_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"segment.bytes"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.TopicConfig.SEGMENT_BYTES_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/TopicConfig.html#SEGMENT_BYTES_DOC">SEGMENT_BYTES_DOC</a></code></div>
<div class="col-last odd-row-color"><code>"This configuration controls the segment file size for the log. Retention and cleaning is always done a file at a time so a larger segment size means fewer files but less granular control over retention."</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.TopicConfig.SEGMENT_INDEX_BYTES_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/TopicConfig.html#SEGMENT_INDEX_BYTES_CONFIG">SEGMENT_INDEX_BYTES_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"segment.index.bytes"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.TopicConfig.SEGMENT_INDEX_BYTES_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/TopicConfig.html#SEGMENT_INDEX_BYTES_DOC">SEGMENT_INDEX_BYTES_DOC</a></code></div>
<div class="col-last odd-row-color"><code>"This configuration controls the size of the index that maps offsets to file positions. We preallocate this index file and shrink it only after log rolls. You generally should not need to change this setting."</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.TopicConfig.SEGMENT_JITTER_MS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/TopicConfig.html#SEGMENT_JITTER_MS_CONFIG">SEGMENT_JITTER_MS_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"segment.jitter.ms"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.TopicConfig.SEGMENT_JITTER_MS_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/TopicConfig.html#SEGMENT_JITTER_MS_DOC">SEGMENT_JITTER_MS_DOC</a></code></div>
<div class="col-last odd-row-color"><code>"The maximum random jitter subtracted from the scheduled segment roll time to avoid thundering herds of segment rolling"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.TopicConfig.SEGMENT_MS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/TopicConfig.html#SEGMENT_MS_CONFIG">SEGMENT_MS_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"segment.ms"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.TopicConfig.SEGMENT_MS_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/TopicConfig.html#SEGMENT_MS_DOC">SEGMENT_MS_DOC</a></code></div>
<div class="col-last odd-row-color"><code>"This configuration controls the period of time after which Kafka will force the log to roll even if the segment file isn\'t full to ensure that retention can delete or compact old data."</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.config.TopicConfig.UNCLEAN_LEADER_ELECTION_ENABLE_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/config/TopicConfig.html#UNCLEAN_LEADER_ELECTION_ENABLE_CONFIG">UNCLEAN_LEADER_ELECTION_ENABLE_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"unclean.leader.election.enable"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.config.TopicConfig.UNCLEAN_LEADER_ELECTION_ENABLE_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/config/TopicConfig.html#UNCLEAN_LEADER_ELECTION_ENABLE_DOC">UNCLEAN_LEADER_ELECTION_ENABLE_DOC</a></code></div>
<div class="col-last odd-row-color"><code>"Indicates whether to enable replicas not in the ISR set to be elected as leader as a last resort, even though doing so may result in data loss."</code></div>
</div>
</li>
</ul>
<ul class="block-list">
<li>
<div class="caption"><span>org.apache.kafka.common.metrics.<a href="org/apache/kafka/common/metrics/JmxReporter.html" title="class in org.apache.kafka.common.metrics">JmxReporter</a></span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Constant Field</div>
<div class="table-header col-last">Value</div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.metrics.JmxReporter.DEFAULT_EXCLUDE">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/metrics/JmxReporter.html#DEFAULT_EXCLUDE">DEFAULT_EXCLUDE</a></code></div>
<div class="col-last even-row-color"><code>""</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.metrics.JmxReporter.DEFAULT_INCLUDE">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/metrics/JmxReporter.html#DEFAULT_INCLUDE">DEFAULT_INCLUDE</a></code></div>
<div class="col-last odd-row-color"><code>".*"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.metrics.JmxReporter.EXCLUDE_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/metrics/JmxReporter.html#EXCLUDE_CONFIG">EXCLUDE_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"metrics.jmx.exclude"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.metrics.JmxReporter.EXCLUDE_CONFIG_ALIAS">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/metrics/JmxReporter.html#EXCLUDE_CONFIG_ALIAS">EXCLUDE_CONFIG_ALIAS</a></code></div>
<div class="col-last odd-row-color"><code>"metrics.jmx.blacklist"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.metrics.JmxReporter.INCLUDE_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/metrics/JmxReporter.html#INCLUDE_CONFIG">INCLUDE_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"metrics.jmx.include"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.metrics.JmxReporter.INCLUDE_CONFIG_ALIAS">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/metrics/JmxReporter.html#INCLUDE_CONFIG_ALIAS">INCLUDE_CONFIG_ALIAS</a></code></div>
<div class="col-last odd-row-color"><code>"metrics.jmx.whitelist"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.metrics.JmxReporter.METRICS_CONFIG_PREFIX">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/metrics/JmxReporter.html#METRICS_CONFIG_PREFIX">METRICS_CONFIG_PREFIX</a></code></div>
<div class="col-last even-row-color"><code>"metrics.jmx."</code></div>
</div>
</li>
<li>
<div class="caption"><span>org.apache.kafka.common.metrics.<a href="org/apache/kafka/common/metrics/MetricsContext.html" title="interface in org.apache.kafka.common.metrics">MetricsContext</a></span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Constant Field</div>
<div class="table-header col-last">Value</div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.metrics.MetricsContext.NAMESPACE">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/metrics/MetricsContext.html#NAMESPACE">NAMESPACE</a></code></div>
<div class="col-last even-row-color"><code>"_namespace"</code></div>
</div>
</li>
</ul>
<ul class="block-list">
<li>
<div class="caption"><span>org.apache.kafka.common.quota.<a href="org/apache/kafka/common/quota/ClientQuotaEntity.html" title="class in org.apache.kafka.common.quota">ClientQuotaEntity</a></span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Constant Field</div>
<div class="table-header col-last">Value</div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.quota.ClientQuotaEntity.CLIENT_ID">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/quota/ClientQuotaEntity.html#CLIENT_ID">CLIENT_ID</a></code></div>
<div class="col-last even-row-color"><code>"client-id"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.quota.ClientQuotaEntity.IP">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/quota/ClientQuotaEntity.html#IP">IP</a></code></div>
<div class="col-last odd-row-color"><code>"ip"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.quota.ClientQuotaEntity.USER">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/quota/ClientQuotaEntity.html#USER">USER</a></code></div>
<div class="col-last even-row-color"><code>"user"</code></div>
</div>
</li>
</ul>
<ul class="block-list">
<li>
<div class="caption"><span>org.apache.kafka.common.resource.<a href="org/apache/kafka/common/resource/Resource.html" title="class in org.apache.kafka.common.resource">Resource</a></span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Constant Field</div>
<div class="table-header col-last">Value</div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.resource.Resource.CLUSTER_NAME">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/resource/Resource.html#CLUSTER_NAME">CLUSTER_NAME</a></code></div>
<div class="col-last even-row-color"><code>"kafka-cluster"</code></div>
</div>
</li>
<li>
<div class="caption"><span>org.apache.kafka.common.resource.<a href="org/apache/kafka/common/resource/ResourcePattern.html" title="class in org.apache.kafka.common.resource">ResourcePattern</a></span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Constant Field</div>
<div class="table-header col-last">Value</div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.resource.ResourcePattern.WILDCARD_RESOURCE">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/resource/ResourcePattern.html#WILDCARD_RESOURCE">WILDCARD_RESOURCE</a></code></div>
<div class="col-last even-row-color"><code>"*"</code></div>
</div>
</li>
</ul>
<ul class="block-list">
<li>
<div class="caption"><span>org.apache.kafka.common.security.auth.<a href="org/apache/kafka/common/security/auth/KafkaPrincipal.html" title="class in org.apache.kafka.common.security.auth">KafkaPrincipal</a></span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Constant Field</div>
<div class="table-header col-last">Value</div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.security.auth.KafkaPrincipal.USER_TYPE">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/security/auth/KafkaPrincipal.html#USER_TYPE">USER_TYPE</a></code></div>
<div class="col-last even-row-color"><code>"User"</code></div>
</div>
</li>
</ul>
<ul class="block-list">
<li>
<div class="caption"><span>org.apache.kafka.common.security.oauthbearer.<a href="org/apache/kafka/common/security/oauthbearer/OAuthBearerLoginModule.html" title="class in org.apache.kafka.common.security.oauthbearer">OAuthBearerLoginModule</a></span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Constant Field</div>
<div class="table-header col-last">Value</div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.security.oauthbearer.OAuthBearerLoginModule.OAUTHBEARER_MECHANISM">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/security/oauthbearer/OAuthBearerLoginModule.html#OAUTHBEARER_MECHANISM">OAUTHBEARER_MECHANISM</a></code></div>
<div class="col-last even-row-color"><code>"OAUTHBEARER"</code></div>
</div>
</li>
</ul>
<ul class="block-list">
<li>
<div class="caption"><span>org.apache.kafka.common.security.oauthbearer.secured.<a href="org/apache/kafka/common/security/oauthbearer/secured/HttpAccessTokenRetriever.html" title="class in org.apache.kafka.common.security.oauthbearer.secured">HttpAccessTokenRetriever</a></span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Constant Field</div>
<div class="table-header col-last">Value</div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.security.oauthbearer.secured.HttpAccessTokenRetriever.AUTHORIZATION_HEADER">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/security/oauthbearer/secured/HttpAccessTokenRetriever.html#AUTHORIZATION_HEADER">AUTHORIZATION_HEADER</a></code></div>
<div class="col-last even-row-color"><code>"Authorization"</code></div>
</div>
</li>
<li>
<div class="caption"><span>org.apache.kafka.common.security.oauthbearer.secured.<a href="org/apache/kafka/common/security/oauthbearer/secured/LoginAccessTokenValidator.html" title="class in org.apache.kafka.common.security.oauthbearer.secured">LoginAccessTokenValidator</a></span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Constant Field</div>
<div class="table-header col-last">Value</div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.security.oauthbearer.secured.LoginAccessTokenValidator.EXPIRATION_CLAIM_NAME">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/security/oauthbearer/secured/LoginAccessTokenValidator.html#EXPIRATION_CLAIM_NAME">EXPIRATION_CLAIM_NAME</a></code></div>
<div class="col-last even-row-color"><code>"exp"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.security.oauthbearer.secured.LoginAccessTokenValidator.ISSUED_AT_CLAIM_NAME">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/security/oauthbearer/secured/LoginAccessTokenValidator.html#ISSUED_AT_CLAIM_NAME">ISSUED_AT_CLAIM_NAME</a></code></div>
<div class="col-last odd-row-color"><code>"iat"</code></div>
</div>
</li>
<li>
<div class="caption"><span>org.apache.kafka.common.security.oauthbearer.secured.<a href="org/apache/kafka/common/security/oauthbearer/secured/OAuthBearerLoginCallbackHandler.html" title="class in org.apache.kafka.common.security.oauthbearer.secured">OAuthBearerLoginCallbackHandler</a></span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Constant Field</div>
<div class="table-header col-last">Value</div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.security.oauthbearer.secured.OAuthBearerLoginCallbackHandler.CLIENT_ID_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/security/oauthbearer/secured/OAuthBearerLoginCallbackHandler.html#CLIENT_ID_CONFIG">CLIENT_ID_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"clientId"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.security.oauthbearer.secured.OAuthBearerLoginCallbackHandler.CLIENT_ID_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/security/oauthbearer/secured/OAuthBearerLoginCallbackHandler.html#CLIENT_ID_DOC">CLIENT_ID_DOC</a></code></div>
<div class="col-last odd-row-color"><code>"The OAuth/OIDC identity provider-issued client ID to uniquely identify the service account to use for authentication for this client. The value must be paired with a corresponding clientSecret value and is provided to the OAuth provider using the OAuth clientcredentials grant type."</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.security.oauthbearer.secured.OAuthBearerLoginCallbackHandler.CLIENT_SECRET_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/security/oauthbearer/secured/OAuthBearerLoginCallbackHandler.html#CLIENT_SECRET_CONFIG">CLIENT_SECRET_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"clientSecret"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.security.oauthbearer.secured.OAuthBearerLoginCallbackHandler.CLIENT_SECRET_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/security/oauthbearer/secured/OAuthBearerLoginCallbackHandler.html#CLIENT_SECRET_DOC">CLIENT_SECRET_DOC</a></code></div>
<div class="col-last odd-row-color"><code>"The OAuth/OIDC identity provider-issued client secret serves a similar function as a password to the clientId account and identifies the service account to use for authentication for this client. The value must be paired with a corresponding clientId value and is provided to the OAuth provider using the OAuth clientcredentials grant type."</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.security.oauthbearer.secured.OAuthBearerLoginCallbackHandler.SCOPE_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/security/oauthbearer/secured/OAuthBearerLoginCallbackHandler.html#SCOPE_CONFIG">SCOPE_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"scope"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.common.security.oauthbearer.secured.OAuthBearerLoginCallbackHandler.SCOPE_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/common/security/oauthbearer/secured/OAuthBearerLoginCallbackHandler.html#SCOPE_DOC">SCOPE_DOC</a></code></div>
<div class="col-last odd-row-color"><code>"The (optional) HTTP/HTTPS login request to the token endpoint (sasl.oauthbearer.token.endpoint.url) may need to specify an OAuth \"scope\". If so, the scope is used to provide the value to include with the login request."</code></div>
</div>
</li>
</ul>
<ul class="block-list">
<li>
<div class="caption"><span>org.apache.kafka.common.security.scram.<a href="org/apache/kafka/common/security/scram/ScramLoginModule.html" title="class in org.apache.kafka.common.security.scram">ScramLoginModule</a></span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Constant Field</div>
<div class="table-header col-last">Value</div>
<div class="col-first even-row-color"><code id="org.apache.kafka.common.security.scram.ScramLoginModule.TOKEN_AUTH_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/common/security/scram/ScramLoginModule.html#TOKEN_AUTH_CONFIG">TOKEN_AUTH_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"tokenauth"</code></div>
</div>
</li>
</ul>
<ul class="block-list">
<li>
<div class="caption"><span>org.apache.kafka.connect.data.<a href="org/apache/kafka/connect/data/Date.html" title="class in org.apache.kafka.connect.data">Date</a></span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Constant Field</div>
<div class="table-header col-last">Value</div>
<div class="col-first even-row-color"><code id="org.apache.kafka.connect.data.Date.LOGICAL_NAME">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/connect/data/Date.html#LOGICAL_NAME">LOGICAL_NAME</a></code></div>
<div class="col-last even-row-color"><code>"org.apache.kafka.connect.data.Date"</code></div>
</div>
</li>
<li>
<div class="caption"><span>org.apache.kafka.connect.data.<a href="org/apache/kafka/connect/data/Decimal.html" title="class in org.apache.kafka.connect.data">Decimal</a></span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Constant Field</div>
<div class="table-header col-last">Value</div>
<div class="col-first even-row-color"><code id="org.apache.kafka.connect.data.Decimal.LOGICAL_NAME">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/connect/data/Decimal.html#LOGICAL_NAME">LOGICAL_NAME</a></code></div>
<div class="col-last even-row-color"><code>"org.apache.kafka.connect.data.Decimal"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.connect.data.Decimal.SCALE_FIELD">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/connect/data/Decimal.html#SCALE_FIELD">SCALE_FIELD</a></code></div>
<div class="col-last odd-row-color"><code>"scale"</code></div>
</div>
</li>
<li>
<div class="caption"><span>org.apache.kafka.connect.data.<a href="org/apache/kafka/connect/data/Time.html" title="class in org.apache.kafka.connect.data">Time</a></span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Constant Field</div>
<div class="table-header col-last">Value</div>
<div class="col-first even-row-color"><code id="org.apache.kafka.connect.data.Time.LOGICAL_NAME">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/connect/data/Time.html#LOGICAL_NAME">LOGICAL_NAME</a></code></div>
<div class="col-last even-row-color"><code>"org.apache.kafka.connect.data.Time"</code></div>
</div>
</li>
<li>
<div class="caption"><span>org.apache.kafka.connect.data.<a href="org/apache/kafka/connect/data/Timestamp.html" title="class in org.apache.kafka.connect.data">Timestamp</a></span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Constant Field</div>
<div class="table-header col-last">Value</div>
<div class="col-first even-row-color"><code id="org.apache.kafka.connect.data.Timestamp.LOGICAL_NAME">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/connect/data/Timestamp.html#LOGICAL_NAME">LOGICAL_NAME</a></code></div>
<div class="col-last even-row-color"><code>"org.apache.kafka.connect.data.Timestamp"</code></div>
</div>
</li>
</ul>
<ul class="block-list">
<li>
<div class="caption"><span>org.apache.kafka.connect.mirror.<a href="org/apache/kafka/connect/mirror/Checkpoint.html" title="class in org.apache.kafka.connect.mirror">Checkpoint</a></span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Constant Field</div>
<div class="table-header col-last">Value</div>
<div class="col-first even-row-color"><code id="org.apache.kafka.connect.mirror.Checkpoint.CONSUMER_GROUP_ID_KEY">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/connect/mirror/Checkpoint.html#CONSUMER_GROUP_ID_KEY">CONSUMER_GROUP_ID_KEY</a></code></div>
<div class="col-last even-row-color"><code>"group"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.connect.mirror.Checkpoint.DOWNSTREAM_OFFSET_KEY">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/connect/mirror/Checkpoint.html#DOWNSTREAM_OFFSET_KEY">DOWNSTREAM_OFFSET_KEY</a></code></div>
<div class="col-last odd-row-color"><code>"offset"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.connect.mirror.Checkpoint.METADATA_KEY">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/connect/mirror/Checkpoint.html#METADATA_KEY">METADATA_KEY</a></code></div>
<div class="col-last even-row-color"><code>"metadata"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.connect.mirror.Checkpoint.PARTITION_KEY">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/connect/mirror/Checkpoint.html#PARTITION_KEY">PARTITION_KEY</a></code></div>
<div class="col-last odd-row-color"><code>"partition"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.connect.mirror.Checkpoint.TOPIC_KEY">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/connect/mirror/Checkpoint.html#TOPIC_KEY">TOPIC_KEY</a></code></div>
<div class="col-last even-row-color"><code>"topic"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.connect.mirror.Checkpoint.UPSTREAM_OFFSET_KEY">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/connect/mirror/Checkpoint.html#UPSTREAM_OFFSET_KEY">UPSTREAM_OFFSET_KEY</a></code></div>
<div class="col-last odd-row-color"><code>"upstreamOffset"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.connect.mirror.Checkpoint.VERSION">public&nbsp;static&nbsp;final&nbsp;short</code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/connect/mirror/Checkpoint.html#VERSION">VERSION</a></code></div>
<div class="col-last even-row-color"><code>0</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.connect.mirror.Checkpoint.VERSION_KEY">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/connect/mirror/Checkpoint.html#VERSION_KEY">VERSION_KEY</a></code></div>
<div class="col-last odd-row-color"><code>"version"</code></div>
</div>
</li>
<li>
<div class="caption"><span>org.apache.kafka.connect.mirror.<a href="org/apache/kafka/connect/mirror/DefaultReplicationPolicy.html" title="class in org.apache.kafka.connect.mirror">DefaultReplicationPolicy</a></span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Constant Field</div>
<div class="table-header col-last">Value</div>
<div class="col-first even-row-color"><code id="org.apache.kafka.connect.mirror.DefaultReplicationPolicy.SEPARATOR_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/connect/mirror/DefaultReplicationPolicy.html#SEPARATOR_CONFIG">SEPARATOR_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"replication.policy.separator"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.connect.mirror.DefaultReplicationPolicy.SEPARATOR_DEFAULT">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/connect/mirror/DefaultReplicationPolicy.html#SEPARATOR_DEFAULT">SEPARATOR_DEFAULT</a></code></div>
<div class="col-last odd-row-color"><code>"."</code></div>
</div>
</li>
<li>
<div class="caption"><span>org.apache.kafka.connect.mirror.<a href="org/apache/kafka/connect/mirror/Heartbeat.html" title="class in org.apache.kafka.connect.mirror">Heartbeat</a></span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Constant Field</div>
<div class="table-header col-last">Value</div>
<div class="col-first even-row-color"><code id="org.apache.kafka.connect.mirror.Heartbeat.SOURCE_CLUSTER_ALIAS_KEY">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/connect/mirror/Heartbeat.html#SOURCE_CLUSTER_ALIAS_KEY">SOURCE_CLUSTER_ALIAS_KEY</a></code></div>
<div class="col-last even-row-color"><code>"sourceClusterAlias"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.connect.mirror.Heartbeat.TARGET_CLUSTER_ALIAS_KEY">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/connect/mirror/Heartbeat.html#TARGET_CLUSTER_ALIAS_KEY">TARGET_CLUSTER_ALIAS_KEY</a></code></div>
<div class="col-last odd-row-color"><code>"targetClusterAlias"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.connect.mirror.Heartbeat.TIMESTAMP_KEY">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/connect/mirror/Heartbeat.html#TIMESTAMP_KEY">TIMESTAMP_KEY</a></code></div>
<div class="col-last even-row-color"><code>"timestamp"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.connect.mirror.Heartbeat.VERSION">public&nbsp;static&nbsp;final&nbsp;short</code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/connect/mirror/Heartbeat.html#VERSION">VERSION</a></code></div>
<div class="col-last odd-row-color"><code>0</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.connect.mirror.Heartbeat.VERSION_KEY">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/connect/mirror/Heartbeat.html#VERSION_KEY">VERSION_KEY</a></code></div>
<div class="col-last even-row-color"><code>"version"</code></div>
</div>
</li>
<li>
<div class="caption"><span>org.apache.kafka.connect.mirror.<a href="org/apache/kafka/connect/mirror/IdentityReplicationPolicy.html" title="class in org.apache.kafka.connect.mirror">IdentityReplicationPolicy</a></span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Constant Field</div>
<div class="table-header col-last">Value</div>
<div class="col-first even-row-color"><code id="org.apache.kafka.connect.mirror.IdentityReplicationPolicy.SOURCE_CLUSTER_ALIAS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/connect/mirror/IdentityReplicationPolicy.html#SOURCE_CLUSTER_ALIAS_CONFIG">SOURCE_CLUSTER_ALIAS_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"source.cluster.alias"</code></div>
</div>
</li>
<li>
<div class="caption"><span>org.apache.kafka.connect.mirror.<a href="org/apache/kafka/connect/mirror/MirrorClientConfig.html" title="class in org.apache.kafka.connect.mirror">MirrorClientConfig</a></span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Constant Field</div>
<div class="table-header col-last">Value</div>
<div class="col-first even-row-color"><code id="org.apache.kafka.connect.mirror.MirrorClientConfig.ADMIN_CLIENT_PREFIX">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/connect/mirror/MirrorClientConfig.html#ADMIN_CLIENT_PREFIX">ADMIN_CLIENT_PREFIX</a></code></div>
<div class="col-last even-row-color"><code>"admin."</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.connect.mirror.MirrorClientConfig.CONSUMER_CLIENT_PREFIX">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/connect/mirror/MirrorClientConfig.html#CONSUMER_CLIENT_PREFIX">CONSUMER_CLIENT_PREFIX</a></code></div>
<div class="col-last odd-row-color"><code>"consumer."</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.connect.mirror.MirrorClientConfig.PRODUCER_CLIENT_PREFIX">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/connect/mirror/MirrorClientConfig.html#PRODUCER_CLIENT_PREFIX">PRODUCER_CLIENT_PREFIX</a></code></div>
<div class="col-last even-row-color"><code>"producer."</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.connect.mirror.MirrorClientConfig.REPLICATION_POLICY_CLASS">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/connect/mirror/MirrorClientConfig.html#REPLICATION_POLICY_CLASS">REPLICATION_POLICY_CLASS</a></code></div>
<div class="col-last odd-row-color"><code>"replication.policy.class"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.connect.mirror.MirrorClientConfig.REPLICATION_POLICY_SEPARATOR">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/connect/mirror/MirrorClientConfig.html#REPLICATION_POLICY_SEPARATOR">REPLICATION_POLICY_SEPARATOR</a></code></div>
<div class="col-last even-row-color"><code>"replication.policy.separator"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.connect.mirror.MirrorClientConfig.REPLICATION_POLICY_SEPARATOR_DEFAULT">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/connect/mirror/MirrorClientConfig.html#REPLICATION_POLICY_SEPARATOR_DEFAULT">REPLICATION_POLICY_SEPARATOR_DEFAULT</a></code></div>
<div class="col-last odd-row-color"><code>"."</code></div>
</div>
</li>
</ul>
<ul class="block-list">
<li>
<div class="caption"><span>org.apache.kafka.connect.sink.<a href="org/apache/kafka/connect/sink/SinkConnector.html" title="class in org.apache.kafka.connect.sink">SinkConnector</a></span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Constant Field</div>
<div class="table-header col-last">Value</div>
<div class="col-first even-row-color"><code id="org.apache.kafka.connect.sink.SinkConnector.TOPICS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/connect/sink/SinkConnector.html#TOPICS_CONFIG">TOPICS_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"topics"</code></div>
</div>
</li>
<li>
<div class="caption"><span>org.apache.kafka.connect.sink.<a href="org/apache/kafka/connect/sink/SinkTask.html" title="class in org.apache.kafka.connect.sink">SinkTask</a></span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Constant Field</div>
<div class="table-header col-last">Value</div>
<div class="col-first even-row-color"><code id="org.apache.kafka.connect.sink.SinkTask.TOPICS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/connect/sink/SinkTask.html#TOPICS_CONFIG">TOPICS_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"topics"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.connect.sink.SinkTask.TOPICS_REGEX_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/connect/sink/SinkTask.html#TOPICS_REGEX_CONFIG">TOPICS_REGEX_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"topics.regex"</code></div>
</div>
</li>
</ul>
<ul class="block-list">
<li>
<div class="caption"><span>org.apache.kafka.connect.source.<a href="org/apache/kafka/connect/source/SourceTask.html" title="class in org.apache.kafka.connect.source">SourceTask</a></span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Constant Field</div>
<div class="table-header col-last">Value</div>
<div class="col-first even-row-color"><code id="org.apache.kafka.connect.source.SourceTask.TRANSACTION_BOUNDARY_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/connect/source/SourceTask.html#TRANSACTION_BOUNDARY_CONFIG">TRANSACTION_BOUNDARY_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"transaction.boundary"</code></div>
</div>
</li>
</ul>
<ul class="block-list">
<li>
<div class="caption"><span>org.apache.kafka.connect.storage.<a href="org/apache/kafka/connect/storage/ConverterConfig.html" title="class in org.apache.kafka.connect.storage">ConverterConfig</a></span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Constant Field</div>
<div class="table-header col-last">Value</div>
<div class="col-first even-row-color"><code id="org.apache.kafka.connect.storage.ConverterConfig.TYPE_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/connect/storage/ConverterConfig.html#TYPE_CONFIG">TYPE_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"converter.type"</code></div>
</div>
</li>
<li>
<div class="caption"><span>org.apache.kafka.connect.storage.<a href="org/apache/kafka/connect/storage/StringConverterConfig.html" title="class in org.apache.kafka.connect.storage">StringConverterConfig</a></span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Constant Field</div>
<div class="table-header col-last">Value</div>
<div class="col-first even-row-color"><code id="org.apache.kafka.connect.storage.StringConverterConfig.ENCODING_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/connect/storage/StringConverterConfig.html#ENCODING_CONFIG">ENCODING_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"converter.encoding"</code></div>
</div>
</li>
</ul>
<ul class="block-list">
<li>
<div class="caption"><span>org.apache.kafka.streams.<a href="org/apache/kafka/streams/StreamsConfig.html" title="class in org.apache.kafka.streams">StreamsConfig</a></span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Constant Field</div>
<div class="table-header col-last">Value</div>
<div class="col-first even-row-color"><code id="org.apache.kafka.streams.StreamsConfig.ACCEPTABLE_RECOVERY_LAG_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#ACCEPTABLE_RECOVERY_LAG_CONFIG">ACCEPTABLE_RECOVERY_LAG_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"acceptable.recovery.lag"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.streams.StreamsConfig.ADMIN_CLIENT_PREFIX">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#ADMIN_CLIENT_PREFIX">ADMIN_CLIENT_PREFIX</a></code></div>
<div class="col-last odd-row-color"><code>"admin."</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.streams.StreamsConfig.APPLICATION_ID_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#APPLICATION_ID_CONFIG">APPLICATION_ID_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"application.id"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.streams.StreamsConfig.APPLICATION_SERVER_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#APPLICATION_SERVER_CONFIG">APPLICATION_SERVER_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"application.server"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.streams.StreamsConfig.AT_LEAST_ONCE">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#AT_LEAST_ONCE">AT_LEAST_ONCE</a></code></div>
<div class="col-last even-row-color"><code>"at_least_once"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.streams.StreamsConfig.BOOTSTRAP_SERVERS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#BOOTSTRAP_SERVERS_CONFIG">BOOTSTRAP_SERVERS_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"bootstrap.servers"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.streams.StreamsConfig.BUFFERED_RECORDS_PER_PARTITION_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#BUFFERED_RECORDS_PER_PARTITION_CONFIG">BUFFERED_RECORDS_PER_PARTITION_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"buffered.records.per.partition"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.streams.StreamsConfig.BUFFERED_RECORDS_PER_PARTITION_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#BUFFERED_RECORDS_PER_PARTITION_DOC">BUFFERED_RECORDS_PER_PARTITION_DOC</a></code></div>
<div class="col-last odd-row-color"><code>"Maximum number of records to buffer per partition."</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.streams.StreamsConfig.BUILT_IN_METRICS_VERSION_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#BUILT_IN_METRICS_VERSION_CONFIG">BUILT_IN_METRICS_VERSION_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"built.in.metrics.version"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.streams.StreamsConfig.CACHE_MAX_BYTES_BUFFERING_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#CACHE_MAX_BYTES_BUFFERING_CONFIG">CACHE_MAX_BYTES_BUFFERING_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"cache.max.bytes.buffering"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.streams.StreamsConfig.CACHE_MAX_BYTES_BUFFERING_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#CACHE_MAX_BYTES_BUFFERING_DOC">CACHE_MAX_BYTES_BUFFERING_DOC</a></code></div>
<div class="col-last even-row-color"><code>"Maximum number of memory bytes to be used for buffering across all threads"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.streams.StreamsConfig.CLIENT_ID_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#CLIENT_ID_CONFIG">CLIENT_ID_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"client.id"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.streams.StreamsConfig.CLIENT_TAG_PREFIX">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#CLIENT_TAG_PREFIX">CLIENT_TAG_PREFIX</a></code></div>
<div class="col-last even-row-color"><code>"client.tag."</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.streams.StreamsConfig.COMMIT_INTERVAL_MS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#COMMIT_INTERVAL_MS_CONFIG">COMMIT_INTERVAL_MS_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"commit.interval.ms"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.streams.StreamsConfig.CONNECTIONS_MAX_IDLE_MS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#CONNECTIONS_MAX_IDLE_MS_CONFIG">CONNECTIONS_MAX_IDLE_MS_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"connections.max.idle.ms"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.streams.StreamsConfig.CONSUMER_PREFIX">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#CONSUMER_PREFIX">CONSUMER_PREFIX</a></code></div>
<div class="col-last odd-row-color"><code>"consumer."</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.streams.StreamsConfig.DEFAULT_DESERIALIZATION_EXCEPTION_HANDLER_CLASS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#DEFAULT_DESERIALIZATION_EXCEPTION_HANDLER_CLASS_CONFIG">DEFAULT_DESERIALIZATION_EXCEPTION_HANDLER_CLASS_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"default.deserialization.exception.handler"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.streams.StreamsConfig.DEFAULT_DESERIALIZATION_EXCEPTION_HANDLER_CLASS_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#DEFAULT_DESERIALIZATION_EXCEPTION_HANDLER_CLASS_DOC">DEFAULT_DESERIALIZATION_EXCEPTION_HANDLER_CLASS_DOC</a></code></div>
<div class="col-last odd-row-color"><code>"Exception handling class that implements the &lt;code&gt;org.apache.kafka.streams.errors.DeserializationExceptionHandler&lt;/code&gt; interface."</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.streams.StreamsConfig.DEFAULT_DSL_STORE_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#DEFAULT_DSL_STORE_CONFIG">DEFAULT_DSL_STORE_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"default.dsl.store"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.streams.StreamsConfig.DEFAULT_DSL_STORE_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#DEFAULT_DSL_STORE_DOC">DEFAULT_DSL_STORE_DOC</a></code></div>
<div class="col-last odd-row-color"><code>"The default state store type used by DSL operators."</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.streams.StreamsConfig.DEFAULT_KEY_SERDE_CLASS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#DEFAULT_KEY_SERDE_CLASS_CONFIG">DEFAULT_KEY_SERDE_CLASS_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"default.key.serde"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.streams.StreamsConfig.DEFAULT_PRODUCTION_EXCEPTION_HANDLER_CLASS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#DEFAULT_PRODUCTION_EXCEPTION_HANDLER_CLASS_CONFIG">DEFAULT_PRODUCTION_EXCEPTION_HANDLER_CLASS_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"default.production.exception.handler"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.streams.StreamsConfig.DEFAULT_TIMESTAMP_EXTRACTOR_CLASS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#DEFAULT_TIMESTAMP_EXTRACTOR_CLASS_CONFIG">DEFAULT_TIMESTAMP_EXTRACTOR_CLASS_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"default.timestamp.extractor"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.streams.StreamsConfig.DEFAULT_TIMESTAMP_EXTRACTOR_CLASS_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#DEFAULT_TIMESTAMP_EXTRACTOR_CLASS_DOC">DEFAULT_TIMESTAMP_EXTRACTOR_CLASS_DOC</a></code></div>
<div class="col-last odd-row-color"><code>"Default timestamp extractor class that implements the &lt;code&gt;org.apache.kafka.streams.processor.TimestampExtractor&lt;/code&gt; interface."</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.streams.StreamsConfig.DEFAULT_VALUE_SERDE_CLASS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#DEFAULT_VALUE_SERDE_CLASS_CONFIG">DEFAULT_VALUE_SERDE_CLASS_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"default.value.serde"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.streams.StreamsConfig.DEFAULT_WINDOWED_KEY_SERDE_INNER_CLASS">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#DEFAULT_WINDOWED_KEY_SERDE_INNER_CLASS">DEFAULT_WINDOWED_KEY_SERDE_INNER_CLASS</a></code></div>
<div class="col-last odd-row-color"><code>"default.windowed.key.serde.inner"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.streams.StreamsConfig.DEFAULT_WINDOWED_VALUE_SERDE_INNER_CLASS">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#DEFAULT_WINDOWED_VALUE_SERDE_INNER_CLASS">DEFAULT_WINDOWED_VALUE_SERDE_INNER_CLASS</a></code></div>
<div class="col-last even-row-color"><code>"default.windowed.value.serde.inner"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.streams.StreamsConfig.DUMMY_THREAD_INDEX">public&nbsp;static&nbsp;final&nbsp;int</code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#DUMMY_THREAD_INDEX">DUMMY_THREAD_INDEX</a></code></div>
<div class="col-last odd-row-color"><code>1</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.streams.StreamsConfig.EXACTLY_ONCE">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#EXACTLY_ONCE">EXACTLY_ONCE</a></code></div>
<div class="col-last even-row-color"><code>"exactly_once"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.streams.StreamsConfig.EXACTLY_ONCE_BETA">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#EXACTLY_ONCE_BETA">EXACTLY_ONCE_BETA</a></code></div>
<div class="col-last odd-row-color"><code>"exactly_once_beta"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.streams.StreamsConfig.EXACTLY_ONCE_V2">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#EXACTLY_ONCE_V2">EXACTLY_ONCE_V2</a></code></div>
<div class="col-last even-row-color"><code>"exactly_once_v2"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.streams.StreamsConfig.GLOBAL_CONSUMER_PREFIX">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#GLOBAL_CONSUMER_PREFIX">GLOBAL_CONSUMER_PREFIX</a></code></div>
<div class="col-last odd-row-color"><code>"global.consumer."</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.streams.StreamsConfig.IN_MEMORY">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#IN_MEMORY">IN_MEMORY</a></code></div>
<div class="col-last even-row-color"><code>"in_memory"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.streams.StreamsConfig.MAIN_CONSUMER_PREFIX">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#MAIN_CONSUMER_PREFIX">MAIN_CONSUMER_PREFIX</a></code></div>
<div class="col-last odd-row-color"><code>"main.consumer."</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.streams.StreamsConfig.MAX_RACK_AWARE_ASSIGNMENT_TAG_KEY_LENGTH">public&nbsp;static&nbsp;final&nbsp;int</code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#MAX_RACK_AWARE_ASSIGNMENT_TAG_KEY_LENGTH">MAX_RACK_AWARE_ASSIGNMENT_TAG_KEY_LENGTH</a></code></div>
<div class="col-last even-row-color"><code>20</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.streams.StreamsConfig.MAX_RACK_AWARE_ASSIGNMENT_TAG_LIST_SIZE">public&nbsp;static&nbsp;final&nbsp;int</code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#MAX_RACK_AWARE_ASSIGNMENT_TAG_LIST_SIZE">MAX_RACK_AWARE_ASSIGNMENT_TAG_LIST_SIZE</a></code></div>
<div class="col-last odd-row-color"><code>5</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.streams.StreamsConfig.MAX_RACK_AWARE_ASSIGNMENT_TAG_VALUE_LENGTH">public&nbsp;static&nbsp;final&nbsp;int</code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#MAX_RACK_AWARE_ASSIGNMENT_TAG_VALUE_LENGTH">MAX_RACK_AWARE_ASSIGNMENT_TAG_VALUE_LENGTH</a></code></div>
<div class="col-last even-row-color"><code>30</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.streams.StreamsConfig.MAX_TASK_IDLE_MS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#MAX_TASK_IDLE_MS_CONFIG">MAX_TASK_IDLE_MS_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"max.task.idle.ms"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.streams.StreamsConfig.MAX_TASK_IDLE_MS_DISABLED">public&nbsp;static&nbsp;final&nbsp;long</code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#MAX_TASK_IDLE_MS_DISABLED">MAX_TASK_IDLE_MS_DISABLED</a></code></div>
<div class="col-last even-row-color"><code>-1L</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.streams.StreamsConfig.MAX_TASK_IDLE_MS_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#MAX_TASK_IDLE_MS_DOC">MAX_TASK_IDLE_MS_DOC</a></code></div>
<div class="col-last odd-row-color"><code>"This config controls whether joins and merges may produce out-of-order results. The config value is the maximum amount of time in milliseconds a stream task will stay idle when it is fully caught up on some (but not all) input partitions to wait for producers to send additional records and avoid potential out-of-order record processing across multiple input streams. The default (zero) does not wait for producers to send more records, but it does wait to fetch data that is already present on the brokers. This default means that for records that are already present on the brokers, Streams will process them in timestamp order. Set to -1 to disable idling entirely and process any locally available data, even though doing so may produce out-of-order processing."</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.streams.StreamsConfig.MAX_WARMUP_REPLICAS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#MAX_WARMUP_REPLICAS_CONFIG">MAX_WARMUP_REPLICAS_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"max.warmup.replicas"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.streams.StreamsConfig.METADATA_MAX_AGE_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#METADATA_MAX_AGE_CONFIG">METADATA_MAX_AGE_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"metadata.max.age.ms"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.streams.StreamsConfig.METRIC_REPORTER_CLASSES_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#METRIC_REPORTER_CLASSES_CONFIG">METRIC_REPORTER_CLASSES_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"metric.reporters"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.streams.StreamsConfig.METRICS_LATEST">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#METRICS_LATEST">METRICS_LATEST</a></code></div>
<div class="col-last odd-row-color"><code>"latest"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.streams.StreamsConfig.METRICS_NUM_SAMPLES_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#METRICS_NUM_SAMPLES_CONFIG">METRICS_NUM_SAMPLES_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"metrics.num.samples"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.streams.StreamsConfig.METRICS_RECORDING_LEVEL_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#METRICS_RECORDING_LEVEL_CONFIG">METRICS_RECORDING_LEVEL_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"metrics.recording.level"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.streams.StreamsConfig.METRICS_SAMPLE_WINDOW_MS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#METRICS_SAMPLE_WINDOW_MS_CONFIG">METRICS_SAMPLE_WINDOW_MS_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"metrics.sample.window.ms"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.streams.StreamsConfig.NO_OPTIMIZATION">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#NO_OPTIMIZATION">NO_OPTIMIZATION</a></code></div>
<div class="col-last odd-row-color"><code>"none"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.streams.StreamsConfig.NUM_STANDBY_REPLICAS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#NUM_STANDBY_REPLICAS_CONFIG">NUM_STANDBY_REPLICAS_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"num.standby.replicas"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.streams.StreamsConfig.NUM_STREAM_THREADS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#NUM_STREAM_THREADS_CONFIG">NUM_STREAM_THREADS_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"num.stream.threads"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.streams.StreamsConfig.OPTIMIZE">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#OPTIMIZE">OPTIMIZE</a></code></div>
<div class="col-last even-row-color"><code>"all"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.streams.StreamsConfig.POLL_MS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#POLL_MS_CONFIG">POLL_MS_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"poll.ms"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.streams.StreamsConfig.PROBING_REBALANCE_INTERVAL_MS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#PROBING_REBALANCE_INTERVAL_MS_CONFIG">PROBING_REBALANCE_INTERVAL_MS_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"probing.rebalance.interval.ms"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.streams.StreamsConfig.PROCESSING_GUARANTEE_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#PROCESSING_GUARANTEE_CONFIG">PROCESSING_GUARANTEE_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"processing.guarantee"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.streams.StreamsConfig.PRODUCER_PREFIX">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#PRODUCER_PREFIX">PRODUCER_PREFIX</a></code></div>
<div class="col-last even-row-color"><code>"producer."</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.streams.StreamsConfig.RACK_AWARE_ASSIGNMENT_TAGS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#RACK_AWARE_ASSIGNMENT_TAGS_CONFIG">RACK_AWARE_ASSIGNMENT_TAGS_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"rack.aware.assignment.tags"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.streams.StreamsConfig.RECEIVE_BUFFER_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#RECEIVE_BUFFER_CONFIG">RECEIVE_BUFFER_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"receive.buffer.bytes"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.streams.StreamsConfig.RECONNECT_BACKOFF_MAX_MS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#RECONNECT_BACKOFF_MAX_MS_CONFIG">RECONNECT_BACKOFF_MAX_MS_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"reconnect.backoff.max.ms"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.streams.StreamsConfig.RECONNECT_BACKOFF_MS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#RECONNECT_BACKOFF_MS_CONFIG">RECONNECT_BACKOFF_MS_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"reconnect.backoff.ms"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.streams.StreamsConfig.REPARTITION_PURGE_INTERVAL_MS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#REPARTITION_PURGE_INTERVAL_MS_CONFIG">REPARTITION_PURGE_INTERVAL_MS_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"repartition.purge.interval.ms"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.streams.StreamsConfig.REPLICATION_FACTOR_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#REPLICATION_FACTOR_CONFIG">REPLICATION_FACTOR_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"replication.factor"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.streams.StreamsConfig.REQUEST_TIMEOUT_MS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#REQUEST_TIMEOUT_MS_CONFIG">REQUEST_TIMEOUT_MS_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"request.timeout.ms"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.streams.StreamsConfig.RESTORE_CONSUMER_PREFIX">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#RESTORE_CONSUMER_PREFIX">RESTORE_CONSUMER_PREFIX</a></code></div>
<div class="col-last even-row-color"><code>"restore.consumer."</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.streams.StreamsConfig.RETRIES_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#RETRIES_CONFIG">RETRIES_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"retries"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.streams.StreamsConfig.RETRY_BACKOFF_MS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#RETRY_BACKOFF_MS_CONFIG">RETRY_BACKOFF_MS_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"retry.backoff.ms"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.streams.StreamsConfig.ROCKS_DB">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#ROCKS_DB">ROCKS_DB</a></code></div>
<div class="col-last odd-row-color"><code>"rocksDB"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.streams.StreamsConfig.ROCKSDB_CONFIG_SETTER_CLASS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#ROCKSDB_CONFIG_SETTER_CLASS_CONFIG">ROCKSDB_CONFIG_SETTER_CLASS_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"rocksdb.config.setter"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.streams.StreamsConfig.SECURITY_PROTOCOL_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#SECURITY_PROTOCOL_CONFIG">SECURITY_PROTOCOL_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"security.protocol"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.streams.StreamsConfig.SEND_BUFFER_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#SEND_BUFFER_CONFIG">SEND_BUFFER_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"send.buffer.bytes"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.streams.StreamsConfig.STATE_CLEANUP_DELAY_MS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#STATE_CLEANUP_DELAY_MS_CONFIG">STATE_CLEANUP_DELAY_MS_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"state.cleanup.delay.ms"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.streams.StreamsConfig.STATE_DIR_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#STATE_DIR_CONFIG">STATE_DIR_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"state.dir"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.streams.StreamsConfig.TASK_TIMEOUT_MS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#TASK_TIMEOUT_MS_CONFIG">TASK_TIMEOUT_MS_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"task.timeout.ms"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.streams.StreamsConfig.TASK_TIMEOUT_MS_DOC">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#TASK_TIMEOUT_MS_DOC">TASK_TIMEOUT_MS_DOC</a></code></div>
<div class="col-last even-row-color"><code>"The maximum amount of time in milliseconds a task might stall due to internal errors and retries until an error is raised. For a timeout of 0ms, a task would raise an error for the first internal error. For any timeout larger than 0ms, a task will retry at least once before an error is raised."</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.streams.StreamsConfig.TOPIC_PREFIX">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#TOPIC_PREFIX">TOPIC_PREFIX</a></code></div>
<div class="col-last odd-row-color"><code>"topic."</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.streams.StreamsConfig.TOPOLOGY_OPTIMIZATION">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#TOPOLOGY_OPTIMIZATION">TOPOLOGY_OPTIMIZATION</a></code></div>
<div class="col-last even-row-color"><code>"topology.optimization"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.streams.StreamsConfig.TOPOLOGY_OPTIMIZATION_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#TOPOLOGY_OPTIMIZATION_CONFIG">TOPOLOGY_OPTIMIZATION_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"topology.optimization"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.streams.StreamsConfig.UPGRADE_FROM_0100">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#UPGRADE_FROM_0100">UPGRADE_FROM_0100</a></code></div>
<div class="col-last even-row-color"><code>"0.10.0"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.streams.StreamsConfig.UPGRADE_FROM_0101">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#UPGRADE_FROM_0101">UPGRADE_FROM_0101</a></code></div>
<div class="col-last odd-row-color"><code>"0.10.1"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.streams.StreamsConfig.UPGRADE_FROM_0102">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#UPGRADE_FROM_0102">UPGRADE_FROM_0102</a></code></div>
<div class="col-last even-row-color"><code>"0.10.2"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.streams.StreamsConfig.UPGRADE_FROM_0110">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#UPGRADE_FROM_0110">UPGRADE_FROM_0110</a></code></div>
<div class="col-last odd-row-color"><code>"0.11.0"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.streams.StreamsConfig.UPGRADE_FROM_10">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#UPGRADE_FROM_10">UPGRADE_FROM_10</a></code></div>
<div class="col-last even-row-color"><code>"1.0"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.streams.StreamsConfig.UPGRADE_FROM_11">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#UPGRADE_FROM_11">UPGRADE_FROM_11</a></code></div>
<div class="col-last odd-row-color"><code>"1.1"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.streams.StreamsConfig.UPGRADE_FROM_20">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#UPGRADE_FROM_20">UPGRADE_FROM_20</a></code></div>
<div class="col-last even-row-color"><code>"2.0"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.streams.StreamsConfig.UPGRADE_FROM_21">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#UPGRADE_FROM_21">UPGRADE_FROM_21</a></code></div>
<div class="col-last odd-row-color"><code>"2.1"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.streams.StreamsConfig.UPGRADE_FROM_22">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#UPGRADE_FROM_22">UPGRADE_FROM_22</a></code></div>
<div class="col-last even-row-color"><code>"2.2"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.streams.StreamsConfig.UPGRADE_FROM_23">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#UPGRADE_FROM_23">UPGRADE_FROM_23</a></code></div>
<div class="col-last odd-row-color"><code>"2.3"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.streams.StreamsConfig.UPGRADE_FROM_24">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#UPGRADE_FROM_24">UPGRADE_FROM_24</a></code></div>
<div class="col-last even-row-color"><code>"2.4"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.streams.StreamsConfig.UPGRADE_FROM_25">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#UPGRADE_FROM_25">UPGRADE_FROM_25</a></code></div>
<div class="col-last odd-row-color"><code>"2.5"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.streams.StreamsConfig.UPGRADE_FROM_26">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#UPGRADE_FROM_26">UPGRADE_FROM_26</a></code></div>
<div class="col-last even-row-color"><code>"2.6"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.streams.StreamsConfig.UPGRADE_FROM_27">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#UPGRADE_FROM_27">UPGRADE_FROM_27</a></code></div>
<div class="col-last odd-row-color"><code>"2.7"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.streams.StreamsConfig.UPGRADE_FROM_28">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#UPGRADE_FROM_28">UPGRADE_FROM_28</a></code></div>
<div class="col-last even-row-color"><code>"2.8"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.streams.StreamsConfig.UPGRADE_FROM_30">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#UPGRADE_FROM_30">UPGRADE_FROM_30</a></code></div>
<div class="col-last odd-row-color"><code>"3.0"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.streams.StreamsConfig.UPGRADE_FROM_31">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#UPGRADE_FROM_31">UPGRADE_FROM_31</a></code></div>
<div class="col-last even-row-color"><code>"3.1"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.streams.StreamsConfig.UPGRADE_FROM_32">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#UPGRADE_FROM_32">UPGRADE_FROM_32</a></code></div>
<div class="col-last odd-row-color"><code>"3.2"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.streams.StreamsConfig.UPGRADE_FROM_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#UPGRADE_FROM_CONFIG">UPGRADE_FROM_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"upgrade.from"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.streams.StreamsConfig.WINDOW_SIZE_MS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#WINDOW_SIZE_MS_CONFIG">WINDOW_SIZE_MS_CONFIG</a></code></div>
<div class="col-last odd-row-color"><code>"window.size.ms"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.streams.StreamsConfig.WINDOW_STORE_CHANGE_LOG_ADDITIONAL_RETENTION_MS_CONFIG">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#WINDOW_STORE_CHANGE_LOG_ADDITIONAL_RETENTION_MS_CONFIG">WINDOW_STORE_CHANGE_LOG_ADDITIONAL_RETENTION_MS_CONFIG</a></code></div>
<div class="col-last even-row-color"><code>"windowstore.changelog.additional.retention.ms"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.streams.StreamsConfig.WINDOWED_INNER_CLASS_SERDE">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.html#WINDOWED_INNER_CLASS_SERDE">WINDOWED_INNER_CLASS_SERDE</a></code></div>
<div class="col-last odd-row-color"><code>"windowed.inner.class.serde"</code></div>
</div>
</li>
<li>
<div class="caption"><span>org.apache.kafka.streams.<a href="org/apache/kafka/streams/StreamsConfig.InternalConfig.html" title="class in org.apache.kafka.streams">StreamsConfig.InternalConfig</a></span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Constant Field</div>
<div class="table-header col-last">Value</div>
<div class="col-first even-row-color"><code id="org.apache.kafka.streams.StreamsConfig.InternalConfig.ASSIGNMENT_LISTENER">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.InternalConfig.html#ASSIGNMENT_LISTENER">ASSIGNMENT_LISTENER</a></code></div>
<div class="col-last even-row-color"><code>"__assignment.listener__"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.streams.StreamsConfig.InternalConfig.EMIT_INTERVAL_MS_KSTREAMS_OUTER_JOIN_SPURIOUS_RESULTS_FIX">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.InternalConfig.html#EMIT_INTERVAL_MS_KSTREAMS_OUTER_JOIN_SPURIOUS_RESULTS_FIX">EMIT_INTERVAL_MS_KSTREAMS_OUTER_JOIN_SPURIOUS_RESULTS_FIX</a></code></div>
<div class="col-last odd-row-color"><code>"__emit.interval.ms.kstreams.outer.join.spurious.results.fix__"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.streams.StreamsConfig.InternalConfig.EMIT_INTERVAL_MS_KSTREAMS_WINDOWED_AGGREGATION">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.InternalConfig.html#EMIT_INTERVAL_MS_KSTREAMS_WINDOWED_AGGREGATION">EMIT_INTERVAL_MS_KSTREAMS_WINDOWED_AGGREGATION</a></code></div>
<div class="col-last even-row-color"><code>"__emit.interval.ms.kstreams.windowed.aggregation__"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.streams.StreamsConfig.InternalConfig.INTERNAL_TASK_ASSIGNOR_CLASS">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.InternalConfig.html#INTERNAL_TASK_ASSIGNOR_CLASS">INTERNAL_TASK_ASSIGNOR_CLASS</a></code></div>
<div class="col-last odd-row-color"><code>"internal.task.assignor.class"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.streams.StreamsConfig.InternalConfig.IQ_CONSISTENCY_OFFSET_VECTOR_ENABLED">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.InternalConfig.html#IQ_CONSISTENCY_OFFSET_VECTOR_ENABLED">IQ_CONSISTENCY_OFFSET_VECTOR_ENABLED</a></code></div>
<div class="col-last even-row-color"><code>"__iq.consistency.offset.vector.enabled__"</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.streams.StreamsConfig.InternalConfig.REFERENCE_CONTAINER_PARTITION_ASSIGNOR">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.InternalConfig.html#REFERENCE_CONTAINER_PARTITION_ASSIGNOR">REFERENCE_CONTAINER_PARTITION_ASSIGNOR</a></code></div>
<div class="col-last odd-row-color"><code>"__reference.container.instance__"</code></div>
<div class="col-first even-row-color"><code id="org.apache.kafka.streams.StreamsConfig.InternalConfig.TOPIC_PREFIX_ALTERNATIVE">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/streams/StreamsConfig.InternalConfig.html#TOPIC_PREFIX_ALTERNATIVE">TOPIC_PREFIX_ALTERNATIVE</a></code></div>
<div class="col-last even-row-color"><code>"__internal.override.topic.prefix__"</code></div>
</div>
</li>
</ul>
<ul class="block-list">
<li>
<div class="caption"><span>org.apache.kafka.streams.kstream.<a href="org/apache/kafka/streams/kstream/Windows.html" title="class in org.apache.kafka.streams.kstream">Windows</a>&lt;<a href="org/apache/kafka/streams/kstream/Windows.html" title="type parameter in Windows">W</a> extends <a href="org/apache/kafka/streams/kstream/Window.html" title="class in org.apache.kafka.streams.kstream">Window</a>&gt;</span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Constant Field</div>
<div class="table-header col-last">Value</div>
<div class="col-first even-row-color"><code id="org.apache.kafka.streams.kstream.Windows.DEPRECATED_DEFAULT_24_HR_GRACE_PERIOD">protected&nbsp;static&nbsp;final&nbsp;long</code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/streams/kstream/Windows.html#DEPRECATED_DEFAULT_24_HR_GRACE_PERIOD">DEPRECATED_DEFAULT_24_HR_GRACE_PERIOD</a></code></div>
<div class="col-last even-row-color"><code>86400000L</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.streams.kstream.Windows.NO_GRACE_PERIOD">protected&nbsp;static&nbsp;final&nbsp;long</code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/streams/kstream/Windows.html#NO_GRACE_PERIOD">NO_GRACE_PERIOD</a></code></div>
<div class="col-last odd-row-color"><code>0L</code></div>
</div>
</li>
</ul>
<ul class="block-list">
<li>
<div class="caption"><span>org.apache.kafka.streams.processor.<a href="org/apache/kafka/streams/processor/TaskId.html" title="class in org.apache.kafka.streams.processor">TaskId</a></span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Constant Field</div>
<div class="table-header col-last">Value</div>
<div class="col-first even-row-color"><code id="org.apache.kafka.streams.processor.TaskId.NAMED_TOPOLOGY_DELIMITER">public&nbsp;static&nbsp;final&nbsp;<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/streams/processor/TaskId.html#NAMED_TOPOLOGY_DELIMITER">NAMED_TOPOLOGY_DELIMITER</a></code></div>
<div class="col-last even-row-color"><code>"__"</code></div>
</div>
</li>
</ul>
<ul class="block-list">
<li>
<div class="caption"><span>org.apache.kafka.streams.state.<a href="org/apache/kafka/streams/state/StateSerdes.html" title="class in org.apache.kafka.streams.state">StateSerdes</a>&lt;<a href="org/apache/kafka/streams/state/StateSerdes.html" title="type parameter in StateSerdes">K</a>,<wbr><a href="org/apache/kafka/streams/state/StateSerdes.html" title="type parameter in StateSerdes">V</a>&gt;</span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Constant Field</div>
<div class="table-header col-last">Value</div>
<div class="col-first even-row-color"><code id="org.apache.kafka.streams.state.StateSerdes.BOOLEAN_SIZE">public&nbsp;static&nbsp;final&nbsp;int</code></div>
<div class="col-second even-row-color"><code><a href="org/apache/kafka/streams/state/StateSerdes.html#BOOLEAN_SIZE">BOOLEAN_SIZE</a></code></div>
<div class="col-last even-row-color"><code>1</code></div>
<div class="col-first odd-row-color"><code id="org.apache.kafka.streams.state.StateSerdes.TIMESTAMP_SIZE">public&nbsp;static&nbsp;final&nbsp;int</code></div>
<div class="col-second odd-row-color"><code><a href="org/apache/kafka/streams/state/StateSerdes.html#TIMESTAMP_SIZE">TIMESTAMP_SIZE</a></code></div>
<div class="col-last odd-row-color"><code>8</code></div>
</div>
</li>
</ul>
</section>
</main>
</div>
</div>
</body>
</html>
