*
     * @return The facet response, or null if no facets were requested
     */
    public FacetResponse getFacetResponse() {
        return facetResponse;
    }

    /**
     * Creates a new SearchResultBuilder for constructing SearchResult instances.
     *
     * @return A new SearchResultBuilder instance
     */
    public static SearchResultBuilder create() {

 *     #from(ValueGraph)}.
 * @since 20.0
 */
@Beta
public final class ValueGraphBuilder<N, V> extends AbstractGraphBuilder<N> {

  /** Creates a new instance with the specified edge directionality. */
  private ValueGraphBuilder(boolean directed) {
    super(directed);
  }

  /** Returns a {@link ValueGraphBuilder} for building directed graphs. */

        Element plugin = insertNewElement(PLUGIN, pluginsElement);
        addGAVElements(plugin, groupId, artifactId, version);
        return plugin;
    }

    /**
     * Updates or creates a child element with the given content.
     *
     * @param parent the parent element
     * @param childName the child element name
     * @param content the content to set
     * @return the updated or created element

// EventNotifier - notifies external systems about events in MinIO.
type EventNotifier struct {
	sync.RWMutex
	targetList     *event.TargetList
	bucketRulesMap map[string]event.RulesMap
}

// NewEventNotifier - creates new event notification object.
func NewEventNotifier(ctx context.Context) *EventNotifier {
	// targetList/bucketRulesMap/bucketRemoteTargetRulesMap are populated by NotificationSys.InitBucketTargets()
	return &EventNotifier{

 * finalizeReferent()} on the remaining references.
 *
 * <p>As an example of how this is used, imagine you have a class {@code MyServer} that creates a
 * {@link java.net.ServerSocket ServerSocket}, and you would like to ensure that the {@code
 * ServerSocket} is closed even if the {@code MyServer} object is garbage-collected without calling

    /**
     * Returns an {@link Iterable} of {@link FieldDesc}.
     *
     * @return An {@link Iterable} of {@link FieldDesc}
     */
    Iterable<FieldDesc> getFieldDescs();

    /**
     * Creates a new instance.
     *
     * @param <T>
     *            The type of the Bean class
     * @param args
     *            The arguments to pass to the constructor
     * @return A new instance
     */

     */
    public static CrawlerClientFactory getCrawlerClientFactory() {
        return getComponent(CrawlerClientFactory.class);
    }

    /**
     * Gets the crawler client creator component.
     * @return The crawler client creator.
     */
    public static CrawlerClientCreator getCrawlerClientCreator() {
        return getComponent(CrawlerClientCreator.class);
    }

    /**

     *
     * @param detector The language detector.
     */
    public void setDetector(final LanguageDetector detector) {
        this.detector = detector;
    }

    /**
     * Creates a script for updating a document with language information.
     *
     * @param doc The document.
     * @param code The script code.
     * @return The script.
     */

 * and list retrieval. Character mappings are used for text normalization
 * and character substitution during document processing and search operations.
 * </p>
 */
public class CharMappingService {

    /**
     * Creates a new instance of CharMappingService.
     */
    public CharMappingService() {
        // Default constructor
    }

    /**
     * Dictionary manager for accessing and managing dictionary files.
     */

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.NavigableMap;
import java.util.SortedMap;
import junit.framework.TestSuite;

/**
 * Creates, based on your criteria, a JUnit test suite that exhaustively tests a NavigableMap
 * implementation.
 */
@GwtIncompatible
public class NavigableMapTestSuiteBuilder<K, V> extends SortedMapTestSuiteBuilder<K, V> {