timeout: Int,
    unit: TimeUnit,
  ): Interceptor.Chain {
    check(exchange == null) { "Timeouts can't be adjusted in a network interceptor" }

    return copy(connectTimeoutMillis = checkDuration("connectTimeout", timeout.toLong(), unit))
  }

  override fun readTimeoutMillis(): Int = readTimeoutMillis

  override fun withReadTimeout(
    timeout: Int,
    unit: TimeUnit,
  ): Interceptor.Chain {

  @Test fun timeoutValidRange() {
    val builder = OkHttpClient.Builder()
    try {
      builder.callTimeout(Duration.ofNanos(1))
    } catch (ignored: IllegalArgumentException) {
    }
    try {
      builder.connectTimeout(Duration.ofNanos(1))
    } catch (ignored: IllegalArgumentException) {
    }
    try {
      builder.writeTimeout(Duration.ofNanos(1))
    } catch (ignored: IllegalArgumentException) {
    }
    try {

    val request =
      Request.Builder()
        .url(server.url("/"))
        .build()
    val response = client.newCall(request).execute()
    response.body.close()
  }

  @Test
  fun connectTimeout() {
    val interceptor1 =
      Interceptor { chainA: Interceptor.Chain ->
        assertThat(chainA.connectTimeoutMillis()).isEqualTo(5000)
        val chainB = chainA.withConnectTimeout(100, TimeUnit.MILLISECONDS)

      listOf(
        localhostIpv4,
        localhostIpv6,
      )

    client =
      clientTestRule.newClientBuilder()
        .eventListenerFactory(clientTestRule.wrap(listener))
        .connectTimeout(60, TimeUnit.SECONDS) // Deliberately exacerbate slow fallbacks.
        .dns { dnsResults }
        .fastFallback(true)
        .build()
    url =
      serverIpv4.url("/")
        .newBuilder()

    proxySelector.proxies.add(Proxy.NO_PROXY)
    server.shutdown()

    client =
      client.newBuilder()
        .proxySelector(proxySelector)
        .readTimeout(Duration.ofMillis(100))
        .connectTimeout(Duration.ofMillis(100))
        .build()

    val request = Request(server.url("/"))
    assertFailsWith<IOException> {
      client.newCall(request).execute()
    }.also { expected ->

                    0);
            }
            return message;
        }
    }


    private void reconnect () throws IOException {
        int readTimeout = getReadTimeout();
        int connectTimeout = getConnectTimeout();

        HostnameVerifier hv = null;
        SSLSocketFactory ssf = null;
        if ( this.connection instanceof HttpsURLConnection ) {

        } catch (final Exception e) {
            throw new CrawlingAccessException("Failed to create MinioClient(" + endpoint + ")", e);
        }

        minioClient.setTimeout(getInitParameter("connectTimeout", (long) 10000, Long.class),
                getInitParameter("writeTimeout", (long) 10000, Long.class), getInitParameter("readTimeout", (long) 10000, Long.class));
    }

=== ":material-language-kotlin: Kotlin"
    ```kotlin
      private val client: OkHttpClient = OkHttpClient.Builder()
          .connectTimeout(5, TimeUnit.SECONDS)
          .writeTimeout(5, TimeUnit.SECONDS)
          .readTimeout(5, TimeUnit.SECONDS)
          .callTimeout(10, TimeUnit.SECONDS)
          .build()

      fun run() {

    builder = builder.callTimeout(0L, TimeUnit.SECONDS)
    builder = builder.callTimeout(Duration.ofSeconds(0L))
    builder = builder.connectTimeout(0L, TimeUnit.SECONDS)
    builder = builder.connectTimeout(Duration.ofSeconds(0L))
    builder = builder.readTimeout(0L, TimeUnit.SECONDS)
    builder = builder.readTimeout(Duration.ofSeconds(0L))
    builder = builder.writeTimeout(0L, TimeUnit.SECONDS)

	public final fun certificatePinner (Lokhttp3/CertificatePinner;)Lokhttp3/OkHttpClient$Builder;
	public final fun connectTimeout (JLjava/util/concurrent/TimeUnit;)Lokhttp3/OkHttpClient$Builder;
	public final fun connectTimeout (Ljava/time/Duration;)Lokhttp3/OkHttpClient$Builder;
	public final fun connectTimeout-LRDsOJo (J)Lokhttp3/OkHttpClient$Builder;
	public final fun connectionPool (Lokhttp3/ConnectionPool;)Lokhttp3/OkHttpClient$Builder;