content: /*
   * Licensed to the Apache Software Foundation (ASF) under one
   * or more contributor license agreements.  See the NOTICE file
   * distributed with this work for additional information
   * regarding copyright ownership.  The ASF licenses this file
   * to you under the Apache License, Version 2.0 (the
   * "License"); you may not use this file except in compliance
   * with the License.  You may obtain a copy of the License at
   *
   *     http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  package com.datastax.oss.driver.api.core.config;
  
  import com.datastax.dse.driver.api.core.config.DseDriverOption;
  import com.datastax.oss.driver.api.core.type.reflect.GenericType;
  import com.datastax.oss.driver.shaded.guava.common.collect.ImmutableList;
  import edu.umd.cs.findbugs.annotations.NonNull;
  import java.lang.reflect.Field;
  import java.lang.reflect.Modifier;
  import java.time.Duration;
  import java.util.List;
  import java.util.Map;
  import java.util.Objects;
  import java.util.StringJoiner;
  
  /**
   * A type-safe wrapper around {@link DriverOption}, that encodes the intended value type of each
   * option.
   *
   * <p>This type was introduced in conjunction with {@link DriverConfigLoader#fromMap(OptionsMap)}.
   * Unfortunately, for backward compatibility reasons, it wasn't possible to retrofit the rest of the
   * driver to use it; therefore the APIs used to read the configuration, such as {@link DriverConfig}
   * and {@link DriverExecutionProfile}, still use the untyped {@link DriverOption}.
   *
   * @since 4.6.0
   */
  public class TypedDriverOption<ValueT> {
  
    private static volatile Iterable<TypedDriverOption<?>> builtInValues;
  
    /**
     * Returns the list of all built-in options known to the driver codebase; in other words, all the
     * {@link TypedDriverOption} constants defined on this class.
     *
     * <p>Note that 3rd-party driver extensions might define their own {@link TypedDriverOption}
     * constants for custom options.
     *
     * <p>This method uses reflection to introspect all the constants on this class; the result is
     * computed lazily on the first invocation, and then cached for future calls.
     */
    public static Iterable<TypedDriverOption<?>> builtInValues() {
      if (builtInValues == null) {
        builtInValues = introspectBuiltInValues();
      }
      return builtInValues;
    }
  
    private final DriverOption rawOption;
    private final GenericType<ValueT> expectedType;
  
    public TypedDriverOption(
        @NonNull DriverOption rawOption, @NonNull GenericType<ValueT> expectedType) {
      this.rawOption = Objects.requireNonNull(rawOption);
      this.expectedType = Objects.requireNonNull(expectedType);
    }
  
    @NonNull
    public DriverOption getRawOption() {
      return rawOption;
    }
  
    @NonNull
    public GenericType<ValueT> getExpectedType() {
      return expectedType;
    }
  
    @Override
    public boolean equals(Object other) {
      if (other == this) {
        return true;
      } else if (other instanceof TypedDriverOption) {
        TypedDriverOption<?> that = (TypedDriverOption<?>) other;
        return this.rawOption.equals(that.rawOption) && this.expectedType.equals(that.expectedType);
      } else {
        return false;
      }
    }
  
    @Override
    public int hashCode() {
      return Objects.hash(rawOption, expectedType);
    }
  
    @Override
    public String toString() {
      return new StringJoiner(", ", TypedDriverOption.class.getSimpleName() + "[", "]")
          .add("rawOption=" + rawOption)
          .add("expectedType=" + expectedType)
          .toString();
    }
  
    /** The contact points to use for the initial connection to the cluster. */
    public static final TypedDriverOption<List<String>> CONTACT_POINTS =
        new TypedDriverOption<>(DefaultDriverOption.CONTACT_POINTS, GenericType.listOf(String.class));
    /** A name that uniquely identifies the driver instance. */
    public static final TypedDriverOption<String> SESSION_NAME =
        new TypedDriverOption<>(DefaultDriverOption.SESSION_NAME, GenericType.STRING);
    /** The name of the keyspace that the session should initially be connected to. */
    public static final TypedDriverOption<String> SESSION_KEYSPACE =
        new TypedDriverOption<>(DefaultDriverOption.SESSION_KEYSPACE, GenericType.STRING);
    /** How often the driver tries to reload the configuration. */
    public static final TypedDriverOption<Duration> CONFIG_RELOAD_INTERVAL =
        new TypedDriverOption<>(DefaultDriverOption.CONFIG_RELOAD_INTERVAL, GenericType.DURATION);
    /** How long the driver waits for a request to complete. */
    public static final TypedDriverOption<Duration> REQUEST_TIMEOUT =
        new TypedDriverOption<>(DefaultDriverOption.REQUEST_TIMEOUT, GenericType.DURATION);
    /** The consistency level. */
    public static final TypedDriverOption<String> REQUEST_CONSISTENCY =
        new TypedDriverOption<>(DefaultDriverOption.REQUEST_CONSISTENCY, GenericType.STRING);
    /** The page size. */
    public static final TypedDriverOption<Integer> REQUEST_PAGE_SIZE =
        new TypedDriverOption<>(DefaultDriverOption.REQUEST_PAGE_SIZE, GenericType.INTEGER);
    /** The serial consistency level. */
    public static final TypedDriverOption<String> REQUEST_SERIAL_CONSISTENCY =
        new TypedDriverOption<>(DefaultDriverOption.REQUEST_SERIAL_CONSISTENCY, GenericType.STRING);
    /** The default idempotence of a request. */
    public static final TypedDriverOption<Boolean> REQUEST_DEFAULT_IDEMPOTENCE =
        new TypedDriverOption<>(DefaultDriverOption.REQUEST_DEFAULT_IDEMPOTENCE, GenericType.BOOLEAN);
    /** The class of the load balancing policy. */
    public static final TypedDriverOption<String> LOAD_BALANCING_POLICY_CLASS =
        new TypedDriverOption<>(DefaultDriverOption.LOAD_BALANCING_POLICY_CLASS, GenericType.STRING);
    /** The datacenter that is considered "local". */
    public static final TypedDriverOption<String> LOAD_BALANCING_LOCAL_DATACENTER =
        new TypedDriverOption<>(
            DefaultDriverOption.LOAD_BALANCING_LOCAL_DATACENTER, GenericType.STRING);
    /**
     * A custom filter to include/exclude nodes.
     *
     * @deprecated Use {@link #LOAD_BALANCING_DISTANCE_EVALUATOR_CLASS} instead.
     */
    @Deprecated
    public static final TypedDriverOption<String> LOAD_BALANCING_FILTER_CLASS =
        new TypedDriverOption<>(DefaultDriverOption.LOAD_BALANCING_FILTER_CLASS, GenericType.STRING);
    /**
     * The class name of a custom {@link
     * com.datastax.oss.driver.api.core.loadbalancing.NodeDistanceEvaluator}.
     */
    public static final TypedDriverOption<String> LOAD_BALANCING_DISTANCE_EVALUATOR_CLASS =
        new TypedDriverOption<>(
            DefaultDriverOption.LOAD_BALANCING_DISTANCE_EVALUATOR_CLASS, GenericType.STRING);
    /** The timeout to use for internal queries that run as part of the initialization process. */
    public static final TypedDriverOption<Duration> CONNECTION_INIT_QUERY_TIMEOUT =
        new TypedDriverOption<>(
            DefaultDriverOption.CONNECTION_INIT_QUERY_TIMEOUT, GenericType.DURATION);
    /** The timeout to use when the driver changes the keyspace on a connection at runtime. */
    public static final TypedDriverOption<Duration> CONNECTION_SET_KEYSPACE_TIMEOUT =
        new TypedDriverOption<>(
            DefaultDriverOption.CONNECTION_SET_KEYSPACE_TIMEOUT, GenericType.DURATION);
    /** The maximum number of requests that can be executed concurrently on a connection. */
    public static final TypedDriverOption<Integer> CONNECTION_MAX_REQUESTS =
        new TypedDriverOption<>(DefaultDriverOption.CONNECTION_MAX_REQUESTS, GenericType.INTEGER);
    /** The maximum number of "orphaned" requests before a connection gets closed automatically. */
    public static final TypedDriverOption<Integer> CONNECTION_MAX_ORPHAN_REQUESTS =
        new TypedDriverOption<>(
            DefaultDriverOption.CONNECTION_MAX_ORPHAN_REQUESTS, GenericType.INTEGER);
    /** Whether to log non-fatal errors when the driver tries to open a new connection. */
    public static final TypedDriverOption<Boolean> CONNECTION_WARN_INIT_ERROR =
        new TypedDriverOption<>(DefaultDriverOption.CONNECTION_WARN_INIT_ERROR, GenericType.BOOLEAN);
    /** The number of connections in the LOCAL pool. */
    public static final TypedDriverOption<Integer> CONNECTION_POOL_LOCAL_SIZE =
        new TypedDriverOption<>(DefaultDriverOption.CONNECTION_POOL_LOCAL_SIZE, GenericType.INTEGER);
    /** The number of connections in the REMOTE pool. */
    public static final TypedDriverOption<Integer> CONNECTION_POOL_REMOTE_SIZE =
        new TypedDriverOption<>(DefaultDriverOption.CONNECTION_POOL_REMOTE_SIZE, GenericType.INTEGER);
    /**
     * Whether to schedule reconnection attempts if all contact points are unreachable on the first
     * initialization attempt.
     */
    public static final TypedDriverOption<Boolean> RECONNECT_ON_INIT =
        new TypedDriverOption<>(DefaultDriverOption.RECONNECT_ON_INIT, GenericType.BOOLEAN);
    /** The class of the reconnection policy. */
    public static final TypedDriverOption<String> RECONNECTION_POLICY_CLASS =
        new TypedDriverOption<>(DefaultDriverOption.RECONNECTION_POLICY_CLASS, GenericType.STRING);
    /** Base delay for computing time between reconnection attempts. */
    public static final TypedDriverOption<Duration> RECONNECTION_BASE_DELAY =
        new TypedDriverOption<>(DefaultDriverOption.RECONNECTION_BASE_DELAY, GenericType.DURATION);
    /** Maximum delay between reconnection attempts. */
    public static final TypedDriverOption<Duration> RECONNECTION_MAX_DELAY =
        new TypedDriverOption<>(DefaultDriverOption.RECONNECTION_MAX_DELAY, GenericType.DURATION);
    /** The class of the retry policy. */
    public static final TypedDriverOption<String> RETRY_POLICY_CLASS =
        new TypedDriverOption<>(DefaultDriverOption.RETRY_POLICY_CLASS, GenericType.STRING);
    /** The class of the speculative execution policy. */
    public static final TypedDriverOption<String> SPECULATIVE_EXECUTION_POLICY_CLASS =
        new TypedDriverOption<>(
            DefaultDriverOption.SPECULATIVE_EXECUTION_POLICY_CLASS, GenericType.STRING);
    /** The maximum number of executions. */
    public static final TypedDriverOption<Integer> SPECULATIVE_EXECUTION_MAX =
        new TypedDriverOption<>(DefaultDriverOption.SPECULATIVE_EXECUTION_MAX, GenericType.INTEGER);
    /** The delay between each execution. */
    public static final TypedDriverOption<Duration> SPECULATIVE_EXECUTION_DELAY =
        new TypedDriverOption<>(
            DefaultDriverOption.SPECULATIVE_EXECUTION_DELAY, GenericType.DURATION);
    /** The class of the authentication provider. */
    public static final TypedDriverOption<String> AUTH_PROVIDER_CLASS =
        new TypedDriverOption<>(DefaultDriverOption.AUTH_PROVIDER_CLASS, GenericType.STRING);
    /** Plain text auth provider username. */
    public static final TypedDriverOption<String> AUTH_PROVIDER_USER_NAME =
        new TypedDriverOption<>(DefaultDriverOption.AUTH_PROVIDER_USER_NAME, GenericType.STRING);
    /** Plain text auth provider password. */
    public static final TypedDriverOption<String> AUTH_PROVIDER_PASSWORD =
        new TypedDriverOption<>(DefaultDriverOption.AUTH_PROVIDER_PASSWORD, GenericType.STRING);
    /** The class of the SSL Engine Factory. */
    public static final TypedDriverOption<String> SSL_ENGINE_FACTORY_CLASS =
        new TypedDriverOption<>(DefaultDriverOption.SSL_ENGINE_FACTORY_CLASS, GenericType.STRING);
    /** The cipher suites to enable when creating an SSLEngine for a connection. */
    public static final TypedDriverOption<List<String>> SSL_CIPHER_SUITES =
        new TypedDriverOption<>(
            DefaultDriverOption.SSL_CIPHER_SUITES, GenericType.listOf(String.class));
    /**
     * Whether or not to require validation that the hostname of the server certificate's common name
     * matches the hostname of the server being connected to.
     */
    public static final TypedDriverOption<Boolean> SSL_HOSTNAME_VALIDATION =
        new TypedDriverOption<>(DefaultDriverOption.SSL_HOSTNAME_VALIDATION, GenericType.BOOLEAN);
  
    public static final TypedDriverOption<Boolean> SSL_ALLOW_DNS_REVERSE_LOOKUP_SAN =
        new TypedDriverOption<>(
            DefaultDriverOption.SSL_ALLOW_DNS_REVERSE_LOOKUP_SAN, GenericType.BOOLEAN);
    /** The location of the keystore file. */
    public static final TypedDriverOption<String> SSL_KEYSTORE_PATH =
        new TypedDriverOption<>(DefaultDriverOption.SSL_KEYSTORE_PATH, GenericType.STRING);
    /** The keystore password. */
    public static final TypedDriverOption<String> SSL_KEYSTORE_PASSWORD =
        new TypedDriverOption<>(DefaultDriverOption.SSL_KEYSTORE_PASSWORD, GenericType.STRING);
  
    /** The duration between attempts to reload the keystore. */
    public static final TypedDriverOption<Duration> SSL_KEYSTORE_RELOAD_INTERVAL =
        new TypedDriverOption<>(
            DefaultDriverOption.SSL_KEYSTORE_RELOAD_INTERVAL, GenericType.DURATION);
  
    /** The location of the truststore file. */
    public static final TypedDriverOption<String> SSL_TRUSTSTORE_PATH =
        new TypedDriverOption<>(DefaultDriverOption.SSL_TRUSTSTORE_PATH, GenericType.STRING);
    /** The truststore password. */
    public static final TypedDriverOption<String> SSL_TRUSTSTORE_PASSWORD =
        new TypedDriverOption<>(DefaultDriverOption.SSL_TRUSTSTORE_PASSWORD, GenericType.STRING);
    /** The class of the generator that assigns a microsecond timestamp to each request. */
    public static final TypedDriverOption<String> TIMESTAMP_GENERATOR_CLASS =
        new TypedDriverOption<>(DefaultDriverOption.TIMESTAMP_GENERATOR_CLASS, GenericType.STRING);
    /** Whether to force the driver to use Java's millisecond-precision system clock. */
    public static final TypedDriverOption<Boolean> TIMESTAMP_GENERATOR_FORCE_JAVA_CLOCK =
        new TypedDriverOption<>(
            DefaultDriverOption.TIMESTAMP_GENERATOR_FORCE_JAVA_CLOCK, GenericType.BOOLEAN);
    /** How far in the future timestamps are allowed to drift before the warning is logged. */
    public static final TypedDriverOption<Duration> TIMESTAMP_GENERATOR_DRIFT_WARNING_THRESHOLD =
        new TypedDriverOption<>(
            DefaultDriverOption.TIMESTAMP_GENERATOR_DRIFT_WARNING_THRESHOLD, GenericType.DURATION);
    /** How often the warning will be logged if timestamps keep drifting above the threshold. */
    public static final TypedDriverOption<Duration> TIMESTAMP_GENERATOR_DRIFT_WARNING_INTERVAL =
        new TypedDriverOption<>(
            DefaultDriverOption.TIMESTAMP_GENERATOR_DRIFT_WARNING_INTERVAL, GenericType.DURATION);
  
    /**
     * The class of a session-wide component that tracks the outcome of requests.
     *
     * @deprecated Use {@link #REQUEST_TRACKER_CLASSES} instead.
     */
    @Deprecated
    public static final TypedDriverOption<String> REQUEST_TRACKER_CLASS =
        new TypedDriverOption<>(DefaultDriverOption.REQUEST_TRACKER_CLASS, GenericType.STRING);
  
    /** The classes of session-wide components that track the outcome of requests. */
    public static final TypedDriverOption<List<String>> REQUEST_TRACKER_CLASSES =
        new TypedDriverOption<>(
            DefaultDriverOption.REQUEST_TRACKER_CLASSES, GenericType.listOf(String.class));
  
    /** The class of a session-wide component that generates request IDs. */
    public static final TypedDriverOption<String> REQUEST_ID_GENERATOR_CLASS =
        new TypedDriverOption<>(DefaultDriverOption.REQUEST_ID_GENERATOR_CLASS, GenericType.STRING);
  
    /** Whether to log successful requests. */
    public static final TypedDriverOption<Boolean> REQUEST_LOGGER_SUCCESS_ENABLED =
        new TypedDriverOption<>(
            DefaultDriverOption.REQUEST_LOGGER_SUCCESS_ENABLED, GenericType.BOOLEAN);
    /** The threshold to classify a successful request as "slow". */
    public static final TypedDriverOption<Duration> REQUEST_LOGGER_SLOW_THRESHOLD =
        new TypedDriverOption<>(
            DefaultDriverOption.REQUEST_LOGGER_SLOW_THRESHOLD, GenericType.DURATION);
    /** Whether to log slow requests. */
    public static final TypedDriverOption<Boolean> REQUEST_LOGGER_SLOW_ENABLED =
        new TypedDriverOption<>(DefaultDriverOption.REQUEST_LOGGER_SLOW_ENABLED, GenericType.BOOLEAN);
    /** Whether to log failed requests. */
    public static final TypedDriverOption<Boolean> REQUEST_LOGGER_ERROR_ENABLED =
        new TypedDriverOption<>(
            DefaultDriverOption.REQUEST_LOGGER_ERROR_ENABLED, GenericType.BOOLEAN);
    /** The maximum length of the query string in the log message. */
    public static final TypedDriverOption<Integer> REQUEST_LOGGER_MAX_QUERY_LENGTH =
        new TypedDriverOption<>(
            DefaultDriverOption.REQUEST_LOGGER_MAX_QUERY_LENGTH, GenericType.INTEGER);
    /** Whether to log bound values in addition to the query string. */
    public static final TypedDriverOption<Boolean> REQUEST_LOGGER_VALUES =
        new TypedDriverOption<>(DefaultDriverOption.REQUEST_LOGGER_VALUES, GenericType.BOOLEAN);
    /** The maximum length for bound values in the log message. */
    public static final TypedDriverOption<Integer> REQUEST_LOGGER_MAX_VALUE_LENGTH =
        new TypedDriverOption<>(
            DefaultDriverOption.REQUEST_LOGGER_MAX_VALUE_LENGTH, GenericType.INTEGER);
    /** The maximum number of bound values to log. */
    public static final TypedDriverOption<Integer> REQUEST_LOGGER_MAX_VALUES =
        new TypedDriverOption<>(DefaultDriverOption.REQUEST_LOGGER_MAX_VALUES, GenericType.INTEGER);
    /** Whether to log stack traces for failed queries. */
    public static final TypedDriverOption<Boolean> REQUEST_LOGGER_STACK_TRACES =
        new TypedDriverOption<>(DefaultDriverOption.REQUEST_LOGGER_STACK_TRACES, GenericType.BOOLEAN);
    /**
     * The class of a session-wide component that controls the rate at which requests are executed.
     */
    public static final TypedDriverOption<String> REQUEST_THROTTLER_CLASS =
        new TypedDriverOption<>(DefaultDriverOption.REQUEST_THROTTLER_CLASS, GenericType.STRING);
    /** The maximum number of requests that are allowed to execute in parallel. */
    public static final TypedDriverOption<Integer> REQUEST_THROTTLER_MAX_CONCURRENT_REQUESTS =
        new TypedDriverOption<>(
            DefaultDriverOption.REQUEST_THROTTLER_MAX_CONCURRENT_REQUESTS, GenericType.INTEGER);
    /** The maximum allowed request rate. */
    public static final TypedDriverOption<Integer> REQUEST_THROTTLER_MAX_REQUESTS_PER_SECOND =
        new TypedDriverOption<>(
            DefaultDriverOption.REQUEST_THROTTLER_MAX_REQUESTS_PER_SECOND, GenericType.INTEGER);
    /**
     * The maximum number of requests that can be enqueued when the throttling threshold is exceeded.
     */
    public static final TypedDriverOption<Integer> REQUEST_THROTTLER_MAX_QUEUE_SIZE =
        new TypedDriverOption<>(
            DefaultDriverOption.REQUEST_THROTTLER_MAX_QUEUE_SIZE, GenericType.INTEGER);
    /** How often the throttler attempts to dequeue requests. */
    public static final TypedDriverOption<Duration> REQUEST_THROTTLER_DRAIN_INTERVAL =
        new TypedDriverOption<>(
            DefaultDriverOption.REQUEST_THROTTLER_DRAIN_INTERVAL, GenericType.DURATION);
  
    /**
     * The class of a session-wide component that listens for node state changes.
     *
     * @deprecated Use {@link #METADATA_NODE_STATE_LISTENER_CLASSES} instead.
     */
    @Deprecated
    public static final TypedDriverOption<String> METADATA_NODE_STATE_LISTENER_CLASS =
        new TypedDriverOption<>(
            DefaultDriverOption.METADATA_NODE_STATE_LISTENER_CLASS, GenericType.STRING);
  
    /**
     * The class of a session-wide component that listens for schema changes.
     *
     * @deprecated Use {@link #METADATA_SCHEMA_CHANGE_LISTENER_CLASSES} instead.
     */
    @Deprecated
    public static final TypedDriverOption<String> METADATA_SCHEMA_CHANGE_LISTENER_CLASS =
        new TypedDriverOption<>(
            DefaultDriverOption.METADATA_SCHEMA_CHANGE_LISTENER_CLASS, GenericType.STRING);
  
    /** The classes of session-wide components that listen for node state changes. */
    public static final TypedDriverOption<List<String>> METADATA_NODE_STATE_LISTENER_CLASSES =
        new TypedDriverOption<>(
            DefaultDriverOption.METADATA_NODE_STATE_LISTENER_CLASSES,
            GenericType.listOf(String.class));
  
    /** The classes of session-wide components that listen for schema changes. */
    public static final TypedDriverOption<List<String>> METADATA_SCHEMA_CHANGE_LISTENER_CLASSES =
        new TypedDriverOption<>(
            DefaultDriverOption.METADATA_SCHEMA_CHANGE_LISTENER_CLASSES,
            GenericType.listOf(String.class));
  
    /**
     * The class of the address translator to use to convert the addresses sent by Cassandra nodes
     * into ones that the driver uses to connect.
     */
    public static final TypedDriverOption<String> ADDRESS_TRANSLATOR_CLASS =
        new TypedDriverOption<>(DefaultDriverOption.ADDRESS_TRANSLATOR_CLASS, GenericType.STRING);
    /** The native protocol version to use. */
    public static final TypedDriverOption<String> PROTOCOL_VERSION =
        new TypedDriverOption<>(DefaultDriverOption.PROTOCOL_VERSION, GenericType.STRING);
    /** The name of the algorithm used to compress protocol frames. */
    public static final TypedDriverOption<String> PROTOCOL_COMPRESSION =
        new TypedDriverOption<>(DefaultDriverOption.PROTOCOL_COMPRESSION, GenericType.STRING);
    /** The maximum length, in bytes, of the frames supported by the driver. */
    public static final TypedDriverOption<Long> PROTOCOL_MAX_FRAME_LENGTH =
        new TypedDriverOption<>(DefaultDriverOption.PROTOCOL_MAX_FRAME_LENGTH, GenericType.LONG);
    /**
     * Whether a warning is logged when a request (such as a CQL `USE ...`) changes the active
     * keyspace.
     */
    public static final TypedDriverOption<Boolean> REQUEST_WARN_IF_SET_KEYSPACE =
        new TypedDriverOption<>(
            DefaultDriverOption.REQUEST_WARN_IF_SET_KEYSPACE, GenericType.BOOLEAN);
    /** How many times the driver will attempt to fetch the query trace if it is not ready yet. */
    public static final TypedDriverOption<Integer> REQUEST_TRACE_ATTEMPTS =
        new TypedDriverOption<>(DefaultDriverOption.REQUEST_TRACE_ATTEMPTS, GenericType.INTEGER);
    /** The interval between each attempt. */
    public static final TypedDriverOption<Duration> REQUEST_TRACE_INTERVAL =
        new TypedDriverOption<>(DefaultDriverOption.REQUEST_TRACE_INTERVAL, GenericType.DURATION);
    /** The consistency level to use for trace queries. */
    public static final TypedDriverOption<String> REQUEST_TRACE_CONSISTENCY =
        new TypedDriverOption<>(DefaultDriverOption.REQUEST_TRACE_CONSISTENCY, GenericType.STRING);
    /** Whether or not to publish aggregable histogram for metrics */
    public static final TypedDriverOption<Boolean> METRICS_GENERATE_AGGREGABLE_HISTOGRAMS =
        new TypedDriverOption<>(
            DefaultDriverOption.METRICS_GENERATE_AGGREGABLE_HISTOGRAMS, GenericType.BOOLEAN);
    /** List of enabled session-level metrics. */
    public static final TypedDriverOption<List<String>> METRICS_SESSION_ENABLED =
        new TypedDriverOption<>(
            DefaultDriverOption.METRICS_SESSION_ENABLED, GenericType.listOf(String.class));
    /** List of enabled node-level metrics. */
    public static final TypedDriverOption<List<String>> METRICS_NODE_ENABLED =
        new TypedDriverOption<>(
            DefaultDriverOption.METRICS_NODE_ENABLED, GenericType.listOf(String.class));
    /** The largest latency that we expect to record for requests. */
    public static final TypedDriverOption<Duration> METRICS_SESSION_CQL_REQUESTS_HIGHEST =
        new TypedDriverOption<>(
            DefaultDriverOption.METRICS_SESSION_CQL_REQUESTS_HIGHEST, GenericType.DURATION);
    /** The shortest latency that we expect to record for requests. */
    public static final TypedDriverOption<Duration> METRICS_SESSION_CQL_REQUESTS_LOWEST =
        new TypedDriverOption<>(
            DefaultDriverOption.METRICS_SESSION_CQL_REQUESTS_LOWEST, GenericType.DURATION);
    /** Optional service-level objectives to meet, as a list of latencies to track. */
    public static final TypedDriverOption<List<Duration>> METRICS_SESSION_CQL_REQUESTS_SLO =
        new TypedDriverOption<>(
            DefaultDriverOption.METRICS_SESSION_CQL_REQUESTS_SLO,
            GenericType.listOf(GenericType.DURATION));
    /** Optional pre-defined percentile of cql requests to publish, as a list of percentiles . */
    public static final TypedDriverOption<List<Double>>
        METRICS_SESSION_CQL_REQUESTS_PUBLISH_PERCENTILES =
            new TypedDriverOption<>(
                DefaultDriverOption.METRICS_SESSION_CQL_REQUESTS_PUBLISH_PERCENTILES,
                GenericType.listOf(GenericType.DOUBLE));
    /**
     * The number of significant decimal digits to which internal structures will maintain for
     * requests.
     */
    public static final TypedDriverOption<Integer> METRICS_SESSION_CQL_REQUESTS_DIGITS =
        new TypedDriverOption<>(
            DefaultDriverOption.METRICS_SESSION_CQL_REQUESTS_DIGITS, GenericType.INTEGER);
    /** The interval at which percentile data is refreshed for requests. */
    public static final TypedDriverOption<Duration> METRICS_SESSION_CQL_REQUESTS_INTERVAL =
        new TypedDriverOption<>(
            DefaultDriverOption.METRICS_SESSION_CQL_REQUESTS_INTERVAL, GenericType.DURATION);
    /** The largest latency that we expect to record for throttling. */
    public static final TypedDriverOption<Duration> METRICS_SESSION_THROTTLING_HIGHEST =
        new TypedDriverOption<>(
            DefaultDriverOption.METRICS_SESSION_THROTTLING_HIGHEST, GenericType.DURATION);
    /** The shortest latency that we expect to record for throttling. */
    public static final TypedDriverOption<Duration> METRICS_SESSION_THROTTLING_LOWEST =
        new TypedDriverOption<>(
            DefaultDriverOption.METRICS_SESSION_THROTTLING_LOWEST, GenericType.DURATION);
    /** Optional service-level objectives to meet, as a list of latencies to track. */
    public static final TypedDriverOption<List<Duration>> METRICS_SESSION_THROTTLING_SLO =
        new TypedDriverOption<>(
            DefaultDriverOption.METRICS_SESSION_THROTTLING_SLO,
            GenericType.listOf(GenericType.DURATION));
    /** Optional pre-defined percentile of throttling delay to publish, as a list of percentiles . */
    public static final TypedDriverOption<List<Double>>
        METRICS_SESSION_THROTTLING_PUBLISH_PERCENTILES =
            new TypedDriverOption<>(
                DefaultDriverOption.METRICS_SESSION_THROTTLING_PUBLISH_PERCENTILES,
                GenericType.listOf(GenericType.DOUBLE));
    /**
     * The number of significant decimal digits to which internal structures will maintain for
     * throttling.
     */
    public static final TypedDriverOption<Integer> METRICS_SESSION_THROTTLING_DIGITS =
        new TypedDriverOption<>(
            DefaultDriverOption.METRICS_SESSION_THROTTLING_DIGITS, GenericType.INTEGER);
    /** The interval at which percentile data is refreshed for throttling. */
    public static final TypedDriverOption<Duration> METRICS_SESSION_THROTTLING_INTERVAL =
        new TypedDriverOption<>(
            DefaultDriverOption.METRICS_SESSION_THROTTLING_INTERVAL, GenericType.DURATION);
    /** The largest latency that we expect to record for requests. */
    public static final TypedDriverOption<Duration> METRICS_NODE_CQL_MESSAGES_HIGHEST =
        new TypedDriverOption<>(
            DefaultDriverOption.METRICS_NODE_CQL_MESSAGES_HIGHEST, GenericType.DURATION);
    /** The shortest latency that we expect to record for requests. */
    public static final TypedDriverOption<Duration> METRICS_NODE_CQL_MESSAGES_LOWEST =
        new TypedDriverOption<>(
            DefaultDriverOption.METRICS_NODE_CQL_MESSAGES_LOWEST, GenericType.DURATION);
    /** Optional service-level objectives to meet, as a list of latencies to track. */
    public static final TypedDriverOption<List<Duration>> METRICS_NODE_CQL_MESSAGES_SLO =
        new TypedDriverOption<>(
            DefaultDriverOption.METRICS_NODE_CQL_MESSAGES_SLO,
            GenericType.listOf(GenericType.DURATION));
    /** Optional pre-defined percentile of node cql messages to publish, as a list of percentiles . */
    public static final TypedDriverOption<List<Double>>
        METRICS_NODE_CQL_MESSAGES_PUBLISH_PERCENTILES =
            new TypedDriverOption<>(
                DefaultDriverOption.METRICS_NODE_CQL_MESSAGES_PUBLISH_PERCENTILES,
                GenericType.listOf(GenericType.DOUBLE));
    /**
     * The number of significant decimal digits to which internal structures will maintain for
     * requests.
     */
    public static final TypedDriverOption<Integer> METRICS_NODE_CQL_MESSAGES_DIGITS =
        new TypedDriverOption<>(
            DefaultDriverOption.METRICS_NODE_CQL_MESSAGES_DIGITS, GenericType.INTEGER);
    /** The interval at which percentile data is refreshed for requests. */
    public static final TypedDriverOption<Duration> METRICS_NODE_CQL_MESSAGES_INTERVAL =
        new TypedDriverOption<>(
            DefaultDriverOption.METRICS_NODE_CQL_MESSAGES_INTERVAL, GenericType.DURATION);
    /** Whether or not to disable the Nagle algorithm. */
    public static final TypedDriverOption<Boolean> SOCKET_TCP_NODELAY =
        new TypedDriverOption<>(DefaultDriverOption.SOCKET_TCP_NODELAY, GenericType.BOOLEAN);
    /** Whether or not to enable TCP keep-alive probes. */
    public static final TypedDriverOption<Boolean> SOCKET_KEEP_ALIVE =
        new TypedDriverOption<>(DefaultDriverOption.SOCKET_KEEP_ALIVE, GenericType.BOOLEAN);
    /** Whether or not to allow address reuse. */
    public static final TypedDriverOption<Boolean> SOCKET_REUSE_ADDRESS =
        new TypedDriverOption<>(DefaultDriverOption.SOCKET_REUSE_ADDRESS, GenericType.BOOLEAN);
    /** Sets the linger interval. */
    public static final TypedDriverOption<Integer> SOCKET_LINGER_INTERVAL =
        new TypedDriverOption<>(DefaultDriverOption.SOCKET_LINGER_INTERVAL, GenericType.INTEGER);
    /** Sets a hint to the size of the underlying buffers for incoming network I/O. */
    public static final TypedDriverOption<Integer> SOCKET_RECEIVE_BUFFER_SIZE =
        new TypedDriverOption<>(DefaultDriverOption.SOCKET_RECEIVE_BUFFER_SIZE, GenericType.INTEGER);
    /** Sets a hint to the size of the underlying buffers for outgoing network I/O. */
    public static final TypedDriverOption<Integer> SOCKET_SEND_BUFFER_SIZE =
        new TypedDriverOption<>(DefaultDriverOption.SOCKET_SEND_BUFFER_SIZE, GenericType.INTEGER);
    /** The connection heartbeat interval. */
    public static final TypedDriverOption<Duration> HEARTBEAT_INTERVAL =
        new TypedDriverOption<>(DefaultDriverOption.HEARTBEAT_INTERVAL, GenericType.DURATION);
    /** How long the driver waits for the response to a heartbeat. */
    public static final TypedDriverOption<Duration> HEARTBEAT_TIMEOUT =
        new TypedDriverOption<>(DefaultDriverOption.HEARTBEAT_TIMEOUT, GenericType.DURATION);
    /** How long the driver waits to propagate a Topology event. */
    public static final TypedDriverOption<Duration> METADATA_TOPOLOGY_WINDOW =
        new TypedDriverOption<>(DefaultDriverOption.METADATA_TOPOLOGY_WINDOW, GenericType.DURATION);
    /** The maximum number of events that can accumulate. */
    public static final TypedDriverOption<Integer> METADATA_TOPOLOGY_MAX_EVENTS =
        new TypedDriverOption<>(
            DefaultDriverOption.METADATA_TOPOLOGY_MAX_EVENTS, GenericType.INTEGER);
    /** Whether schema metadata is enabled. */
    public static final TypedDriverOption<Boolean> METADATA_SCHEMA_ENABLED =
        new TypedDriverOption<>(DefaultDriverOption.METADATA_SCHEMA_ENABLED, GenericType.BOOLEAN);
    /** The timeout for the requests to the schema tables. */
    public static final TypedDriverOption<Duration> METADATA_SCHEMA_REQUEST_TIMEOUT =
        new TypedDriverOption<>(
            DefaultDriverOption.METADATA_SCHEMA_REQUEST_TIMEOUT, GenericType.DURATION);
    /** The page size for the requests to the schema tables. */
    public static final TypedDriverOption<Integer> METADATA_SCHEMA_REQUEST_PAGE_SIZE =
        new TypedDriverOption<>(
            DefaultDriverOption.METADATA_SCHEMA_REQUEST_PAGE_SIZE, GenericType.INTEGER);
    /** The list of keyspaces for which schema and token metadata should be maintained. */
    public static final TypedDriverOption<List<String>> METADATA_SCHEMA_REFRESHED_KEYSPACES =
        new TypedDriverOption<>(
            DefaultDriverOption.METADATA_SCHEMA_REFRESHED_KEYSPACES,
            GenericType.listOf(String.class));
    /** How long the driver waits to apply a refresh. */
    public static final TypedDriverOption<Duration> METADATA_SCHEMA_WINDOW =
        new TypedDriverOption<>(DefaultDriverOption.METADATA_SCHEMA_WINDOW, GenericType.DURATION);
    /** The maximum number of refreshes that can accumulate. */
    public static final TypedDriverOption<Integer> METADATA_SCHEMA_MAX_EVENTS =
        new TypedDriverOption<>(DefaultDriverOption.METADATA_SCHEMA_MAX_EVENTS, GenericType.INTEGER);
    /** Whether token metadata is enabled. */
    public static final TypedDriverOption<Boolean> METADATA_TOKEN_MAP_ENABLED =
        new TypedDriverOption<>(DefaultDriverOption.METADATA_TOKEN_MAP_ENABLED, GenericType.BOOLEAN);
    /** How long the driver waits for responses to control queries. */
    public static final TypedDriverOption<Duration> CONTROL_CONNECTION_TIMEOUT =
        new TypedDriverOption<>(DefaultDriverOption.CONTROL_CONNECTION_TIMEOUT, GenericType.DURATION);
    /** The interval between each schema agreement check attempt. */
    public static final TypedDriverOption<Duration> CONTROL_CONNECTION_AGREEMENT_INTERVAL =
        new TypedDriverOption<>(
            DefaultDriverOption.CONTROL_CONNECTION_AGREEMENT_INTERVAL, GenericType.DURATION);
    /** The timeout after which schema agreement fails. */
    public static final TypedDriverOption<Duration> CONTROL_CONNECTION_AGREEMENT_TIMEOUT =
        new TypedDriverOption<>(
            DefaultDriverOption.CONTROL_CONNECTION_AGREEMENT_TIMEOUT, GenericType.DURATION);
    /** Whether to log a warning if schema agreement fails. */
    public static final TypedDriverOption<Boolean> CONTROL_CONNECTION_AGREEMENT_WARN =
        new TypedDriverOption<>(
            DefaultDriverOption.CONTROL_CONNECTION_AGREEMENT_WARN, GenericType.BOOLEAN);
    /** Whether `Session.prepare` calls should be sent to all nodes in the cluster. */
    public static final TypedDriverOption<Boolean> PREPARE_ON_ALL_NODES =
        new TypedDriverOption<>(DefaultDriverOption.PREPARE_ON_ALL_NODES, GenericType.BOOLEAN);
    /** Whether the driver tries to prepare on new nodes at all. */
    public static final TypedDriverOption<Boolean> REPREPARE_ENABLED =
        new TypedDriverOption<>(DefaultDriverOption.REPREPARE_ENABLED, GenericType.BOOLEAN);
    /** Whether to check `system.prepared_statements` on the target node before repreparing. */
    public static final TypedDriverOption<Boolean> REPREPARE_CHECK_SYSTEM_TABLE =
        new TypedDriverOption<>(
            DefaultDriverOption.REPREPARE_CHECK_SYSTEM_TABLE, GenericType.BOOLEAN);
    /** The maximum number of statements that should be reprepared. */
    public static final TypedDriverOption<Integer> REPREPARE_MAX_STATEMENTS =
        new TypedDriverOption<>(DefaultDriverOption.REPREPARE_MAX_STATEMENTS, GenericType.INTEGER);
    /** The maximum number of concurrent requests when repreparing. */
    public static final TypedDriverOption<Integer> REPREPARE_MAX_PARALLELISM =
        new TypedDriverOption<>(DefaultDriverOption.REPREPARE_MAX_PARALLELISM, GenericType.INTEGER);
    /** The request timeout when repreparing. */
    public static final TypedDriverOption<Duration> REPREPARE_TIMEOUT =
        new TypedDriverOption<>(DefaultDriverOption.REPREPARE_TIMEOUT, GenericType.DURATION);
    /** Whether the prepared statements cache use weak values. */
    public static final TypedDriverOption<Boolean> PREPARED_CACHE_WEAK_VALUES =
        new TypedDriverOption<>(DefaultDriverOption.PREPARED_CACHE_WEAK_VALUES, GenericType.BOOLEAN);
    /** The number of threads in the I/O group. */
    public static final TypedDriverOption<Integer> NETTY_IO_SIZE =
        new TypedDriverOption<>(DefaultDriverOption.NETTY_IO_SIZE, GenericType.INTEGER);
    /** Quiet period for I/O group shutdown. */
    public static final TypedDriverOption<Integer> NETTY_IO_SHUTDOWN_QUIET_PERIOD =
        new TypedDriverOption<>(
            DefaultDriverOption.NETTY_IO_SHUTDOWN_QUIET_PERIOD, GenericType.INTEGER);
    /** Max time to wait for I/O group shutdown. */
    public static final TypedDriverOption<Integer> NETTY_IO_SHUTDOWN_TIMEOUT =
        new TypedDriverOption<>(DefaultDriverOption.NETTY_IO_SHUTDOWN_TIMEOUT, GenericType.INTEGER);
    /** Units for I/O group quiet period and timeout. */
    public static final TypedDriverOption<String> NETTY_IO_SHUTDOWN_UNIT =
        new TypedDriverOption<>(DefaultDriverOption.NETTY_IO_SHUTDOWN_UNIT, GenericType.STRING);
    /** The number of threads in the Admin group. */
    public static final TypedDriverOption<Integer> NETTY_ADMIN_SIZE =
        new TypedDriverOption<>(DefaultDriverOption.NETTY_ADMIN_SIZE, GenericType.INTEGER);
    /** Quiet period for admin group shutdown. */
    public static final TypedDriverOption<Integer> NETTY_ADMIN_SHUTDOWN_QUIET_PERIOD =
        new TypedDriverOption<>(
            DefaultDriverOption.NETTY_ADMIN_SHUTDOWN_QUIET_PERIOD, GenericType.INTEGER);
    /** Max time to wait for admin group shutdown. */
    public static final TypedDriverOption<Integer> NETTY_ADMIN_SHUTDOWN_TIMEOUT =
        new TypedDriverOption<>(
            DefaultDriverOption.NETTY_ADMIN_SHUTDOWN_TIMEOUT, GenericType.INTEGER);
    /** Units for admin group quiet period and timeout. */
    public static final TypedDriverOption<String> NETTY_ADMIN_SHUTDOWN_UNIT =
        new TypedDriverOption<>(DefaultDriverOption.NETTY_ADMIN_SHUTDOWN_UNIT, GenericType.STRING);
    /** @deprecated This option was removed in version 4.6.1. */
    @Deprecated
    public static final TypedDriverOption<Integer> COALESCER_MAX_RUNS =
        new TypedDriverOption<>(DefaultDriverOption.COALESCER_MAX_RUNS, GenericType.INTEGER);
    /** The coalescer reschedule interval. */
    public static final TypedDriverOption<Duration> COALESCER_INTERVAL =
        new TypedDriverOption<>(DefaultDriverOption.COALESCER_INTERVAL, GenericType.DURATION);
    /** Whether to resolve the addresses passed to `basic.contact-points`. */
    public static final TypedDriverOption<Boolean> RESOLVE_CONTACT_POINTS =
        new TypedDriverOption<>(DefaultDriverOption.RESOLVE_CONTACT_POINTS, GenericType.BOOLEAN);
    /**
     * This is how frequent the timer should wake up to check for timed-out tasks or speculative
     * executions.
     */
    public static final TypedDriverOption<Duration> NETTY_TIMER_TICK_DURATION =
        new TypedDriverOption<>(DefaultDriverOption.NETTY_TIMER_TICK_DURATION, GenericType.DURATION);
    /** Number of ticks in the Timer wheel. */
    public static final TypedDriverOption<Integer> NETTY_TIMER_TICKS_PER_WHEEL =
        new TypedDriverOption<>(DefaultDriverOption.NETTY_TIMER_TICKS_PER_WHEEL, GenericType.INTEGER);
    /**
     * Whether logging of server warnings generated during query execution should be disabled by the
     * driver.
     */
    public static final TypedDriverOption<Boolean> REQUEST_LOG_WARNINGS =
        new TypedDriverOption<>(DefaultDriverOption.REQUEST_LOG_WARNINGS, GenericType.BOOLEAN);
    /** Whether the threads created by the driver should be daemon threads. */
    public static final TypedDriverOption<Boolean> NETTY_DAEMON =
        new TypedDriverOption<>(DefaultDriverOption.NETTY_DAEMON, GenericType.BOOLEAN);
    /**
     * The location of the cloud secure bundle used to connect to DataStax Apache Cassandra as a
     * service.
     */
    public static final TypedDriverOption<String> CLOUD_SECURE_CONNECT_BUNDLE =
        new TypedDriverOption<>(DefaultDriverOption.CLOUD_SECURE_CONNECT_BUNDLE, GenericType.STRING);
    /** Whether the slow replica avoidance should be enabled in the default LBP. */
    public static final TypedDriverOption<Boolean> LOAD_BALANCING_POLICY_SLOW_AVOIDANCE =
        new TypedDriverOption<>(
            DefaultDriverOption.LOAD_BALANCING_POLICY_SLOW_AVOIDANCE, GenericType.BOOLEAN);
    /** The timeout to use when establishing driver connections. */
    public static final TypedDriverOption<Duration> CONNECTION_CONNECT_TIMEOUT =
        new TypedDriverOption<>(DefaultDriverOption.CONNECTION_CONNECT_TIMEOUT, GenericType.DURATION);
    /** The maximum number of live sessions that are allowed to coexist in a given VM. */
    public static final TypedDriverOption<Integer> SESSION_LEAK_THRESHOLD =
        new TypedDriverOption<>(DefaultDriverOption.SESSION_LEAK_THRESHOLD, GenericType.INTEGER);
  
    /** The name of the application using the session. */
    public static final TypedDriverOption<String> APPLICATION_NAME =
        new TypedDriverOption<>(DseDriverOption.APPLICATION_NAME, GenericType.STRING);
    /** The version of the application using the session. */
    public static final TypedDriverOption<String> APPLICATION_VERSION =
        new TypedDriverOption<>(DseDriverOption.APPLICATION_VERSION, GenericType.STRING);
    /** Proxy authentication for GSSAPI authentication: allows to login as another user or role. */
    public static final TypedDriverOption<String> AUTH_PROVIDER_AUTHORIZATION_ID =
        new TypedDriverOption<>(DseDriverOption.AUTH_PROVIDER_AUTHORIZATION_ID, GenericType.STRING);
    /** Service name for GSSAPI authentication. */
    public static final TypedDriverOption<String> AUTH_PROVIDER_SERVICE =
        new TypedDriverOption<>(DseDriverOption.AUTH_PROVIDER_SERVICE, GenericType.STRING);
    /** Login configuration for GSSAPI authentication. */
    public static final TypedDriverOption<String> AUTH_PROVIDER_LOGIN_CONFIGURATION =
        new TypedDriverOption<>(
            DseDriverOption.AUTH_PROVIDER_LOGIN_CONFIGURATION, GenericType.STRING);
    /** Internal SASL properties, if any, such as QOP, for GSSAPI authentication. */
    public static final TypedDriverOption<Map<String, String>> AUTH_PROVIDER_SASL_PROPERTIES =
        new TypedDriverOption<>(
            DseDriverOption.AUTH_PROVIDER_SASL_PROPERTIES,
            GenericType.mapOf(GenericType.STRING, GenericType.STRING));
    /** The page size for continuous paging. */
    public static final TypedDriverOption<Integer> CONTINUOUS_PAGING_PAGE_SIZE =
        new TypedDriverOption<>(DseDriverOption.CONTINUOUS_PAGING_PAGE_SIZE, GenericType.INTEGER);
    /**
     * Whether {@link #CONTINUOUS_PAGING_PAGE_SIZE} should be interpreted in number of rows or bytes.
     */
    public static final TypedDriverOption<Boolean> CONTINUOUS_PAGING_PAGE_SIZE_BYTES =
        new TypedDriverOption<>(
            DseDriverOption.CONTINUOUS_PAGING_PAGE_SIZE_BYTES, GenericType.BOOLEAN);
    /** The maximum number of continuous pages to return. */
    public static final TypedDriverOption<Integer> CONTINUOUS_PAGING_MAX_PAGES =
        new TypedDriverOption<>(DseDriverOption.CONTINUOUS_PAGING_MAX_PAGES, GenericType.INTEGER);
    /** The maximum number of continuous pages per second. */
    public static final TypedDriverOption<Integer> CONTINUOUS_PAGING_MAX_PAGES_PER_SECOND =
        new TypedDriverOption<>(
            DseDriverOption.CONTINUOUS_PAGING_MAX_PAGES_PER_SECOND, GenericType.INTEGER);
    /** The maximum number of continuous pages that can be stored in the local queue. */
    public static final TypedDriverOption<Integer> CONTINUOUS_PAGING_MAX_ENQUEUED_PAGES =
        new TypedDriverOption<>(
            DseDriverOption.CONTINUOUS_PAGING_MAX_ENQUEUED_PAGES, GenericType.INTEGER);
    /** How long to wait for the coordinator to send the first continuous page. */
    public static final TypedDriverOption<Duration> CONTINUOUS_PAGING_TIMEOUT_FIRST_PAGE =
        new TypedDriverOption<>(
            DseDriverOption.CONTINUOUS_PAGING_TIMEOUT_FIRST_PAGE, GenericType.DURATION);
    /** How long to wait for the coordinator to send subsequent continuous pages. */
    public static final TypedDriverOption<Duration> CONTINUOUS_PAGING_TIMEOUT_OTHER_PAGES =
        new TypedDriverOption<>(
            DseDriverOption.CONTINUOUS_PAGING_TIMEOUT_OTHER_PAGES, GenericType.DURATION);
    /** The largest latency that we expect to record for continuous requests. */
    public static final TypedDriverOption<Duration>
        CONTINUOUS_PAGING_METRICS_SESSION_CQL_REQUESTS_HIGHEST =
            new TypedDriverOption<>(
                DseDriverOption.CONTINUOUS_PAGING_METRICS_SESSION_CQL_REQUESTS_HIGHEST,
                GenericType.DURATION);
    /** The shortest latency that we expect to record for continuous requests. */
    public static final TypedDriverOption<Duration>
        CONTINUOUS_PAGING_METRICS_SESSION_CQL_REQUESTS_LOWEST =
            new TypedDriverOption<>(
                DseDriverOption.CONTINUOUS_PAGING_METRICS_SESSION_CQL_REQUESTS_LOWEST,
                GenericType.DURATION);
    /** Optional service-level objectives to meet, as a list of latencies to track. */
    public static final TypedDriverOption<List<Duration>>
        CONTINUOUS_PAGING_METRICS_SESSION_CQL_REQUESTS_SLO =
            new TypedDriverOption<>(
                DseDriverOption.CONTINUOUS_PAGING_METRICS_SESSION_CQL_REQUESTS_SLO,
                GenericType.listOf(GenericType.DURATION));
    /**
     * Optional pre-defined percentile of continuous paging cql requests to publish, as a list of
     * percentiles .
     */
    public static final TypedDriverOption<List<Double>>
        CONTINUOUS_PAGING_METRICS_SESSION_CQL_REQUESTS_PUBLISH_PERCENTILES =
            new TypedDriverOption<>(
                DseDriverOption.CONTINUOUS_PAGING_METRICS_SESSION_CQL_REQUESTS_PUBLISH_PERCENTILES,
                GenericType.listOf(GenericType.DOUBLE));
    /**
     * The number of significant decimal digits to which internal structures will maintain for
     * continuous requests.
     */
    public static final TypedDriverOption<Integer>
        CONTINUOUS_PAGING_METRICS_SESSION_CQL_REQUESTS_DIGITS =
            new TypedDriverOption<>(
                DseDriverOption.CONTINUOUS_PAGING_METRICS_SESSION_CQL_REQUESTS_DIGITS,
                GenericType.INTEGER);
    /** The interval at which percentile data is refreshed for continuous requests. */
    public static final TypedDriverOption<Duration>
        CONTINUOUS_PAGING_METRICS_SESSION_CQL_REQUESTS_INTERVAL =
            new TypedDriverOption<>(
                DseDriverOption.CONTINUOUS_PAGING_METRICS_SESSION_CQL_REQUESTS_INTERVAL,
                GenericType.DURATION);
    /** The read consistency level to use for graph statements. */
    public static final TypedDriverOption<String> GRAPH_READ_CONSISTENCY_LEVEL =
        new TypedDriverOption<>(DseDriverOption.GRAPH_READ_CONSISTENCY_LEVEL, GenericType.STRING);
    /** The write consistency level to use for graph statements. */
    public static final TypedDriverOption<String> GRAPH_WRITE_CONSISTENCY_LEVEL =
        new TypedDriverOption<>(DseDriverOption.GRAPH_WRITE_CONSISTENCY_LEVEL, GenericType.STRING);
    /** The traversal source to use for graph statements. */
    public static final TypedDriverOption<String> GRAPH_TRAVERSAL_SOURCE =
        new TypedDriverOption<>(DseDriverOption.GRAPH_TRAVERSAL_SOURCE, GenericType.STRING);
    /**
     * The sub-protocol the driver will use to communicate with DSE Graph, on top of the Cassandra
     * native protocol.
     */
    public static final TypedDriverOption<String> GRAPH_SUB_PROTOCOL =
        new TypedDriverOption<>(DseDriverOption.GRAPH_SUB_PROTOCOL, GenericType.STRING);
    /** Whether a script statement represents a system query. */
    public static final TypedDriverOption<Boolean> GRAPH_IS_SYSTEM_QUERY =
        new TypedDriverOption<>(DseDriverOption.GRAPH_IS_SYSTEM_QUERY, GenericType.BOOLEAN);
    /** The name of the graph targeted by graph statements. */
    public static final TypedDriverOption<String> GRAPH_NAME =
        new TypedDriverOption<>(DseDriverOption.GRAPH_NAME, GenericType.STRING);
    /** How long the driver waits for a graph request to complete. */
    public static final TypedDriverOption<Duration> GRAPH_TIMEOUT =
        new TypedDriverOption<>(DseDriverOption.GRAPH_TIMEOUT, GenericType.DURATION);
    /** Whether to send events for Insights monitoring. */
    public static final TypedDriverOption<Boolean> MONITOR_REPORTING_ENABLED =
        new TypedDriverOption<>(DseDriverOption.MONITOR_REPORTING_ENABLED, GenericType.BOOLEAN);
    /** Whether to enable paging for Graph queries. */
    public static final TypedDriverOption<String> GRAPH_PAGING_ENABLED =
        new TypedDriverOption<>(DseDriverOption.GRAPH_PAGING_ENABLED, GenericType.STRING);
    /** The page size for Graph continuous paging. */
    public static final TypedDriverOption<Integer> GRAPH_CONTINUOUS_PAGING_PAGE_SIZE =
        new TypedDriverOption<>(
            DseDriverOption.GRAPH_CONTINUOUS_PAGING_PAGE_SIZE, GenericType.INTEGER);
    /** The maximum number of Graph continuous pages to return. */
    public static final TypedDriverOption<Integer> GRAPH_CONTINUOUS_PAGING_MAX_PAGES =
        new TypedDriverOption<>(
            DseDriverOption.GRAPH_CONTINUOUS_PAGING_MAX_PAGES, GenericType.INTEGER);
    /** The maximum number of Graph continuous pages per second. */
    public static final TypedDriverOption<Integer> GRAPH_CONTINUOUS_PAGING_MAX_PAGES_PER_SECOND =
        new TypedDriverOption<>(
            DseDriverOption.GRAPH_CONTINUOUS_PAGING_MAX_PAGES_PER_SECOND, GenericType.INTEGER);
    /** The maximum number of Graph continuous pages that can be stored in the local queue. */
    public static final TypedDriverOption<Integer> GRAPH_CONTINUOUS_PAGING_MAX_ENQUEUED_PAGES =
        new TypedDriverOption<>(
            DseDriverOption.GRAPH_CONTINUOUS_PAGING_MAX_ENQUEUED_PAGES, GenericType.INTEGER);
    /** The largest latency that we expect to record for graph requests. */
    public static final TypedDriverOption<Duration> METRICS_SESSION_GRAPH_REQUESTS_HIGHEST =
        new TypedDriverOption<>(
            DseDriverOption.METRICS_SESSION_GRAPH_REQUESTS_HIGHEST, GenericType.DURATION);
    /** The shortest latency that we expect to record for graph requests. */
    public static final TypedDriverOption<Duration> METRICS_SESSION_GRAPH_REQUESTS_LOWEST =
        new TypedDriverOption<>(
            DseDriverOption.METRICS_SESSION_GRAPH_REQUESTS_LOWEST, GenericType.DURATION);
    /** Optional service-level objectives to meet, as a list of latencies to track. */
    public static final TypedDriverOption<List<Duration>> METRICS_SESSION_GRAPH_REQUESTS_SLO =
        new TypedDriverOption<>(
            DseDriverOption.METRICS_SESSION_GRAPH_REQUESTS_SLO,
            GenericType.listOf(GenericType.DURATION));
    /** Optional pre-defined percentile of graph requests to publish, as a list of percentiles . */
    public static final TypedDriverOption<List<Double>>
        METRICS_SESSION_GRAPH_REQUESTS_PUBLISH_PERCENTILES =
            new TypedDriverOption<>(
                DseDriverOption.METRICS_SESSION_GRAPH_REQUESTS_PUBLISH_PERCENTILES,
                GenericType.listOf(GenericType.DOUBLE));
    /**
     * The number of significant decimal digits to which internal structures will maintain for graph
     * requests.
     */
    public static final TypedDriverOption<Integer> METRICS_SESSION_GRAPH_REQUESTS_DIGITS =
        new TypedDriverOption<>(
            DseDriverOption.METRICS_SESSION_GRAPH_REQUESTS_DIGITS, GenericType.INTEGER);
    /** The interval at which percentile data is refreshed for graph requests. */
    public static final TypedDriverOption<Duration> METRICS_SESSION_GRAPH_REQUESTS_INTERVAL =
        new TypedDriverOption<>(
            DseDriverOption.METRICS_SESSION_GRAPH_REQUESTS_INTERVAL, GenericType.DURATION);
    /** The largest latency that we expect to record for graph requests. */
    public static final TypedDriverOption<Duration> METRICS_NODE_GRAPH_MESSAGES_HIGHEST =
        new TypedDriverOption<>(
            DseDriverOption.METRICS_NODE_GRAPH_MESSAGES_HIGHEST, GenericType.DURATION);
    /** The shortest latency that we expect to record for graph requests. */
    public static final TypedDriverOption<Duration> METRICS_NODE_GRAPH_MESSAGES_LOWEST =
        new TypedDriverOption<>(
            DseDriverOption.METRICS_NODE_GRAPH_MESSAGES_LOWEST, GenericType.DURATION);
    /** Optional service-level objectives to meet, as a list of latencies to track. */
    public static final TypedDriverOption<List<Duration>> METRICS_NODE_GRAPH_MESSAGES_SLO =
        new TypedDriverOption<>(
            DseDriverOption.METRICS_NODE_GRAPH_MESSAGES_SLO,
            GenericType.listOf(GenericType.DURATION));
    /**
     * Optional pre-defined percentile of node graph requests to publish, as a list of percentiles .
     */
    public static final TypedDriverOption<List<Double>>
        METRICS_NODE_GRAPH_MESSAGES_PUBLISH_PERCENTILES =
            new TypedDriverOption<>(
                DseDriverOption.METRICS_NODE_GRAPH_MESSAGES_PUBLISH_PERCENTILES,
                GenericType.listOf(GenericType.DOUBLE));
    /**
     * The number of significant decimal digits to which internal structures will maintain for graph
     * requests.
     */
    public static final TypedDriverOption<Integer> METRICS_NODE_GRAPH_MESSAGES_DIGITS =
        new TypedDriverOption<>(
            DseDriverOption.METRICS_NODE_GRAPH_MESSAGES_DIGITS, GenericType.INTEGER);
    /** The interval at which percentile data is refreshed for graph requests. */
    public static final TypedDriverOption<Duration> METRICS_NODE_GRAPH_MESSAGES_INTERVAL =
        new TypedDriverOption<>(
            DseDriverOption.METRICS_NODE_GRAPH_MESSAGES_INTERVAL, GenericType.DURATION);
  
    /** The time after which the node level metrics will be evicted. */
    public static final TypedDriverOption<Duration> METRICS_NODE_EXPIRE_AFTER =
        new TypedDriverOption<>(DefaultDriverOption.METRICS_NODE_EXPIRE_AFTER, GenericType.DURATION);
  
    /** The classname of the desired MetricsFactory implementation. */
    public static final TypedDriverOption<String> METRICS_FACTORY_CLASS =
        new TypedDriverOption<>(DefaultDriverOption.METRICS_FACTORY_CLASS, GenericType.STRING);
  
    /** The classname of the desired {@code MetricIdGenerator} implementation. */
    public static final TypedDriverOption<String> METRICS_ID_GENERATOR_CLASS =
        new TypedDriverOption<>(DefaultDriverOption.METRICS_ID_GENERATOR_CLASS, GenericType.STRING);
  
    /** The value of the prefix to prepend to all metric names. */
    public static final TypedDriverOption<String> METRICS_ID_GENERATOR_PREFIX =
        new TypedDriverOption<>(DefaultDriverOption.METRICS_ID_GENERATOR_PREFIX, GenericType.STRING);
  
    /** The maximum number of nodes from remote DCs to include in query plans. */
    public static final TypedDriverOption<Integer>
        LOAD_BALANCING_DC_FAILOVER_MAX_NODES_PER_REMOTE_DC =
            new TypedDriverOption<>(
                DefaultDriverOption.LOAD_BALANCING_DC_FAILOVER_MAX_NODES_PER_REMOTE_DC,
                GenericType.INTEGER);
    /** Whether to consider nodes from remote DCs if the request's consistency level is local. */
    public static final TypedDriverOption<Boolean>
        LOAD_BALANCING_DC_FAILOVER_ALLOW_FOR_LOCAL_CONSISTENCY_LEVELS =
            new TypedDriverOption<>(
                DefaultDriverOption.LOAD_BALANCING_DC_FAILOVER_ALLOW_FOR_LOCAL_CONSISTENCY_LEVELS,
                GenericType.BOOLEAN);
  
    public static final TypedDriverOption<String> ADDRESS_TRANSLATOR_ADVERTISED_HOSTNAME =
        new TypedDriverOption<>(
            DefaultDriverOption.ADDRESS_TRANSLATOR_ADVERTISED_HOSTNAME, GenericType.STRING);
    public static final TypedDriverOption<Map<String, String>> ADDRESS_TRANSLATOR_SUBNET_ADDRESSES =
        new TypedDriverOption<>(
            DefaultDriverOption.ADDRESS_TRANSLATOR_SUBNET_ADDRESSES,
            GenericType.mapOf(GenericType.STRING, GenericType.STRING));
    public static final TypedDriverOption<String> ADDRESS_TRANSLATOR_DEFAULT_ADDRESS =
        new TypedDriverOption<>(
            DefaultDriverOption.ADDRESS_TRANSLATOR_DEFAULT_ADDRESS, GenericType.STRING);
    public static final TypedDriverOption<Boolean> ADDRESS_TRANSLATOR_RESOLVE_ADDRESSES =
        new TypedDriverOption<>(
            DefaultDriverOption.ADDRESS_TRANSLATOR_RESOLVE_ADDRESSES, GenericType.BOOLEAN);
  
    /**
     * Ordered preference list of remote dcs optionally supplied for automatic failover and included
     * in query plan. This feature is enabled only when max-nodes-per-remote-dc is greater than 0.
     */
    public static final TypedDriverOption<List<String>>
        LOAD_BALANCING_DC_FAILOVER_PREFERRED_REMOTE_DCS =
            new TypedDriverOption<>(
                DefaultDriverOption.LOAD_BALANCING_DC_FAILOVER_PREFERRED_REMOTE_DCS,
                GenericType.listOf(String.class));
  
    private static Iterable<TypedDriverOption<?>> introspectBuiltInValues() {
      try {
        ImmutableList.Builder<TypedDriverOption<?>> result = ImmutableList.builder();
        for (Field field : TypedDriverOption.class.getFields()) {
          if ((field.getModifiers() & PUBLIC_STATIC_FINAL) == PUBLIC_STATIC_FINAL
              && field.getType() == TypedDriverOption.class) {
            TypedDriverOption<?> typedOption = (TypedDriverOption<?>) field.get(null);
            result.add(typedOption);
          }
        }
        return result.build();
      } catch (IllegalAccessException e) {
        throw new IllegalStateException("Unexpected error while introspecting built-in values", e);
      }
    }
  
    private static final int PUBLIC_STATIC_FINAL = Modifier.PUBLIC | Modifier.STATIC | Modifier.FINAL;
  }
  