!spigot.yml!
# This is the main configuration file for Spigot.
# As you can see, there's tons to configure. Some options may impact gameplay, so use
# with caution, and make sure you know what each option does before configuring.
# For a reference for any variable inside this file, check out the Spigot wiki at
# http://www.spigotmc.org/wiki/spigot-configuration/
#
# If you need help with the configuration or have any questions related to Spigot,
# join us at the Discord or drop by our forums and leave a post.
#
# Discord: https://www.spigotmc.org/go/discord
# Forums: http://www.spigotmc.org/

commands:
  log: true
  tab-complete: 0
  send-namespaced: true
  spam-exclusions:
  - /skill
  silent-commandblock-console: false
  replace-commands:
  - setblock
  - summon
  - testforblock
  - tellraw
settings:
  bungeecord: false
  sample-count: 12
  player-shuffle: 0
  user-cache-size: 1000
  save-user-cache-on-stop-only: false
  moved-wrongly-threshold: 0.0625
  moved-too-quickly-multiplier: 10.0
  timeout-time: 60
  restart-on-crash: true
  restart-script: ./start.sh
  netty-threads: 4
  attribute:
    maxAbsorption:
      max: 2048.0
    maxHealth:
      max: 2048.0
    movementSpeed:
      max: 2048.0
    attackDamage:
      max: 2048.0
  log-villager-deaths: true
  log-named-deaths: true
  debug: false
advancements:
  disable-saving: false
  disabled:
  - minecraft:story/disabled
players:
  disable-saving: false
world-settings:
  default:
    below-zero-generation-in-existing-chunks: true
    verbose: true
    unload-frozen-chunks: false
    merge-radius:
      exp: 3.0
      item: 2.5
    mob-spawn-range: 6
    growth:
      cactus-modifier: 100
      cane-modifier: 100
      melon-modifier: 100
      mushroom-modifier: 100
      pumpkin-modifier: 100
      sapling-modifier: 100
      beetroot-modifier: 100
      carrot-modifier: 100
      potato-modifier: 100
      wheat-modifier: 100
      netherwart-modifier: 100
      vine-modifier: 100
      cocoa-modifier: 100
      bamboo-modifier: 100
      sweetberry-modifier: 100
      kelp-modifier: 100
      twistingvines-modifier: 100
      weepingvines-modifier: 100
      cavevines-modifier: 100
    entity-tracking-range:
      players: 48
      animals: 48
      monsters: 48
      misc: 32
      display: 128
      other: 64
    ticks-per:
      hopper-transfer: 8
      hopper-check: 1
    hopper-amount: 1
    hopper-can-load-chunks: false
    dragon-death-sound-radius: 0
    seed-village: 10387312
    seed-desert: 14357617
    seed-igloo: 14357618
    seed-jungle: 14357619
    seed-swamp: 14357620
    seed-monument: 10387313
    seed-shipwreck: 165745295
    seed-ocean: 14357621
    seed-outpost: 165745296
    seed-endcity: 10387313
    seed-slime: 987234911
    seed-nether: 30084232
    seed-mansion: 10387319
    seed-fossil: 14357921
    seed-portal: 34222645
    hunger:
      jump-walk-exhaustion: 0.05
      jump-sprint-exhaustion: 0.2
      combat-exhaustion: 0.1
      regen-exhaustion: 6.0
      swim-multiplier: 0.01
      sprint-multiplier: 0.1
      other-multiplier: 0.0
    max-tnt-per-tick: 100
    max-tick-time:
      tile: 50
      entity: 50
    view-distance: default
    simulation-distance: default
    thunder-chance: 100000
    item-despawn-rate: 6000
    entity-activation-range:
      animals: 32
      monsters: 32
      raiders: 48
      misc: 16
      tick-inactive-villagers: true
      ignore-spectators: false
    enable-zombie-pigmen-portal-spawns: true
    arrow-despawn-rate: 1200
    trident-despawn-rate: 1200
    wither-spawn-sound-radius: 0
    hanging-tick-frequency: 100
    zombie-aggressive-towards-villager: true
    nerf-spawner-mobs: false
    end-portal-sound-radius: 0
messages:
  whitelist: You are not whitelisted on this server!
  unknown-command: Unknown command. Type "/help" for help.
  server-full: The server is full!
  outdated-client: Outdated client! Please use {0}
  outdated-server: Outdated server! I'm still on {0}
  restart: Server is restarting
config-version: 12
stats:
  disable-saving: false
  forced-stats: {}
                                                                                                              !bukkit.yml!
settings:
  allow-nether: true
  allow-end: true
  warn-on-overload: true
  permissions-file: permissions.yml
  update-folder: update
  plugin-profiling: false
  connection-throttle: 4000
  query-plugins: true
  deprecated-verbose: default
  shutdown-message: Server closed
  minimum-api: none
  use-map-color-cache: true
  compatibility:
    allow-old-keys-in-registry: false
    enum-compatibility-mode: false
spawn-limits:
  monsters: 75
  animals: 20
  water-animals: 10
  water-ambient: 20
  water-underground-creature: 5
  axolotls: 5
  ambient: 10
chunk-gc:
  period-in-ticks: 600
ticks-per:
  animal-spawns: 400
  monster-spawns: 1
  water-spawns: 1
  water-ambient-spawns: 1
  water-underground-creature-spawns: 1
  axolotl-spawns: 1
  ambient-spawns: 1
  autosave: 6000
aliases: now-in-commands.yml
                                                                                                              Clan.java (from my plugin)
package ru.simpleclans;

import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import org.bukkit.entity.Player;
import org.bukkit.scoreboard.Scoreboard;
import org.bukkit.scoreboard.Team;

import java.util.*;

public class Clan {
    private String name;
    private String color;
    private UUID owner;
    private String motto;
    private final Map<UUID, Rank> members = new HashMap<>();
    private final Set<UUID> invitedPlayers = new HashSet<>();
    private final Set<UUID> trustedMembers = new HashSet<>();
    private final Set<UUID> joinRequests = new HashSet<>();
    private Team team;

    public Clan(String name, String color, UUID owner) {
        this.name = name;
        this.color = color;
        this.owner = owner;
        this.motto = null;
        members.put(owner, Rank.OWNER);
    }

    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public String getColor() { return color; }
    public void setColor(String color) { this.color = color; }
    public UUID getOwner() { return owner; }
    public void setOwner(UUID newOwner) { this.owner = newOwner; }
    public String getMotto() { return motto; }
    public void setMotto(String motto) { this.motto = motto; }

    public Map<UUID, Rank> getMembers() { return members; }
    public Set<UUID> getInvitedPlayers() { return invitedPlayers; }
    public Set<UUID> getTrustedMembers() { return trustedMembers; }
    public Set<UUID> getJoinRequests() { return joinRequests; }

    public boolean isRepresentativeTrusted(UUID uuid) { return trustedMembers.contains(uuid); }
    public Rank getRank(UUID uuid) { return members.get(uuid); }

    public void addMember(UUID uuid, Rank rank) { members.put(uuid, rank); }

    public void removePlayerFromAllTeams(Player player) {
        if (team != null) {
            team.removeEntry(player.getName());
        }
    }

    public void unregisterAllTeams() {
        if (team != null) {
            team.unregister();
            team = null;
        }
    }

    public void removeMember(UUID uuid) {
        members.remove(uuid);
        trustedMembers.remove(uuid);
        joinRequests.remove(uuid);
        Player player = Bukkit.getPlayer(uuid);
        if (player != null) {
            if (team != null) team.removeEntry(player.getName());
            player.setDisplayName(player.getName());
        }
    }

    public void updateScoreboardTeam() {
        Scoreboard board = Bukkit.getScoreboardManager().getMainScoreboard();
        ChatColor clanColor = ChatColor.valueOf(color.toUpperCase());

        if (team != null) {
            team.unregister();
            team = null;
        }

        team = board.registerNewTeam(name);
        team.setPrefix(clanColor + "[" + name + "] ");
        team.setColor(clanColor);
        team.setSuffix("");

        for (UUID uuid : members.keySet()) {
            Player player = Bukkit.getPlayer(uuid);
            if (player != null) {
                team.addEntry(player.getName());
                updateDisplayName(player);
            }
        }
    }

    public void updateDisplayName(Player player) {
        Rank rank = members.get(player.getUniqueId());
        if (rank == null) return;
        ChatColor clanColor = ChatColor.valueOf(color.toUpperCase());
        String fullName = "" + ChatColor.RESET + clanColor + "[" + name + "] " + player.getName() + " " + clanColor + "[" + rank.getDisplayName() + "]" + ChatColor.RESET;
        player.setDisplayName(fullName);
    }

    public void disband() {
        if (team != null) {
            team.unregister();
            team = null;
        }
        for (UUID uuid : members.keySet()) {
            Player player = Bukkit.getPlayer(uuid);
            if (player != null) {
                player.setDisplayName(player.getName());
            }
        }
        members.clear();
        trustedMembers.clear();
        invitedPlayers.clear();
        joinRequests.clear();
        motto = null;
    }
}
                                                                                                              ClanManager.java (from my plugin)
package ru.simpleclans;

import org.bukkit.Bukkit;
import org.bukkit.configuration.file.YamlConfiguration;
import org.bukkit.entity.Player;

import java.io.File;
import java.io.IOException;
import java.util.*;
import java.util.logging.Level;

public class ClanManager {
    public final Map<String, Clan> clans = new HashMap<>();
    public final Map<UUID, String> playerClan = new HashMap<>();
    private final File file = new File(Main.getInstance().getDataFolder(), "clans.yml");

    public ClanManager() {
        loadClans();
    }

    public Clan getClan(String name) { return clans.get(name); }
    public Clan getPlayerClan(UUID uuid) {
        String name = playerClan.get(uuid);
        return name != null ? clans.get(name) : null;
    }

    public boolean createClan(String name, String color, UUID owner) {
        if (clans.containsKey(name)) return false;
        if (playerClan.containsKey(owner)) return false;
        Clan clan = new Clan(name, color.toUpperCase(), owner);
        clans.put(name, clan);
        playerClan.put(owner, name);
        clan.updateScoreboardTeam();
        saveClans();
        return true;
    }

    public boolean disbandClan(String name) {
        Clan clan = clans.get(name);
        if (clan == null) return false;
        clan.disband();
        for (UUID uuid : clan.getMembers().keySet()) {
            playerClan.remove(uuid);
        }
        clans.remove(name);
        saveClans();
        return true;
    }

    public boolean joinClan(String clanName, UUID uuid, Rank rank) {
        Clan clan = clans.get(clanName);
        if (clan == null) return false;
        if (playerClan.containsKey(uuid)) return false;

        clan.addMember(uuid, rank);
        playerClan.put(uuid, clanName);
        clan.getJoinRequests().remove(uuid);
        clan.updateScoreboardTeam();
        saveClans();
        return true;
    }

    public boolean leaveClan(UUID uuid) {
        String clanName = playerClan.get(uuid);
        if (clanName == null) return false;
        Clan clan = clans.get(clanName);
        if (clan == null) return false;
        if (clan.getOwner().equals(uuid)) return false;

        Player player = Bukkit.getPlayer(uuid);
        if (player != null) {
            player.setDisplayName(player.getName());
        }
        clan.removeMember(uuid);
        playerClan.remove(uuid);
        clan.updateScoreboardTeam();
        saveClans();
        return true;
    }

    public void saveClans() {
        YamlConfiguration yaml = new YamlConfiguration();
        for (Map.Entry<String, Clan> entry : clans.entrySet()) {
            Clan c = entry.getValue();
            String key = "clans." + c.getName();
            yaml.set(key + ".color", c.getColor());
            yaml.set(key + ".owner", c.getOwner().toString());
            yaml.set(key + ".motto", c.getMotto());

            Map<String, Object> membersSerial = new LinkedHashMap<>();
            for (Map.Entry<UUID, Rank> me : c.getMembers().entrySet())
                membersSerial.put(me.getKey().toString(), me.getValue().name());
            yaml.set(key + ".members", membersSerial);

            List<String> trusted = new ArrayList<>();
            for (UUID id : c.getTrustedMembers()) trusted.add(id.toString());
            yaml.set(key + ".trusted", trusted);

            List<String> requests = new ArrayList<>();
            for (UUID id : c.getJoinRequests()) requests.add(id.toString());
            yaml.set(key + ".requests", requests);
        }
        try {
            yaml.save(file);
        } catch (IOException e) {
            Main.getInstance().getLogger().log(Level.SEVERE, "Не удалось сохранить clans.yml", e);
        }
    }

    public void loadClans() {
        if (!file.exists()) {
            try { file.createNewFile(); } catch (IOException e) { e.printStackTrace(); }
            return;
        }
        YamlConfiguration yaml = YamlConfiguration.loadConfiguration(file);
        if (!yaml.contains("clans")) return;

        for (String name : yaml.getConfigurationSection("clans").getKeys(false)) {
            String path = "clans." + name;
            String color = yaml.getString(path + ".color", "white").toUpperCase();
            UUID owner = UUID.fromString(yaml.getString(path + ".owner"));
            Clan clan = new Clan(name, color, owner);
            clan.setMotto(yaml.getString(path + ".motto"));

            if (yaml.contains(path + ".members")) {
                for (String uuidStr : yaml.getConfigurationSection(path + ".members").getKeys(false)) {
                    UUID uuid = UUID.fromString(uuidStr);
                    Rank rank = Rank.valueOf(yaml.getString(path + ".members." + uuidStr));
                    clan.addMember(uuid, rank);
                    playerClan.put(uuid, name);
                }
            }
            if (yaml.contains(path + ".trusted")) {
                for (String uuidStr : yaml.getStringList(path + ".trusted"))
                    clan.getTrustedMembers().add(UUID.fromString(uuidStr));
            }
            if (yaml.contains(path + ".requests")) {
                for (String uuidStr : yaml.getStringList(path + ".requests"))
                    clan.getJoinRequests().add(UUID.fromString(uuidStr));
            }
            clans.put(name, clan);
            clan.updateScoreboardTeam();
            for (UUID uuid : clan.getMembers().keySet()) {
                Player player = Bukkit.getPlayer(uuid);
                if (player != null) {
                    clan.updateDisplayName(player);
                }
            }
        }
    }
}