# Entwickler-API-Referenz

Verité stellt eine stabile öffentliche Java-API unter dem Paket `teacommontea.api` bereit. Jedes Teilsystem ist eine Fassade aus statischen Methoden über stabilen öffentlichen Typen, sodass du alles tun kannst, was das Plugin tut, ohne jemals auf eine interne Implementierungsklasse zu verweisen.

Diese Seite ist die vollständige Oberfläche, zum Nachschlagen organisiert. Zwei Themen haben ihre eigenen dedizierten Anleitungen und werden hier nur querverwiesen:

- Der Chatfilter: [Integration benutzerdefinierter Chat-Systeme](page:developers/wiring).
- Durchsetzung von Stummschaltung, Slowmode und Chat-Freeze: [Benutzerdefinierte Moderationsdurchsetzung](page:developers/moderation-enforcement).

## Erste Schritte

### Verité als optionale Abhängigkeit hinzufügen

Füge Verité zu deiner `plugin.yml` hinzu, damit es vor deinem Plugin geladen wird, sofern es installiert ist, ohne verpflichtend zu werden:

```yaml
softdepend:
  - Verite
```

### Auf Verfügbarkeit prüfen

Wenn Verité optional ist, prüfe vor der Verwendung der API auf eine Klasse:

```java
private static final boolean VERITE_AVAILABLE;

static {
    boolean available;
    try {
        Class.forName("teacommontea.api.VeriteAPI");
        available = true;
    } catch (ClassNotFoundException ignored) {
        available = false;
    }
    VERITE_AVAILABLE = available;
}
```

Jedes Teilsystem verhält sich außerdem für sich abbaubar: Wenn das zugrunde liegende Modul deaktiviert ist, geben Abfragemethoden `null`, `false` oder eine leere Sammlung zurück, verändernde Aufrufe werden zu No-Ops, und ausführende Aufrufe geben ein fehlgeschlagenes Ergebnis zurück. Du musst ein deaktiviertes Modul selten gesondert behandeln.

## VeriteAPI

`VeriteAPI` ist der einzige übergeordnete Einstiegspunkt. Es meldet die API-Version, meldet, welche Module aktiviert sind, und gibt zur Erkennung die Klasse jedes Teilsystems zurück.

| Member | Gibt zurück | Bedeutung |
| --- | --- | --- |
| `VeriteAPI.VERSION` | `String` | Der API-Versionsstring. |
| `moderationEnabled()` | `boolean` | Ob das Moderationsmodul geladen ist. |
| `vanishEnabled()` | `boolean` | Ob das Vanish-Modul geladen ist. |
| `captchaEnabled()` | `boolean` | Ob das Captcha-Modul geladen ist. |
| `moderation()` | `Class<VeriteModeration>` | Die Klasse des Moderations-Teilsystems. |
| `playerData()` | `Class<VeritePlayerData>` | Die Klasse des Spielerdaten-Teilsystems. |
| `store()` | `Class<VeriteStore>` | Die Klasse des Store-Teilsystems. |
| `vanish()` | `Class<VeriteVanish>` | Die Klasse des Vanish-Teilsystems. |
| `captcha()` | `Class<VeriteCaptcha>` | Die Klasse des Captcha-Teilsystems. |
| `filter()` | `Class<VeriteFilter>` | Die Klasse des Chatfilter-Teilsystems. |
| `text()` | `Class<VeriteText>` | Die Klasse des Textformatierungs-Teilsystems. |

Alle Teilsysteme sind statische Fassaden, sodass du sie direkt aufrufst (zum Beispiel `VeriteModeration.isBanned(uuid)`). Die Zugriffsmethoden existieren zur Erkennung und für zentralisierte Aktiviert-Prüfungen.

## VeriteModeration

Der vollständige Einstiegspunkt zum Verhängen, Abfragen und Aufheben von Strafen. `durationMillis` verwendet `Punishment.PERMANENT` für eine dauerhafte Strafe. Gate-Methoden geben `true` zurück, wenn sie den Spieler gestoppt haben. Siehe [Benutzerdefinierte Moderationsdurchsetzung](page:developers/moderation-enforcement) für den Gate- und Listener-Workflow im Detail.

### Status und Abfragen

| Methode | Gibt zurück | Bedeutung |
| --- | --- | --- |
| `enabled()` | `boolean` | Ob das Moderationsmodul geladen ist. |
| `isBanned(UUID player)` | `boolean` | Ob der Spieler einen aktiven Bann hat. |
| `isMuted(UUID player)` | `boolean` | Ob der Spieler eine aktive Stummschaltung hat. |
| `activeBan(UUID player)` | `Punishment` | Der aktive Bann oder `null`. |
| `activeMute(UUID player)` | `Punishment` | Die aktive Stummschaltung oder `null`. |
| `history(UUID player, int limit)` | `List<Punishment>` | Jüngster Strafverlauf für den Spieler. |
| `byIp(String ip, int limit)` | `List<Punishment>` | Gegen eine IP aufgezeichnete Strafen. |
| `byStaff(UUID staff, int limit)` | `List<Punishment>` | Von einem Mitarbeiter verhängte Strafen. |
| `activeWarnings(UUID player)` | `List<Punishment>` | Derzeit aktive Verwarnungen für den Spieler. |
| `activePunishments()` | `List<ActivePunishment>` | Leichtgewichtige Zeiger auf jede aktive Strafe. |
| `activeOfType(PunishmentType type, long now)` | `List<Punishment>` | Aktive Strafen eines Typs zu einem gegebenen Zeitpunkt. |
| `loadPunishment(long id)` | `Punishment` | Der vollständige Datensatz für eine numerische ID oder `null`. |
| `altsOf(UUID player)` | `List<UUID>` | Konten, die sich die erste bekannte IP des Spielers teilen. |
| `pruneHistory(UUID player, long cutoff, long now)` | `int` | Entfernt Verlauf, der älter als der Stichtag ist, und gibt die Anzahl der entfernten zurück. |
| `warningExpire()` | `long` | Das Ablauffenster für Verwarnungen in Millisekunden. |

### Strafen verhängen

| Methode | Gibt zurück |
| --- | --- |
| `ban(UUID target, String targetName, String reason, UUID executor, String executorName, long durationMillis, boolean silent)` | `PunishmentResult` |
| `mute(UUID target, String targetName, String reason, UUID executor, String executorName, long durationMillis, boolean silent)` | `PunishmentResult` |
| `ipban(UUID target, String ip, String targetName, String reason, UUID executor, String executorName, long durationMillis, boolean silent)` | `PunishmentResult` |
| `ipmute(UUID target, String ip, String targetName, String reason, UUID executor, String executorName, long durationMillis, boolean silent)` | `PunishmentResult` |
| `warn(UUID target, String targetName, String reason, UUID executor, String executorName, boolean silent)` | `PunishmentResult` |
| `kick(UUID target, String targetName, String reason, UUID executor, String executorName, boolean silent)` | `PunishmentResult` |

### Strafen aufheben

| Methode | Gibt zurück | Bedeutung |
| --- | --- | --- |
| `unban(UUID target, String targetName, UUID remover, String removerName, String reason)` | `boolean` | Hebt den aktiven Bann auf, `true` bei Erfolg. |
| `unmute(UUID target, String targetName, UUID remover, String removerName, String reason)` | `boolean` | Hebt die aktive Stummschaltung auf, `true` bei Erfolg. |
| `unwarn(UUID target, String targetName, UUID removedBy, String removedByName, String reason)` | `PunishmentResult` | Entfernt eine Verwarnung. |

### Rendering und Hinweise

| Methode | Gibt zurück | Bedeutung |
| --- | --- | --- |
| `banScreen(Punishment ban)` | `String` | Der vollständige Bannbildschirm für einen Banndatensatz. |
| `muteLine(Punishment mute)` | `String` | Die einzeilige Zusammenfassung der Stummschaltung. |
| `muteNotice(Punishment mute)` | `String` | Der Stummschaltungshinweis, der an einen stummgeschalteten Spieler gesendet wird. |

### Chat-Gates

Jedes Gate gibt `true` zurück, wenn der Spieler gestoppt werden sollte, und sendet ihm als Nebeneffekt den Grund. Verwende sie dort, wo du durchsetzen willst.

| Methode | Gibt zurück | Bedeutung |
| --- | --- | --- |
| `muteGate(Player p)` | `boolean` | Spieler ist stummgeschaltet; sendet den Stummschaltungshinweis. |
| `chatMuteGate(Player p)` | `boolean` | Globaler Chat-Freeze ist aktiv; sendet den Freeze-Hinweis. |
| `slowmodeGate(Player p)` | `boolean` | Spieler wird durch Slowmode aufgehalten; sendet die verbleibende Wartezeit. |

### Chat-Befehle

Diese steuern die plugineigenen Chat-Befehle für einen `CommandSender`.

| Methode | Bedeutung |
| --- | --- |
| `broadcast(CommandSender sender, String[] args)` | Sendet eine Verbreitung. |
| `chatClear(CommandSender sender)` | Leert den Chat. |
| `chatMute(CommandSender sender)` | Schaltet den globalen Chat-Freeze um. |
| `slowmode(CommandSender sender, String[] args)` | Setzt den Slowmode. |

### Listener

| Methode | Bedeutung |
| --- | --- |
| `registerListener(ModerationListener listener)` | Abonniert Strafaktivität. |
| `unregisterListener(ModerationListener listener)` | Beendet den Empfang von Ereignissen. |

## VeritePlayerData

Liest und zeichnet die Konto-, Sitzungs- und Identitätsdaten auf, die das Moderationssystem speichert. Zeitstempel sind Epoch-Millisekunden. Wenn das Modul deaktiviert ist, geben Abfragen `null` oder leer zurück und Aufzeichnungsaufrufe sind No-Ops.

| Methode | Gibt zurück | Bedeutung |
| --- | --- | --- |
| `enabled()` | `boolean` | Ob der Datenspeicher geöffnet ist. |
| `hasProfile(UUID player)` | `boolean` | Ob ein Profil existiert. |
| `profile(UUID player)` | `PlayerProfile` | Das vollständige Profil oder `null`. |
| `uuidByName(String name)` | `UUID` | Löst eine UUID aus einem Namen auf. |
| `nameOf(UUID player)` | `String` | Löst den aktuellen Namen aus einer UUID auf. |
| `knownNames()` | `List<String>` | Jeder bekannte Name im Speicher. |
| `namesOf(UUID player)` | `List<String>` | Alle Namen, die ein Spieler verwendet hat. |
| `ipsOf(UUID player)` | `List<String>` | Alle IPs, von denen aus sich ein Spieler verbunden hat. |
| `usersOfIp(String ip)` | `List<UUID>` | Alle Nutzer, die sich eine IP geteilt haben. |
| `clientsOf(UUID player)` | `List<String>` | Alle Clients, die ein Spieler verwendet hat. |
| `recordLogin(UUID player, String name, String ip, long now)` | `void` | Zeichnet einen Login auf. |
| `recordClient(UUID player, String brand, int protocol, String referrer, long now)` | `void` | Zeichnet eine Client-Marke und ein Protokoll auf. |
| `flushSession(UUID player, long now)` | `void` | Leert die Sitzung des Spielers. |
| `recordLogout(UUID player, long now)` | `void` | Zeichnet einen Logout auf. |

## VeriteStore und VeriteScope

`VeriteStore` öffnet benannte Datenbereiche im gemeinsamen persistenten Schlüssel-Wert-Speicher des Plugins, sodass dein Plugin Daten neben Verité persistieren kann, ohne eine eigene Datenbank. Versieh deine Bereichsnamen mit einem Namespace, um Kollisionen mit Plugin-Daten zu vermeiden.

| `VeriteStore`-Methode | Gibt zurück | Bedeutung |
| --- | --- | --- |
| `available()` | `boolean` | Ob der Speicher geöffnet ist. |
| `scope(String name)` | `VeriteScope` | Öffnet einen benannten Bereich oder `null`, wenn nicht verfügbar. |

Ein `VeriteScope` ist ein benannter Bereich, den du frei liest und beschreibst. Schreibvorgänge werden über den normalen Flush-Zyklus des Plugins persistiert.

| `VeriteScope`-Methode | Gibt zurück | Bedeutung |
| --- | --- | --- |
| `set(String key, Object value)` | `void` | Speichert einen Wert unter einem Schlüssel. |
| `delete(String key)` | `void` | Entfernt einen Schlüssel. |
| `has(String key)` | `boolean` | Prüft das Vorhandensein eines Schlüssels. |
| `get(String key)` | `Object` | Der rohe gespeicherte Wert. |
| `getString(String key, String def)` | `String` | Typisiertes Lesen mit einem Standardwert. |
| `getLong(String key, long def)` | `long` | Typisiertes Lesen mit einem Standardwert. |
| `getInt(String key, int def)` | `int` | Typisiertes Lesen mit einem Standardwert. |
| `getBoolean(String key, boolean def)` | `boolean` | Typisiertes Lesen mit einem Standardwert. |
| `getBigDecimal(String key)` | `BigDecimal` | Typisiertes Lesen. |
| `entries()` | `List<ScopeEntry>` | Jedes Schlüssel-Wert-Paar im Bereich. |

```java
VeriteScope scope = VeriteStore.scope("myplugin");
if (scope != null) {
    scope.set("greeting", "hello");
    String greeting = scope.getString("greeting", "");
}
```

## VeriteVanish

Vanish-Zustand und -Steuerung für Mitarbeiter. `vanish`, `unvanish` und `toggle` geben `true` zurück, wenn sich der Zustand tatsächlich geändert hat. Wenn das Modul deaktiviert ist, geben Abfragen `false` oder leer zurück und verändernde Aufrufe sind No-Ops.

| Methode | Gibt zurück | Bedeutung |
| --- | --- | --- |
| `enabled()` | `boolean` | Ob das Vanish-Modul geladen ist. |
| `isVanished(UUID player)` | `boolean` | Ob ein Spieler versteckt ist. |
| `isVanished(Player player)` | `boolean` | Bequeme Überladung für einen Online-Spieler. |
| `getVanished()` | `Set<UUID>` | Jeder derzeit versteckte Spieler. |
| `vanish(Player p)` | `boolean` | Versteckt einen Spieler. |
| `unvanish(Player p)` | `boolean` | Macht einen Spieler wieder sichtbar. |
| `toggle(Player p)` | `boolean` | Schaltet den Vanish-Zustand eines Spielers um. |
| `registerPlaceholders()` | `void` | Registriert die PlaceholderAPI-Erweiterung für Vanish. |
| `registerListener(VanishListener listener)` | `void` | Abonniert Vanish-Änderungen. |
| `unregisterListener(VanishListener listener)` | `void` | Beendet den Empfang von Vanish-Ereignissen. |

## VeriteCaptcha

Captcha-Herausforderungen ausstellen und verfolgen. `challenge`-Methoden geben `true` zurück, wenn tatsächlich eine Herausforderung gestartet wurde. Das Label `source` zeichnet auf, warum die Herausforderung geöffnet wurde, und wird bis zu den Abschluss- und Strafanforderungsereignissen weitergereicht. Wenn das Modul deaktiviert ist, geben alle Aufrufe `false` zurück.

| Member | Gibt zurück | Bedeutung |
| --- | --- | --- |
| `VeriteCaptcha.BYPASS_PERMISSION` | `String` | Der Berechtigungsknoten, der Captcha umgeht. |
| `VeriteCaptcha.NOTIFY_PERMISSION` | `String` | Der Captcha-Benachrichtigungs-Berechtigungsknoten. |
| `enabled()` | `boolean` | Ob das Captcha-Modul geladen ist. |
| `isActive(UUID player)` | `boolean` | Ob für den Spieler eine Herausforderung aktiv ist. |
| `challengeStandard(Player player, String source)` | `boolean` | Öffnet eine Standard-Herausforderung. |
| `challengeDetailed(Player player, String source)` | `boolean` | Öffnet eine detaillierte Herausforderung. |
| `challenge(Player player, CaptchaType type, String source)` | `boolean` | Öffnet eine Herausforderung eines expliziten Typs. |

## VeriteFilter

Der umgehungsbewusste Chatfilter. Der vollständige Workflow, einschließlich anonymer Prüfungen, wiederholungssensitiver Prüfungen und der Hilfsmethoden für Blockmeldungen, ist in [Integration benutzerdefinierter Chat-Systeme](page:developers/wiring) dokumentiert. Die Oberfläche:

| Member | Gibt zurück | Bedeutung |
| --- | --- | --- |
| `VeriteFilter.ANONYMOUS` | `UUID` | Als Spieler übergeben, wenn es keinen Täter gibt, gegen den aufgezeichnet werden soll. |
| `check(UUID player, String message)` | `FilterResult` | Klassifiziert eine Nachricht und zeichnet den Treffer gegen den Spieler auf. |
| `check(UUID player, String message, boolean repeatAware)` | `FilterOutcome` | Wiederholungssensitive Klassifizierung. |
| `count(UUID player)` | `int` | Wie oft ein Spieler markiert wurde. |
| `blockMessage()` | `String` | Die konfigurierte Blockmeldung. |
| `repeatMessage()` | `String` | Der konfigurierte Wiederholungshinweis. |
| `selfHarmMessage()` | `String` | Der konfigurierte Selbstverletzungshinweis. |
| `blockNotice(FilterResult result, String message)` | `BaseComponent[]` | Die gerenderte Hinweiskomponente für ein Ergebnis. |
| `foldAccents(String s)` | `String` | Normalisierungshilfe: entfernt Akzente. |
| `stripDeletes(String s)` | `String` | Normalisierungshilfe: entfernt Zeichen ohne Breite und Löschzeichen. |
| `stripEntities(String s)` | `String` | Normalisierungshilfe: entfernt HTML-artige Entities. |
| `reduceRuns(String s, int max)` | `String` | Normalisierungshilfe: reduziert wiederholte Buchstaben. |
| `fingerprint(String word)` | `String` | Reihenfolgenunabhängige Buchstabensignatur für den Abgleich von Transpositionen. |
| `trimEdges(String word)` | `String` | Schneidet Nicht-Buchstaben-Ränder von einem Wort ab. |

Die Normalisierungshilfen sind reine Funktionen und können gefahrlos außerhalb des Haupt-Threads aufgerufen werden.

## VeriteText

Analysiert Verite-Tag-Text und wendet das Präfix des Plugins so an, wie es das Plugin tut, sodass deine Ausgabe identisch gestylt wird.

| Methode | Gibt zurück | Bedeutung |
| --- | --- | --- |
| `parse(String tagged)` | `BaseComponent[]` | Analysiert Verite-Tags zu einem Komponenten-Array. |
| `prefixed(String tagged)` | `BaseComponent[]` | Analysiert und stellt das Plugin-Präfix voran. |
| `prefix()` | `String` | Das aktuelle Präfix. |
| `setPrefix(String prefix)` | `void` | Ändert das Präfix. |

## Hilfsmittel

### VeriteGeoIp

Ermittelt das Land einer IP und prüft den Zustand der GeoIP-Datenbank.

| Methode | Gibt zurück | Bedeutung |
| --- | --- | --- |
| `country(String ip)` | `String` | Ländername für eine IP oder `null`, wenn nicht auflösbar. |
| `available()` | `boolean` | Ob die GeoIP-Datenbank geladen wurde. |
| `isPrivate(String ip)` | `boolean` | Ob eine IP in einem privaten oder reservierten Bereich liegt. |
| `attempted()` | `boolean` | Ob ein Ladeversuch der Datenbank unternommen wurde. |

### VeriteDuration

Analysiert und formatiert menschenlesbare Strafdauern, mit Millisekunden-Einheitenkonstanten: `SECOND`, `MINUTE`, `HOUR`, `DAY`, `WEEK`, `MONTH`, `YEAR`.

| Methode | Gibt zurück | Bedeutung |
| --- | --- | --- |
| `suggestions()` | `List<String>` | Vorgeschlagene Dauer-Token. |
| `parse(String token)` | `long` | Analysiert ein Token wie `7d` in Millisekunden. |
| `parseTwoToken(String number, String unitWord)` | `long` | Analysiert eine getrennte Zahl und ein Einheitenwort in Millisekunden. |
| `format(long millis)` | `String` | Formatiert Millisekunden in einen menschenlesbaren String. |

### VeriteFormat

Formatiert Zeiten, bildet Plurale von Nomen und benennt Client-Protokollversionen.

| Methode | Gibt zurück | Bedeutung |
| --- | --- | --- |
| `fancyTime(long millis)` | `String` | Eine Millisekundenspanne als menschenlesbarer String. |
| `plural(long count, String noun)` | `String` | Eine Anzahl mit dem korrekten Singular- oder Plural-Nomen. |
| `pluralize(long count, String noun)` | `String` | Eine Anzahl mit dem korrekten Singular- oder Plural-Nomen. |
| `versionName(int protocol)` | `String` | Der Minecraft-Versionsname für eine Client-Protokollnummer. |

### VeriteLimits

Setzt dieselben aussteller-bezogenen Dauerobergrenzen und Abklingzeiten durch, die auch das Plugin verwendet.

| Methode | Gibt zurück | Bedeutung |
| --- | --- | --- |
| `capDuration(CommandSender issuer, PunishmentType type, long requested)` | `DurationCheck` | Validiert eine angeforderte Dauer und gibt den begrenzten Wert zurück. |
| `cooldownRemaining(CommandSender issuer, PunishmentType type, long now)` | `long` | Millisekunden, bis der Aussteller wieder handeln darf. |
| `markUsed(CommandSender issuer, PunishmentType type, long now)` | `void` | Zeichnet auf, dass ein Aussteller sein Kontingent genutzt hat. |

### VeriteMojang

Löst einen Minecraft-Benutzernamen gegen Mojang auf, unter Verwendung desselben Pfads und Caches, die das Plugin verwendet.

| Methode | Gibt zurück | Bedeutung |
| --- | --- | --- |
| `lookup(String name)` | `MojangProfile` | Löst einen Namen zu einer UUID, einem kanonischen Namen und einem Status auf. |

### VeriteExempt

Prüft, ob ein Aussteller daran gehindert ist, ein Ziel zu bestrafen.

| Methode | Gibt zurück | Bedeutung |
| --- | --- | --- |
| `blockReason(CommandSender issuer, UUID target, PunishmentType type)` | `String` | Der Grund, warum die Strafe nicht erlaubt ist, oder `null`, wenn erlaubt. |

### VeriteLockdown

Fragt den Server-Lockdown-Zustand ab und steuert ihn. Im Kontext behandelt in [Benutzerdefinierte Moderationsdurchsetzung](page:developers/moderation-enforcement).

| Methode | Gibt zurück | Bedeutung |
| --- | --- | --- |
| `active()` | `boolean` | Ob ein Lockdown in Kraft ist. |
| `reason()` | `String` | Der aktuelle Lockdown-Grund. |
| `begin(String why)` | `void` | Startet einen Lockdown mit einem Grund. |
| `end()` | `void` | Hebt den Lockdown auf. |

### VeriteConfig

Liest die effektive Konfiguration des Moderationsmoduls.

| Methode | Gibt zurück | Bedeutung |
| --- | --- | --- |
| `banAlts()` | `boolean` | Ob Alt-Konten gebannt werden. |
| `muteCommandBlacklist()` | `List<String>` | Befehle, die während der Stummschaltung blockiert sind. |
| `warningExpire()` | `long` | Das Ablauffenster für Verwarnungen in Millisekunden. |
| `useGroupWeights()` | `boolean` | Ob Gruppengewichtungen verwendet werden. |
| `permitSameWeight()` | `boolean` | Ob Aktionen bei gleicher Gewichtung erlaubt sind. |
| `reduceToLimit()` | `boolean` | Ob Dauern auf das Ausstellerlimit reduziert werden. |
| `dupeipScanLimit()` | `int` | Das Dupeip-Scan-Limit. |
| `yaml()` | `YamlConfiguration` | Die rohe zugrunde liegende Konfiguration. |

## Typen

### Punishment

Ein unveränderlicher Moderationsdatensatz. `PERMANENT` ist der Sentinel-Endzeitstempel für eine dauerhafte Strafe (`-1L`). `GLOBAL_SCOPE` ist der Platzhalterbereich (`"*"`). Zeitstempel sind Epoch-Millisekunden. Eine `null`-Ziel-IP bedeutet, dass die Strafe UUID-bezogen statt IP-bezogen ist.

Accessoren: `id()`, `randomId()`, `type()`, `uuid()`, `ip()`, `reason()`, `executorUuid()`, `executorName()`, `removedByUuid()`, `removedByName()`, `removalReason()`, `dateStart()`, `dateEnd()`, `serverScope()`, `serverOrigin()`, `template()`, `silent()`, `ipban()`, `active()`.

Abgeleitete Hilfsmethoden:

| Methode | Gibt zurück | Bedeutung |
| --- | --- | --- |
| `permanent()` | `boolean` | Ob `dateEnd` gleich `PERMANENT` ist. |
| `expired(long now)` | `boolean` | Ob eine temporäre Strafe ihr Ende überschritten hat. |
| `inForce(long now)` | `boolean` | Ob der Datensatz aktiv und nicht abgelaufen ist. |
| `duration()` | `long` | Gesamtdauer oder `PERMANENT`. |
| `remaining(long now)` | `long` | Verbleibende Millisekunden oder `PERMANENT`. |
| `hasTemplate()` | `boolean` | Ob der Datensatz eine Vorlage trägt. |

### PunishmentType

Enum: `BAN`, `MUTE`, `WARNING`, `KICK`.

| Methode | Gibt zurück | Bedeutung |
| --- | --- | --- |
| `id()` | `String` | Der kleingeschriebene Name in der Root-Locale. |
| `PunishmentType.of(String s)` | `PunishmentType` | Analysiert die kleingeschriebene Form zurück, ohne Beachtung der Groß- und Kleinschreibung. |

### PunishmentResult

Record: `PunishmentResult(boolean ok, Punishment entry, String error)`. Bei Erfolg ist `ok` gleich `true`, `entry` hält die resultierende Strafe, und `error` ist `null`. Bei Fehlschlag ist `entry` gleich `null` und `error` hält den Grund.

### ActivePunishment

Record: `ActivePunishment(PunishmentType type, UUID uuid, long entryId)`. Ein leichtgewichtiger Zeiger; lade den vollständigen Datensatz mit `VeriteModeration.loadPunishment(entryId)`.

### FilterResult

Enum: `CLEAN`, `BLOCK`, `SELF_HARM`, `ABUSE`, `PROFANITY`. `blocks()` gibt für alles außer `CLEAN` den Wert `true` zurück. Eine Nachricht, die wegen Wiederholung einer kürzlichen gestoppt wurde, meldet hier `BLOCK`; verwende die wiederholungssensitive `check`-Überladung, um diese zu unterscheiden. `SELF_HARM` und `ABUSE` kennzeichnen einen Sprecher, der sich in einer Krise befinden könnte; behandle sie nicht als gewöhnliche Regelverstöße.

### FilterOutcome

Der Wert von `VeriteFilter.check(player, message, true)`.

| Methode | Gibt zurück | Bedeutung |
| --- | --- | --- |
| `category()` | `FilterResult` | Die gewöhnliche Filterkategorie, niemals `null`. |
| `repeat()` | `boolean` | Ob die Blockierung eine Wiederholung war (nur dann `true`, wenn `category()` gleich `BLOCK` ist). |
| `blocks()` | `boolean` | Ob die Nachricht verworfen werden sollte. |

### PlayerProfile

Record mit den Feldern: `uuid`, `name`, `names`, `ips`, `lastIp`, `clients`, `lastClient`, `protocol`, `referrer`, `firstJoin`, `lastSeen`, `joinCount`, `playtimeMs`, `online`, `punishments`. Zeitstempel sind Epoch-Millisekunden. Listenfelder sind niemals `null`, können aber leer sein.

### MojangProfile und MojangStatus

`MojangProfile(UUID uuid, String name, MojangStatus status)`. Wenn `status` nicht `FOUND` ist, sind `uuid` und `name` gleich `null`.

`MojangStatus`: `FOUND` (aufgelöst), `NOT_FOUND` (Mojang hat bestätigt, dass es kein solches Konto gibt), `UNKNOWN` (die Abfrage konnte nicht abgeschlossen werden, zum Beispiel wegen eines Netzwerkfehlers).

### DurationCheck

Record: `DurationCheck(boolean ok, long durationMillis, String error)`. Wenn `ok`, hält `durationMillis` die möglicherweise begrenzte anzuwendende Dauer und `error` ist `null`. Wenn nicht `ok`, erklärt `error` die Ablehnung.

### ScopeEntry

Record: `ScopeEntry(String key, Object value)`. Ein Schlüssel-Wert-Paar aus einem Store-Bereich.

### CaptchaType und CaptchaOutcomeType

`CaptchaType`: `STANDARD` (eine schnelle, reibungsarme Herausforderung), `DETAILED` (eine strengere mehrstufige Herausforderung).

`CaptchaOutcomeType`: `PASS`, `FAIL`, `TIMEOUT`.

## Listener

### ModerationListener

Implementiere und registriere über `VeriteModeration.registerListener`. Alle Methoden sind standardmäßig No-Ops, überschreibe also nur, was du brauchst. Callbacks können im Haupt-Thread des Servers laufen; blockiere nicht.

| Methode | Wird ausgelöst, wenn |
| --- | --- |
| `entryAdded(Punishment punishment)` | Eine Strafe verhängt wird. |
| `entryRemoved(Punishment punishment)` | Eine Strafe aufgehoben, begnadigt oder abgelaufen ist. |
| `broadcastSent(String message, String target)` | Das Moderationssystem eine Verbreitung sendet. |

### VanishListener

Implementiere und registriere über `VeriteVanish.registerListener`. Standardmäßig No-Ops; blockiere nicht in Callbacks.

| Methode | Wird ausgelöst, wenn |
| --- | --- |
| `vanished(UUID player)` | Ein Spieler in den Vanish geht. |
| `unvanished(UUID player)` | Ein Spieler den Vanish verlässt. |