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.
Durchsetzung von Stummschaltung, Slowmode und Chat-Freeze: Benutzerdefinierte Moderationsdurchsetzung.

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:

softdepend:
  - Verite

Auf Verfügbarkeit prüfen

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

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 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.

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 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.

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.