*/
  fun cancel()

  fun interface Factory {
    /**
     * Creates a new event source and immediately returns it. Creating an event source initiates an
     * asynchronous process to connect the socket. Once that succeeds or fails, `listener` will be
     * notified. The caller must cancel the returned event source when it is no longer in use.
     */
    fun newEventSource(

        ("/synchronous-method-dependency", "synchronous-method-dependency"),
        ("/synchronous-method-gen-dependency", "synchronous-method-gen-dependency"),
        ("/asynchronous-method-dependency", "asynchronous-method-dependency"),
        ("/asynchronous-method-gen-dependency", "asynchronous-method-gen-dependency"),
        ("/callable-dependency-class", "callable-dependency-class"),
        ("/callable-gen-dependency-class", "callable-gen-dependency-class"),

    // We post the event, but our Executor will not deliver it until instructed.
    bus.post(EVENT);

    List<String> events = catcher.getEvents();
    assertTrue("No events should be delivered synchronously.", events.isEmpty());

    // Now we find the task in our Executor and explicitly activate it.
    List<Runnable> tasks = executor.getTasks();
    assertEquals("One event dispatch task should be queued.", 1, tasks.size());

   * @throws IllegalStateException if {@link #refreshAfterWrite} was already set
   * @since 11.0
   * @deprecated Use {@link #refreshAfterWrite(Duration)} instead.
   */
  @GwtIncompatible // To be supported (synchronously).
  @Deprecated // GoodTime
  @CanIgnoreReturnValue
  public CacheBuilder<K, V> refreshAfterWrite(long duration, TimeUnit unit) {
    checkNotNull(unit);

      // interact poorly with the reentrancy-avoiding behavior of this executor - when the operation
      // before the cancelled future completes, it will synchronously complete both the newFuture
      // from the cancelled operation and its own. This can cause one runnable to queue two tasks,
      // breaking the invariant this method relies on to iteratively run the next task after the

   * @throws IllegalStateException if {@link #refreshAfterWrite} was already set
   * @since 11.0
   * @deprecated Use {@link #refreshAfterWrite(Duration)} instead.
   */
  @GwtIncompatible // To be supported (synchronously).
  @Deprecated // GoodTime
  @CanIgnoreReturnValue
  public CacheBuilder<K, V> refreshAfterWrite(long duration, TimeUnit unit) {
    checkNotNull(unit);

- Support create or update VMSS asynchronously. ([#89248](https://github.com/kubernetes/kubernetes/pull/89248), [@nilo19](https://github.com/nilo19)) [SIG Cloud Provider]

  @Throws(IOException::class)
  fun peekTrailers(): Headers?

  /**
   * Cancel this stream. Resources held by this stream will be cleaned up, though not synchronously.
   * That may happen later by the connection pool thread.
   */
  fun cancel()

  /**
   * Carries an exchange. This is usually a connection, but it could also be a connect plan for

      // interact poorly with the reentrancy-avoiding behavior of this executor - when the operation
      // before the cancelled future completes, it will synchronously complete both the newFuture
      // from the cancelled operation and its own. This can cause one runnable to queue two tasks,
      // breaking the invariant this method relies on to iteratively run the next task after the

		}
	}

	for i, version := range x.versions {
		if version.header.VersionID != uv || version.header.Type != ObjectType {
			continue
		}
		// if uv has tiered content we add a
		// free-version to track it for asynchronous
		// deletion via scanner.
		ver, err := x.getIdx(i)
		if err != nil {
			return err
		}

		if freeVersion, toFree := ver.ObjectV2.InitFreeVersion(fi); toFree {
			return x.addVersion(freeVersion)