assertThat(Enums.getIfPresent(TestEnum.class, "POODLE")).hasValue(TestEnum.POODLE);

    assertThat(Enums.getIfPresent(TestEnum.class, "CHEETO")).isPresent();
    assertThat(Enums.getIfPresent(TestEnum.class, "HONDA")).isPresent();
    assertThat(Enums.getIfPresent(TestEnum.class, "POODLE")).isPresent();

    assertThat(Enums.getIfPresent(TestEnum.class, "CHEETO")).hasValue(TestEnum.CHEETO);

          .that(returnType.getComponentType())
          .isEqualTo(annotationClass.getDeclaringClass());
    }
  }

  // This is public so that tests for Feature enums we haven't yet imagined
  // can reuse it.
  public static <E extends Enum<?> & Feature<?>> void assertGoodFeatureEnum(
      Class<E> featureEnumClass) {
    Class<?>[] classes = featureEnumClass.getDeclaredClasses();
    for (Class<?> containedClass : classes) {

<img src="/img/tutorial/path-operation-configuration/image01.png">

### Tags con Enums { #tags-with-enums }

Si tienes una gran aplicación, podrías terminar acumulando **varias tags**, y querrías asegurarte de que siempre uses la **misma tag** para *path operations* relacionadas.

En estos casos, podría tener sentido almacenar las tags en un `Enum`.

**FastAPI** soporta eso de la misma manera que con strings normales:

<img src="/img/tutorial/path-operation-configuration/image01.png">

### Tags com Enums { #tags-with-enums }

Se você tem uma grande aplicação, você pode acabar acumulando **várias tags**, e você gostaria de ter certeza de que você sempre usa a **mesma tag** para *operações de rota* relacionadas.

Nestes casos, pode fazer sentido armazenar as tags em um `Enum`.

**FastAPI** suporta isso da mesma maneira que com strings simples:

<img src="/img/tutorial/path-operation-configuration/image01.png">

### Tags with Enums { #tags-with-enums }

If you have a big application, you might end up accumulating **several tags**, and you would want to make sure you always use the **same tag** for related *path operations*.

In these cases, it could make sense to store the tags in an `Enum`.

**FastAPI** supports that the same way as with plain strings:

	public static final field BASIC Lokhttp3/logging/HttpLoggingInterceptor$Level;
	public static final field BODY Lokhttp3/logging/HttpLoggingInterceptor$Level;
	public static final field HEADERS Lokhttp3/logging/HttpLoggingInterceptor$Level;
	public static final field NONE Lokhttp3/logging/HttpLoggingInterceptor$Level;
	public static fun getEntries ()Lkotlin/enums/EnumEntries;

<img src="/img/tutorial/path-operation-configuration/image01.png">

### Tags mittels Enumeration { #tags-with-enums }

Wenn Sie eine große Anwendung haben, können sich am Ende **viele Tags** anhäufen, und Sie möchten sicherstellen, dass Sie für verwandte *Pfadoperationen* immer den **gleichen Tag** verwenden.

In diesem Fall macht es Sinn, die Tags in einem `Enum` zu speichern.

**FastAPI** unterstützt das auf die gleiche Weise wie einfache Strings:

### Теги с перечислениями { #tags-with-enums }

Если у вас большое приложение, вы можете прийти к необходимости добавить **несколько тегов**, и возможно, вы захотите убедиться в том, что всегда используете **один и тот же тег** для связанных *операций пути*.

В этих случаях, имеет смысл хранить теги в классе `Enum`.

**FastAPI** поддерживает это так же, как и в случае с обычными строками:

   *
   * @since 16.0
   */
  public static <K0 extends Enum<K0>> MultimapBuilderWithKeys<K0> enumKeys(Class<K0> keyClass) {
    checkNotNull(keyClass);
    return new MultimapBuilderWithKeys<K0>() {
      @SuppressWarnings("unchecked")
      @Override
      <K extends K0, V extends @Nullable Object> Map<K, Collection<V>> createMap() {
        // K must actually be K0, since enums are effectively final

### Створення класу `Enum`

Імпортуйте `Enum` і створіть підклас, що наслідується від `str` та `Enum`.

Наслідуючи від `str`, документація API зможе визначити, що значення повинні бути типу `string`, і правильно їх відобразить.