* @since 11.0
 */
@Immutable
public interface HashFunction {
  /**
   * Begins a new hash code computation by returning an initialized, stateful {@code Hasher}
   * instance that is ready to receive data. Example:
   *
   * {@snippet :
   * HashFunction hf = Hashing.md5();
   * HashCode hc = hf.newHasher()
   *     .putLong(id)
   *     .putBoolean(isActive)
   *     .hash();
   * }
   */

  // These properties are only accessed by the thread executing the call.

  /** Initialized in [callStart]. */
  private var callStackTrace: Any? = null

  /** Finds an exchange to send the next request and receive the next response. */
  private var exchangeFinder: ExchangeFinder? = null

  var connection: RealConnection? = null
    private set
  private var timeoutEarlyExit = false

  /**

                final ListObjectsArgs args = ListObjectsArgs.builder()
                        .bucket(bucketName)
                        .prefix(path)
                        .recursive(false)
                        .includeUserMetadata(false)
                        .useApiVersion1(false)
                        .build();
                for (final Result<Item> result : minioClient.listObjects(args)) {

//     kmskey: "key-id" # match objects with KMS key-id (applicable only for sse-kms)
//   notify:
//     endpoint: "https://notify.endpoint" # notification endpoint to receive job status events
//     token: "Bearer xxxxx" # optional authentication token for the notification endpoint

//   retry:
//     attempts: 10 # number of retries for the job before giving up

import java.net.Proxy

/**
 * Listener for metrics events. Extend this class to monitor the quantity, size, and duration of
 * your application's HTTP calls.
 *
 * All start/connect/acquire events will eventually receive a matching end/release event, either
 * successful (non-null parameters), or failed (non-null throwable). The first common parameters of
 * each event pair are used to link the event in case of concurrent or repeated events e.g.

    )
    val openAtNanos = System.nanoTime()
    newWebSocket()
    clientListener.assertOpen()
    clientListener.assertFailure(
      SocketTimeoutException::class.java,
      "sent ping but didn't receive pong within 500ms (after 0 successful ping/pongs)",
    )
    latch.countDown()
    val elapsedUntilFailure = System.nanoTime() - openAtNanos
    assertThat(TimeUnit.NANOSECONDS.toMillis(elapsedUntilFailure).toDouble())

// 3) The folder only contains objects and no subfolders.
//
// A bucket root will never be compacted.
//
// Furthermore if a has more than dataScannerCompactAtChildren recursive children (uncompacted folders)
// the tree will be recursively scanned and the branches with the least number of objects will be
// compacted until the limit is reached.
//

     */
    fun priority(
      streamId: Int,
      streamDependency: Int,
      weight: Int,
      exclusive: Boolean,
    )

    /**
     * HTTP/2 only. Receive a push promise header block.
     *
     * A push promise contains all the headers that pertain to a server-initiated request, and a

                this.projects = map;
            } else {
                return Collections.emptyMap();
            }
        }
        return projects;
    }

    /**
     * Singleton class used to receive events by implementing the EventSpy.
     * It simply forwards all {@code ExecutionEvent}s to the {@code ReactorReader}.
     */
    @Named
    @Singleton
    @SuppressWarnings("unused")

      e.initCause(throwable);
      throw e;
    }
  }

  /**
   * Returns a string containing the result of {@link Throwable#toString() toString()}, followed by
   * the full, recursive stack trace of {@code throwable}. Note that you probably should not be
   * parsing the resulting string; if you need programmatic access to the stack frames, you can call
   * {@link Throwable#getStackTrace()}.
   */