* pinning.
 */
abstract class CertificateChainCleaner {
  @Throws(SSLPeerUnverifiedException::class)
  abstract fun clean(
    chain: List<Certificate>,
    hostname: String,
  ): List<Certificate>

  companion object {
    fun get(trustManager: X509TrustManager): CertificateChainCleaner {
      return Platform.get().buildCertificateChainCleaner(trustManager)
    }

     *     represented as a combination of scheme, host and port. When empty, the origin is that of
     *     the `streamId`.
     * @param protocol an ALPN protocol, such as `h2`.
     * @param host an IP address or hostname.
     * @param port the IP port associated with the service.
     * @param maxAge time in seconds that this alternative is considered fresh.
     */
    fun alternateService(
      streamId: Int,

        val networkRequest = chain.request()
        assertThat(networkRequest.header("User-Agent")).isNotNull()
        assertThat(networkRequest.header("Host")).isEqualTo(
          server.hostName + ":" + server.port,
        )
        assertThat(networkRequest.header("Accept-Encoding")).isNotNull()

        // The network response also has everything, including the raw gzipped content.

        get() = withValidityAssertion {
            val enumClassId = enumDescriptor.classId ?: return null
            CallableId(
                packageName = enumClassId.packageFqName,
                className = enumClassId.relativeClassName,
                callableName = descriptor.name
            )
        }

    override val returnType: KtType

      null
    }
  }

  @SuppressLint("NewApi")
  override fun configureTlsExtensions(
    sslSocket: SSLSocket,
    hostname: String?,
    protocols: List<Protocol>,
  ) {
    try {
      SSLSockets.setUseSessionTickets(sslSocket, true)

      val sslParameters = sslSocket.sslParameters

      // Enable ALPN.

    webServer.enqueue(
      MockResponse.Builder()
        .webSocketUpgrade(serverListener)
        .build(),
    )
    val request =
      Request.Builder()
        .url(scheme + "://" + webServer.hostName + ":" + webServer.port + "/")
        .build()
    val webSocket = newWebSocket(request)
    clientListener.assertOpen()
    val server = serverListener.assertOpen()
    webSocket.send("abc")

                fun visitClassFile(file: Path) {
                    try {
                        val reader = ClassReader(Files.newInputStream(file))
                        val details = classes[reader.className]
                        details.visited = true
                        val classWriter = ClassWriter(0)
                        reader.accept(
                            ClassRemapper(

    result = 31 * result + address.hashCode()
    result = 31 * result + proxy.hashCode()
    result = 31 * result + socketAddress.hashCode()
    return result
  }

  /**
   * Returns a string with the URL hostname, socket IP address, and socket port, like one of these:
   *
   *  * `example.com:80 at 1.2.3.4:8888`
   *  * `example.com:443 via proxy [::1]:8888`
   *
   * This omits duplicate information when possible.
   */

   * what was used to establish [chain].
   */
  @Throws(SSLPeerUnverifiedException::class)
  override fun clean(
    chain: List<Certificate>,
    hostname: String,
  ): List<Certificate> {
    val queue: Deque<Certificate> = ArrayDeque(chain)
    val result = mutableListOf<Certificate>()
    result.add(queue.removeFirst())
    var foundTrustedCertificate = false

  optional string clientCIDR = 1;

  // Address of this server, suitable for a client that matches the above CIDR.
  // This can be a hostname, hostname:port, IP or IP:port.
  optional string serverAddress = 2;
}

// Status is a return value for calls that don't return other objects.
message Status {
  // Standard list metadata.