sourceFile.text = apiElement == 'enum' ? """
                /**
                 * @since 11.38
                 */
                public enum $TEST_INTERFACE_SIMPLE_NAME {
                    field;

                    void method() { }
                }
            """
            : apiElement.startsWith('enum') ? """
                public enum $TEST_INTERFACE_SIMPLE_NAME {
                    /**

from enum import Enum
from typing import Any, Callable, Dict, Iterable, List, Optional, Set, Type, Union

from fastapi._compat import (
    PYDANTIC_V2,
    CoreSchema,
    GetJsonSchemaHandler,
    JsonSchemaValue,
    _model_rebuild,
    with_info_plain_validator_function,
)
from fastapi.logger import logger
from pydantic import AnyUrl, BaseModel, Field
from typing_extensions import Annotated, Literal, TypedDict

  }

  // Wrapper of EnumMultiset factory methods, because we need to skip create(Class).
  // create(Enum1.class) is equal to create(Enum2.class) but testEquals() expects otherwise.
  // For the same reason, we need to skip create(Iterable, Class).
  private static class EnumMultisetFactory {
    public static <E extends Enum<E>> EnumMultiset<E> create(Iterable<E> elements) {
      return EnumMultiset.create(elements);
    }
  }

### Create an `Enum` class

Import `Enum` and create a sub-class that inherits from `str` and from `Enum`.

By inheriting from `str` the API docs will be able to know that the values must be of type `string` and will be able to render correctly.

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

            "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;
  }

  /**

                enum:
                - FAIL_CLOSE
                - FAIL_OPEN
                type: string
              imagePullPolicy:
                description: |-
                  The pull behaviour to be applied when fetching Wasm module by either OCI image or `http/https`.

                  Valid Options: IfNotPresent, Always
                enum:
                - UNSPECIFIED_POLICY

def test_custom_enum_encoders():
    def custom_enum_encoder(v: Enum):
        return v.value.lower()

    class MyEnum(Enum):
        ENUM_VAL_1 = "ENUM_VAL_1"

    instance = MyEnum.ENUM_VAL_1

    encoded_instance = jsonable_encoder(
        instance, custom_encoder={MyEnum: custom_enum_encoder}
    )
    assert encoded_instance == custom_enum_encoder(instance)

  @IgnoreJRERequirement // see enclosing class (whose annotation Animal Sniffer ignores here...)
  private static final class EnumSetAccumulator<E extends Enum<E>> {
    @SuppressWarnings({"rawtypes", "unchecked"})
    static final Collector<Enum<?>, ?, ImmutableSet<? extends Enum<?>>> TO_IMMUTABLE_ENUM_SET =
        (Collector) toImmutableEnumSetGeneric();

    @CheckForNull private EnumSet<E> set;

    void add(E e) {