"ipFamilies": {
              "items": {
                "type": "string",
                "enum": [
                  "IPv4",
                  "IPv6"
                ]
              }
            },
            "ipFamilyPolicy": {
              "type": "string",
              "enum": [
                "",
                "SingleStack",
                "PreferDualStack",

    this.enumConstants = type.getEnumConstants();
    this.counts = new int[enumConstants.length];
  }

  private boolean isActuallyE(@CheckForNull Object o) {
    if (o instanceof Enum) {
      Enum<?> e = (Enum<?>) o;
      int index = e.ordinal();
      return index < enumConstants.length && enumConstants[index] == e;
    }
    return false;
  }

  /**

import org.apache.maven.api.annotations.Nonnull;

/**
 * An SPI interface to extend Maven with a new enum value.
 *
 * @param <T> The type of extensible enum to extend
 */
@Experimental
@Consumer
public interface ExtensibleEnumProvider<T extends ExtensibleEnum> extends SpiService {

    /**
     * Registers new values for the T extensible enum.
     *
     * @return a collection of T instances to register
     */
    @Nonnull

}

public typealias KtKClassAnnotationValue = KaKClassAnnotationValue

/**
 * Some enum entry (enum constant) used as annotation argument. E.g: `@A(Color.RED)`
 */
public class KaEnumEntryAnnotationValue @KaAnalysisApiInternals constructor(
    /**
     * Fully qualified name of used enum entry.
     */
    callableId: CallableId?,
    sourcePsi: KtElement?,
    token: KaLifetimeToken

    /**
     * Identifier used to encode this strategy, when marshalled as part of a BloomFilter. Only
     * values in the [-128, 127] range are valid for the compact serial form. Non-negative values
     * are reserved for enums defined in BloomFilterStrategies; negative values are reserved for any
     * custom, stateful strategy we may define (e.g. any kind of strategy that would depend on user
     * input).
     */
    int ordinal();
  }

		enums = append(enums, schema.JSON{Object: v})
	}
	return func(maxLength *int64) *schema.Structural {
		return &schema.Structural{
			Generic: schema.Generic{
				Type: "string",
			},
			ValueValidation: &schema.ValueValidation{
				MaxLength: maxLength,
				Enum:      enums,
			},
			ValidationExtensions: schema.ValidationExtensions{
				XValidations: apiextensions.ValidationRules{
					{

    runTest("analysis/analysis-api/testData/components/typeProvider/haveCommonSubtype/dataClasses.kt");
  }

  @Test
  @TestMetadata("enums.kt")
  public void testEnums() {
    runTest("analysis/analysis-api/testData/components/typeProvider/haveCommonSubtype/enums.kt");
  }

  @Test
  @TestMetadata("simple.kt")
  public void testSimple() {

 */
@GwtCompatible(serializable = true, emulated = true)
@SuppressWarnings("serial") // we're overriding default serialization
@ElementTypesAreNonnullByDefault
final class ImmutableEnumSet<E extends Enum<E>> extends ImmutableSet<E> {
  static <E extends Enum<E>> ImmutableSet<E> asImmutable(EnumSet<E> set) {
    switch (set.size()) {
      case 0:
        return ImmutableSet.of();
      case 1:

// MODULE: lib1
// FILE: anno.kt
package kotlin.annotation

public enum class AnnotationTarget {
    CLASS;
}

// MODULE: dep(lib1)
// FILE: annotation.kt
package my.pack

import kotlin.annotation.AnnotationTarget

@Target(AnnotationTarget.CLASS)
annotation class Deprecated

// MODULE: lib2
// FILE: anno.kt
package kotlin.annotation

public enum class AnnotationTarget {
    CLASS;
}

import java.util.EnumSet;

/**
 * Request for interceptors. Currently, we support filter just for interception types, but in the feature we could also filter per version etc.
 *
 * Implemented as a enum, so it's easier to generate bytecode.
 */
public enum BytecodeInterceptorFilter {
    INSTRUMENTATION_ONLY(EnumSet.of(BytecodeInterceptorType.INSTRUMENTATION)),