class WebSocketRecorder(
  private val name: String,
) : WebSocketListener() {
  private val events = LinkedBlockingQueue<Any>()
  private var delegate: WebSocketListener? = null

  /** Sets a delegate for handling the next callback to this listener. Cleared after invoked.  */
  fun setNextEventDelegate(delegate: WebSocketListener?) {
    this.delegate = delegate
  }

  override fun onOpen(
    webSocket: WebSocket,
    response: Response,

     * handleAllCompleted(), they will already have been nulled out. But in the case of
     * whenAll*().call*(), this future may be pending until the callback runs -- or even longer in
     * the case of callAsync(), which waits for the callback's returned future to complete.
     */
    releaseResources(ALL_INPUT_FUTURES_PROCESSED);
  }

  /**

    private UnaryOperator<String> callback;
    boolean substitute = true;
    boolean typed;

    public MavenProperties() {}

    public MavenProperties(Path location) throws IOException {
        this(location, null);
    }

    public MavenProperties(Path location, UnaryOperator<String> callback) throws IOException {
        this.location = location;
        this.callback = callback;

    private UnaryOperator<String> callback;
    boolean substitute = true;
    boolean typed;

    public MavenProperties() {}

    public MavenProperties(Path location) throws IOException {
        this(location, null);
    }

    public MavenProperties(Path location, UnaryOperator<String> callback) throws IOException {
        this.location = location;
        this.callback = callback;

     */
    protected void writeJsonResponse(final int status, final String body) {
        final String callback = LaRequestUtil.getOptionalRequest().map(req -> req.getParameter("callback")).orElse(null);
        final boolean isJsonp = ComponentUtil.getFessConfig().isApiJsonpEnabled() && StringUtil.isNotBlank(callback);

        final HttpServletResponse response = LaResponseUtil.getResponse();
        response.setStatus(status);

     * @param callback the callback to receive phase notifications and streaming chunks
     * @return the chat result with session info, sources, and HTML content
     */
    public ChatResult streamChatEnhanced(final String sessionId, final String userMessage, final String userId,
            final ChatPhaseCallback callback) {

   * case of an error.
   *
   * @param event the callback to execute on {@link #dispatch}
   */
  public void enqueue(Event<L> event) {
    enqueueHelper(event, event);
  }

  /**
   * Enqueues an event to be run on currently known listeners, with a label.
   *
   * @param event the callback to execute on {@link #dispatch}

        @Override
        public int load() {
            loadCallCount.incrementAndGet();
            return loadCallback.call();
        }

        public void setLoadCallback(LoadCallback callback) {
            this.loadCallback = callback;
        }

        public int getLoadCallCount() {
            return loadCallCount.get();
        }
    }

    @FunctionalInterface
    interface LoadCallback {

        }
        response.request
      }
    val blockingAuthClient =
      client
        .newBuilder()
        .authenticator(authenticator)
        .build()
    val callback: Callback =
      object : Callback {
        override fun onFailure(
          call: Call,
          e: IOException,
        ) {
          fail("")
        }

        override fun onResponse(

        /**
         * @param op The option of condition to be set up. (NotNull)
         */
        void callback(OP op);
    }

    @FunctionalInterface
    public interface OperatorCall<CA extends EsAbstractConditionAggregation> {

        void callback(CA query);
    }