Die ursprüngliche Abhängigkeit könnte in einer *Pfadoperation-Funktion*, einem *Pfadoperation-Dekorator* (wenn Sie den Rückgabewert nicht verwenden), einem `.include_router()`-Aufruf, usw. verwendet werden.

FastAPI kann sie in jedem Fall überschreiben.

///

```markdown
# ADR-000X - Title

## Status

- REPLACED by ADR-000X on 20YY-MM-DD
- DEPRECATED on 20YY-MM-DD
- ACCEPTED on 20YY-MM-DD
- REJECTED on 20YY-MM-DD
- PROPOSED on 20YY-MM-DD

## Context

Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna
aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.

        // Test that values() returns all enum constants
        SsoResponseType[] values = SsoResponseType.values();
        assertNotNull(values);
        assertEquals(2, values.length);
        assertEquals(SsoResponseType.METADATA, values[0]);
        assertEquals(SsoResponseType.LOGOUT, values[1]);
    }

    @Test
    public void test_valueOf() {
        // Test valueOf for valid enum names

     * is referenced somewhere for as long as the enum class is loaded. *Maybe in theory* the enum
     * class could be unloaded after the above call to `getEnumConstants` but before we call
     * `get()`, but that is vanishingly unlikely.
     */
    return ref == null ? Optional.absent() : Optional.fromNullable(enumClass.cast(ref.get()));
  }

  static String formatCompact4Digits(double value) {

Das würde einer Drittanbieteranwendung passieren, die versucht, auf eine dieser *Pfadoperationen* mit einem Token zuzugreifen, das von einem Benutzer bereitgestellt wurde, abhängig davon, wie viele Berechtigungen der Benutzer dieser Anwendung erteilt hat.

## Über Integrationen von Drittanbietern { #about-third-party-integrations }

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

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

  /**

      }
    };
  }

  enum QueueImpl implements CollectionsImplEnum {
    MinMaxPriorityQueueImpl {
      @Override
      public <E extends Comparable<E>> Queue<E> create(Collection<E> contents) {
        return MinMaxPriorityQueue.create(contents);
      }
    };
  }

  enum TableImpl {
    HashBasedTableImpl {
      @Override

### `orjson` oder Responsemodell { #orjson-or-response-model }

Wenn es Ihnen um Leistung geht, sind Sie wahrscheinlich mit einem [Responsemodell](../tutorial/response-model.md) besser beraten als mit einer `orjson`-Response.

# Fehler behandeln { #handling-errors }

Es gibt viele Situationen, in denen Sie einem Client, der Ihre API nutzt, einen Fehler mitteilen müssen.

Dieser Client könnte ein Browser mit einem Frontend sein, ein Code von jemand anderem, ein IoT-Gerät usw.

Sie könnten dem Client mitteilen müssen, dass:

* Der Client nicht genügend Berechtigungen für diese Operation hat.
* Der Client keinen Zugriff auf diese Ressource hat.

# Made an issue in:
# https://github.com/fastapi/fastapi/issues/14247
from enum import Enum

from fastapi import FastAPI
from fastapi.testclient import TestClient
from inline_snapshot import snapshot
from pydantic import BaseModel, Field


class MessageEventType(str, Enum):
    alpha = "alpha"
    beta = "beta"


class MessageEvent(BaseModel):