return new HtmlNext(basePath + page.getRoutingPath());
        }, page);
    }

    /**
     * Gets the base path for virtual host based on the virtual host key and page.
     *
     * @param s The virtual host key
     * @param page The HTML page
     * @return The base path for the virtual host
     */
    protected String getVirtualHostBasePath(final String s, final HtmlNext page) {

  /** Returns the platform preferred implementation of a map based on a hash table. */
  static <K extends @Nullable Object, V extends @Nullable Object>
      Map<K, V> newHashMapWithExpectedSize(int expectedSize) {
    return CompactHashMap.createWithExpectedSize(expectedSize);
  }

  /**
   * Returns the platform preferred implementation of an insertion ordered map based on a hash
   * table.
   */

  private final Object subscriber;
  private final Method subscriberMethod;

  /**
   * @param eventBus The {@link EventBus} that handled the event and the subscriber. Useful for
   *     broadcasting a new event based on the error.
   * @param event The event object that caused the subscriber to throw.
   * @param subscriber The source subscriber context.
   * @param subscriberMethod the subscribed method.
   */

A major advantage of certificate-based authentication compared to other STS authentication methods, like OpenID Connect or LDAP/AD, is that client authentication works without any additional/external component that must be constantly available. Therefore, certificate-based authentication may provide better availability / lower operational complexity.

import jakarta.annotation.Resource;

/**
 * <p>
 * {@link DefaultResponseProcessor} is a default implementation of {@link ResponseProcessor}.
 * It processes the response data based on the HTTP status code and configured transformer.
 * </p>
 *
 * <p>
 * It handles successful responses by transforming the data using a {@link Transformer}

            // Set event type based on message type
            WitnessEventType eventType = convertMessageTypeToEventType(message.getType());
            notification.setEventType(eventType);
            notification.setTimestamp(message.getTimestamp());

            // Set resource name based on message content
            if (message.getResourceName() != null) {

  /** Returns the platform preferred implementation of a map based on a hash table. */
  static <K extends @Nullable Object, V extends @Nullable Object>
      Map<K, V> newHashMapWithExpectedSize(int expectedSize) {
    return Maps.newHashMapWithExpectedSize(expectedSize);
  }

  /**
   * Returns the platform preferred implementation of an insertion ordered map based on a hash
   * table.
   */

**NOTE**: When configuring multiple OpenID based authentication providers on a MinIO cluster, any number of Role Policy based providers may be configured, and at most one JWT Claim based provider may be configured.

<details><summary>Example 1: Two role policy providers</summary>

Sample environment variables:

```

# GraphQL { #graphql }

As **FastAPI** is based on the **ASGI** standard, it's very easy to integrate any **GraphQL** library also compatible with ASGI.

You can combine normal FastAPI *path operations* with GraphQL on the same application.

/// tip

**GraphQL** solves some very specific use cases.

It has **advantages** and **disadvantages** when compared to common **web APIs**.

  /**
   * @since 15.0 (previously returned ScheduledFuture)
   */
  @Override
  ListenableScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit);

  /**
   * Duration-based overload of {@link #schedule(Runnable, long, TimeUnit)}.
   *
   * @since 29.0
   */
  @J2ktIncompatible
  default ListenableScheduledFuture<?> schedule(Runnable command, Duration delay) {