* @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) {

3. If the daemon is not able to run the request, for example it is already running a request or is shutting down, it rejects the request. The client starts again.
4. The daemon runs the request, sending back data such as logging output or tooling API events and intermediate models while doing so.

    /**
     * Channel binding is disabled
     */
    public static final int CHANNEL_BINDING_DISABLED = 0;

    /**
     * Channel binding is preferred but not required
     */
    public static final int CHANNEL_BINDING_PREFERRED = 1;

    /**
     * Channel binding is required
     */
    public static final int CHANNEL_BINDING_REQUIRED = 2;

    /**

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(CompressionInterceptor(Zstd, Gzip))
  .build();
```

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

## 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();

    /**
     * Get the protocol for this binding.
     * @return the proto
     */
    public String getProto() {
        return this.proto;
    }

    /**
     * Get the options for this binding.
     * @return the options
     */
    public Map<String, Object> getOptions() {
        return this.options;
    }

    /**
     * Get the server for this binding.
     * @return the server
     */

package jcifs.ntlmssp.av;

/**
 * NTLMSSP AV pair representing channel binding information for enhanced security.
 * Used to bind NTLM authentication to specific communication channels.
 *
 * @author mbechler
 */
public class AvChannelBindings extends AvPair {

    /**
     * Constructs an AV channel bindings pair
     * @param channelBindingHash the channel binding hash value
     */

/// info

Added in FastAPI 0.134.0.

///

## What is a Stream? { #what-is-a-stream }

"**Streaming**" data means that your app will start sending data items to the client without waiting for the entire sequence of items to be ready.

So, it will send the first item, the client will receive and start processing it, and you might still be producing the next item.

```mermaid

     * @param <T> the response type
     * @param request the request to send
     * @param params optional request parameters
     * @return response message
     * @throws CIFSException if an error occurs sending the request
     */
    <T extends CommonServerMessageBlockResponse> T send(Request<T> request, RequestParam... params) throws CIFSException;