return true;
                }
                return false;
              }
            },
            isParallel)
        .onClose(streamA::close)
        .onClose(streamB::close);
  }

  /**
   * Invokes {@code consumer} once for each pair of <i>corresponding</i> elements in {@code streamA}

                  return true;
                }
                return false;
              }
            },
            isParallel)
        .onClose(streamA::close)
        .onClose(streamB::close);
  }

  /**
   * Invokes {@code consumer} once for each pair of <i>corresponding</i> elements in {@code streamA}

  @IgnoreJRERequirement
  public Stream<String> lines() throws IOException {
    BufferedReader reader = openBufferedStream();
    return reader.lines().onClose(() -> closeUnchecked(reader));
  }

  @IgnoreJRERequirement // helper for lines()
  /*
   * If we make these calls inline inside the lambda inside lines(), we get an Animal Sniffer error,

  open fun onEvent(
    eventSource: EventSource,
    id: String?,
    type: String?,
    data: String,
  ) {
  }

  /**
   * No further calls to this listener will be made.
   */
  open fun onClosed(eventSource: EventSource) {
  }

  /**
   * Invoked when an event source has been closed due to an error reading from or writing to the

	public abstract fun newEventSource (Lokhttp3/Request;Lokhttp3/sse/EventSourceListener;)Lokhttp3/sse/EventSource;
}

public abstract class okhttp3/sse/EventSourceListener {
	public fun <init> ()V
	public fun onClosed (Lokhttp3/sse/EventSource;)V
	public fun onEvent (Lokhttp3/sse/EventSource;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V
	public fun onFailure (Lokhttp3/sse/EventSource;Ljava/lang/Throwable;Lokhttp3/Response;)V

   *   <li>{@code [3..6]} encloses {@code [4..4)} (even though the latter is empty)
   *   <li>{@code (3..6]} does not enclose {@code [3..6]}
   *   <li>{@code [4..5]} does not enclose {@code (3..6)} (even though it contains every value
   *       contained by the latter range)
   *   <li>{@code [3..6]} does not enclose {@code (1..1]} (even though it contains every value
   *       contained by the latter range)
   * </ul>
   *

          }
        listener.onFailure(this, exception, response)
        return
      }
      if (canceled) {
        listener.onFailure(this, IOException("canceled"), response)
      } else {
        listener.onClosed(this)
      }
    }
  }

  private fun ResponseBody.isEventStream(): Boolean {
    val contentType = contentType() ?: return false
    return contentType.type == "text" && contentType.subtype == "event-stream"

              return
            }

          // Apply the extensions. If they're unacceptable initiate a graceful shut down.
          // TODO(jwilson): Listeners should get onFailure() instead of onClosing() + onClosed(1010).
          val extensions = WebSocketExtensions.parse(response.headers)
          ******@****.***ions = extensions
          if (!extensions.isValid()) {
            synchronized(this@RealWebSocket) {

        ) = TODO()

        override fun onClosing(
          webSocket: WebSocket,
          code: Int,
          reason: String,
        ) = TODO()

        override fun onClosed(
          webSocket: WebSocket,
          code: Int,
          reason: String,
        ) = TODO()

        override fun onFailure(
          webSocket: WebSocket,
          t: Throwable,

	public abstract fun newWebSocket (Lokhttp3/Request;Lokhttp3/WebSocketListener;)Lokhttp3/WebSocket;
}

public abstract class okhttp3/WebSocketListener {
	public fun <init> ()V
	public fun onClosed (Lokhttp3/WebSocket;ILjava/lang/String;)V
	public fun onClosing (Lokhttp3/WebSocket;ILjava/lang/String;)V
	public fun onFailure (Lokhttp3/WebSocket;Ljava/lang/Throwable;Lokhttp3/Response;)V