private final ConcurrentHashMap<String, ChangeNotificationHandle> activeWatchers;
    private final ConcurrentHashMap<String, Integer> failureCounts;

    /**
     * Directory change types
     */
    public enum DirectoryChangeType {
        /**
         * File was added to the directory
         */
        FILE_ADDED,
        /**
         * File was removed from the directory
         */
        FILE_REMOVED,

 *
 * @since 4.0.0
 */
@Experimental
@Immutable
public interface ModelBuilderRequest extends RepositoryAwareRequest {

    /**
     * The possible request types for building a model.
     */
    enum RequestType {
        /**
         * The request is for building an initial model from a POM file in a project on the filesystem.
         */
        BUILD_PROJECT,
        /**

 * AbstractSet#iterator()}.
 */
abstract class IncidentEdgeSet<N> extends AbstractSet<EndpointPair<N>> {
  final N node;
  final ArchetypeGraph<N> graph;
  final EdgeType edgeType;

  enum EdgeType {
    INCOMING, // incoming incident edges only
    OUTGOING, // outgoing incident edges only
    BOTH // both incoming and outgoing incident edges
  }

   * <p>The ordering of the {@link State} enum is defined such that if there is a state transition
   * from {@code A -> B} then {@code A.compareTo(B) < 0}. N.B. The converse is not true, i.e. if
   * {@code A.compareTo(B) < 0} then there is <b>not</b> guaranteed to be a valid state transition
   * {@code A -> B}.
   *
   * @since 9.0 (in 1.0 as {@code com.google.common.base.Service.State})
   */
  enum State {

    private static final long serialVersionUID = 1L;
    private static final Logger log = LoggerFactory.getLogger(SmbOperationException.class);

    /**
     * Error categories for SMB operations
     */
    public enum ErrorCategory {
        /** Network-related errors (connection, timeout, etc.) */
        NETWORK,
        /** Authentication and authorization errors */
        AUTHENTICATION,

      "SunApi",
      "deprecation",
      // The `deprecation` suppression is for Unsafe APIs that aren't deprecated under some versions
      "UnnecessaryJavacSuppressWarnings"
    })
    @VisibleForTesting
    enum UnsafeComparator implements LexicographicalComparator {
      INSTANCE;

      static final boolean BIG_ENDIAN = ByteOrder.nativeOrder().equals(ByteOrder.BIG_ENDIAN);

      /*

        }
    }

    @SuppressWarnings("unchecked")
    private static <T extends Enum<T>> Object getSessionKeyInquireType(Class<?> inquireTypeClass) {
        return Enum.valueOf((Class<T>) inquireTypeClass, "KRB5_GET_SESSION_KEY");
    }

                throw new CycleDetectedException(
                        "Edge between '" + from + "' and '" + to + "' introduces to cycle in the graph", cycle);
            }
        }
    }

    private enum DfsState {
        VISITING,
        VISITED
    }

    private static List<String> visitCycle(
            Map<String, Set<String>> graph,
            Collection<String> children,

        @Override
        public Lock get() {
          return new ReentrantLock();
        }
      };

  @Param({"2", "8", "64", "1024", "65536"})
  int numStripes;

  @Param Impl impl;

  enum Impl {
    EAGER {
      @Override
      Striped<Lock> get(int stripes) {
        return Striped.lock(stripes);
      }
    },
    LAZY_SMALL {
      @Override
      Striped<Lock> get(int stripes) {

 */
@Deprecated(since = "4.0.0")
public interface SettingsProblem {

    /**
     * The different severity levels for a problem, in decreasing order.
     */
    enum Severity {
        FATAL, //
        ERROR, //
        WARNING //
    }

    /**
     * Gets the hint about the source of the problem. While the syntax of this hint is unspecified and depends on the