It enables Brotli support in addition to tranparent Gzip support,
provided Accept-Encoding is not set previously.  Modern web servers
must choose to return Brotli responses.  n.b. It is not used for
sending requests.

```java
OkHttpClient client = new OkHttpClient.Builder()
  .addInterceptor(BrotliInterceptor.INSTANCE)
  .build();
```

```kotlin
implementation("com.squareup.okhttp3:okhttp-brotli:5.3.0")
```

Being able to use asynchronous functions in your tests could be useful, for example, when you're querying your database asynchronously. Imagine you want to test sending requests to your FastAPI application and then verify that your backend successfully wrote the correct data in the database, while using an async database library.

Let's look at how we can make that work.

This module enables [Zstandard (zstd)][1] response compression in addition to Gzip, as long as
the `Accept-Encoding` header is not otherwise set. Web servers must be configured to return zstd
responses.

Note that zstd is not used for sending requests.

```java
OkHttpClient client = new OkHttpClient.Builder()
  .addInterceptor(ZstdInterceptor.INSTANCE)
  .build();
```

```kotlin
implementation("com.squareup.okhttp3:okhttp-zstd:5.3.0")
```

# OpenAPI Webhooks { #openapi-webhooks }

There are cases where you want to tell your API **users** that your app could call *their* app (sending a request) with some data, normally to **notify** of some type of **event**.

This means that instead of the normal process of your users sending requests to your API, it's **your API** (or your app) that could **send requests to their system** (to their API, their app).

This is normally called a **webhook**.

     * @return true if registration exists
     */
    public boolean hasRegistration(String registrationId) {
        return registrations.containsKey(registrationId);
    }

    /**
     * Simulate sending a witness notification
     *
     * @param eventType the event type
     * @param resourceName the resource name
     */
    public void sendNotification(WitnessEventType eventType, String resourceName) {

 * limitations under the License.
 */
package mockwebserver3

import okio.Socket

/**
 * Handles a call's request and response streams directly. Use this instead of [MockResponseBody] to
 * begin sending response data before all request data has been received.
 *
 * See [okhttp3.RequestBody.isDuplex].
 */
public interface SocketHandler {
  public fun handle(socket: Socket)

## Reporting a Vulnerability

If you think you found a vulnerability, and even if you are not sure about it, please report it right away by sending an email to: ******@****.***. Please try to be as explicit as possible, describing all the steps and example code to reproduce the security issue.

    @Override public Response intercept(Chain chain) throws IOException {
      long t1 = System.nanoTime();
      Request request = chain.request();
      logger.info(String.format("Sending request %s on %s%n%s",
          request.url(), chain.connection(), request.headers()));
      Response response = chain.proceed(request);

      long t2 = System.nanoTime();

import org.opensearch.index.query.QueryBuilder;
import org.opensearch.index.query.QueryBuilders;

/**
 * Helper class for indexing operations in the Fess search engine.
 * This class provides functionality for sending documents to the search engine,
 * managing document lifecycle operations (create, update, delete), and handling
 * thumbnail processing during indexing.
 *

     *
     * @return average send latency
     */
    public double getAverageSendLatencyMicros() {
        long sends = rdmaSends.get();
        if (sends == 0) {
            return 0.0;
        }
        return totalSendTime.get() / (double) sends / 1000.0; // Convert to microseconds
    }

    /**
     * Calculate average receive latency in microseconds
     *