val address: Address = factory.newAddress()
    val url: HttpUrl = address.url()
    val dns: Dns = address.dns()
    val socketFactory: SocketFactory = address.socketFactory()
    val proxyAuthenticator: Authenticator = address.proxyAuthenticator()
    val protocols: List<Protocol> = address.protocols()
    val connectionSpecs: List<ConnectionSpec> = address.connectionSpecs()
    val proxySelector: ProxySelector = address.proxySelector()

Kotlin does have properties and we take advantage of them in OkHttp.

 * **Address**: certificatePinner, connectionSpecs, dns, hostnameVerifier, protocols, proxy,
   proxyAuthenticator, proxySelector, socketFactory, sslSocketFactory, url
 * **Cache**: directory
 * **CacheControl**: immutable, maxAgeSeconds, maxStaleSeconds, minFreshSeconds, mustRevalidate,

    val address: Address = factory.newAddress()
    val url: HttpUrl = address.url
    val dns: Dns = address.dns
    val socketFactory: SocketFactory = address.socketFactory
    val proxyAuthenticator: Authenticator = address.proxyAuthenticator
    val protocols: List<Protocol> = address.protocols
    val connectionSpecs: List<ConnectionSpec> = address.connectionSpecs
    val proxySelector: ProxySelector = address.proxySelector

        if (selectedProxy.type() != Proxy.Type.HTTP) {
          throw ProtocolException("Received HTTP_PROXY_AUTH (407) code while not using proxy")
        }
        return client.proxyAuthenticator.authenticate(route, userResponse)
      }

      HTTP_UNAUTHORIZED -> return client.authenticator.authenticate(route, userResponse)

int previousDownloadPerc; public void Download$DefaultDownloadProgr(Logger); public final void downloadStatusChange(long, long); } org/gradle/wrapper/Download$ProxyAuthenticator.class package org.gradle.wrapper; public final synchronized class Download$ProxyAuthenticator extends java.net.Authenticator { public void Download$ProxyAuthenticator(Download); public final java.net.PasswordAuthenticati getPasswordAuthentic(); } org/gradle/wrapper/Download.class package org.gradle.wrapper; public final synchronized...

        .sentRequestAtMillis(-1L)
        .receivedResponseAtMillis(-1L)
        .header("Proxy-Authenticate", "OkHttp-Preemptive")
        .build()

    val authenticatedRequest =
      route.address.proxyAuthenticator
        .authenticate(route, fakeAuthChallengeResponse)

    return authenticatedRequest ?: proxyConnectRequest
  }

  override fun hasNext(failedConnection: RealConnection?): Boolean {

      client.newBuilder()
        .dns { listOf() }
        .build()
        .routeDatabase,
    )
    assertNotSame(
      client.routeDatabase,
      client.newBuilder()
        .proxyAuthenticator { _: Route?, _: Response? -> null }
        .build()
        .routeDatabase,
    )
    assertNotSame(
      client.routeDatabase,
      client.newBuilder()
        .protocols(listOf(Protocol.HTTP_1_1))

      tunnelCodec.skipConnectBody(response)

      when (response.code) {
        HttpURLConnection.HTTP_OK -> return null

        HttpURLConnection.HTTP_PROXY_AUTH -> {
          nextRequest = route.address.proxyAuthenticator.authenticate(route, response)
            ?: throw IOException("Failed to authenticate with proxy")

          if ("close".equals(response.header("Connection"), ignoreCase = true)) {
            return nextRequest