*/
    fun responseBodyComplete(trailers: Headers) {
      if (state == STATE_CLOSED) return
      if (state != STATE_READING_RESPONSE_BODY) throw IllegalStateException("state: $state")

      detachTimeout(timeout)

      this@Http1ExchangeCodec.trailers = trailers
      state = STATE_CLOSED
      if (trailers.size > 0) {
        client?.cookieJar?.receiveHeaders(url, trailers)
      }
    }
  }

   * @throws IOException if the trailers cannot be loaded, such as if the network connection is
   *     dropped.
   */
  @Throws(IOException::class)
  fun trailers(): Headers = trailersSource.get()

  /**
   * Returns the trailers after the HTTP response, if they are available to read immediately. Unlike
   * [trailers], this doesn't block if the trailers are not immediately available, and instead

      }

      socket.sleepWhileOpen(response.headersDelayNanos)
      stream.writeHeaders(response.toHttp2Headers(), outFinished, flushHeaders)

      if (trailers.size > 0) {
        stream.enqueueTrailers(trailers)
      }
      pushPromises(stream, request, response.pushPromises)
      if (body != null) {
        socket.sleepWhileOpen(bodyDelayNanos)
        val responseBodySink =

interface ExchangeCodec {
  /** The connection or CONNECT tunnel that owns this codec. */
  val carrier: Carrier

  /** Returns true if the response body and (possibly empty) trailers have been received. */
  val isResponseComplete: Boolean

  /** The socket that carries this exchange. */
  val socket: Socket

  /** Returns an output stream where the request body can be streamed. */

            }
            val responseBody = exchange.openResponseBody(response)
            response
              .newBuilder()
              .body(responseBody)
              .trailers(
                object : TrailersSource {
                  override fun peek() = exchange.peekTrailers()

                  override fun get(): Headers {
                    val source = responseBody.source()

        // header names must be lowercase.
        val name = headers.name(i).lowercase(Locale.US)
        if (name !in HTTP_2_SKIPPED_REQUEST_HEADERS ||
          name == TE &&
          headers.value(i) == "trailers"
        ) {
          result.add(Header(name, headers.value(i)))
        }
      }
      return result
    }

    /** Returns headers for a name value block containing an HTTP/2 response. */

      MockResponse
        .Builder()
        .clearHeaders()
        .addHeader("h1", "v1")
        .addHeader("h2", "v2")
        .chunkedBody("HelloBonjour", 1024)
        .trailers(headersOf("trailers", "boom"))
        .build(),
    )
    val call = client.newCall(Request(server.url("/")))
    val response = call.execute()
    val source = response.body.source()

    peer.acceptFrame() // ACK
    peer.acceptFrame() // SYN_STREAM
    peer.sendFrame().headers(false, 3, headerEntries("headers", "bam"))
    peer.acceptFrame() // PING
    peer.sendFrame().headers(true, 3, headerEntries("trailers", "boom"))
    peer.sendFrame().ping(true, Http2Connection.AWAIT_PING, 0) // PONG
    peer.play()

    // Play it back.
    val connection = connect(peer)

	public final fun request ()Lokhttp3/Request;
	public final fun sentRequestAtMillis ()J
	public final fun socket ()Lokio/Socket;
	public fun toString ()Ljava/lang/String;
	public final fun trailers ()Lokhttp3/Headers;
}

public class okhttp3/Response$Builder {
	public fun <init> ()V
	public fun addHeader (Ljava/lang/String;Ljava/lang/String;)Lokhttp3/Response$Builder;

	public final fun request ()Lokhttp3/Request;
	public final fun sentRequestAtMillis ()J
	public final fun socket ()Lokio/Socket;
	public fun toString ()Ljava/lang/String;
	public final fun trailers ()Lokhttp3/Headers;
}

public class okhttp3/Response$Builder {
	public fun <init> ()V
	public fun addHeader (Ljava/lang/String;Ljava/lang/String;)Lokhttp3/Response$Builder;