Update API to 4.1

Separate prefix/suffix/meta nodes into their own section within yaml/json/hocon storage files
Replace deprecated method usage in NodeTools
2018-02-23 22:13:41 +00:00 · 2018-02-23 15:59:12 +00:00 · 2018-02-23 14:20:30 +00:00 · 2018-02-22 23:38:26 +00:00 · 2018-02-22 23:34:35 +00:00 · 2018-02-22 22:24:21 +00:00
836 changed files with 80090 additions and 29532 deletions
@@ -1,31 +1,27 @@
-# built application files
-*.jar
+# Created by https://www.gitignore.io/

-# Java class files
-*.class
+### Intellij ###
+# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio and Webstorm
+# Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839

-# Local configuration file (sdk path, etc)
-logs/
-
-# Eclipse project files
-.classpath
-.project
-
-# Intellij project files
-*.iml
-*.ipr
-*.iws
+# User-specific stuff:
 .idea/
+*.iws
+/out/
+*.iml
+.idea_modules/

-# Gradle
-.gradletasknamecache
-.gradle/
-build/
-bin/
-gradle/
-gradlew*
+# JIRA plugin
+atlassian-ide-plugin.xml

-# Maven
+# Crashlytics plugin (for Android Studio and IntelliJ)
+com_crashlytics_export_strings.xml
+crashlytics.properties
+crashlytics-build.properties
+fabric.properties
+
+
+### Maven ###
 target/
 pom.xml.tag
 pom.xml.releaseBackup
@@ -34,4 +30,135 @@ pom.xml.next
 release.properties
 dependency-reduced-pom.xml
 buildNumber.properties
-.mvn/timing.properties
+.mvn/timing.properties
+
+
+### Eclipse ###
+
+.metadata
+bin/
+tmp/
+*.tmp
+*.bak
+*.swp
+*~.nib
+local.properties
+.settings/
+.loadpath
+.recommenders
+
+# Eclipse Core
+.project
+
+# External tool builders
+.externalToolBuilders/
+
+# Locally stored "Eclipse launch configurations"
+*.launch
+
+# PyDev specific (Python IDE for Eclipse)
+*.pydevproject
+
+# CDT-specific (C/C++ Development Tooling)
+.cproject
+
+# JDT-specific (Eclipse Java Development Tools)
+.classpath
+
+# Java annotation processor (APT)
+.factorypath
+
+# PDT-specific (PHP Development Tools)
+.buildpath
+
+# sbteclipse plugin
+.target
+
+# Tern plugin
+.tern-project
+
+# TeXlipse plugin
+.texlipse
+
+# STS (Spring Tool Suite)
+.springBeans
+
+# Code Recommenders
+.recommenders/
+
+
+### Linux ###
+*~
+
+# temporary files which can be created if a process still has a handle open of a deleted file
+.fuse_hidden*
+
+# KDE directory preferences
+.directory
+
+# Linux trash folder which might appear on any partition or disk
+.Trash-*
+
+# .nfs files are created when an open file is removed but is still being accessed
+.nfs*
+
+
+### macOS ###
+*.DS_Store
+.AppleDouble
+.LSOverride
+
+# Icon must end with two \r
+Icon
+# Thumbnails
+._*
+# Files that might appear in the root of a volume
+.DocumentRevisions-V100
+.fseventsd
+.Spotlight-V100
+.TemporaryItems
+.Trashes
+.VolumeIcon.icns
+.com.apple.timemachine.donotpresent
+# Directories potentially created on remote AFP share
+.AppleDB
+.AppleDesktop
+Network Trash Folder
+Temporary Items
+.apdisk
+
+
+### Windows ###
+# Windows image file caches
+Thumbs.db
+ehthumbs.db
+
+# Folder config file
+Desktop.ini
+
+# Recycle Bin used on file shares
+$RECYCLE.BIN/
+
+# Windows Installer files
+*.cab
+*.msi
+*.msm
+*.msp
+
+# Windows shortcuts
+*.lnk
+
+
+### Java ###
+*.class
+
+# Mobile Tools for Java (J2ME)
+.mtj.tmp/
+
+# Package Files #
+*.jar
+*.war
+*.ear
+
+# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
+hs_err_pid*
@@ -0,0 +1,26 @@
+### :speech_balloon: Looking for support?
+
+Details about support for the project can be found [here, on the Wiki Homepage](https://github.com/lucko/LuckPerms/wiki#support).
+
+### :bug: Reporting bugs?
+
+Before reporting a bug or issue, please make sure that the issue is actually being caused by or related to LuckPerms. We get a lot of reports which are caused by other software - please double check!
+
+If you're unsure, feel free to ask using the above resources BEFORE making a report.
+
+Bugs or issues should be reported using the [GitHub Issues tab](https://github.com/lucko/LuckPerms/issues).
+
+### :pencil: Want to contribute code?
+#### Pull Requests
+If you make any changes or improvements to the plugin which you think would be beneficial to others, please consider making a pull request to merge your changes back into the upstream project. (especially if your changes are bug fixes!)
+
+LuckPerms loosely follows the [Google Java Style Guide](https://google.github.io/styleguide/javaguide.html). Generally, try to copy the style of code found in the class you're editing. 
+
+If you're considering submitting a substantial pull request, please open an issue so we can discuss the change before starting work on the contribution. Most pull requests are happily accepted, but larger changes may have an inpact on the maintainability of the project, and require more consideration. 
+
+#### Project Layout
+The project is split up into 5 seperate modules.
+
+* **API** - The public, semantically versioned API used by other plugins wishing to integrate with and retrieve data from LuckPerms. This module (for the most part) does not contain any implementation itself, and is provided by the plugin.
+* **Common** - The common module contains most of the code which implements the respective LuckPerms plugins. This abstract module reduces duplicated code throughout the project.
+* **Bukkit, BungeeCord & Sponge** - Each use the common module to implement plugins on the respective server platforms.
@@ -1,6 +1,7 @@
-MIT License
+The MIT License.

-Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+Copyright (c) lucko (Luck) <luck@lucko.me>
+Copyright (c) contributors

 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -1,26 +1,51 @@
 ![alt text](https://i.imgur.com/7TwJZ5e.png "Banner")
-# LuckPerms [![Build Status](https://ci.lucko.me/job/LuckPerms/badge/icon)](https://ci.lucko.me/job/LuckPerms/)
-An advanced permissions implementation for Bukkit/Spigot, BungeeCord and Sponge.
+# LuckPerms [![Build Status](https://ci.lucko.me/job/LuckPerms/badge/icon)](https://ci.lucko.me/job/LuckPerms/) [![Javadocs](https://javadoc.io/badge/me.lucko.luckperms/luckperms-api.svg)](https://javadoc.io/doc/me.lucko.luckperms/luckperms-api) [![Maven Central](https://maven-badges.herokuapp.com/maven-central/me.lucko.luckperms/luckperms-api/badge.svg)](https://maven-badges.herokuapp.com/maven-central/me.lucko.luckperms/luckperms-api)

-## Links
-* **Development Builds** - <https://ci.lucko.me/job/LuckPerms>
-* **Javadocs** - <https://jd.lucko.me/LuckPerms>
+LuckPerms is an advanced permissions implementation aiming to be a fast, reliable and flexible alternative to existing permission plugins. The project's main goals are centered around high performance and a wide feature set, filling the gaps of functionality and building upon existing features found in other plugins.
+
+LuckPerms also includes an extensive API for developers, and support for a variety of Minecraft server software & data storage options.
+
+The main features of the project are detailed on this wiki page: [Why LuckPerms?](https://github.com/lucko/LuckPerms/wiki/Why-LuckPerms)
+
+* [Spigot Plugin Release Page](https://www.spigotmc.org/resources/luckperms-an-advanced-permissions-system.28140/ "Spigot Plugin Page")
+* [Sponge Plugin Release Page](https://forums.spongepowered.org/t/luckperms-an-advanced-permissions-system/14274 "Sponge Plugin Page")
+
+## Useful Links
+* **Downloads** - <https://ci.lucko.me/job/LuckPerms>
 * **Wiki** - <https://github.com/lucko/LuckPerms/wiki>

-## Description
-LuckPerms is an advanced permissions implementation aiming to be a flexible, performant and reliable alternative to other permission systems, providing all the features you could ever possibly need in a permissions plugin, along with an extensive and well documented API for developers.
+## Building
+LuckPerms uses Maven to handle dependencies.

-* [Spigot Plugin Page](https://www.spigotmc.org/resources/luckperms-an-advanced-permissions-system.28140/ "Spigot Plugin Page")
-* [Sponge Plugin Page](https://forums.spongepowered.org/t/luckperms-an-advanced-permissions-system/14274 "Sponge Plugin Page")
+#### Requirements
+* Java 8 JDK
+* Maven 3.3.x (the older versions will not work.)
+* Git

-## LuckPerms vs Other Plugins
-![alt text](https://static.lucko.me/luckperms-compare-copy.png "Feature comparison")
-_Features checked on 23rd Aug 2016. If you find any inaccuracies, please do let me know. I tried to be as fair as possible, and copy all major features from the respective plugin pages._
+#### Then run
+```sh
+git clone https://github.com/lucko/LuckPerms.git
+cd LuckPerms/
+mvn clean package
+```
+
+You can find the output jars in the `target` directories.
+
+## Contributing
+#### Pull Requests
+If you make any changes or improvements to the plugin which you think would be beneficial to others, please consider making a pull request to merge your changes back into the upstream project. (especially if your changes are bug fixes!)
+
+LuckPerms loosely follows the [Google Java Style Guide](https://google.github.io/styleguide/javaguide.html). Generally, try to copy the style of code found in the class you're editing. 
+
+#### Project Layout
+The project is split up into 5 seperate modules.
+
+* **API** - The public, semantically versioned API used by other plugins wishing to integrate with and retrieve data from LuckPerms. This module (for the most part) does not contain any implementation itself, and is provided by the plugin.
+* **Common** - The common module contains most of the code which implements the respective LuckPerms plugins. This abstract module reduces duplicated code throughout the project.
+* **Bukkit, BungeeCord & Sponge** - Each use the common module to implement plugins on the respective server platforms.

 ## License
-See LICENSE.md.
+LuckPerms is licensed under the permissive MIT license. Please see [`LICENSE.txt`](https://github.com/lucko/LuckPerms/blob/master/LICENSE.txt) for more info.

-## Thanks to:
-[![JProfiler](https://www.ej-technologies.com/images/product_banners/jprofiler_large.png)](http://www.ej-technologies.com/products/jprofiler/overview.html)
-
-Thanks to ej-technologies for granting LuckPerms an open source licence to their [java profiling software](http://www.ej-technologies.com/products/jprofiler/overview.html "Java Profiler").
+## Thanks
+Thanks to ej-technologies for granting LuckPerms an open source licence to their [Java Profiling Software](http://www.ej-technologies.com/products/jprofiler/overview.html "Java Profiler").
@@ -1,21 +1,32 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0"
-         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xmlns="http://maven.apache.org/POM/4.0.0"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>luckperms</artifactId>
        <groupId>me.lucko.luckperms</groupId>
-        <version>2.10-SNAPSHOT</version>
+        <version>4.1-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>luckperms-api</artifactId>
+
    <build>
+        <finalName>LuckPerms-API-${release.version}</finalName>
+        <resources>
+            <resource>
+                <directory>../</directory>
+                <filtering>false</filtering>
+                <includes>
+                    <include>LICENSE.txt</include>
+                </includes>
+            </resource>
+        </resources>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
-                <version>3.5.1</version>
+                <version>${compiler.version}</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
@@ -24,6 +35,47 @@
        </plugins>
    </build>

+    <profiles>
+        <profile>
+            <id>deployment</id>
+            <build>
+                <plugins>
+                    <plugin>
+                        <groupId>org.apache.maven.plugins</groupId>
+                        <artifactId>maven-source-plugin</artifactId>
+                        <version>3.0.1</version>
+                        <executions>
+                            <execution>
+                                <id>attach-sources</id>
+                                <goals>
+                                    <goal>jar</goal>
+                                </goals>
+                            </execution>
+                        </executions>
+                    </plugin>
+                    <plugin>
+                        <groupId>org.apache.maven.plugins</groupId>
+                        <artifactId>maven-javadoc-plugin</artifactId>
+                        <version>3.0.0</version>
+                        <executions>
+                            <execution>
+                                <id>attach-javadocs</id>
+                                <goals>
+                                    <goal>jar</goal>
+                                </goals>
+                            </execution>
+                        </executions>
+                        <configuration>
+                            <links>
+                                <link>https://google.github.io/guava/releases/21.0/api/docs/</link>
+                            </links>
+                        </configuration>
+                    </plugin>
+                </plugins>
+            </build>
+        </profile>
+    </profiles>
+
    <dependencies>
        <!-- guava -->
        <dependency>
@@ -32,6 +84,13 @@
            <version>19.0</version>
            <scope>provided</scope>
        </dependency>
+        <!-- jsr305 -->
+        <dependency>
+            <groupId>com.google.code.findbugs</groupId>
+            <artifactId>jsr305</artifactId>
+            <version>3.0.2</version>
+            <scope>provided</scope>
+        </dependency>
    </dependencies>

 </project>
@@ -1,5 +1,8 @@
 /*
- * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
 *
 *  Permission is hereby granted, free of charge, to any person obtaining a copy
 *  of this software and associated documentation files (the "Software"), to deal
@@ -26,39 +29,62 @@ import me.lucko.luckperms.api.LuckPermsApi;

 import java.util.Optional;

+import javax.annotation.Nonnull;
+
 /**
- * Static access to LuckPerms
+ * Provides static access to the {@link LuckPermsApi}.
+ *
+ * <p>Ideally, the ServiceManager for the platform should be used to obtain an instance,
+ * however, this provider can be used if you need static access.</p>
 */
 public final class LuckPerms {
-    private static LuckPermsApi api = null;
+    private static LuckPermsApi instance = null;

    /**
-     * Gets an instance of {@link LuckPermsApi}
+     * Gets an instance of the {@link LuckPermsApi},
+     * throwing {@link IllegalStateException} if an instance is not yet loaded.
+     *
+     * <p>Will never return null.</p>
+     *
     * @return an api instance
     * @throws IllegalStateException if the api is not loaded
     */
+    @Nonnull
    public static LuckPermsApi getApi() {
-        if (api == null) {
+        if (instance == null) {
            throw new IllegalStateException("API is not loaded.");
        }
-        return api;
+        return instance;
    }

    /**
-     * Gets an instance of {@link LuckPermsApi} safely. Unlike {@link LuckPerms#getApi}, this method will not throw an
-     * {@link IllegalStateException} if the api is not loaded, rather return an empty {@link Optional}.
+     * Gets an instance of {@link LuckPermsApi}, if it is loaded.
+     *
+     * <p>Unlike {@link LuckPerms#getApi}, this method will not throw an
+     * {@link IllegalStateException} if an instance is not yet loaded, rather return
+     * an empty {@link Optional}.
+     *
     * @return an optional api instance
     */
+    @Nonnull
    public static Optional<LuckPermsApi> getApiSafe() {
-        return Optional.ofNullable(api);
+        return Optional.ofNullable(instance);
    }

-    static void registerProvider(LuckPermsApi luckPermsApi) {
-        api = luckPermsApi;
+    /**
+     * Registers an instance of the {@link LuckPermsApi} with this provider.
+     *
+     * @param instance the instance
+     */
+    static void registerProvider(LuckPermsApi instance) {
+        LuckPerms.instance = instance;
    }

+    /**
+     * Removes the current instance from this provider.
+     */
    static void unregisterProvider() {
-        api = null;
+        LuckPerms.instance = null;
    }

    private LuckPerms() {
@@ -0,0 +1,100 @@
+/*
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api;
+
+import java.util.concurrent.CompletableFuture;
+
+import javax.annotation.Nonnull;
+
+/**
+ * Represents the object responsible for handling action logging.
+ *
+ * @since 4.1
+ */
+public interface ActionLogger {
+
+    /**
+     * Returns a new {@link LogEntry.Builder} instance
+     *
+     * @return a new builder
+     */
+    @Nonnull
+    LogEntry.Builder newEntryBuilder();
+
+    /**
+     * Gets a {@link Log} instance from the plugin storage.
+     *
+     * <p>Returns the same result as {@link Storage#getLog()}.</p>
+     *
+     * @return a log instance
+     * @see Storage#getLog()
+     */
+    @Nonnull
+    CompletableFuture<Log> getLog();
+
+    /**
+     * Submits a log entry to the plugin to be handled.
+     *
+     * <p>This method submits the log to the storage provider and broadcasts
+     * it.</p>
+     *
+     * <p>It is therefore roughly equivalent to calling
+     * {@link #submitToStorage(LogEntry)} and {@link #broadcastAction(LogEntry)},
+     * however, using this method is preferred to making the calls individually.</p>
+     *
+     * <p>If you want to submit a log entry but don't know which method to pick,
+     * use this one.</p>
+     *
+     * @param entry the entry to submit
+     * @return a future which will complete when the action is done
+     */
+    @Nonnull
+    CompletableFuture<Void> submit(@Nonnull LogEntry entry);
+
+    /**
+     * Submits a log entry to the plugins storage handler.
+     *
+     * <p>Performs the same action as {@link Storage#logAction(LogEntry)}.</p>
+     *
+     * @param entry the entry to submit
+     * @return a future which will complete when the action is done
+     */
+    @Nonnull
+    CompletableFuture<Void> submitToStorage(@Nonnull LogEntry entry);
+
+    /**
+     * Submits a log entry to the plugins log broadcasting handler.
+     *
+     * <p>If enabled, this method will also dispatch the log entry via the
+     * plugins {@link MessagingService}.</p>
+     *
+     * @param entry the entry to submit
+     * @return a future which will complete when the action is done
+     */
+    @Nonnull
+    CompletableFuture<Void> broadcastAction(@Nonnull LogEntry entry);
+
+}
@@ -0,0 +1,130 @@
+/*
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api;
+
+import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
+
+import javax.annotation.Nonnull;
+
+/**
+ * Represents a type of chat meta
+ *
+ * @since 3.2
+ */
+public enum ChatMetaType {
+
+    /**
+     * Represents a prefix
+     */
+    PREFIX("prefix") {
+        @Override
+        public boolean matches(@Nonnull Node node) {
+            return Objects.requireNonNull(node, "node").isPrefix();
+        }
+
+        @Nonnull
+        @Override
+        public Map.Entry<Integer, String> getEntry(@Nonnull Node node) {
+            return Objects.requireNonNull(node, "node").getPrefix();
+        }
+    },
+
+    /**
+     * Represents a suffix
+     */
+    SUFFIX("suffix") {
+        @Override
+        public boolean matches(@Nonnull Node node) {
+            return Objects.requireNonNull(node, "node").isSuffix();
+        }
+
+        @Nonnull
+        @Override
+        public Map.Entry<Integer, String> getEntry(@Nonnull Node node) {
+            return Objects.requireNonNull(node, "node").getSuffix();
+        }
+    };
+
+    private final String str;
+
+    ChatMetaType(String str) {
+        this.str = str;
+    }
+
+    /**
+     * Returns if the passed node matches the type
+     *
+     * @param node the node to test
+     * @return true if the node has the same type
+     */
+    public abstract boolean matches(@Nonnull Node node);
+
+    /**
+     * Returns if the passed node should be ignored when searching for meta of this type
+     *
+     * @param node the node to test
+     * @return true if the node does not share the same type
+     */
+    public boolean shouldIgnore(@Nonnull Node node) {
+        return !matches(node);
+    }
+
+    /**
+     * Maps the corresponding entry from the given node
+     *
+     * @param node the node to retrieve the entry from
+     * @return the entry
+     * @throws IllegalStateException if the node does not share the same type
+     */
+    @Nonnull
+    public abstract Map.Entry<Integer, String> getEntry(@Nonnull Node node);
+
+    @Override
+    public String toString() {
+        return this.str;
+    }
+
+    /**
+     * Parses a ChatMetaType from the given node.
+     *
+     * @param node the node
+     * @return the parsed chat meta type
+     * @since 3.4
+     */
+    @Nonnull
+    public static Optional<ChatMetaType> ofNode(@Nonnull Node node) {
+        if (node.isPrefix()) {
+            return Optional.of(PREFIX);
+        } else if (node.isSuffix()) {
+            return Optional.of(SUFFIX);
+        } else {
+            return Optional.empty();
+        }
+    }
+
+}
@@ -0,0 +1,253 @@
+/*
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api;
+
+import me.lucko.luckperms.api.context.ContextSet;
+import me.lucko.luckperms.api.context.ImmutableContextSet;
+
+import java.util.Objects;
+
+import javax.annotation.Nonnull;
+import javax.annotation.concurrent.Immutable;
+
+/**
+ * Encapsulates the options and settings for a permission or meta lookup.
+ *
+ * <p>This class is immutable.</p>
+ *
+ * @since 2.11
+ */
+@Immutable
+public class Contexts {
+
+    /**
+     * The context key used to denote the subjects server
+     */
+    public static final String SERVER_KEY = "server";
+
+    /**
+     * The context key used to denote the subjects world
+     */
+    public static final String WORLD_KEY = "world";
+
+    /**
+     * A 'global' or default contexts instance.
+     *
+     * Simply passes an empty context set, with all accumulation settings set to true.
+     */
+    private static final Contexts GLOBAL = new Contexts(ContextSet.empty(), true, true, true, true, true, false);
+
+    /**
+     * Gets the {@link FullySatisfiedContexts} instance.
+     *
+     * @return a context that will satisfy all contextual requirements.
+     */
+    @Nonnull
+    public static Contexts allowAll() {
+        return FullySatisfiedContexts.getInstance();
+    }
+
+    /**
+     * A contexts instance with no defined context.
+     *
+     * @return the global contexts
+     * @since 3.3
+     */
+    @Nonnull
+    public static Contexts global() {
+        return GLOBAL;
+    }
+
+    @Nonnull
+    public static Contexts of(@Nonnull ContextSet context, boolean includeGlobal, boolean includeGlobalWorld, boolean applyGroups, boolean applyGlobalGroups, boolean applyGlobalWorldGroups, boolean op) {
+        return new Contexts(context, includeGlobal, includeGlobalWorld, applyGroups, applyGlobalGroups, applyGlobalWorldGroups, op);
+    }
+
+    /**
+     * The contexts that apply for this lookup
+     */
+    private final ImmutableContextSet context;
+
+    /**
+     * If the target subject is OP. This is used to parse defaults on Bukkit,
+     * and is ignored on all other platforms.
+     *
+     * @since 2.12
+     */
+    private final boolean op;
+
+    /**
+     * If global or non server specific nodes should be applied
+     */
+    private final boolean includeGlobal;
+
+    /**
+     * If global or non world specific nodes should be applied
+     */
+    private final boolean includeGlobalWorld;
+
+    /**
+     * If parent groups should be applied
+     */
+    private final boolean applyGroups;
+
+    /**
+     * If global or non server specific group memberships should be applied
+     */
+    private final boolean applyGlobalGroups;
+
+    /**
+     * If global or non world specific group memberships should be applied
+     */
+    private final boolean applyGlobalWorldGroups;
+
+    // cache hashcode - this class is immutable, and is used as an index in the permission cache.
+    private final int hashCode;
+
+    public Contexts(@Nonnull ContextSet context, boolean includeGlobal, boolean includeGlobalWorld, boolean applyGroups, boolean applyGlobalGroups, boolean applyGlobalWorldGroups, boolean op) {
+        this.context = Objects.requireNonNull(context, "context").makeImmutable();
+        this.includeGlobal = includeGlobal;
+        this.includeGlobalWorld = includeGlobalWorld;
+        this.applyGroups = applyGroups;
+        this.applyGlobalGroups = applyGlobalGroups;
+        this.applyGlobalWorldGroups = applyGlobalWorldGroups;
+        this.op = op;
+        this.hashCode = calculateHashCode();
+    }
+
+    /**
+     * Gets the contexts that apply for this lookup
+     *
+     * @return an immutable set of context key value pairs
+     * @since 2.13
+     */
+    @Nonnull
+    public ContextSet getContexts() {
+        return this.context;
+    }
+
+    /**
+     * Gets if the target subject is OP. This is used to parse defaults on Bukkit,
+     * and is ignored on all other platforms.
+     *
+     * @return true if op defaults should be included
+     */
+    public boolean isOp() {
+        return this.op;
+    }
+
+    /**
+     * Gets if global or non server specific nodes should be applied
+     *
+     * @return true if global or non server specific nodes should be applied
+     */
+    public boolean isIncludeGlobal() {
+        return this.includeGlobal;
+    }
+
+    /**
+     * Gets if global or non world specific nodes should be applied
+     *
+     * @return true if global or non world specific nodes should be applied
+     */
+    public boolean isIncludeGlobalWorld() {
+        return this.includeGlobalWorld;
+    }
+
+    /**
+     * Gets if parent groups should be applied
+     *
+     * @return true if parent groups should be applied
+     */
+    public boolean isApplyGroups() {
+        return this.applyGroups;
+    }
+
+    /**
+     * Gets if global or non server specific group memberships should be applied
+     *
+     * @return true if global or non server specific group memberships should be applied
+     */
+    public boolean isApplyGlobalGroups() {
+        return this.applyGlobalGroups;
+    }
+
+    /**
+     * Gets if global or non world specific group memberships should be applied
+     *
+     * @return true if global or non world specific group memberships should be applied
+     */
+    public boolean isApplyGlobalWorldGroups() {
+        return this.applyGlobalWorldGroups;
+    }
+
+    @Nonnull
+    @Override
+    public String toString() {
+        return "Contexts(" +
+                "context=" + this.context + ", " +
+                "op=" + this.op + ", " +
+                "includeGlobal=" + this.includeGlobal + ", " +
+                "includeGlobalWorld=" + this.includeGlobalWorld + ", " +
+                "applyGroups=" + this.applyGroups + ", " +
+                "applyGlobalGroups=" + this.applyGlobalGroups + ", " +
+                "applyGlobalWorldGroups=" + this.applyGlobalWorldGroups + ")";
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (o == this) return true;
+        if (o == allowAll()) return false;
+        if (!(o instanceof Contexts)) return false;
+        final Contexts that = (Contexts) o;
+
+        return this.context.equals(that.context) &&
+                this.op == that.op &&
+                this.includeGlobal == that.includeGlobal &&
+                this.includeGlobalWorld == that.includeGlobalWorld &&
+                this.applyGroups == that.applyGroups &&
+                this.applyGlobalGroups == that.applyGlobalGroups &&
+                this.applyGlobalWorldGroups == that.applyGlobalWorldGroups;
+    }
+
+    private int calculateHashCode() {
+        final int PRIME = 59;
+        int result = 1;
+        result = result * PRIME + this.context.hashCode();
+        result = result * PRIME + (this.op ? 79 : 97);
+        result = result * PRIME + (this.includeGlobal ? 79 : 97);
+        result = result * PRIME + (this.includeGlobalWorld ? 79 : 97);
+        result = result * PRIME + (this.applyGroups ? 79 : 97);
+        result = result * PRIME + (this.applyGlobalGroups ? 79 : 97);
+        result = result * PRIME + (this.applyGlobalWorldGroups ? 79 : 97);
+        return result;
+    }
+
+    @Override
+    public int hashCode() {
+        return this.hashCode;
+    }
+}
@@ -0,0 +1,88 @@
+/*
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api;
+
+/**
+ * Represents the result of a mutation call.
+ */
+public enum DataMutateResult {
+
+    /**
+     * Indicates the mutation was a success
+     */
+    SUCCESS(true),
+
+    /**
+     * Indicates the mutation failed because the subject of the action already has something
+     */
+    ALREADY_HAS(false),
+
+    /**
+     * Indicates the mutation failed because the subject of the action lacks something
+     */
+    LACKS(false),
+
+    /**
+     * Indicates the mutation failed
+     */
+    FAIL(false);
+
+    private final boolean value;
+
+    DataMutateResult(boolean value) {
+        this.value = value;
+    }
+
+    /**
+     * Gets a boolean representation of the result.
+     *
+     * @return a boolean representation
+     */
+    public boolean asBoolean() {
+        return this.value;
+    }
+
+    /**
+     * Gets if the result indicates a success
+     *
+     * @return if the result indicates a success
+     * @since 3.4
+     */
+    public boolean wasSuccess() {
+        return this.value;
+    }
+
+    /**
+     * Gets if the result indicates a failure
+     *
+     * @return if the result indicates a failure
+     * @since 3.4
+     */
+    public boolean wasFailure() {
+        return !this.value;
+    }
+
+}
@@ -1,308 +0,0 @@
-/*
- * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
- *
- *  Permission is hereby granted, free of charge, to any person obtaining a copy
- *  of this software and associated documentation files (the "Software"), to deal
- *  in the Software without restriction, including without limitation the rights
- *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- *  copies of the Software, and to permit persons to whom the Software is
- *  furnished to do so, subject to the following conditions:
- *
- *  The above copyright notice and this permission notice shall be included in all
- *  copies or substantial portions of the Software.
- *
- *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- *  SOFTWARE.
- */
-
-package me.lucko.luckperms.api;
-
-import me.lucko.luckperms.api.data.Callback;
-
-import java.util.Set;
-import java.util.UUID;
-
-/**
- * Interface for the internal Datastore instance
- */
-@SuppressWarnings("unused")
-public interface Datastore {
-
-    String getName();
-    boolean isAcceptingLogins();
-
-    /**
-     * Gets the {@link Sync} interface.
-     *
-     * All operations through this interface are called immediately and in the same thread as they are called.
-     * Datastore operations are thread blocking, and Sync operations should not be called on the main server thread.
-     * @return the sync interface
-     */
-    Sync sync();
-
-    /**
-     * Gets the {@link Async} interface.
-     * 
-     * All operations through this interface are called in a new, separate asynchronous thread.
-     * When the operation is complete, the provided callback method is called, in applicable, in the main server thread.
-     * @return the async interface
-     */
-    Async async();
-
-    /**
-     * Gets the {@link Future} interface.
-     * 
-     * All operations through this interface are called in a new, separate asynchronous thread, similar to {@link Async}.
-     * The only difference is that instead of providing a callback, a {@link java.util.concurrent.Future} is returned.
-     * See the Oracle JavaDocs for usage of the Future class.
-     * @return the future interface
-     */
-    Future future();
-
-    /**
-     * All operations through this interface are called immediately and in the same thread as they are called.
-     * Datastore operations are thread blocking, and Sync operations should not be called on the main server thread.
-     */
-    interface Sync {
-
-        /**
-         * Saves an action to the datastore
-         * @param entry the log entry to be saved
-         * @return true if the operation completed successfully.
-         * @throws NullPointerException if entry is null
-         */
-        boolean logAction(LogEntry entry);
-
-        /**
-         * Loads and returns the log from the datastore
-         * @return a log instance, could be null
-         */
-        Log getLog();
-
-        /**
-         * Either loads or creates a user object, and loads it into the plugins internal storage
-         * @param uuid the uuid of the user
-         * @param username the users username. (if you want to specify <code>null</code> here, just input "null" as a string.)
-         * @return true if the operation completed successfully.
-         * @throws NullPointerException if uuid or username is null
-         * @throws IllegalArgumentException if either of the parameters are invalid
-         * @deprecated functionality of this method is taken on by {@link #loadUser(UUID, String)}
-         */
-        @Deprecated
-        boolean loadOrCreateUser(UUID uuid, String username);
-
-        /**
-         * Loads a user from the datastore into the plugins internal storage.
-         * @param uuid the uuid of the user to load
-         * @return true if the user exists, and was loaded correctly.
-         * @throws NullPointerException if uuid is null
-         * @deprecated replaced by {@link #loadUser(UUID, String)}
-         */
-        @Deprecated
-        boolean loadUser(UUID uuid);
-
-        /**
-         * Loads a user's data into the plugins internal storage.
-         * @param uuid the uuid of the user to load
-         * @param username the users username. (if you want to specify <code>null</code> here, just input "null" as a string.)
-         * @return if the operation was performed successfully
-         * @throws NullPointerException if uuid or username is null
-         * @since 2.6
-         */
-        boolean loadUser(UUID uuid, String username);
-
-        /**
-         * Saves a user object into the datastore. You should call this after you make any changes to a user.
-         * @param user the user to save
-         * @return true if the operation completed successfully.
-         * @throws NullPointerException if user is null
-         * @throws IllegalStateException if the user instance was not obtained from LuckPerms.
-         */
-        boolean saveUser(User user);
-
-        /**
-         * Removes users from the datastore who are "default". This is called every time the plugin loads.
-         * @return true if the operation completed successfully
-         * @since 2.6
-         */
-        boolean cleanupUsers();
-
-        /**
-         * Gets a set all user's UUIDs who are "unique", and aren't just a member of the "default" group.
-         * @return a set of uuids, or null if the operation failed.
-         * @since 2.6
-         */
-        Set<UUID> getUniqueUsers();
-
-        /**
-         * Creates and loads a group into the plugins internal storage
-         * @param name the name of the group
-         * @return true if the operation completed successfully
-         * @throws NullPointerException if name is null
-         * @throws IllegalArgumentException if the name is invalid
-         */
-        boolean createAndLoadGroup(String name);
-
-        /**
-         * Loads a group into the plugins internal storage.
-         * @param name the name of the group
-         * @return true if the operation completed successfully
-         * @throws NullPointerException if name is null
-         * @throws IllegalArgumentException if the name is invalid
-         */
-        boolean loadGroup(String name);
-
-        /**
-         * Loads all groups from the datastore into the plugins internal storage
-         * @return true if the operation completed successfully.
-         */
-        boolean loadAllGroups();
-
-        /**
-         * Saves a group back to the datastore. You should call this after you make any changes to a group.
-         * @param group the group to save
-         * @return true if the operation completed successfully.
-         * @throws NullPointerException if group is null
-         * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
-         */
-        boolean saveGroup(Group group);
-
-        /**
-         * Permanently deletes a group from the datastore
-         * @param group the group to delete
-         * @return true if the operation completed successfully.
-         * @throws NullPointerException if group is null
-         * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
-         */
-        boolean deleteGroup(Group group);
-
-        /**
-         * Creates and loads a track into the plugins internal storage
-         * @param name the name of the track
-         * @return true if the operation completed successfully
-         * @throws NullPointerException if name is null
-         * @throws IllegalArgumentException if the name is invalid
-         */
-        boolean createAndLoadTrack(String name);
-
-        /**
-         * Loads a track into the plugins internal storage.
-         * @param name the name of the track
-         * @return true if the operation completed successfully
-         * @throws NullPointerException if name is null
-         * @throws IllegalArgumentException if the name is invalid
-         */
-        boolean loadTrack(String name);
-
-        /**
-         * Loads all tracks from the datastore into the plugins internal storage
-         * @return true if the operation completed successfully.
-         */
-        boolean loadAllTracks();
-
-        /**
-         * Saves a track back to the datastore. You should call this after you make any changes to a track.
-         * @param track the track to save
-         * @return true if the operation completed successfully.
-         * @throws NullPointerException if track is null
-         * @throws IllegalStateException if the track instance was not obtained from LuckPerms.
-         */
-        boolean saveTrack(Track track);
-
-        /**
-         * Permanently deletes a track from the datastore
-         * @param track the track to delete
-         * @return true if the operation completed successfully.
-         * @throws NullPointerException if track is null
-         * @throws IllegalStateException if the track instance was not obtained from LuckPerms.
-         */
-        boolean deleteTrack(Track track);
-
-        /**
-         * Saves UUID caching data to the datastore
-         * @param username the users username
-         * @param uuid the users mojang unique id
-         * @return true if the operation completed successfully.
-         * @throws NullPointerException if either parameters are null
-         * @throws IllegalArgumentException if the username is invalid
-         */
-        boolean saveUUIDData(String username, UUID uuid);
-
-        /**
-         * Gets a UUID from a username
-         * @param username the corresponding username
-         * @return a uuid object, could be null
-         * @throws NullPointerException if either parameters are null
-         * @throws IllegalArgumentException if the username is invalid
-         */
-        UUID getUUID(String username);
-    }
-
-    /**
-     * All operations through this interface are called in a new, separate asynchronous thread.
-     * When the operation is complete, the provided callback method is called, in applicable, in the main server thread.
-     * 
-     * See {@link Sync} for method documentation. 
-     */
-    interface Async {
-        void logAction(LogEntry entry, Callback<Boolean> callback);
-        void getLog(Callback<Log> callback);
-        @Deprecated
-        void loadOrCreateUser(UUID uuid, String username, Callback<Boolean> callback);
-        @Deprecated
-        void loadUser(UUID uuid, Callback<Boolean> callback);
-        void loadUser(UUID uuid, String username, Callback<Boolean> callback);
-        void saveUser(User user, Callback<Boolean> callback);
-        void cleanupUsers(Callback<Boolean> callback);
-        void getUniqueUsers(Callback<Set<UUID>> callback);
-        void createAndLoadGroup(String name, Callback<Boolean> callback);
-        void loadGroup(String name, Callback<Boolean> callback);
-        void loadAllGroups(Callback<Boolean> callback);
-        void saveGroup(Group group, Callback<Boolean> callback);
-        void deleteGroup(Group group, Callback<Boolean> callback);
-        void createAndLoadTrack(String name, Callback<Boolean> callback);
-        void loadTrack(String name, Callback<Boolean> callback);
-        void loadAllTracks(Callback<Boolean> callback);
-        void saveTrack(Track track, Callback<Boolean> callback);
-        void deleteTrack(Track track, Callback<Boolean> callback);
-        void saveUUIDData(String username, UUID uuid, Callback<Boolean> callback);
-        void getUUID(String username, Callback<UUID> callback);
-    }
-
-    /**
-     * All operations through this interface are called in a new, separate asynchronous thread, similar to {@link Async}.
-     * The only difference is that instead of providing a callback, a {@link java.util.concurrent.Future} is returned.
-     * See the Oracle JavaDocs for usage of the Future class.
-     * 
-     * See {@link Sync} for method documentation.
-     */
-    interface Future {
-        java.util.concurrent.Future<Boolean> logAction(LogEntry entry);
-        java.util.concurrent.Future<Log> getLog();
-        @Deprecated
-        java.util.concurrent.Future<Boolean> loadOrCreateUser(UUID uuid, String username);
-        @Deprecated
-        java.util.concurrent.Future<Boolean> loadUser(UUID uuid);
-        java.util.concurrent.Future<Boolean> loadUser(UUID uuid, String username);
-        java.util.concurrent.Future<Boolean> saveUser(User user);
-        java.util.concurrent.Future<Boolean> cleanupUsers();
-        java.util.concurrent.Future<Set<UUID>> getUniqueUsers();
-        java.util.concurrent.Future<Boolean> createAndLoadGroup(String name);
-        java.util.concurrent.Future<Boolean> loadGroup(String name);
-        java.util.concurrent.Future<Boolean> loadAllGroups();
-        java.util.concurrent.Future<Boolean> saveGroup(Group group);
-        java.util.concurrent.Future<Boolean> deleteGroup(Group group);
-        java.util.concurrent.Future<Boolean> createAndLoadTrack(String name);
-        java.util.concurrent.Future<Boolean> loadTrack(String name);
-        java.util.concurrent.Future<Boolean> loadAllTracks();
-        java.util.concurrent.Future<Boolean> saveTrack(Track track);
-        java.util.concurrent.Future<Boolean> deleteTrack(Track track);
-        java.util.concurrent.Future<Boolean> saveUUIDData(String username, UUID uuid);
-        java.util.concurrent.Future<UUID> getUUID(String username);
-    }
-}
@@ -0,0 +1,87 @@
+/*
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api;
+
+import java.util.UUID;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
+/**
+ * Represents an entity on the server.
+ *
+ * <p>This does not relate directly to a "Minecraft Entity". The closest
+ * comparison is to a "CommandSender" or "CommandSource" in Bukkit/Sponge.</p>
+ *
+ * <p>The various types of {@link Entity} are detailed in {@link Type}.</p>
+ *
+ * @since 4.1
+ */
+public interface Entity {
+
+    /**
+     * Gets the unique id of the entity, if it has one.
+     *
+     * <p>For players, this returns their uuid assigned by the server.</p>
+     *
+     * @return the uuid of the object, if available
+     */
+    @Nullable
+    UUID getUniqueId();
+
+    /**
+     * Gets the name of the object
+     *
+     * @return the object name
+     */
+    @Nonnull
+    String getName();
+
+    /**
+     * Gets the entities type.
+     *
+     * @return the type
+     */
+    @Nonnull
+    Type getType();
+
+    /**
+     * The different types of {@link Entity}
+     */
+    enum Type {
+
+        /**
+         * Represents a player connected to the server
+         */
+        PLAYER,
+
+        /**
+         * Represents the server console
+         */
+        CONSOLE
+    }
+
+}
@@ -0,0 +1,81 @@
+/*
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api;
+
+import me.lucko.luckperms.api.caching.CachedData;
+import me.lucko.luckperms.api.caching.MetaContexts;
+import me.lucko.luckperms.api.context.ContextSet;
+
+import javax.annotation.Nonnull;
+
+/**
+ * A special instance of {@link Contexts}, which when passed to:
+ *
+ * <p></p>
+ * <ul>
+ *     <li>{@link CachedData#getPermissionData(Contexts)}</li>
+ *     <li>{@link CachedData#getMetaData(Contexts)}</li>
+ *     <li>{@link CachedData#getMetaData(MetaContexts)}</li>
+ * </ul>
+ *
+ * <p>... will always satisfy all contextual requirements.</p>
+ *
+ * <p>This effectively allows you to do lookups which ignore context.</p>
+ *
+ * @since 3.3
+ */
+public final class FullySatisfiedContexts extends Contexts {
+
+    // singleton
+    private static final FullySatisfiedContexts INSTANCE = new FullySatisfiedContexts();
+
+    @Nonnull
+    public static Contexts getInstance() {
+        return INSTANCE;
+    }
+
+    private FullySatisfiedContexts() {
+        super(ContextSet.empty(), true, true, true, true, true, false);
+    }
+
+    @Nonnull
+    @Override
+    public String toString() {
+        return "FullySatisfiedContexts()";
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        // this class is a singleton, so we can use object comparison to check equality.
+        return o == this;
+    }
+
+    @Override
+    public int hashCode() {
+        // just use the system hashcode - we need to override the hashcode impl in super
+        return System.identityHashCode(this);
+    }
+}
@@ -1,5 +1,8 @@
 /*
- * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
 *
 *  Permission is hereby granted, free of charge, to any person obtaining a copy
 *  of this software and associated documentation files (the "Software"), to deal
@@ -22,216 +25,42 @@

 package me.lucko.luckperms.api;

-import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
-import me.lucko.luckperms.exceptions.ObjectLacksException;
+import me.lucko.luckperms.api.caching.GroupData;

-import java.util.List;
+import java.util.OptionalInt;
+
+import javax.annotation.Nonnull;

 /**
- * Interface for internal Group instances
+ * An inheritable holder of permission data.
 */
-@SuppressWarnings("unused")
 public interface Group extends PermissionHolder {

    /**
+     * Get the name of the group
+     *
     * @return the name of the group
     */
+    @Nonnull
    String getName();

    /**
-     * Check to see if a group inherits a group
-     * @param group The group to check membership of
-     * @return true if the group inherits the other group
-     * @throws NullPointerException if the group is null
-     * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
+     * Gets the weight of this group, if present.
+     *
+     * @return the group weight
+     * @since 2.17
     */
-    boolean inheritsGroup(Group group);
+    @Nonnull
+    OptionalInt getWeight();

    /**
-     * Check to see if the group inherits a group on a specific server
-     * @param group The group to check membership of
-     * @param server The server to check on
-     * @return true if the group inherits the group on the server
-     * @throws NullPointerException if the group or server is null
-     * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
-     * @throws IllegalArgumentException if the server is invalid
+     * Gets the groups's {@link GroupData} cache.
+     *
+     * @return the groups cached data.
+     * @since 4.0
     */
-    boolean inheritsGroup(Group group, String server);
+    @Nonnull
+    @Override
+    GroupData getCachedData();

-    /**
-     * Check to see if the group inherits a group on a specific server and world
-     * @param group The group to check membership of
-     * @param server The server to check on
-     * @param world The world to check on
-     * @return true if the group inherits the group on the server and world
-     * @throws NullPointerException if the group, server or world is null
-     * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
-     * @throws IllegalArgumentException if the server or world is invalid
-     */
-    boolean inheritsGroup(Group group, String server, String world);
-
-    /**
-     * Make this group inherit another group
-     * @param group the group to be inherited
-     * @throws ObjectAlreadyHasException if the group already inherits the group
-     * @throws NullPointerException if the group is null
-     * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
-     */
-    void setInheritGroup(Group group) throws ObjectAlreadyHasException;
-
-    /**
-     * Make this group inherit another group on a specific server
-     * @param group the group to be inherited
-     * @param server The server to inherit the group on
-     * @throws ObjectAlreadyHasException if the group already inherits the group on that server
-     * @throws NullPointerException if the group or server is null
-     * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
-     * @throws IllegalArgumentException if the server is invalid
-     */
-    void setInheritGroup(Group group, String server) throws ObjectAlreadyHasException;
-
-    /**
-     * Make this group inherit another group on a specific server and world
-     * @param group the group to be inherited
-     * @param server The server to inherit the group on
-     * @param world The world to inherit the group on
-     * @throws ObjectAlreadyHasException if the group already inherits the group on that server and world
-     * @throws NullPointerException if the group, server or world is null
-     * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
-     * @throws IllegalArgumentException if the server or world is invalid
-     */
-    void setInheritGroup(Group group, String server, String world) throws ObjectAlreadyHasException;
-
-    /**
-     * Make this group inherit another group temporarily
-     * @param group the group to be inherited
-     * @param expireAt the unix time when the group should expire
-     * @throws ObjectAlreadyHasException if the group already inherits the group temporarily
-     * @throws NullPointerException if the group is null
-     * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
-     * @throws IllegalArgumentException if the expiry time is in the past
-     */
-    void setInheritGroup(Group group, long expireAt) throws ObjectAlreadyHasException;
-
-    /**
-     * Make this group inherit another group on a specific server temporarily
-     * @param group the group to be inherited
-     * @param server The server inherit add the group on
-     * @param expireAt when the group should expire
-     * @throws ObjectAlreadyHasException if the group already inherits the group on that server temporarily
-     * @throws NullPointerException if the group or server is null
-     * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
-     * @throws IllegalArgumentException if the expiry time is in the past or the server is invalid
-     */
-    void setInheritGroup(Group group, String server, long expireAt) throws ObjectAlreadyHasException;
-
-    /**
-     * Make this group inherit another group on a specific server and world temporarily
-     * @param group the group to be inherited
-     * @param server The server to inherit the group on
-     * @param world The world to inherit the group on
-     * @param expireAt when the group should expire
-     * @throws ObjectAlreadyHasException if the group already inherits the group on that server and world temporarily
-     * @throws NullPointerException if the group, server or world is null
-     * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
-     * @throws IllegalArgumentException if the expiry time is in the past or the server/world is invalid
-     */
-    void setInheritGroup(Group group, String server, String world, long expireAt) throws ObjectAlreadyHasException;
-
-    /**
-     * Remove a previously set inheritance rule
-     * @param group the group to uninherit
-     * @throws ObjectLacksException if the group does not already inherit the group
-     * @throws NullPointerException if the group is null
-     * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
-     */
-    void unsetInheritGroup(Group group) throws ObjectLacksException;
-
-    /**
-     * Remove a previously set inheritance rule
-     * @param group the group to uninherit
-     * @param temporary if the group being removed is temporary
-     * @throws ObjectLacksException if the group does not already inherit the group
-     * @throws NullPointerException if the group is null
-     * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
-     */
-    void unsetInheritGroup(Group group, boolean temporary) throws ObjectLacksException;
-
-    /**
-     * Remove a previously set inheritance rule on a specific server
-     * @param group the group to uninherit
-     * @param server The server to remove the group on
-     * @throws ObjectLacksException if the group does not already inherit the group on that server
-     * @throws NullPointerException if the group or server is null
-     * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
-     * @throws IllegalArgumentException if the server is invalid
-     */
-    void unsetInheritGroup(Group group, String server) throws ObjectLacksException;
-
-    /**
-     * Remove a previously set inheritance rule on a specific server and world
-     * @param group the group to uninherit
-     * @param server The server to remove the group on
-     * @param world The world to remove the group on
-     * @throws ObjectLacksException if the group does not already inherit the group
-     * @throws NullPointerException if the group, server or world is null
-     * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
-     * @throws IllegalArgumentException if the server or world is invalid
-     */
-    void unsetInheritGroup(Group group, String server, String world) throws ObjectLacksException;
-
-    /**
-     * Remove a previously set inheritance rule on a specific server
-     * @param group the group to uninherit
-     * @param server The server to remove the group on
-     * @param temporary if the group being removed is temporary
-     * @throws ObjectLacksException if the group does not already inherit the group
-     * @throws NullPointerException if the group or server is null
-     * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
-     * @throws IllegalArgumentException if the expiry time is in the past or the server is invalid
-     */
-    void unsetInheritGroup(Group group, String server, boolean temporary) throws ObjectLacksException;
-
-    /**
-     * Remove a previously set inheritance rule on a specific server and world
-     * @param group the group to uninherit
-     * @param server The server to remove the group on
-     * @param world The world to remove the group on
-     * @param temporary if the group being removed was set temporarily
-     * @throws ObjectLacksException if the group does not already inherit the group
-     * @throws NullPointerException if the group, server or world is null
-     * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
-     * @throws IllegalArgumentException if the expiry time is in the past or the server/world is invalid
-     */
-    void unsetInheritGroup(Group group, String server, String world, boolean temporary) throws ObjectLacksException;
-
-    /**
-     * Clear all of the groups permission nodes
-     */
-    void clearNodes();
-
-    /**
-     * Get a {@link List} of all of the groups the group inherits, on all servers
-     * @return a {@link List} of group names
-     */
-    List<String> getGroupNames();
-
-    /**
-     * Get a {@link List} of the groups the group inherits on a specific server
-     * @param server the server to check
-     * @param world the world to check
-     * @return a {@link List} of group names
-     * @throws NullPointerException if the server or world is null
-     * @throws IllegalArgumentException if the server or world is invalid
-     */
-    List<String> getLocalGroups(String server, String world);
-
-    /**
-     * Get a {@link List} of the groups the group inherits on a specific server
-     * @param server the server to check
-     * @return a {@link List} of group names
-     * @throws NullPointerException if the server is null
-     * @throws IllegalArgumentException if the server is invalid
-     */
-    List<String> getLocalGroups(String server);
 }
@@ -0,0 +1,106 @@
+/*
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api;
+
+import me.lucko.luckperms.api.context.ContextSet;
+
+import java.util.Optional;
+import java.util.OptionalLong;
+
+import javax.annotation.Nonnull;
+import javax.annotation.concurrent.Immutable;
+
+/**
+ * A relationship between a {@link PermissionHolder} and a permission.
+ *
+ * @param <T> the identifier type of the holder
+ * @since 2.17
+ */
+@Immutable
+public interface HeldPermission<T> {
+
+    /**
+     * Gets the holder of the permission
+     *
+     * @return the holder
+     */
+    @Nonnull
+    T getHolder();
+
+    /**
+     * Gets the permission being held
+     *
+     * @return the permission
+     */
+    @Nonnull
+    String getPermission();
+
+    /**
+     * Gets the value of the permission
+     *
+     * @return the value
+     */
+    boolean getValue();
+
+    /**
+     * Gets the server where the permission is held
+     *
+     * @return the server
+     */
+    @Nonnull
+    Optional<String> getServer();
+
+    /**
+     * Gets the world where the permission is held
+     *
+     * @return the world
+     */
+    @Nonnull
+    Optional<String> getWorld();
+
+    /**
+     * Gets the time in unix time when the permission will expire
+     *
+     * @return the expiry time
+     */
+    OptionalLong getExpiry();
+
+    /**
+     * Gets the extra context for the permission.
+     *
+     * @return the extra context
+     */
+    ContextSet getContexts();
+
+    /**
+     * Converts this permission into a Node
+     *
+     * @return a Node copy of this permission
+     */
+    @Nonnull
+    Node asNode();
+
+}
@@ -1,5 +1,8 @@
 /*
- * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
 *
 *  Permission is hereby granted, free of charge, to any person obtaining a copy
 *  of this software and associated documentation files (the "Software"), to deal
@@ -22,155 +25,98 @@

 package me.lucko.luckperms.api;

-import me.lucko.luckperms.api.data.DatastoreConfiguration;
-import me.lucko.luckperms.api.data.MySQLConfiguration;
-
 import java.util.Map;

+import javax.annotation.Nonnull;
+
 /**
- * A wrapper interface for the internal LuckPerms configuration, providing read only access.
+ * Wrapper around parts of the LuckPerms configuration file
 */
-@SuppressWarnings("unused")
 public interface LPConfiguration {

    /**
+     * Gets the name of this server
+     *
     * @return the name of this server
     */
+    @Nonnull
    String getServer();

    /**
-     * @return how often a sync task will run in minutes
-     */
-    int getSyncTime();
-
-    /**
-     * @return the default group, in a node representation
-     * @deprecated as of 2.6, the default group is always "default"
-     */
-    @Deprecated
-    String getDefaultGroupNode();
-
-    /**
-     * @return the name of the default group
-     * @deprecated as of 2.6, the default group is always "default"
-     */
-    @Deprecated
-    String getDefaultGroupName();
-
-    /**
+     * Gets if the users on this server will have their global permissions applied
+     *
     * @return if the users on this server will have their global permissions applied
     */
    boolean getIncludeGlobalPerms();

    /**
+     * Gets if the users on this server will have their global world permissions applied
+     *
     * @return if the users on this server will have their global world permissions applied
     * @since 2.9
     */
    boolean getIncludeGlobalWorldPerms();

    /**
+     * Gets if the platform is applying global groups
+     *
     * @return true if the platform is applying global groups
     * @since 2.9
     */
    boolean getApplyGlobalGroups();

    /**
+     * Gets if the platform is applying global world groups
+     *
     * @return true if the platform is applying global world groups
     * @since 2.9
     */
    boolean getApplyGlobalWorldGroups();

    /**
-     * @return the online mode setting in the config
-     */
-    boolean getOnlineMode();
-
-    /**
-     * @return if LuckPerms is applying wildcard permissions
-     */
-    boolean getApplyWildcards();
-
-    /**
-     * @return if LuckPerms is resolving and applying regex permissions
-     */
-    boolean getApplyRegex();
-
-    /**
-     * @return if LuckPerms is expanding shorthand permissions
-     */
-    boolean getApplyShorthand();
-
-    /**
-     * @return if LuckPerms will send notifications to users when permissions are modified
-     * @since 2.7
-     */
-    boolean getLogNotify();
-
-    /**
-     * @return true if permission checks are being recorded / debugged
-     * @since 2.9
-     */
-    boolean getDebugPermissionChecks();
-
-    /**
-     * @return true if the vanilla op system is enabled
-     * @since 2.8
-     */
-    boolean getEnableOps();
-
-    /**
-     * @return true if opped players are allowed to use LuckPerms commands
-     * @since 2.8
-     */
-    boolean getCommandsAllowOp();
-
-    /**
-     * @return true if auto op is enabled
-     * @since 2.9
-     */
-    boolean getAutoOp();
-
-    /**
-     * @return the name of the server used within Vault operations
-     * @since 2.7
-     */
-    String getVaultServer();
-
-    /**
-     * @return true if global permissions should be considered when retrieving meta or player groups
-     * @since 2.7
-     */
-    boolean getVaultIncludeGlobal();
-
-    /**
-     * @return the database values set in the configuration
-     * @deprecated use {@link #getDatastoreConfig()}
-     */
-    @SuppressWarnings("deprecation")
-    @Deprecated
-    MySQLConfiguration getDatabaseValues();
-
-    /**
-     * @return the values set for data storage in the configuration
-     */
-    DatastoreConfiguration getDatastoreConfig();
-
-    /**
+     * Gets the storage method string from the configuration
+     *
     * @return the storage method string from the configuration
     */
+    @Nonnull
    String getStorageMethod();

    /**
+     * Gets true if split storage is enabled
+     *
     * @return true if split storage is enabled
     * @since 2.7
     */
    boolean getSplitStorage();

    /**
-     * @return a map of split storage options, where the key is the storage section, and the value is the storage method.
-     * For example: key = user, value = json
+     * Gets a map of split storage options
+     *
+     * @return a map of split storage options, where the key is the storage section, and the value is the storage
+     * method. For example: key = user, value = json
     * @since 2.7
     */
+    @Nonnull
    Map<String, String> getSplitStorageOptions();

+    @Nonnull
+    Unsafe unsafe();
+
+    interface Unsafe {
+
+        /**
+         * Gets an Object from the config.
+         *
+         * <p>This method is nested under {@link Unsafe} because the keys
+         * and return types may change between versions without warning.</p>
+         *
+         * @param key the key, as defined as a field name in
+         *            the "ConfigKeys" class.
+         * @return the corresponding object, if one is present
+         * @throws IllegalArgumentException if the key isn't known
+         */
+        @Nonnull
+        Object getObject(String key);
+    }
+
 }
@@ -0,0 +1,56 @@
+/*
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api;
+
+import javax.annotation.Nonnull;
+import javax.annotation.concurrent.Immutable;
+
+/**
+ * A node with a traceable origin
+ *
+ * @since 2.11
+ */
+@Immutable
+public interface LocalizedNode extends Node {
+
+    /**
+     * Gets the delegate node
+     *
+     * @return the node this instance is representing
+     */
+    @Nonnull
+    Node getNode();
+
+    /**
+     * Gets the location where the {@link Node} is inherited from
+     *
+     * @return where the node was inherited from. Will not return null.
+     * @see PermissionHolder#getObjectName()
+     */
+    @Nonnull
+    String getLocation();
+
+}
@@ -1,5 +1,8 @@
 /*
- * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
 *
 *  Permission is hereby granted, free of charge, to any person obtaining a copy
 *  of this software and associated documentation files (the "Software"), to deal
@@ -26,136 +29,204 @@ import java.util.SortedMap;
 import java.util.SortedSet;
 import java.util.UUID;

+import javax.annotation.Nonnull;
+import javax.annotation.concurrent.Immutable;
+
 /**
 * Represents the internal LuckPerms log.
- * All content internally is immutable. You can add to the log using the {@link Datastore}, and then request an updated copy.
+ *
+ * <p>The returned instance provides a copy of the data at the time of retrieval.</p>
+ *
+ * <p>Any changes made to log entries will only apply to this instance of the log.
+ * You can add to the log using the {@link Storage}, and then request an updated copy.</p>
+ *
+ * <p>All methods are thread safe, and return immutable and thread safe collections.</p>
 */
-@SuppressWarnings("unused")
+@Immutable
 public interface Log {

    /**
+     * Get the content of the log
+     *
     * @return a {@link SortedSet} of all of the {@link LogEntry} objects in this {@link Log}
     */
+    @Nonnull
    SortedSet<LogEntry> getContent();

    /**
+     * Get the content of the log
+     *
     * @return all content in this log
     */
+    @Nonnull
    SortedSet<LogEntry> getRecent();

    /**
     * Gets the recent content separated by page
+     *
     * @param pageNo the page number
     * @return the page content
+     * @throws IllegalArgumentException if the pageNo is less than 1
+     * @throws IllegalStateException if the log doesn't contain enough entries to populate the page. See {@link #getRecentMaxPages()}
     */
+    @Nonnull
    SortedMap<Integer, LogEntry> getRecent(int pageNo);

    /**
+     * Gets the max page number for the recent pages.
+     *
     * @return the max page number allowed in the {@link #getRecent(int)} method
     */
    int getRecentMaxPages();


    /**
+     * Gets the recent content for a given actor
+     *
     * @param actor the uuid of the actor to filter by
     * @return all content in this log where is actor = uuid
     */
-    SortedSet<LogEntry> getRecent(UUID actor);
+    @Nonnull
+    SortedSet<LogEntry> getRecent(@Nonnull UUID actor);

    /**
-     * Gets the recent content for the uuid, separated into pages
+     * Gets the recent content for a given actor, separated by page
+     *
     * @param pageNo the page number
-     * @param actor the uuid of the actor to filter by
+     * @param actor  the uuid of the actor to filter by
     * @return the page content
+     * @throws IllegalArgumentException if the pageNo is less than 1
+     * @throws IllegalStateException if the log doesn't contain enough entries to populate the page. See {@link #getRecentMaxPages(UUID)}
     */
-    SortedMap<Integer, LogEntry> getRecent(int pageNo, UUID actor);
+    @Nonnull
+    SortedMap<Integer, LogEntry> getRecent(int pageNo, @Nonnull UUID actor);

    /**
+     * Gets the max page number for the recent pages.
+     *
     * @param actor the actor to filter by
     * @return the max page number allowed in the {@link #getRecent(int, UUID)} method
     */
-    int getRecentMaxPages(UUID actor);
+    int getRecentMaxPages(@Nonnull UUID actor);


    /**
+     * Gets the log content for a given user
+     *
     * @param uuid the uuid to filter by
     * @return all content in this log where the user = uuid
     */
-    SortedSet<LogEntry> getUserHistory(UUID uuid);
+    @Nonnull
+    SortedSet<LogEntry> getUserHistory(@Nonnull UUID uuid);

    /**
-     * Gets the user history content, separated by pages
+     * Gets the log content for a given user, separated by page
+     *
     * @param pageNo the page number
-     * @param uuid the uuid of the acted user to filter by
+     * @param uuid   the uuid of the acted user to filter by
     * @return the page content
+     * @throws IllegalArgumentException if the pageNo is less than 1
+     * @throws IllegalStateException if the log doesn't contain enough entries to populate the page. See {@link #getUserHistoryMaxPages(UUID)}
     */
-    SortedMap<Integer, LogEntry> getUserHistory(int pageNo, UUID uuid);
+    @Nonnull
+    SortedMap<Integer, LogEntry> getUserHistory(int pageNo, @Nonnull UUID uuid);

    /**
+     * Gets the max page number for the user history pages.
+     *
     * @param uuid the uuid to filter by
     * @return the max page number allowed in the {@link #getUserHistory(int, UUID)} method
     */
-    int getUserHistoryMaxPages(UUID uuid);
+    int getUserHistoryMaxPages(@Nonnull UUID uuid);
+

-    
    /**
+     * Gets the log content for a given group
+     *
     * @param name the name to filter by
     * @return all content in this log where the group = name
     */
-    SortedSet<LogEntry> getGroupHistory(String name);
+    @Nonnull
+    SortedSet<LogEntry> getGroupHistory(@Nonnull String name);

    /**
-     * Gets the group history content, separated by pages
+     * Gets the log content for a given group, separated by page
+     *
     * @param pageNo the page number
-     * @param name the name of the acted group to filter by
+     * @param name   the name of the acted group to filter by
     * @return the page content
+     * @throws IllegalArgumentException if the pageNo is less than 1
+     * @throws IllegalStateException if the log doesn't contain enough entries to populate the page. See {@link #getGroupHistoryMaxPages(String)}
     */
-    SortedMap<Integer, LogEntry> getGroupHistory(int pageNo, String name);
+    @Nonnull
+    SortedMap<Integer, LogEntry> getGroupHistory(int pageNo, @Nonnull String name);

    /**
+     * Gets the max page number for the group history pages.
+     *
     * @param name the name to filter by
     * @return the max page number allowed in the {@link #getGroupHistory(int, String)} method
     */
-    int getGroupHistoryMaxPages(String name);
+    int getGroupHistoryMaxPages(@Nonnull String name);


    /**
+     * Gets the log content for a given track
+     *
     * @param name the name to filter by
     * @return all content in this log where the track = name
     */
-    SortedSet<LogEntry> getTrackHistory(String name);
+    @Nonnull
+    SortedSet<LogEntry> getTrackHistory(@Nonnull String name);

    /**
-     * Gets the track history content, separated by pages
+     * Gets the log content for a given track, separated by page
+     *
     * @param pageNo the page number
-     * @param name the name of the acted track to filter by
+     * @param name   the name of the acted track to filter by
     * @return the page content
+     * @throws IllegalArgumentException if the pageNo is less than 1
+     * @throws IllegalStateException if the log doesn't contain enough entries to populate the page. See {@link #getTrackHistoryMaxPages(String)}
     */
-    SortedMap<Integer, LogEntry> getTrackHistory(int pageNo, String name);
+    @Nonnull
+    SortedMap<Integer, LogEntry> getTrackHistory(int pageNo, @Nonnull String name);

    /**
+     * Gets the max page number for the track history pages.
+     *
     * @param name the name to filter by
     * @return the max page number allowed in the {@link #getTrackHistory(int, String)} method
     */
-    int getTrackHistoryMaxPages(String name);
+    int getTrackHistoryMaxPages(@Nonnull String name);
+

    /**
+     * Gets the log content for a given search query
+     *
     * @param query the query to filter by
     * @return all content in this log where the content matches query
     */
-    SortedSet<LogEntry> getSearch(String query);
+    @Nonnull
+    SortedSet<LogEntry> getSearch(@Nonnull String query);

    /**
-     * Gets the search content, separated by pages
+     * Gets the log content for a given search query, separated by page
+     *
     * @param pageNo the page number
-     * @param query the query to filter by
+     * @param query  the query to filter by
     * @return the page content
+     * @throws IllegalArgumentException if the pageNo is less than 1
+     * @throws IllegalStateException if the log doesn't contain enough entries to populate the page. See {@link #getSearchMaxPages(String)}}
     */
-    SortedMap<Integer, LogEntry> getSearch(int pageNo, String query);
+    @Nonnull
+    SortedMap<Integer, LogEntry> getSearch(int pageNo, @Nonnull String query);

    /**
+     * Gets the max page number for the search query pages.
+     *
     * @param query the query to filter by
     * @return the max page number allowed in the {@link #getSearch(int, String)} method
     */
-    int getSearchMaxPages(String query);
+    int getSearchMaxPages(@Nonnull String query);
+
 }
@@ -1,5 +1,8 @@
 /*
- * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
 *
 *  Permission is hereby granted, free of charge, to any person obtaining a copy
 *  of this software and associated documentation files (the "Software"), to deal
@@ -22,298 +25,204 @@

 package me.lucko.luckperms.api;

+import java.util.Optional;
 import java.util.UUID;

+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import javax.annotation.concurrent.Immutable;
+
 /**
- * Represents a single entry in a log
+ * Represents a logged action.
+ *
+ * @see ActionLogger#newEntryBuilder() for creating an instance
 */
-@SuppressWarnings({"unused", "WeakerAccess"})
-public class LogEntry implements Comparable<LogEntry> {
-    public static LogEntryBuilder builder() {
-        return new LogEntryBuilder();
-    }
+@Immutable
+public interface LogEntry extends Comparable<LogEntry> {

-    private static final String FORMAT = "&8(&e%s&8) [&a%s&8] (&b%s&8) &7--> &f%s";
+    /**
+     * Gets the time in unix seconds when the action occurred.
+     *
+     * @return the timestamp
+     */
+    long getTimestamp();

-    private long timestamp;
-    private UUID actor;
-    private String actorName;
-    private char type;
-    private UUID acted;
-    private String actedName;
-    private String action;
+    /**
+     * Gets the id of the object which performed the action.
+     *
+     * <p>This is the players uuid in most cases.</p>
+     *
+     * @return the actor id
+     */
+    @Nonnull
+    UUID getActor();

-    public LogEntry(long timestamp, UUID actor, String actorName, char type, UUID acted, String actedName, String action) {
-        if (actor == null) {
-            throw new NullPointerException("actor");
-        }
-        if (actorName == null) {
-            throw new NullPointerException("actorName");
-        }
-        if (actedName == null) {
-            throw new NullPointerException("actedName");
-        }
-        if (action == null) {
-            throw new NullPointerException("action");
+    /**
+     * Gets the name describing the actor.
+     *
+     * @return the name of the actor
+     */
+    @Nonnull
+    String getActorName();
+
+    /**
+     * Gets the type of action.
+     *
+     * @return the action type
+     */
+    @Nonnull
+    Type getType();
+
+    /**
+     * Gets the uuid of the object which was acted upon.
+     *
+     * <p>Will only return a value for {@link Type#USER} entries.</p>
+     *
+     * @return the uuid of acted object
+     */
+    @Nonnull
+    Optional<UUID> getActed();
+
+    /**
+     * Gets the name describing the object which was acted upon
+     *
+     * @return the name of the acted object
+     */
+    @Nonnull
+    String getActedName();
+
+    /**
+     * Returns a string describing the action which took place.
+     *
+     * <p>In most instances, this returns a variation of the command string which caused
+     * the change.</p>
+     *
+     * @return the action
+     */
+    @Nonnull
+    String getAction();
+
+    /**
+     * Represents the type of a {@link LogEntry}.
+     *
+     * @since 3.3
+     */
+    enum Type {
+        USER('U'),
+        GROUP('G'),
+        TRACK('T');
+
+        private final char code;
+
+        Type(char code) {
+            this.code = code;
        }

-        this.timestamp = timestamp;
-        this.actor = actor;
-        this.actorName = actorName;
-        this.type = type;
-        this.acted = acted;
-        this.actedName = actedName;
-        this.action = action;
-    }
-
-    protected LogEntry() {
-        this.timestamp = 0L;
-        this.actor = null;
-        this.actorName = null;
-        this.type = Character.MIN_VALUE;
-        this.acted = null;
-        this.actedName = null;
-        this.action = null;
-    }
-
-    @Override
-    public int compareTo(LogEntry o) {
-        return equals(o) ? 0 : (Long.compare(timestamp, o.getTimestamp()) == 0 ? 1 : Long.compare(timestamp, o.getTimestamp()));
-    }
-
-    public boolean matchesSearch(String query) {
-        query = query.toLowerCase();
-        return actorName.toLowerCase().contains(query) || actedName.toLowerCase().contains(query)
-                || action.toLowerCase().contains(query);
-    }
-
-    public String getFormatted() {
-        return String.format(FORMAT,
-                actorName,
-                Character.toString(type),
-                actedName,
-                action
-        );
-    }
-
-    public long getTimestamp() {
-        return timestamp;
-    }
-
-    public UUID getActor() {
-        return actor;
-    }
-
-    public String getActorName() {
-        return actorName;
-    }
-
-    public char getType() {
-        return type;
-    }
-
-    public UUID getActed() {
-        return acted;
-    }
-
-    public String getActedName() {
-        return actedName;
-    }
-
-    public String getAction() {
-        return action;
-    }
-
-    void setTimestamp(long timestamp) {
-        this.timestamp = timestamp;
-    }
-
-    void setActor(UUID actor) {
-        this.actor = actor;
-    }
-
-    void setActorName(String actorName) {
-        this.actorName = actorName;
-    }
-
-    void setType(char type) {
-        this.type = type;
-    }
-
-    void setActed(UUID acted) {
-        this.acted = acted;
-    }
-
-    void setActedName(String actedName) {
-        this.actedName = actedName;
-    }
-
-    void setAction(String action) {
-        this.action = action;
-    }
-
-    @Override
-    public String toString() {
-        return "LogEntry(timestamp=" + this.getTimestamp() + ", actor=" + this.getActor() + ", actorName=" +
-                this.getActorName() + ", type=" + this.getType() + ", acted=" + this.getActed() + ", actedName=" +
-                this.getActedName() + ", action=" + this.getAction() + ")";
-    }
-
-    @Override
-    public boolean equals(Object o) {
-        if (o == this) return true;
-        if (!(o instanceof LogEntry)) return false;
-        final LogEntry other = (LogEntry) o;
-        if (this.getTimestamp() != other.getTimestamp()) return false;
-        final Object this$actor = this.getActor();
-        final Object other$actor = other.getActor();
-        if (this$actor == null ? other$actor != null : !this$actor.equals(other$actor)) return false;
-        final Object this$actorName = this.getActorName();
-        final Object other$actorName = other.getActorName();
-        if (this$actorName == null ? other$actorName != null : !this$actorName.equals(other$actorName)) return false;
-        if (this.getType() != other.getType()) return false;
-        final Object this$acted = this.getActed();
-        final Object other$acted = other.getActed();
-        if (this$acted == null ? other$acted != null : !this$acted.equals(other$acted)) return false;
-        final Object this$actedName = this.getActedName();
-        final Object other$actedName = other.getActedName();
-        if (this$actedName == null ? other$actedName != null : !this$actedName.equals(other$actedName)) return false;
-        final Object this$action = this.getAction();
-        final Object other$action = other.getAction();
-        return this$action == null ? other$action == null : this$action.equals(other$action);
-    }
-
-    @Override
-    public int hashCode() {
-        final int PRIME = 59;
-        int result = 1;
-        final long $timestamp = this.getTimestamp();
-        result = result * PRIME + (int) ($timestamp >>> 32 ^ $timestamp);
-        final Object $actor = this.getActor();
-        result = result * PRIME + ($actor == null ? 43 : $actor.hashCode());
-        final Object $actorName = this.getActorName();
-        result = result * PRIME + ($actorName == null ? 43 : $actorName.hashCode());
-        result = result * PRIME + this.getType();
-        final Object $acted = this.getActed();
-        result = result * PRIME + ($acted == null ? 43 : $acted.hashCode());
-        final Object $actedName = this.getActedName();
-        result = result * PRIME + ($actedName == null ? 43 : $actedName.hashCode());
-        final Object $action = this.getAction();
-        result = result * PRIME + ($action == null ? 43 : $action.hashCode());
-        return result;
-    }
-
-    public static class LogEntryBuilder extends AbstractLogEntryBuilder<LogEntry, LogEntry.LogEntryBuilder> {
-
-        @Override
-        protected LogEntry createObj() {
-            return new LogEntry();
+        public char getCode() {
+            return this.code;
        }

-        @Override
-        protected LogEntryBuilder getThis() {
-            return this;
-        }
-    }
-
-    public static abstract class AbstractLogEntryBuilder<T extends LogEntry, B extends AbstractLogEntryBuilder<T, B>> {
-        private T obj;
-        private B thisObj;
-
-        public AbstractLogEntryBuilder() {
-            obj = createObj();
-            thisObj = getThis();
-        }
-
-        protected abstract T createObj();
-        protected abstract B getThis();
-
-        public long getTimestamp() {
-            return obj.getTimestamp();
-        }
-
-        public UUID getActor() {
-            return obj.getActor();
-        }
-
-        public String getActorName() {
-            return obj.getActorName();
-        }
-
-        public char getType() {
-            return obj.getType();
-        }
-
-        public UUID getActed() {
-            return obj.getActed();
-        }
-
-        public String getActedName() {
-            return obj.getActedName();
-        }
-
-        public String getAction() {
-            return obj.getAction();
-        }
-
-        public B timestamp(long timestamp) {
-            obj.setTimestamp(timestamp);
-            return thisObj;
-        }
-
-        public B actor(UUID actor) {
-            obj.setActor(actor);
-            return thisObj;
-        }
-
-        public B actorName(String actorName) {
-            obj.setActorName(actorName);
-            return thisObj;
-        }
-
-        public B type(char type) {
-            obj.setType(type);
-            return thisObj;
-        }
-
-        public B acted(UUID acted) {
-            obj.setActed(acted);
-            return thisObj;
-        }
-
-        public B actedName(String actedName) {
-            obj.setActedName(actedName);
-            return thisObj;
-        }
-
-        public B action(String action) {
-            obj.setAction(action);
-            return thisObj;
-        }
-
-        public T build() {
-            if (getActor() == null) {
-                throw new NullPointerException("actor");
+        @Nonnull
+        public static Type valueOf(char code) {
+            switch (code) {
+                case 'U':
+                case 'u':
+                    return USER;
+                case 'G':
+                case 'g':
+                    return GROUP;
+                case 'T':
+                case 't':
+                    return TRACK;
+                default:
+                    throw new IllegalArgumentException("Unknown code: " + code);
            }
-            if (getActorName() == null) {
-                throw new NullPointerException("actorName");
-            }
-            if (getActedName() == null) {
-                throw new NullPointerException("actedName");
-            }
-            if (getAction() == null) {
-                throw new NullPointerException("action");
-            }
-
-            return obj;
        }
+    }
+
+    /**
+     * Builds a LogEntry instance
+     */
+    interface Builder {
+
+        /**
+         * Sets the timestamp of the entry.
+         *
+         * @param timestamp the timestamp
+         * @return the builder
+         * @see LogEntry#getTimestamp()
+         */
+        @Nonnull
+        Builder setTimestamp(long timestamp);
+
+        /**
+         * Sets the actor of the entry.
+         *
+         * @param actor the actor
+         * @return the builder
+         * @see LogEntry#getActor()
+         */
+        @Nonnull
+        Builder setActor(@Nonnull UUID actor);
+
+        /**
+         * Sets the actor name of the entry.
+         *
+         * @param actorName the actor name
+         * @return the builder
+         * @see LogEntry#getActorName()
+         */
+        @Nonnull
+        Builder setActorName(@Nonnull String actorName);
+
+        /**
+         * Sets the type of the entry.
+         *
+         * @param type the type
+         * @return the builder
+         * @see LogEntry#getType()
+         */
+        @Nonnull
+        Builder setType(@Nonnull Type type);
+
+        /**
+         * Sets the acted object for the entry.
+         *
+         * @param acted the acted object
+         * @return the builder
+         * @see LogEntry#getActed()
+         */
+        @Nonnull
+        Builder setActed(@Nullable UUID acted);
+
+        /**
+         * Sets the acted name for the entry.
+         *
+         * @param actedName the acted name
+         * @return the builder
+         * @see LogEntry#getActedName()
+         */
+        @Nonnull
+        Builder setActedName(@Nonnull String actedName);
+
+        /**
+         * Sets the action of the entry.
+         *
+         * @param action the action
+         * @return the builder
+         * @see LogEntry#getAction()
+         */
+        @Nonnull
+        Builder setAction(@Nonnull String action);
+
+        /**
+         * Creates a {@link LogEntry} instance from the builder.
+         *
+         * @return a new log entry instance
+         */
+        @Nonnull
+        LogEntry build();

-        @Override
-        public String toString() {
-            return "LogEntry.LogEntryBuilder(timestamp=" + getTimestamp() + ", actor=" + getActor() + ", actorName=" +
-                    getActorName() + ", type=" + getType() + ", acted=" + getActed() + ", actedName=" + getActedName() +
-                    ", action=" + getAction() + ")";
-        }
    }

 }
@@ -1,5 +1,8 @@
 /*
- * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
 *
 *  Permission is hereby granted, free of charge, to any person obtaining a copy
 *  of this software and associated documentation files (the "Software"), to deal
@@ -22,216 +25,481 @@

 package me.lucko.luckperms.api;

-import me.lucko.luckperms.api.context.ContextListener;
-import me.lucko.luckperms.api.context.IContextCalculator;
-import me.lucko.luckperms.api.event.LPListener;
+import me.lucko.luckperms.LuckPerms;
+import me.lucko.luckperms.api.context.ContextCalculator;
+import me.lucko.luckperms.api.context.ContextManager;
+import me.lucko.luckperms.api.context.ContextSet;
+import me.lucko.luckperms.api.event.EventBus;
+import me.lucko.luckperms.api.manager.GroupManager;
+import me.lucko.luckperms.api.manager.TrackManager;
+import me.lucko.luckperms.api.manager.UserManager;
+import me.lucko.luckperms.api.messenger.MessengerProvider;
+import me.lucko.luckperms.api.metastacking.MetaStackFactory;
+import me.lucko.luckperms.api.platform.PlatformInfo;

 import java.util.Optional;
 import java.util.Set;
 import java.util.UUID;
+import java.util.concurrent.CompletableFuture;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;

 /**
- * The root API interface in LuckPerms
+ * The LuckPerms API.
+ *
+ * <p>This interface is the base of the entire API package. All API functions
+ * are accessed via this interface.</p>
+ *
+ * <p>An instance can be obtained via {@link LuckPerms#getApi()}, or the platforms
+ * Services Manager.</p>
 */
-@SuppressWarnings("unused")
 public interface LuckPermsApi {

    /**
-     * Schedules an update task to run
+     * Gets information about the platform LuckPerms is running on.
+     *
+     * @return the platform info
+     * @since 4.0
     */
-    void runUpdateTask();
+    @Nonnull
+    PlatformInfo getPlatformInfo();

    /**
-     * @return the version of the API running on the platform
-     * @since 2.6
+     * Gets the {@link UserManager}, responsible for managing
+     * {@link User} instances.
+     *
+     * <p>This manager can be used to retrieve instances of {@link User} by uuid
+     * or name, or query all loaded users.</p>
+     *
+     * <p>The {@link #getStorage() storage} instance should be used to
+     * load/create/save users.</p>
+     *
+     * @return the user manager
+     * @since 4.0
     */
-    double getApiVersion();
+    @Nonnull
+    UserManager getUserManager();

    /**
-     * @return the version of the plugin running on the platform
+     * Gets the {@link GroupManager}, responsible for managing
+     * {@link Group} instances.
+     *
+     * <p>This manager can be used to retrieve instances of {@link Group} by
+     * name, or query all loaded groups.</p>
+     *
+     * <p>The {@link #getStorage() storage} instance should be used to
+     * load/create/save/delete groups.</p>
+     *
+     * @return the group manager
+     * @since 4.0
     */
-    String getVersion();
+    @Nonnull
+    GroupManager getGroupManager();

    /**
-     * @return the platform LuckPerms is running on
-     * @since 2.7
+     * Gets the {@link TrackManager}, responsible for managing
+     * {@link Track} instances.
+     *
+     * <p>This manager can be used to retrieve instances of {@link Track} by
+     * name, or query all loaded tracks.</p>
+     *
+     * <p>The {@link #getStorage() storage} instance should be used to
+     * load/create/save/delete tracks.</p>
+     *
+     * @return the track manager
+     * @since 4.0
     */
-    PlatformType getPlatformType();
+    @Nonnull
+    TrackManager getTrackManager();

    /**
-     * Registers a listener to be sent LuckPerms events
-     * @param listener the listener instance
-     * @throws NullPointerException if the listener is null
+     * Schedules the execution of an update task, and returns an encapsulation
+     * of the task as a {@link CompletableFuture}.
+     *
+     * <p>The exact actions performed in an update task remains an
+     * implementation detail of the plugin, however, as a minimum, it is
+     * expected to perform a full reload of user, group and track data, and
+     * ensure that any changes are fully applied and propagated.</p>
+     *
+     * @return a future
+     * @since 4.0
     */
-    void registerListener(LPListener listener);
+    @Nonnull
+    CompletableFuture<Void> runUpdateTask();

    /**
-     * Unregisters a previously registered listener from the EventBus
-     * @param listener the listener instance to unregister
-     * @throws NullPointerException if the listener is null
+     * Gets the {@link EventBus}, used for subscribing to internal LuckPerms
+     * events.
+     *
+     * @return the event bus
+     * @since 3.0
     */
-    void unregisterListener(LPListener listener);
+    @Nonnull
+    EventBus getEventBus();

    /**
-     * Gets a wrapped {@link LPConfiguration} instance, with read only access
-     * @return a configuration instance
+     * Gets a representation of the plugins configuration
+     *
+     * @return the configuration
     */
+    @Nonnull
    LPConfiguration getConfiguration();

    /**
-     * Gets a wrapped {@link Datastore} instance, with somewhat limited access
-     * @return a datastore instance
+     * Gets an object representing the plugins primary {@link Storage} backend.
+     *
+     * <p>The instance propagates calls to the internal DAO (Data Access Object),
+     * and applies any changes to the storage provider.</p>
+     *
+     * @return a storage instance
+     * @since 2.14
     */
-    Datastore getDatastore();
+    @Nonnull
+    Storage getStorage();

    /**
-     * Gets the {@link Logger} wrapping used by the platform
-     * @return the logger instance
+     * Gets the {@link MessagingService}, if present.
+     *
+     * <p>The MessagingService is used to dispatch updates throughout a network
+     * of servers running the plugin.</p>
+     *
+     * <p>Not all instances of LuckPerms will have a messaging service setup and
+     * configured, but it is recommended that all users of the API account for
+     * and make use of this.</p>
+     *
+     * @return the messaging service instance, if present.
     */
-    Logger getLogger();
+    @Nonnull
+    Optional<MessagingService> getMessagingService();

    /**
-     * Gets a wrapped {@link UuidCache} instance, providing read access to the LuckPerms internal uuid caching system
-     * @return a uuidcache instance
+     * Registers a {@link MessengerProvider} for use by the platform.
+     *
+     * <p>Note that the mere action of registering a provider doesn't
+     * necessarily mean that it will be used.</p>
+     *
+     * @param messengerProvider the messenger provider.
+     * @since 4.1
     */
+    void registerMessengerProvider(@Nonnull MessengerProvider messengerProvider);
+
+    /**
+     * Gets the {@link ActionLogger}.
+     *
+     * <p>The action logger is responsible for saving and broadcasting defined
+     * actions occurring on the platform.</p>
+     *
+     * @return the action logger
+     * @since 4.1
+     */
+    ActionLogger getActionLogger();
+
+    /**
+     * Gets a {@link UuidCache}.
+     *
+     * <p>The uuid cache provides read access to the internal LuckPerms uuid
+     * mapping system.</p>
+     *
+     * @return the uuid cache
+     * @deprecated this feature is now handled internally - and the API returns a
+     *             No-op implementation of this class.
+     */
+    @Nonnull
+    @Deprecated
    UuidCache getUuidCache();

+    /**
+     * Gets the {@link ContextManager}.
+     *
+     * <p>The context manager manages {@link ContextCalculator}s, and calculates
+     * applicable contexts for a given type.</p>
+     *
+     * @return the context manager
+     * @since 4.0
+     */
+    ContextManager getContextManager();
+
+    /**
+     * Gets the {@link NodeFactory}.
+     *
+     * <p>The node factory provides methods for building {@link Node} instances.</p>
+     *
+     * @return the node factory
+     */
+    @Nonnull
+    NodeFactory getNodeFactory();
+
+    /**
+     * Gets the {@link MetaStackFactory}.
+     *
+     * <p>The metastack factory provides methods for retrieving
+     * {@link me.lucko.luckperms.api.metastacking.MetaStackElement}s and constructing
+     * {@link me.lucko.luckperms.api.metastacking.MetaStackDefinition}s.</p>
+     *
+     * @return the meta stack factory
+     * @since 3.2
+     */
+    @Nonnull
+    MetaStackFactory getMetaStackFactory();
+
+
+
+
+    /*
+     * The following methods are provided only for convenience, and offer no
+     * additional functionality.
+     *
+     * They are implemented as "default" methods, using the manager and factory
+     * instances provided by the methods above.
+     */
+
+
+
    /**
     * Gets a wrapped user object from the user storage
+     *
     * @param uuid the uuid of the user to get
     * @return a {@link User} object, if one matching the uuid is loaded, or null if not
     * @throws NullPointerException if the uuid is null
     */
-    User getUser(UUID uuid);
+    @Nullable
+    default User getUser(@Nonnull UUID uuid) {
+        return getUserManager().getUser(uuid);
+    }

    /**
-     * Gets a wrapped user object from the user storage. This method does not return null, unlike {@link #getUser(UUID)}
+     * Gets a wrapped user object from the user storage.
+     *
     * @param uuid the uuid of the user to get
     * @return an optional {@link User} object
     * @throws NullPointerException if the uuid is null
     */
-    Optional<User> getUserSafe(UUID uuid);
+    @Nonnull
+    default Optional<User> getUserSafe(@Nonnull UUID uuid) {
+        return getUserManager().getUserOpt(uuid);
+    }

    /**
     * Gets a wrapped user object from the user storage
+     *
     * @param name the username of the user to get
     * @return a {@link User} object, if one matching the uuid is loaded, or null if not
     * @throws NullPointerException if the name is null
     */
-    User getUser(String name);
+    @Nullable
+    default User getUser(@Nonnull String name) {
+        return getUserManager().getUser(name);
+    }

    /**
-     * Gets a wrapped user object from the user storage. This method does not return null, unlike {@link #getUser(String)}
+     * Gets a wrapped user object from the user storage.
+     *
     * @param name the username of the user to get
     * @return an optional {@link User} object
     * @throws NullPointerException if the name is null
     */
-    Optional<User> getUserSafe(String name);
+    @Nonnull
+    default Optional<User> getUserSafe(@Nonnull String name) {
+        return getUserManager().getUserOpt(name);
+    }

    /**
     * Gets a set of all loaded users.
+     *
     * @return a {@link Set} of {@link User} objects
     */
-    Set<User> getUsers();
+    @Nonnull
+    default Set<User> getUsers() {
+        return getUserManager().getLoadedUsers();
+    }

    /**
     * Check if a user is loaded in memory
+     *
     * @param uuid the uuid to check for
     * @return true if the user is loaded
     * @throws NullPointerException if the uuid is null
     */
-    boolean isUserLoaded(UUID uuid);
+    default boolean isUserLoaded(@Nonnull UUID uuid) {
+        return getUserManager().isLoaded(uuid);
+    }

    /**
     * Unload a user from the internal storage, if they're not currently online.
+     *
     * @param user the user to unload
     * @throws NullPointerException if the user is null
-     * @since 2.6
     */
-    void cleanupUser(User user);
+    default void cleanupUser(@Nonnull User user) {
+        getUserManager().cleanupUser(user);
+    }

    /**
     * Gets a wrapped group object from the group storage
+     *
     * @param name the name of the group to get
     * @return a {@link Group} object, if one matching the name exists, or null if not
     * @throws NullPointerException if the name is null
     */
-    Group getGroup(String name);
+    @Nullable
+    default Group getGroup(@Nonnull String name) {
+        return getGroupManager().getGroup(name);
+    }

    /**
-     * Gets a wrapped group object from the group storage. This method does not return null, unlike {@link #getGroup}
+     * Gets a wrapped group object from the group storage.
+     *
+     * <p>This method does not return null, unlike {@link #getGroup}</p>
+     *
     * @param name the name of the group to get
     * @return an optional {@link Group} object
     * @throws NullPointerException if the name is null
     */
-    Optional<Group> getGroupSafe(String name);
+    @Nonnull
+    default Optional<Group> getGroupSafe(@Nonnull String name) {
+        return getGroupManager().getGroupOpt(name);
+    }

    /**
     * Gets a set of all loaded groups.
+     *
     * @return a {@link Set} of {@link Group} objects
     */
-    Set<Group> getGroups();
+    @Nonnull
+    default Set<Group> getGroups() {
+        return getGroupManager().getLoadedGroups();
+    }

    /**
     * Check if a group is loaded in memory
+     *
     * @param name the name to check for
     * @return true if the group is loaded
     * @throws NullPointerException if the name is null
     */
-    boolean isGroupLoaded(String name);
+    default boolean isGroupLoaded(@Nonnull String name) {
+        return getGroupManager().isLoaded(name);
+    }

    /**
     * Gets a wrapped track object from the track storage
+     *
     * @param name the name of the track to get
-     * @return a {@link Track} object, if one matching the name exists, or null if not
+     * @return a {@link Track} object, if one matching the name exists, or null
+     * if not
     * @throws NullPointerException if the name is null
     */
-    Track getTrack(String name);
+    @Nullable
+    default Track getTrack(@Nonnull String name) {
+        return getTrackManager().getTrack(name);
+    }

    /**
-     * Gets a wrapped track object from the track storage. This method does not return null, unlike {@link #getTrack}
+     * Gets a wrapped track object from the track storage.
+     *
+     * <p>This method does not return null, unlike {@link #getTrack}</p>
+     *
     * @param name the name of the track to get
     * @return an optional {@link Track} object
     * @throws NullPointerException if the name is null
     */
-    Optional<Track> getTrackSafe(String name);
+    @Nonnull
+    default Optional<Track> getTrackSafe(@Nonnull String name) {
+        return getTrackManager().getTrackOpt(name);
+    }

    /**
     * Gets a set of all loaded tracks.
+     *
     * @return a {@link Set} of {@link Track} objects
     */
-    Set<Track> getTracks();
+    @Nonnull
+    default Set<Track> getTracks() {
+        return getTrackManager().getLoadedTracks();
+    }

    /**
     * Check if a track is loaded in memory
+     *
     * @param name the name to check for
     * @return true if the track is loaded
     * @throws NullPointerException if the name is null
     */
-    boolean isTrackLoaded(String name);
+    default boolean isTrackLoaded(@Nonnull String name) {
+        return getTrackManager().isLoaded(name);
+    }
+
+    /**
+     * Returns a new LogEntry Builder instance
+     *
+     * @return a new builder
+     * @since 4.0
+     */
+    @Nonnull
+    default LogEntry.Builder newLogEntryBuilder() {
+        return getActionLogger().newEntryBuilder();
+    }

    /**
     * Returns a permission builder instance
+     *
     * @param permission the main permission node to build
     * @return a {@link Node.Builder} instance
     * @throws IllegalArgumentException if the permission is invalid
-     * @throws NullPointerException if the permission is null
+     * @throws NullPointerException     if the permission is null
     * @since 2.6
     */
-    Node.Builder buildNode(String permission) throws IllegalArgumentException;
+    @Nonnull
+    default Node.Builder buildNode(@Nonnull String permission) throws IllegalArgumentException {
+        return getNodeFactory().newBuilder(permission);
+    }

    /**
     * Register a custom context calculator to the server
-     * @param contextCalculator the context calculator to register. The type MUST be the player class of the platform.
+     *
+     * @param calculator the context calculator to register. The type MUST be the player class of the platform.
     * @throws ClassCastException if the type is not the player class of the platform.
     */
-    void registerContextCalculator(IContextCalculator<?> contextCalculator);
+    default void registerContextCalculator(@Nonnull ContextCalculator<?> calculator) {
+        getContextManager().registerCalculator(calculator);
+    }

    /**
-     * Registers a custom context listener to the server,
-     * @param contextListener the context listener to register. The type MUST be the player class of the platform.
-     * @throws ClassCastException if the type is not the player class of the platform.
+     * Gets a calculated context instance for the user using the rules of the platform.
+     *
+     * <p> These values are calculated using the options in the configuration, and the provided calculators.
+     *
+     * @param user the user to get contexts for
+     * @return an optional containing contexts. Will return empty if the user is not online.
     */
-    void registerContextListener(ContextListener<?> contextListener);
+    @Nonnull
+    default Optional<Contexts> getContextForUser(@Nonnull User user) {
+        return getContextManager().lookupApplicableContexts(user);
+    }
+
+    /**
+     * Gets set of contexts applicable to a player using the platforms {@link ContextCalculator}s.
+     *
+     * @param player the player to calculate for. Must be the player instance for the platform.
+     * @return a set of contexts.
+     * @since 2.17
+     */
+    @Nonnull
+    default ContextSet getContextForPlayer(@Nonnull Object player) {
+        return getContextManager().getApplicableContext(player);
+    }
+
+    /**
+     * Gets a Contexts instance for the player using the platforms {@link ContextCalculator}s.
+     *
+     * @param player the player to calculate for. Must be the player instance for the platform.
+     * @return a set of contexts.
+     * @since 3.3
+     */
+    @Nonnull
+    default Contexts getContextsForPlayer(@Nonnull Object player) {
+        return getContextManager().getApplicableContexts(player);
+    }

 }
@@ -0,0 +1,76 @@
+/*
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api;
+
+import javax.annotation.Nonnull;
+
+/**
+ * A means to push changes to other servers using the platforms networking
+ *
+ * @since 2.14
+ */
+public interface MessagingService {
+
+    /**
+     * Gets the name of this messaging service
+     *
+     * @return the name of this messaging service
+     * @since 4.1
+     */
+    String getName();
+
+    /**
+     * Uses the messaging service to inform other servers about a general
+     * change.
+     *
+     * <p>The standard response by other servers will be to execute a overall
+     * sync of all live data, equivalent to calling
+     * {@link LuckPermsApi#runUpdateTask()}.</p>
+     *
+     * <p>This will push the update asynchronously, and this method will return
+     * immediately. Note that this method will not cause an update to be
+     * processed on the local server.</p>
+     */
+    void pushUpdate();
+
+    /**
+     * Uses the messaging service to inform other servers about a change to a
+     * specific user.
+     *
+     * <p>The standard response by other servers is undefined, however the
+     * current implementation will reload the corresponding users data if they
+     * are online.</p>
+     *
+     * <p>This will push the update asynchronously, and this method will return
+     * immediately. Note that this method will not cause an update to be
+     * processed on the local server.</p>
+     *
+     * @param user the user to push the update for
+     * @since 4.1
+     */
+    void pushUserUpdate(@Nonnull User user);
+
+}
@@ -1,316 +0,0 @@
-/*
- * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
- *
- *  Permission is hereby granted, free of charge, to any person obtaining a copy
- *  of this software and associated documentation files (the "Software"), to deal
- *  in the Software without restriction, including without limitation the rights
- *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- *  copies of the Software, and to permit persons to whom the Software is
- *  furnished to do so, subject to the following conditions:
- *
- *  The above copyright notice and this permission notice shall be included in all
- *  copies or substantial portions of the Software.
- *
- *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- *  SOFTWARE.
- */
-
-package me.lucko.luckperms.api;
-
-import me.lucko.luckperms.LuckPerms;
-import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
-import me.lucko.luckperms.exceptions.ObjectLacksException;
-
-import java.util.HashSet;
-import java.util.Map;
-import java.util.Set;
-
-/**
- * A collection of utilities to help retrieve meta values for {@link PermissionHolder}s
- * @since 2.7
- */
-public class MetaUtils {
-
-    private MetaUtils(){}
-
-    /**
-     * Escapes special characters used within LuckPerms, so the string can be saved without issues
-     * @param s the string to escape
-     * @return an escaped string
-     * @throws NullPointerException if the string is null
-     */
-    public static String escapeCharacters(String s) {
-        if (s == null) {
-            throw new NullPointerException();
-        }
-        
-        s = s.replace(".", "{SEP}");
-        s = s.replace("/", "{FSEP}");
-        s = s.replace("$", "{DSEP}");
-
-        return s;
-    }
-
-    /**
-     * Unescapes special characters used within LuckPerms, the inverse of {@link #escapeCharacters(String)}
-     * @param s the string to unescape
-     * @return an unescaped string
-     * @throws NullPointerException if the string is null
-     */
-    public static String unescapeCharacters(String s) {
-        if (s == null) {
-            throw new NullPointerException();
-        }
-        
-        s = s.replace("{SEP}", ".");
-        s = s.replace("{FSEP}", "/");
-        s = s.replace("{DSEP}", "$");
-
-        return s;
-    }
-
-    /**
-     * Sets a meta value on a holder
-     * @param holder the holder to apply the meta node to
-     * @param server the server to apply the meta on, can be null
-     * @param world the world to apply the meta on, can be null
-     * @param node the meta node
-     * @param value the meta value
-     * @throws NullPointerException if the holder, node or value is null
-     * @throws IllegalArgumentException if the node or value is empty
-     */
-    public static void setMeta(PermissionHolder holder, String server, String world, String node, String value) {
-        if (holder == null) {
-            throw new NullPointerException("holder");
-        }
-        
-        if (node == null) {
-            throw new NullPointerException("node");
-        }
-
-        if (value == null) {
-            throw new NullPointerException("value");
-        }
-
-        if (node.equals("")) {
-            throw new IllegalArgumentException("node is empty");
-        }
-
-        if (value.equals("")) {
-            throw new IllegalArgumentException("value is empty");
-        }
-
-        if (server == null || server.equals("")) {
-            server = "global";
-        }
-        
-        node = escapeCharacters(node);
-        value = escapeCharacters(value);
-
-        Set<Node> toRemove = new HashSet<>();
-        for (Node n : holder.getEnduringPermissions()) {
-            if (n.isMeta() && n.getMeta().getKey().equals(node)) {
-                toRemove.add(n);
-            }
-        }
-        
-        for (Node n : toRemove) {
-            try {
-                holder.unsetPermission(n);
-            } catch (ObjectLacksException ignored) {}
-        }
-
-        Node.Builder metaNode = LuckPerms.getApi().buildNode("meta." + node + "." + value).setValue(true);
-        if (!server.equalsIgnoreCase("global")) {
-            metaNode.setServer(server);
-        }
-        if (world != null && !world.equals("")) {
-            metaNode.setServer(server).setWorld(world);
-        }
-
-        try {
-            holder.setPermission(metaNode.build());
-        } catch (ObjectAlreadyHasException ignored) {}
-    }
-
-    /**
-     * Gets a meta value for the holder
-     * @param holder the holder to get the meta from
-     * @param server the server to retrieve the meta on, can be null
-     * @param world the world to retrieve the meta on, can be null
-     * @param node the node to get
-     * @param defaultValue the default value to return if the node is not set
-     * @param includeGlobal if global nodes should be considered when retrieving the meta
-     * @return a meta string, or the default value if the user does not have the meta node
-     * @throws NullPointerException if the holder or node is null
-     * @throws IllegalArgumentException if the node is empty
-     */
-    public static String getMeta(PermissionHolder holder, String server, String world, String node, String defaultValue, boolean includeGlobal) {
-        if (holder == null) {
-            throw new NullPointerException("holder");
-        }
-
-        if (server == null || server.equals("")) {
-            server = "global";
-        }
-
-        if (node == null) {
-            throw new NullPointerException("node");
-        }
-
-        if (node.equals("")) {
-            throw new IllegalArgumentException("node is empty");
-        }
-
-        node = escapeCharacters(node);
-
-        for (Node n : holder.getPermissions()) {
-            if (!n.getValue()) {
-                continue;
-            }
-
-            if (!n.isMeta()) {
-                continue;
-            }
-
-            if (!server.equalsIgnoreCase("global")) {
-                if (!n.shouldApplyOnServer(server, includeGlobal, false)) {
-                    continue;
-                }
-            }
-
-            if (!n.shouldApplyOnWorld(world, includeGlobal, false)) {
-                continue;
-            }
-
-            Map.Entry<String, String> meta = n.getMeta();
-            if (meta.getKey().equalsIgnoreCase(node)) {
-                return unescapeCharacters(meta.getValue());
-            }
-        }
-
-        return defaultValue;
-    }
-
-    private static void setChatMeta(boolean prefix, PermissionHolder holder, String value, int priority, String server, String world) {
-        if (holder == null) {
-            throw new NullPointerException("holder");
-        }
-
-        if (value == null || value.equals("")) {
-            throw new IllegalArgumentException("value is null/empty");
-        }
-
-        Node.Builder node = LuckPerms.getApi().buildNode(prefix ? "prefix" : "suffix" + "." + priority + "." + escapeCharacters(value));
-        node.setValue(true);
-        if (!server.equalsIgnoreCase("global")) {
-            node.setServer(server);
-        }
-        if (world != null && !world.equals("")) {
-            node.setServer(server).setWorld(world);
-        }
-
-        try {
-            holder.setPermission(node.build());
-        } catch (ObjectAlreadyHasException ignored) {}
-    }
-
-    /**
-     * Adds a prefix to a holder on a specific server and world
-     * @param holder the holder to set the prefix for
-     * @param prefix the prefix value
-     * @param priority the priority to set the prefix at
-     * @param server the server to set the prefix on, can be null
-     * @param world the world to set the prefix on, can be null
-     * @throws NullPointerException if the holder is null
-     * @throws IllegalArgumentException if the prefix is null or empty
-     */
-    public static void setPrefix(PermissionHolder holder, String prefix, int priority, String server, String world) {
-        setChatMeta(true, holder, prefix, priority, server, world);
-    }
-
-    /**
-     * Adds a suffix to a holder on a specific server and world
-     * @param holder the holder to set the suffix for
-     * @param suffix the suffix value
-     * @param priority the priority to set the suffix at
-     * @param server the server to set the suffix on, can be null
-     * @param world the world to set the suffix on, can be null
-     * @throws NullPointerException if the holder is null
-     * @throws IllegalArgumentException if the suffix is null or empty
-     */
-    public static void setSuffix(PermissionHolder holder, String suffix, int priority, String server, String world) {
-        setChatMeta(false, holder, suffix, priority, server, world);
-    }
-
-    private static String getChatMeta(boolean prefix, PermissionHolder holder, String server, String world, boolean includeGlobal) {
-        if (holder == null) {
-            throw new NullPointerException("holder");
-        }
-        if (server == null) {
-            server = "global";
-        }
-
-        int priority = Integer.MIN_VALUE;
-        String meta = null;
-        for (Node n : holder.getAllNodes()) {
-            if (!n.getValue()) {
-                continue;
-            }
-
-            if (!server.equalsIgnoreCase("global")) {
-                if (!n.shouldApplyOnServer(server, includeGlobal, false)) {
-                    continue;
-                }
-            }
-
-            if (!n.shouldApplyOnWorld(world, includeGlobal, false)) {
-                continue;
-            }
-            
-            if (prefix ? !n.isPrefix() : !n.isSuffix()) {
-                continue;
-            }
-
-            Map.Entry<Integer, String> value = prefix ? n.getPrefix() : n.getSuffix();
-            if (value.getKey() > priority) {
-                meta = value.getValue();
-                priority = value.getKey();
-            }
-        }
-
-        return meta == null ? "" : unescapeCharacters(meta);
-    }
-
-    /**
-     * Returns a holders highest priority prefix, if they have one
-     * @param holder the holder
-     * @param server the server to retrieve the prefix on
-     * @param world the world to retrieve the prefix on
-     * @param includeGlobal if global nodes should be considered when retrieving the prefix
-     * @return a prefix string, if the holder has one, or an empty string if not.
-     * @throws NullPointerException if the holder is null
-     */
-    public static String getPrefix(PermissionHolder holder, String server, String world, boolean includeGlobal) {
-        return getChatMeta(true, holder, server, world, includeGlobal);
-    }
-
-    /**
-     * Returns a holders highest priority suffix, if they have one
-     * @param holder the holder
-     * @param server the server to retrieve the suffix on
-     * @param world the world to retrieve the suffix on
-     * @param includeGlobal if global nodes should be considered when retrieving the suffix
-     * @return a suffix string, if the holder has one, or an empty string if not.
-     * @throws NullPointerException if the holder is null
-     */
-    public static String getSuffix(PermissionHolder holder, String server, String world, boolean includeGlobal) {
-        return getChatMeta(false, holder, server, world, includeGlobal);
-    }
-    
-}
@@ -1,5 +1,8 @@
 /*
- * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
 *
 *  Permission is hereby granted, free of charge, to any person obtaining a copy
 *  of this software and associated documentation files (the "Software"), to deal
@@ -22,287 +25,550 @@

 package me.lucko.luckperms.api;

+import me.lucko.luckperms.api.context.ContextSet;
+
 import java.util.Date;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
+import java.util.Set;
+import java.util.stream.Stream;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import javax.annotation.concurrent.Immutable;

 /**
- * Represents an immutable node object
- * <p> Use {@link LuckPermsApi#buildNode(String)} to get an instance.
+ * Represents a LuckPerms "node".
+ *
+ * <p>The {@link Node} class encapsulates more than just permission assignments.
+ * Nodes are used to store data about inherited groups, as well as assigned
+ * prefixes, suffixes and meta values.</p>
+ *
+ * <p>Combining these various states into one object (a "node") means that a
+ * holder only has to have one type of data set (a set of nodes) in order to
+ * take on various properties.</p>
+ *
+ * <p>It is recommended that users of the API make use of {@link Stream}s
+ * to manipulate data and obtain the required information.</p>
+ *
+ * <p>This interface provides a number of methods to read the attributes of the
+ * node, as well as methods to query and extract additional state and properties
+ * from these settings.</p>
+ *
+ * <p>Nodes have the following attributes:</p>
+ * <p></p>
+ * <ul>
+ *     <li>{@link #getPermission() permission} - the actual permission string</li>
+ *     <li>{@link #getValuePrimitive() value} - the value of the node (false for negated)</li>
+ *     <li>{@link #isOverride() override} - if the node is marked as having special priority over other nodes</li>
+ *     <li>{@link #getServer() server} - the specific server where this node should apply</li>
+ *     <li>{@link #getWorld() world} - the specific world where this node should apply</li>
+ *     <li>{@link #getContexts() context} - the additional contexts required for this node to apply </li>
+ *     <li>{@link #getExpiry() expiry} - the time when this node should expire</li>
+ * </ul>
+ *
+ * <p>Nodes can also fall into the following sub categories.</p>
+ * <p></p>
+ * <ul>
+ *     <li>normal - just a regular permission</li>
+ *     <li>{@link #isGroupNode() group node} - a "group node" marks that the holder should inherit data from another group</li>
+ *     <li>{@link #isPrefix() prefix} - represents an assigned prefix</li>
+ *     <li>{@link #isSuffix() suffix} - represents an assigned suffix</li>
+ *     <li>{@link #isMeta() meta} - represents an assigned meta option</li>
+ * </ul>
+ *
+ * <p>The core node state must be immutable in all implementations.</p>
+ *
+ * @see NodeFactory for obtaining and constructing instances.
 * @since 2.6
 */
-@SuppressWarnings("unused")
-public interface Node extends Map.Entry<String, Boolean> {
+@Immutable
+public interface Node {

    /**
+     * Gets the permission string
+     *
     * @return the actual permission node
     */
+    @Nonnull
    String getPermission();

    /**
-     * Get what value the permission is set to. A negated node would return <code>false</code>.
+     * Gets the value.
+     *
+     * <p>A negated node would return a value of <code>false</code>.</p>
+     *
     * @return the permission's value
     */
-    @Override
-    Boolean getValue();
+    @Nonnull
+    default Boolean getValue() {
+        return getValuePrimitive();
+    }

    /**
+     * Gets the value.
+     *
+     * <p>A negated node would return a value of <code>false</code>.</p>
+     *
+     * @return the permission's value
+     */
+    boolean getValuePrimitive();
+
+    /**
+     * Gets the value of this node as a {@link Tristate}
+     *
     * @return the value of this node as a Tristate
     */
-    Tristate getTristate();
+    @Nonnull
+    default Tristate getTristate() {
+        return Tristate.fromBoolean(getValuePrimitive());
+    }

    /**
+     * Gets if the node is negated
+     *
     * @return true if the node is negated
     */
-    boolean isNegated();
+    default boolean isNegated() {
+        return !getValuePrimitive();
+    }

    /**
-     * If this node is set to override explicitly.
-     * This value does not persist across saves, and is therefore only useful for transient nodes
+     * Gets if this node is set to override explicitly.
+     *
+     * <p>This value does not persist across saves, and is therefore only useful for transient nodes</p>
+     *
     * @return true if this node is set to override explicitly
     */
    boolean isOverride();

    /**
     * Gets the server this node applies on, if the node is server specific
+     *
     * @return an {@link Optional} containing the server, if one is defined
     */
+    @Nonnull
    Optional<String> getServer();

    /**
     * Gets the world this node applies on, if the node is world specific
+     *
     * @return an {@link Optional} containing the world, if one is defined
     */
+    @Nonnull
    Optional<String> getWorld();

    /**
+     * Gets if this node is server specific
+     *
     * @return true if this node is server specific
     */
    boolean isServerSpecific();

    /**
+     * Gets if this node is server specific
+     *
     * @return true if this node is server specific
     */
    boolean isWorldSpecific();

    /**
-     * If this node should apply on a specific server
-     * @param server the name of the server
-     * @param includeGlobal if global permissions should apply
-     * @param applyRegex if regex should be applied
-     * @return true if the node should apply
+     * Gets if this node applies globally, and therefore has no specific context
+     *
+     * @return true if this node applies globally, and has no specific context
+     * @since 3.1
     */
-    boolean shouldApplyOnServer(String server, boolean includeGlobal, boolean applyRegex);
+    boolean appliesGlobally();

    /**
-     * If this node should apply on a specific world
-     * @param world the name of the world
-     * @param includeGlobal if global permissions should apply
-     * @param applyRegex if regex should be applied
-     * @return true if the node should apply
+     * Gets if this node has any specific context in order for it to apply
+     *
+     * @return true if this node has specific context
+     * @since 3.1
     */
-    boolean shouldApplyOnWorld(String world, boolean includeGlobal, boolean applyRegex);
+    boolean hasSpecificContext();

    /**
-     * If this node should apply in the given context
-     * @param context the context key value pairs
-     * @param worldAndServer if world and server contexts should be checked
-     * @return true if the node should apply
-     */
-    boolean shouldApplyWithContext(Map<String, String> context, boolean worldAndServer);
-
-    /**
-     * If this node should apply in the given context
+     * Gets if this node should apply in the given context
+     *
     * @param context the context key value pairs
     * @return true if the node should apply
+     * @since 2.13
     */
-    boolean shouldApplyWithContext(Map<String, String> context);
-
-    /**
-     * Similar to {@link #shouldApplyOnServer(String, boolean, boolean)}, except this method accepts a List
-     * @param servers the list of servers
-     * @param includeGlobal if global permissions should apply
-     * @return true if the node should apply
-     */
-    boolean shouldApplyOnAnyServers(List<String> servers, boolean includeGlobal);
-
-    /**
-     * Similar to {@link #shouldApplyOnWorld(String, boolean, boolean)}, except this method accepts a List
-     * @param worlds the list of world
-     * @param includeGlobal if global permissions should apply
-     * @return true if the node should apply
-     */
-    boolean shouldApplyOnAnyWorlds(List<String> worlds, boolean includeGlobal);
-
-    /**
-     * Resolves a list of wildcards that match this node
-     * @param possibleNodes a list of possible permission nodes
-     * @return a list of permissions that match this wildcard
-     */
-    List<String> resolveWildcard(List<String> possibleNodes);
+    boolean shouldApplyWithContext(@Nonnull ContextSet context);

    /**
     * Resolves any shorthand parts of this node and returns the full list
+     *
     * @return a list of full nodes
     */
+    @Nonnull
    List<String> resolveShorthand();

    /**
+     * Gets if this node will expire in the future
+     *
     * @return true if this node will expire in the future
     */
    boolean isTemporary();

    /**
+     * Gets if this node will not expire
+     *
     * @return true if this node will not expire
     */
-    boolean isPermanent();
+    default boolean isPermanent() {
+        return !isTemporary();
+    }

    /**
+     * Gets a unix timestamp in seconds when this node will expire
+     *
     * @return the time in Unix time when this node will expire
     * @throws IllegalStateException if the node is not temporary
     */
-    long getExpiryUnixTime();
+    long getExpiryUnixTime() throws IllegalStateException;

    /**
+     * Gets the date when this node will expire
+     *
     * @return the {@link Date} when this node will expire
     * @throws IllegalStateException if the node is not temporary
     */
-    Date getExpiry();
+    @Nonnull
+    Date getExpiry() throws IllegalStateException;

    /**
+     * Gets the number of seconds until this permission will expire
+     *
     * @return the number of seconds until this permission will expire
     * @throws IllegalStateException if the node is not temporary
     */
-    long getSecondsTilExpiry();
+    long getSecondsTilExpiry() throws IllegalStateException;

    /**
-     * Return true if the node has expired.
-     * This also returns false if the node is not temporary
+     * Gets if the node has expired.
+     *
+     * <p>This also returns false if the node is not temporary.</p>
     *
     * @return true if this node has expired
     */
    boolean hasExpired();

    /**
+     * Gets the extra contexts required for this node to apply
+     *
     * @return the extra contexts required for this node to apply
+     * @since 2.13
     */
-    Map<String, String> getExtraContexts();
+    @Nonnull
+    ContextSet getContexts();

    /**
-     * Converts this node into a serialized form
-     * @return a serialized node string
+     * The same as {@link #getContexts()}, but also includes values for "server" and "world" keys if present.
+     *
+     * @return the full contexts required for this node to apply
+     * @since 3.1
     */
-    String toSerializedNode();
+    @Nonnull
+    ContextSet getFullContexts();

    /**
+     * Gets if this is a group node
+     *
     * @return true if this is a group node
     */
    boolean isGroupNode();

    /**
+     * Gets the name of the group, if this is a group node.
+     *
     * @return the name of the group
     * @throws IllegalStateException if this is not a group node. See {@link #isGroupNode()}
     */
-    String getGroupName();
+    @Nonnull
+    String getGroupName() throws IllegalStateException;

    /**
-     * @return true is this node is a wildcard node
+     * Gets if this node is a wildcard node
+     *
+     * @return true if this node is a wildcard node
     */
    boolean isWildcard();

    /**
     * Gets the level of this wildcard, higher is more specific
+     *
     * @return the wildcard level
     * @throws IllegalStateException if this is not a wildcard
     */
-    int getWildcardLevel();
+    int getWildcardLevel() throws IllegalStateException;

    /**
+     * Gets if this node is a meta node
+     *
     * @return true if this node is a meta node
     */
    boolean isMeta();

    /**
     * Gets the meta value from this node
+     *
     * @return the meta value
     * @throws IllegalStateException if this node is not a meta node
     */
-    Map.Entry<String, String> getMeta();
+    @Nonnull
+    Map.Entry<String, String> getMeta() throws IllegalStateException;

    /**
+     * Gets if this node is a prefix node
+     *
     * @return true if this node is a prefix node
     */
    boolean isPrefix();

    /**
     * Gets the prefix value from this node
+     *
     * @return the prefix value
     * @throws IllegalStateException if this node is a not a prefix node
     */
-    Map.Entry<Integer, String> getPrefix();
+    @Nonnull
+    Map.Entry<Integer, String> getPrefix() throws IllegalStateException;

    /**
+     * Gets if this node is a suffix node
+     *
     * @return true if this node is a suffix node
     */
    boolean isSuffix();

    /**
     * Gets the suffix value from this node
+     *
     * @return the suffix value
     * @throws IllegalStateException if this node is a not a suffix node
     */
-    Map.Entry<Integer, String> getSuffix();
+    @Nonnull
+    Map.Entry<Integer, String> getSuffix() throws IllegalStateException;

    /**
-     * Checks if this Node is equal to another node
+     * Returns if this Node is equal to another node
+     *
     * @param obj the other node
     * @return true if this node is equal to the other provided
-     * @see #equalsIgnoringValue(Node) for a less strict implementation of this method
+     * @see StandardNodeEquality#EXACT
     */
+    @Override
    boolean equals(Object obj);

    /**
-     * Similar to {@link Node#equals(Object)}, except doesn't take note of the value
+     * Returns if this Node is equal to another node as defined by the given
+     * {@link StandardNodeEquality} predicate.
+     *
     * @param other the other node
-     * @return true if the two nodes are almost equal
+     * @param equalityPredicate the predicate
+     * @return true if this node is considered equal
+     * @since 4.1
     */
-    boolean equalsIgnoringValue(Node other);
+    boolean standardEquals(Node other, StandardNodeEquality equalityPredicate);

    /**
-     * Similar to {@link Node#equals(Object)}, except doesn't take note of the expiry time or value
+     * Returns if this Node is equal to another node as defined by the given
+     * {@link NodeEqualityPredicate}.
+     *
     * @param other the other node
-     * @return true if the two nodes are almost equal
+     * @param equalityPredicate the predicate
+     * @return true if this node is considered equal
+     * @since 4.1
     */
-    boolean almostEquals(Node other);
+    default boolean equals(Node other, NodeEqualityPredicate equalityPredicate) {
+        return equalityPredicate.areEqual(this, other);
+    }

    /**
-     * Similar to {@link Node#equals(Object)}, except doesn't take note of the value or if the node is temporary
+     * Similar to {@link Node#equals(Object)}, except doesn't take note of the
+     * value.
+     *
+     * @param other the other node
+     * @return true if the two nodes are almost equal
+     * @deprecated in favour of {@link #equals(Node, NodeEqualityPredicate)}
+     * @see StandardNodeEquality#IGNORE_VALUE
+     */
+    @Deprecated
+    default boolean equalsIgnoringValue(@Nonnull Node other) {
+        return equals(other, StandardNodeEquality.IGNORE_VALUE);
+    }
+
+    /**
+     * Similar to {@link Node#equals(Object)}, except doesn't take note of the
+     * expiry time or value.
+     *
+     * @param other the other node
+     * @return true if the two nodes are almost equal
+     * @deprecated in favour of {@link #equals(Node, NodeEqualityPredicate)}
+     * @see StandardNodeEquality#IGNORE_EXPIRY_TIME_AND_VALUE
+     */
+    @Deprecated
+    default boolean almostEquals(@Nonnull Node other) {
+        return equals(other, StandardNodeEquality.IGNORE_EXPIRY_TIME_AND_VALUE);
+    }
+
+    /**
+     * Similar to {@link Node#equals(Object)}, except doesn't take note of the
+     * value or if the node is temporary.
+     *
     * @param other the other node
     * @return true if the two nodes are almost equal
     * @since 2.8
+     * @deprecated in favour of {@link #equals(Node, NodeEqualityPredicate)}
+     * @see StandardNodeEquality#IGNORE_VALUE_OR_IF_TEMPORARY
     */
-    boolean equalsIgnoringValueOrTemp(Node other);
+    @Deprecated
+    default boolean equalsIgnoringValueOrTemp(@Nonnull Node other) {
+        return equals(other, StandardNodeEquality.IGNORE_VALUE_OR_IF_TEMPORARY);
+    }
+
+    /**
+     * Constructs a new builder initially containing the current properties of
+     * this node.
+     *
+     * @return a new builder
+     * @since 4.1
+     */
+    Builder toBuilder();

    /**
     * Builds a Node instance
     */
    interface Builder {
+
+        /**
+         * Sets the value of negated for the node.
+         *
+         * @param negated the value
+         * @return the builder
+         * @see Node#isNegated()
+         */
+        @Nonnull
        Builder setNegated(boolean negated);
+
+        /**
+         * Sets the value of the node.
+         *
+         * @param value the value
+         * @return the builder
+         * @see Node#getValuePrimitive()
+         */
+        @Nonnull
        Builder setValue(boolean value);

        /**
-         * Warning: this value does not persist, and disappears when the holder is re-loaded.
-         * It is therefore only useful for transient nodes.
+         * Sets the override property for the node.
+         *
+         * <p>Warning: this value does not persist, and disappears when the holder is re-loaded.
+         * It is therefore only useful for transient nodes.</p>
+         *
+         * @param override the override state
+         * @return the builder
+         * @see Node#isOverride()
         */
+        @Nonnull
        Builder setOverride(boolean override);

+        /**
+         * Sets the nodes expiry as a unix timestamp in seconds.
+         *
+         * @param expireAt the expiry time
+         * @return the builder
+         * @see Node#getExpiryUnixTime()
+         */
+        @Nonnull
        Builder setExpiry(long expireAt);
-        Builder setWorld(String world);
-        Builder setServer(String server) throws IllegalArgumentException;
-        Builder withExtraContext(String key, String value);
-        Builder withExtraContext(Map<String, String> map);
-        Builder withExtraContext(Map.Entry<String, String> entry);
+
+        /**
+         * Sets the world value for the node.
+         *
+         * @param world the world value
+         * @return the builder
+         * @see Node#getWorld()
+         */
+        @Nonnull
+        Builder setWorld(@Nullable String world);
+
+        /**
+         * Sets the server value for the node.
+         *
+         * @param server the world value
+         * @return the builder
+         * @see Node#getServer()
+         */
+        @Nonnull
+        Builder setServer(@Nullable String server);
+
+        /**
+         * Appends an extra context onto the node.
+         *
+         * @param key the context key
+         * @param value the context value
+         * @return the builder
+         * @see ContextSet
+         * @see Node#getContexts()
+         */
+        @Nonnull
+        Builder withExtraContext(@Nonnull String key, @Nonnull String value);
+
+        /**
+         * Appends extra contexts onto the node.
+         *
+         * @param map a map of contexts
+         * @return the builder
+         * @see ContextSet
+         * @see Node#getContexts()
+         */
+        @Nonnull
+        Builder withExtraContext(@Nonnull Map<String, String> map);
+
+        /**
+         * Appends extra contexts onto the node.
+         *
+         * @param context a set of contexts
+         * @return the builder
+         * @see ContextSet
+         * @see Node#getContexts()
+         */
+        @Nonnull
+        Builder withExtraContext(@Nonnull Set<Map.Entry<String, String>> context);
+
+        /**
+         * Appends an extra context onto the node.
+         *
+         * @param entry the context
+         * @return the builder
+         * @see ContextSet
+         * @see Node#getContexts()
+         */
+        @Nonnull
+        Builder withExtraContext(@Nonnull Map.Entry<String, String> entry);
+
+        /**
+         * Appends extra contexts onto the node.
+         *
+         * @param set a contextset
+         * @return the builder
+         * @see ContextSet
+         * @see Node#getContexts()
+         */
+        @Nonnull
+        Builder withExtraContext(@Nonnull ContextSet set);
+
+        /**
+         * Creates a {@link Node} instance from the builder.
+         *
+         * @return a new node instance
+         */
+        @Nonnull
        Node build();
    }

@@ -0,0 +1,53 @@
+/*
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api;
+
+import javax.annotation.Nonnull;
+
+/**
+ * A rule for determining if two nodes are equal.
+ *
+ * <p>Generally, individual instances of this interface should fulfil the same
+ * requirements as the {@link Object#equals(Object)} contract.</p>
+ *
+ * <p>Some standard implementations are provided by
+ * {@link StandardNodeEquality}.</p>
+ *
+ * @since 4.1
+ */
+@FunctionalInterface
+public interface NodeEqualityPredicate {
+
+    /**
+     * Returns if the two nodes are equal
+     *
+     * @param o1 the first node
+     * @param o2 the second node
+     * @return true if equal
+     */
+    boolean areEqual(@Nonnull Node o1, @Nonnull Node o2);
+
+}
@@ -0,0 +1,127 @@
+/*
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api;
+
+import javax.annotation.Nonnull;
+
+/**
+ * Assists with constructing {@link Node} instances.
+ *
+ * @since 2.17
+ */
+public interface NodeFactory {
+
+    /**
+     * Creates a new node builder from a given base permission string
+     *
+     * @param permission the permission
+     * @return a node builder instance
+     * @throws NullPointerException if the permission is null
+     */
+    @Nonnull
+    Node.Builder newBuilder(@Nonnull String permission);
+
+    /**
+     * Creates a node builder instance from an existing node
+     *
+     * @param other the other node
+     * @return a node builder instance
+     * @throws NullPointerException if the other node is null
+     */
+    @Nonnull
+    Node.Builder newBuilderFromExisting(@Nonnull Node other);
+
+
+    /**
+     * Creates a node builder from a group
+     *
+     * @param group the group
+     * @return a node builder instance
+     * @throws NullPointerException  if the group is null
+     * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
+     * @since 3.1
+     */
+    @Nonnull
+    Node.Builder makeGroupNode(@Nonnull Group group);
+
+    /**
+     * Creates a node builder from a group
+     *
+     * @param groupName the name of the group
+     * @return a node builder instance
+     * @throws NullPointerException  if the groupName is null
+     * @since 4.0
+     */
+    @Nonnull
+    Node.Builder makeGroupNode(@Nonnull String groupName);
+
+    /**
+     * Creates a node builder from a key value pair
+     *
+     * @param key   the key
+     * @param value the value
+     * @return a node builder instance
+     * @throws NullPointerException if the key or value is null
+     */
+    @Nonnull
+    Node.Builder makeMetaNode(@Nonnull String key, @Nonnull String value);
+
+    /**
+     * Creates a node builder for the given chat meta type
+     *
+     * @param type the type
+     * @param priority the priority
+     * @param value the value for the prefix/suffix
+     * @return a node builder instance
+     * @throws NullPointerException if the type or value is null
+     * @since 3.2
+     */
+    @Nonnull
+    Node.Builder makeChatMetaNode(@Nonnull ChatMetaType type, int priority, @Nonnull String value);
+
+    /**
+     * Creates a node builder from a prefix string and priority
+     *
+     * @param priority the priority
+     * @param prefix   the prefix string
+     * @return a node builder instance
+     * @throws NullPointerException if the prefix is null
+     */
+    @Nonnull
+    Node.Builder makePrefixNode(int priority, @Nonnull String prefix);
+
+    /**
+     * Creates a node builder from a prefix string and priority
+     *
+     * @param priority the priority
+     * @param suffix   the suffix string
+     * @return a node builder instance
+     * @throws NullPointerException if the suffix is null
+     */
+    @Nonnull
+    Node.Builder makeSuffixNode(int priority, @Nonnull String suffix);
+
+}
@@ -0,0 +1,78 @@
+/*
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api;
+
+import javax.annotation.Nonnull;
+
+/**
+ * Standard {@link NodeEqualityPredicate}s.
+ *
+ * @since 4.1
+ */
+public enum StandardNodeEquality implements NodeEqualityPredicate {
+
+    /**
+     * Represents an exact match.
+     *
+     * <p>All attributes of the nodes must match for them to be considered
+     * equal.</p>
+     */
+    EXACT,
+
+    /**
+     * All attributes must match, except for
+     * {@link Node#getValuePrimitive() value}, which is ignored.
+     */
+    IGNORE_VALUE,
+
+    /**
+     * All attributes must match, except for the
+     * {@link Node#getExpiry() expiry time}, which is ignored.
+     *
+     * <p>Note that with this setting, whether a node is temporary or not is
+     * still considered.</p>
+     */
+    IGNORE_EXPIRY_TIME,
+
+    /**
+     * All attributes must match, except for
+     * {@link Node#getValuePrimitive() value} and the
+     * {@link Node#getExpiry() expiry time}, which are ignored.
+     */
+    IGNORE_EXPIRY_TIME_AND_VALUE,
+
+    /**
+     * All attributes must match, except for
+     * {@link Node#getValuePrimitive() value} and the if the node is
+     * {@link Node#isTemporary() temporary}, which are ignored.
+     */
+    IGNORE_VALUE_OR_IF_TEMPORARY;
+
+    @Override
+    public boolean areEqual(@Nonnull Node o1, @Nonnull Node o2) {
+        return o1.standardEquals(o2, this);
+    }
+}
@@ -0,0 +1,358 @@
+/*
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api;
+
+import me.lucko.luckperms.api.manager.GroupManager;
+import me.lucko.luckperms.api.manager.TrackManager;
+import me.lucko.luckperms.api.manager.UserManager;
+
+import java.util.List;
+import java.util.Set;
+import java.util.UUID;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.Executor;
+import java.util.function.Consumer;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
+/**
+ * A means of loading and saving permission data to/from the backend.
+ *
+ * <p>All blocking methods return {@link CompletableFuture}s, which will be
+ * populated with the result once the data has been loaded/saved asynchronously.
+ * Care should be taken when using such methods to ensure that the main server
+ * thread is not blocked.</p>
+ *
+ * <p>Methods such as {@link CompletableFuture#get()} and equivalent should
+ * <strong>not</strong> be called on the main server thread. If you need to use
+ * the result of these operations on the main server thread, register a
+ * callback using {@link CompletableFuture#thenAcceptAsync(Consumer, Executor)}.</p>
+ *
+ * @since 2.14
+ */
+public interface Storage {
+
+    /**
+     * Get the name of the storage implementation.
+     *
+     * @return the name of the implementation
+     */
+    @Nonnull
+    String getName();
+
+    /**
+     * Loads and returns the entire log from storage
+     *
+     * @return a log instance, could be null if loading failed
+     */
+    @Nonnull
+    CompletableFuture<Log> getLog();
+
+    /**
+     * Gets a set all "unique" user UUIDs.
+     *
+     * <p>"Unique" meaning the user isn't just a member of the "default" group.</p>
+     *
+     * @return a set of uuids, or null if the operation failed.
+     */
+    @Nonnull
+    CompletableFuture<Set<UUID>> getUniqueUsers();
+
+    /**
+     * Searches for a list of users with a given permission.
+     *
+     * @param permission the permission to search for
+     * @return a list of held permissions, or null if the operation failed
+     * @throws NullPointerException if the permission is null
+     * @since 2.17
+     */
+    @Nonnull
+    CompletableFuture<List<HeldPermission<UUID>>> getUsersWithPermission(@Nonnull String permission);
+
+    /**
+     * Searches for a list of groups with a given permission.
+     *
+     * @param permission the permission to search for
+     * @return a list of held permissions, or null if the operation failed
+     * @throws NullPointerException if the permission is null
+     * @since 2.17
+     */
+    @Nonnull
+    CompletableFuture<List<HeldPermission<String>>> getGroupsWithPermission(@Nonnull String permission);
+
+    /**
+     * Saves UUID caching data to the global cache
+     *
+     * @param username the users username
+     * @param uuid     the users mojang unique id
+     * @return true if the operation completed successfully.
+     * @throws NullPointerException     if either parameters are null
+     * @throws IllegalArgumentException if the username is invalid
+     */
+    @Nonnull
+    CompletableFuture<Boolean> saveUUIDData(@Nonnull String username, @Nonnull UUID uuid);
+
+    /**
+     * Gets a UUID from a username
+     *
+     * @param username the corresponding username
+     * @return a uuid object, could be null
+     * @throws NullPointerException     if either parameters are null
+     * @throws IllegalArgumentException if the username is invalid
+     */
+    @Nonnull
+    CompletableFuture<UUID> getUUID(@Nonnull String username);
+
+    /**
+     * Gets a username from a UUID
+     *
+     * @param uuid the corresponding uuid
+     * @return a name string, could be null
+     * @throws NullPointerException if either parameters are null
+     * @since 2.17
+     */
+    @Nonnull
+    CompletableFuture<String> getName(@Nonnull UUID uuid);
+
+    /**
+     * Gets whether the storage instance is allowing logins on the platform.
+     *
+     * @return true if logins are enabled
+     * @deprecated as this method always returns true.
+     */
+    @Deprecated
+    boolean isAcceptingLogins();
+
+    /**
+     * Returns an executor which will run all passed runnables on the
+     * main server thread.
+     *
+     * <p>This method is deprecated as plugins should create and use their own
+     * executor instances.</p>
+     *
+     * @return an executor instance
+     * @deprecated as plugins should create their own executors
+     */
+    @Nonnull
+    @Deprecated
+    Executor getSyncExecutor();
+
+    /**
+     * Returns an executor which will run all passed runnables asynchronously
+     * using the platforms scheduler and thread pools.
+     *
+     * <p>This method is deprecated as plugins should create and use their own
+     * executor instances.</p>
+     *
+     * @return an executor instance
+     * @deprecated as plugins should create their own executors
+     */
+    @Nonnull
+    @Deprecated
+    Executor getAsyncExecutor();
+
+    /**
+     * Saves an action to storage
+     *
+     * @param entry the log entry to be saved
+     * @return true if the operation completed successfully.
+     * @throws NullPointerException if entry is null
+     * @deprecated in favour of {@link ActionLogger#submit(LogEntry)}.
+     */
+    @Nonnull
+    @Deprecated
+    CompletableFuture<Boolean> logAction(@Nonnull LogEntry entry);
+
+    /**
+     * Loads a user's data from the main storage into the plugins local storage.
+     *
+     * @param uuid     the uuid of the user to load
+     * @param username the users username, or null if it is not known.
+     * @return if the operation completed successfully
+     * @throws NullPointerException if uuid is null
+     * @deprecated in favour of {@link UserManager#loadUser(UUID, String)}
+     */
+    @Nonnull
+    @Deprecated
+    CompletableFuture<Boolean> loadUser(@Nonnull UUID uuid, @Nullable String username);
+
+    /**
+     * Loads a user's data from the main storage into the plugins local storage.
+     *
+     * @param uuid the uuid of the user to load
+     * @return if the operation completed successfully
+     * @throws NullPointerException if uuid is null
+     * @deprecated in favour of {@link UserManager#loadUser(UUID)}
+     */
+    @Nonnull
+    @Deprecated
+    default CompletableFuture<Boolean> loadUser(@Nonnull UUID uuid) {
+        return loadUser(uuid, null);
+    }
+
+    /**
+     * Saves a user object back to storage.
+     *
+     * <p>You should call this after you make any changes to a user.</p>
+     *
+     * @param user the user to save
+     * @return true if the operation completed successfully.
+     * @throws NullPointerException  if user is null
+     * @throws IllegalStateException if the user instance was not obtained from LuckPerms.
+     * @deprecated in favour of {@link UserManager#saveUser(User)}
+     */
+    @Nonnull
+    @Deprecated
+    CompletableFuture<Boolean> saveUser(@Nonnull User user);
+
+    /**
+     * Creates and loads a group into the plugins local storage
+     *
+     * @param name the name of the group
+     * @return true if the operation completed successfully
+     * @throws NullPointerException     if name is null
+     * @throws IllegalArgumentException if the name is invalid
+     * @deprecated in favour of {@link GroupManager#createAndLoadGroup(String)}
+     */
+    @Nonnull
+    @Deprecated
+    CompletableFuture<Boolean> createAndLoadGroup(@Nonnull String name);
+
+    /**
+     * Loads a group into the plugins local storage.
+     *
+     * @param name the name of the group
+     * @return true if the operation completed successfully
+     * @throws NullPointerException     if name is null
+     * @throws IllegalArgumentException if the name is invalid
+     * @deprecated in favour of {@link GroupManager#loadGroup(String)}
+     */
+    @Nonnull
+    @Deprecated
+    CompletableFuture<Boolean> loadGroup(@Nonnull String name);
+
+    /**
+     * Loads all groups from the storage into memory
+     *
+     * @return true if the operation completed successfully.
+     * @deprecated in favour of {@link GroupManager#loadAllGroups()}
+     */
+    @Nonnull
+    @Deprecated
+    CompletableFuture<Boolean> loadAllGroups();
+
+    /**
+     * Saves a group back to storage.
+     *
+     * <p>You should call this after you make any changes to a group.</p>
+     *
+     * @param group the group to save
+     * @return true if the operation completed successfully.
+     * @throws NullPointerException  if group is null
+     * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
+     * @deprecated in favour of {@link GroupManager#saveGroup(Group)}
+     */
+    @Nonnull
+    @Deprecated
+    CompletableFuture<Boolean> saveGroup(@Nonnull Group group);
+
+    /**
+     * Permanently deletes a group from storage.
+     *
+     * @param group the group to delete
+     * @return true if the operation completed successfully.
+     * @throws NullPointerException  if group is null
+     * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
+     * @deprecated in favour of {@link GroupManager#deleteGroup(Group)}
+     */
+    @Nonnull
+    @Deprecated
+    CompletableFuture<Boolean> deleteGroup(@Nonnull Group group);
+
+    /**
+     * Creates and loads a track into the plugins local storage
+     *
+     * @param name the name of the track
+     * @return true if the operation completed successfully
+     * @throws NullPointerException     if name is null
+     * @throws IllegalArgumentException if the name is invalid
+     * @deprecated in favour of {@link TrackManager#createAndLoadTrack(String)}
+     */
+    @Nonnull
+    @Deprecated
+    CompletableFuture<Boolean> createAndLoadTrack(@Nonnull String name);
+
+    /**
+     * Loads a track into the plugins local storage.
+     *
+     * @param name the name of the track
+     * @return true if the operation completed successfully
+     * @throws NullPointerException     if name is null
+     * @throws IllegalArgumentException if the name is invalid
+     * @deprecated in favour of {@link TrackManager#loadTrack(String)}
+     */
+    @Nonnull
+    @Deprecated
+    CompletableFuture<Boolean> loadTrack(@Nonnull String name);
+
+    /**
+     * Loads all tracks from the storage into memory
+     *
+     * @return true if the operation completed successfully.
+     * @deprecated in favour of {@link TrackManager#loadAllTracks()}
+     */
+    @Nonnull
+    @Deprecated
+    CompletableFuture<Boolean> loadAllTracks();
+
+    /**
+     * Saves a track back to storage. You should call this after you make any changes to a track.
+     *
+     * @param track the track to save
+     * @return true if the operation completed successfully.
+     * @throws NullPointerException  if track is null
+     * @throws IllegalStateException if the track instance was not obtained from LuckPerms.
+     * @deprecated in favour of {@link TrackManager#saveTrack(Track)}
+     */
+    @Nonnull
+    @Deprecated
+    CompletableFuture<Boolean> saveTrack(@Nonnull Track track);
+
+    /**
+     * Permanently deletes a track from storage
+     *
+     * @param track the track to delete
+     * @return true if the operation completed successfully.
+     * @throws NullPointerException  if track is null
+     * @throws IllegalStateException if the track instance was not obtained from LuckPerms.
+     * @deprecated in favour of {@link TrackManager#deleteTrack(Track)}
+     */
+    @Nonnull
+    @Deprecated
+    CompletableFuture<Boolean> deleteTrack(@Nonnull Track track);
+
+}
@@ -1,5 +1,8 @@
 /*
- * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
 *
 *  Permission is hereby granted, free of charge, to any person obtaining a copy
 *  of this software and associated documentation files (the "Software"), to deal
@@ -22,111 +25,131 @@

 package me.lucko.luckperms.api;

-import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
-import me.lucko.luckperms.exceptions.ObjectLacksException;
-
 import java.util.List;

+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
 /**
- * Interface for internal Track instances
+ * An ordered chain of {@link Group}s.
 */
-@SuppressWarnings("unused")
 public interface Track {

    /**
+     * Gets the name of this track
+     *
     * @return the name of this track
     */
+    @Nonnull
    String getName();

    /**
-     * Gets an ordered list of the groups on this track
-     * Index 0 is the first/lowest group in (or start of) the track
+     * Gets a list of the groups on this track
+     *
+     * <p>Index 0 is the first/lowest group in (or start of) the track.</p>
+     *
+     * <p>The returned collection is immutable, and cannot be modified.</p>
+     *
     * @return an ordered {@link List} of the groups on this track
     */
+    @Nonnull
    List<String> getGroups();

    /**
     * Gets the number of groups on this track
+     *
     * @return the number of groups on this track
     */
    int getSize();

    /**
     * Gets the next group on the track, after the one provided
+     *
+     * <p>{@code null} is returned if the group is not on the track.</p>
+     *
     * @param current the group before the group being requested
     * @return the group name, or null if the end of the track has been reached
-     * @throws ObjectLacksException if the track does not contain the group given
-     * @throws NullPointerException if the group is null
+     * @throws NullPointerException  if the group is null
     * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
     */
-    String getNext(Group current) throws ObjectLacksException;
+    @Nullable
+    String getNext(@Nonnull Group current);

    /**
     * Gets the previous group on the track, before the one provided
+     *
+     * <p>{@code null} is returned if the group is not on the track.</p>
+     *
     * @param current the group after the group being requested
     * @return the group name, or null if the start of the track has been reached
-     * @throws ObjectLacksException if the track does not contain the group given
-     * @throws NullPointerException if the group is null
+     * @throws NullPointerException  if the group is null
     * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
     */
-    String getPrevious(Group current) throws ObjectLacksException;
+    @Nullable
+    String getPrevious(@Nonnull Group current);

    /**
     * Appends a group to the end of this track
+     *
     * @param group the group to append
-     * @throws ObjectAlreadyHasException if the group is already on this track somewhere
-     * @throws NullPointerException if the group is null
-     * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
+     * @return the result of the operation
+     * @throws NullPointerException      if the group is null
+     * @throws IllegalStateException     if the group instance was not obtained from LuckPerms.
     */
-    void appendGroup(Group group) throws ObjectAlreadyHasException;
+    DataMutateResult appendGroup(@Nonnull Group group);

    /**
     * Inserts a group at a certain position on this track
-     * @param group the group to be inserted
+     *
+     * @param group    the group to be inserted
     * @param position the index position (a value of 0 inserts at the start)
-     * @throws ObjectAlreadyHasException if the group is already on this track somewhere
+     * @return the result of the operation
     * @throws IndexOutOfBoundsException if the position is less than 0 or greater than the size of the track
-     * @throws NullPointerException if the group is null
-     * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
+     * @throws NullPointerException      if the group is null
+     * @throws IllegalStateException     if the group instance was not obtained from LuckPerms.
     */
-    void insertGroup(Group group, int position) throws ObjectAlreadyHasException, IndexOutOfBoundsException;
+    DataMutateResult insertGroup(@Nonnull Group group, int position) throws IndexOutOfBoundsException;

    /**
     * Removes a group from this track
+     *
     * @param group the group to remove
-     * @throws ObjectLacksException if the group is not on this track
-     * @throws NullPointerException if the group is null
+     * @return the result of the operation
+     * @throws NullPointerException  if the group is null
     * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
     */
-    void removeGroup(Group group) throws ObjectLacksException;
+    DataMutateResult removeGroup(@Nonnull Group group);

    /**
     * Removes a group from this track
+     *
     * @param group the group to remove
-     * @throws ObjectLacksException if the group is not on this track
+     * @return the result of the operation
     * @throws NullPointerException if the group is null
     */
-    void removeGroup(String group) throws ObjectLacksException;
+    DataMutateResult removeGroup(@Nonnull String group);

    /**
     * Checks if a group features on this track
+     *
     * @param group the group to check
     * @return true if the group is on this track
-     * @throws NullPointerException if the group is null
+     * @throws NullPointerException  if the group is null
     * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
     */
-    boolean containsGroup(Group group);
+    boolean containsGroup(@Nonnull Group group);

    /**
     * Checks if a group features on this track
+     *
     * @param group the group to check
     * @return true if the group is on this track
     * @throws NullPointerException if the group is null
     */
-    boolean containsGroup(String group);
+    boolean containsGroup(@Nonnull String group);

    /**
-     * Clear all of the groups within this track
+     * Clear all of the groups from this track
     */
    void clearGroups();

@@ -1,5 +1,8 @@
 /*
- * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
 *
 *  Permission is hereby granted, free of charge, to any person obtaining a copy
 *  of this software and associated documentation files (the "Software"), to deal
@@ -22,26 +25,77 @@

 package me.lucko.luckperms.api;

+import javax.annotation.Nonnull;
+
 /**
- * Represents a permission value
+ * Represents three different states of a setting.
+ *
+ * <p>Possible values:</p>
+ * <p></p>
+ * <ul>
+ *     <li>{@link #TRUE} - a positive setting</li>
+ *     <li>{@link #FALSE} - a negative (negated) setting</li>
+ *     <li>{@link #UNDEFINED} - a non-existent setting</li>
+ * </ul>
 */
 public enum Tristate {

+    /**
+     * A value indicating a positive setting
+     */
    TRUE(true),
+
+    /**
+     * A value indicating a negative (negated) setting
+     */
    FALSE(false),
+
+    /**
+     * A value indicating a non-existent setting
+     */
    UNDEFINED(false);

+    /**
+     * Returns a {@link Tristate} from a boolean
+     *
+     * @param val the boolean value
+     * @return {@link #TRUE} or {@link #FALSE}, if the value is <code>true</code> or <code>false</code>, respectively.
+     */
+    @Nonnull
+    public static Tristate fromBoolean(boolean val) {
+        return val ? TRUE : FALSE;
+    }
+
+    /**
+     * Returns a {@link Tristate} from a nullable boolean.
+     *
+     * <p>Unlike {@link #fromBoolean(boolean)}, this method returns {@link #UNDEFINED}
+     * if the value is null.</p>
+     *
+     * @param val the boolean value
+     * @return {@link #UNDEFINED}, {@link #TRUE} or {@link #FALSE}, if the value
+     *         is <code>null</code>, <code>true</code> or <code>false</code>, respectively.
+     * @since 4.1
+     */
+    @Nonnull
+    public static Tristate fromNullableBoolean(Boolean val) {
+        return val == null ? UNDEFINED : val ? TRUE : FALSE;
+    }
+
    private final boolean booleanValue;

    Tristate(boolean booleanValue) {
        this.booleanValue = booleanValue;
    }

+    /**
+     * Returns the value of the Tristate as a boolean.
+     *
+     * <p>A value of {@link #UNDEFINED} converts to false.</p>
+     *
+     * @return a boolean representation of the Tristate.
+     */
    public boolean asBoolean() {
-        return booleanValue;
-    }
-
-    public static Tristate fromBoolean(boolean b) {
-        return b ? TRUE : FALSE;
+        return this.booleanValue;
    }
 }
@@ -1,5 +1,8 @@
 /*
- * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
 *
 *  Permission is hereby granted, free of charge, to any person obtaining a copy
 *  of this software and associated documentation files (the "Software"), to deal
@@ -22,240 +25,88 @@

 package me.lucko.luckperms.api;

-import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
-import me.lucko.luckperms.exceptions.ObjectLacksException;
+import me.lucko.luckperms.api.caching.UserData;

-import java.util.List;
 import java.util.UUID;

+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
 /**
- * Interface for internal User instances
+ * A player which holds permission data.
 */
-@SuppressWarnings("unused")
 public interface User extends PermissionHolder {

    /**
+     * Gets the users unique ID
+     *
     * @return the users Mojang assigned unique id
     */
+    @Nonnull
    UUID getUuid();

    /**
-     * @return the Users Username
+     * Gets the users username
+     *
+     * <p>Returns null if no username is associated with this user.</p>
+     *
+     * @return the users username
     */
+    @Nullable
    String getName();

    /**
-     * Gets the users primary group
+     * Gets the users current primary group.
+     *
+     * <p>The result of this method depends on which method is configured for primary group calculation. It may not
+     * be the same as any value set through {@link #setPrimaryGroup(String)}.</p>
+     *
     * @return the users primary group
     */
+    @Nonnull
    String getPrimaryGroup();

    /**
-     * Sets a users primary group
+     * Sets a users primary group. This will only take effect if platform is using stored primary groups.
+     *
     * @param group the new primary group
-     * @throws ObjectAlreadyHasException if the user already has this set as their primary group
-     * @throws IllegalStateException if the user is not a member of that group
-     * @throws NullPointerException if the group is null
+     * @return if the change was applied successfully
+     * @throws IllegalStateException     if the user is not a member of that group
+     * @throws NullPointerException      if the group is null
     */
-    void setPrimaryGroup(String group) throws ObjectAlreadyHasException;
+    DataMutateResult setPrimaryGroup(@Nonnull String group);

    /**
-     * Refresh and re-assign the users permissions
+     * Gets the user's {@link UserData} cache.
+     *
+     * @return the users cached data.
+     * @since 3.2
     */
+    @Nonnull
+    @Override
+    UserData getCachedData();
+
+    /**
+     * Refresh and re-assign the users permissions.
+     *
+     * <p>This request is not buffered, and the refresh call will be ran directly. This should be called on an
+     * asynchronous thread.</p>
+     *
+     * @deprecated in favour of {@link #refreshCachedData()}.
+     */
+    @Deprecated
    void refreshPermissions();

    /**
-     * Check to see if the user is a member of a group
-     * @param group The group to check membership of
-     * @return true if the user is a member of the group
-     * @throws NullPointerException if the group is null
+     * Pre-calculates some values in the user's data cache.
+     *
+     * <p>Is it <b>not</b> necessary to call this method before
+     * using {@link #getCachedData()}.</p>
+     *
+     * @since 2.17
+     * @deprecated because use of this method is no longer necessary.
     */
-    boolean isInGroup(Group group);
-
-    /**
-     * Check to see if a user is a member of a group on a specific server
-     * @param group The group to check membership of
-     * @param server The server to check on
-     * @return true if the user is a member of the group
-     * @throws NullPointerException if the group or server is null
-     * @throws IllegalArgumentException if the server is invalid
-     */
-    boolean isInGroup(Group group, String server);
-
-    /**
-     * Check to see if a user is a member of a group on a specific server and world
-     * @param group The group to check membership of
-     * @param server The server to check on
-     * @param world The world to check on
-     * @return true if the user is a member of the group
-     * @throws NullPointerException if the group, server or world is null
-     * @throws IllegalArgumentException if the server or world is invalid
-     */
-    boolean isInGroup(Group group, String server, String world);
-
-    /**
-     * Add a user to a group
-     * @param group The group to add the user to
-     * @throws ObjectAlreadyHasException if the user is already a member of the group
-     * @throws NullPointerException if the group is null
-     * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
-     */
-    void addGroup(Group group) throws ObjectAlreadyHasException;
-
-    /**
-     * Add a user to a group on a specific server
-     * @param group The group to add the user to
-     * @param server The server to add the group on
-     * @throws ObjectAlreadyHasException if the user is already a member of the group on that server
-     * @throws NullPointerException if the group or server is null
-     * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
-     * @throws IllegalArgumentException if the server is invalid
-     */
-    void addGroup(Group group, String server) throws ObjectAlreadyHasException;
-
-    /**
-     * Add a user to a group on a specific server and world
-     * @param group The group to add the user to
-     * @param server The server to add the group on
-     * @param world The world to add the group on
-     * @throws ObjectAlreadyHasException if the user is already a member of the group on that server
-     * @throws NullPointerException if the group, server or world is null
-     * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
-     * @throws IllegalArgumentException if the server or world is invalid
-     */
-    void addGroup(Group group, String server, String world) throws ObjectAlreadyHasException;
-
-    /**
-     * Add a user to a group temporarily on a specific server
-     * @param group The group to add the user to
-     * @param expireAt when the group should expire
-     * @throws ObjectAlreadyHasException if the user is already a member of the group on that server
-     * @throws NullPointerException if the group is null
-     * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
-     * @throws IllegalArgumentException if the expiry time is in the past
-     */
-    void addGroup(Group group, long expireAt) throws ObjectAlreadyHasException;
-
-    /**
-     * Add a user to a group temporarily on a specific server
-     * @param group The group to add the user to
-     * @param server The server to add the group on
-     * @param expireAt when the group should expire
-     * @throws ObjectAlreadyHasException if the user is already a member of the group on that server
-     * @throws NullPointerException if the group or server is null
-     * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
-     * @throws IllegalArgumentException if the expiry time is in the past or the server is invalid
-     */
-    void addGroup(Group group, String server, long expireAt) throws ObjectAlreadyHasException;
-
-    /**
-     * Add a user to a group temporarily on a specific server and world
-     * @param group The group to add the user to
-     * @param server The server to add the group on
-     * @param world The world to add the group on
-     * @param expireAt when the group should expire
-     * @throws ObjectAlreadyHasException if the user is already a member of the group on that server
-     * @throws NullPointerException if the group, server or world is null
-     * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
-     * @throws IllegalArgumentException if the expiry time is in the past or the server/world is invalid
-     */
-    void addGroup(Group group, String server, String world, long expireAt) throws ObjectAlreadyHasException;
-
-    /**
-     * Remove the user from a group
-     * @param group the group to remove the user from
-     * @throws ObjectLacksException if the user isn't a member of the group
-     * @throws NullPointerException if the group is null
-     * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
-     */
-    void removeGroup(Group group) throws ObjectLacksException;
-
-    /**
-     * Remove the user from a group
-     * @param group the group to remove the user from
-     * @param temporary if the group being removed is temporary
-     * @throws ObjectLacksException if the user isn't a member of the group
-     * @throws NullPointerException if the group is null
-     * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
-     */
-    void removeGroup(Group group, boolean temporary) throws ObjectLacksException;
-
-    /**
-     * Remove the user from a group on a specific server
-     * @param group The group to remove the user from
-     * @param server The server to remove the group on
-     * @throws ObjectLacksException if the user isn't a member of the group
-     * @throws NullPointerException if the group or server is null
-     * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
-     * @throws IllegalArgumentException if the server is invalid
-     */
-    void removeGroup(Group group, String server) throws ObjectLacksException;
-
-    /**
-     * Remove the user from a group on a specific server and world
-     * @param group The group to remove the user from
-     * @param server The server to remove the group on
-     * @param world The world to remove the group on
-     * @throws ObjectLacksException if the user isn't a member of the group
-     * @throws NullPointerException if the group, server or world is null
-     * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
-     * @throws IllegalArgumentException if the server or world is invalid
-     */
-    void removeGroup(Group group, String server, String world) throws ObjectLacksException;
-
-    /**
-     * Remove the user from a group on a specific server
-     * @param group The group to remove the user from
-     * @param server The server to remove the group on
-     * @param temporary if the group being removed is temporary
-     * @throws ObjectLacksException if the user isn't a member of the group
-     * @throws NullPointerException if the group or server is null
-     * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
-     * @throws IllegalArgumentException if the expiry time is in the past or the server is invalid
-     */
-    void removeGroup(Group group, String server, boolean temporary) throws ObjectLacksException;
-
-    /**
-     * Remove the user from a group on a specific server and world
-     * @param group The group to remove the user from
-     * @param server The server to remove the group on
-     * @param world The world to remove the group on
-     * @param temporary if the group being removed is temporary
-     * @throws ObjectLacksException if the user isn't a member of the group
-     * @throws NullPointerException if the group, server or world is null
-     * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
-     * @throws IllegalArgumentException if the expiry time is in the past or the server/world is invalid
-     */
-    void removeGroup(Group group, String server, String world, boolean temporary) throws ObjectLacksException;
-
-    /**
-     * Clear all of the users permission nodes
-     */
-    void clearNodes();
-
-    /**
-     * Get a {@link List} of all of the groups the user is a member of, on all servers
-     * @return a {@link List} of group names
-     */
-    List<String> getGroupNames();
-
-    /**
-     * Get a {@link List} of the groups the user is a member of on a specific server
-     * @param server the server to check
-     * @param world the world to check
-     * @return a {@link List} of group names
-     * @throws NullPointerException if the server or world is null
-     * @throws IllegalArgumentException if the server or world is invalid
-     */
-    List<String> getLocalGroups(String server, String world);
-
-    /**
-     * Get a {@link List} of the groups the user is a member of on a specific server
-     * @param server the server to check
-     * @return a {@link List} of group names
-     * @throws NullPointerException if the server is null
-     * @throws IllegalArgumentException if the server is invalid
-     */
-    List<String> getLocalGroups(String server);
+    @Deprecated
+    void setupDataCache();

 }
@@ -1,5 +1,8 @@
 /*
- * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
 *
 *  Permission is hereby granted, free of charge, to any person obtaining a copy
 *  of this software and associated documentation files (the "Software"), to deal
@@ -24,34 +27,43 @@ package me.lucko.luckperms.api;

 import java.util.UUID;

+import javax.annotation.Nonnull;
+
 /**
- * A UUID cache for online users, between external Mojang UUIDs, and internal LuckPerms UUIDs.
+ * A UUID cache for online users, between external Mojang UUIDs, and internal
+ * LuckPerms UUIDs.
 *
- * <p> This UuidCache is a means of allowing users to have the same internal UUID across a network of offline mode servers
- * or mixed offline mode and online mode servers. Platforms running in offline mode generate a random UUID for a user when
- * they first join the server, but this UUID will then not be consistent across the network. LuckPerms will instead check
- * the datastore cache, to get a UUID for a user that is consistent across an entire network.
- *
- * <p> If you want to get a user object from the datastore using the api on a server in offline mode, you will need to use this cache,
- * OR use Datastore#getUUID, for users that are not online.
- *
- * <p> WARNING: THIS IS ONLY EFFECTIVE FOR ONLINE PLAYERS. USE THE DATASTORE METHODS FOR OFFLINE PLAYERS.
+ * @deprecated this feature is now handled internally - and the API returns a
+ *             No-op implementation of this class.
 */
-@SuppressWarnings("unused")
+@Deprecated
 public interface UuidCache {

    /**
-     * Gets a users internal "LuckPerms" UUID, from the one given by the server.
-     * @param external the UUID assigned by the server, through Player#getUniqueId or ProxiedPlayer#getUniqueId
+     * Gets a users "internal" LuckPerms UUID, from the one given by the server.
+     *
+     * <p>When <code>use-server-uuids</code> is true, this returns the same UUID
+     * instance.</p>
+     *
+     * @param mojangUuid the UUID assigned by the server, through
+     *                   <code>Player#getUniqueId</code> or
+     *                   <code>ProxiedPlayer#getUniqueId</code>
     * @return the corresponding internal UUID
     */
-    UUID getUUID(UUID external);
+    @Nonnull
+    @Deprecated
+    UUID getUUID(@Nonnull UUID mojangUuid);

    /**
-     * Gets a users external, server assigned or Mojang assigned unique id, from the internal one used within LuckPerms.
-     * @param internal the UUID used within LuckPerms, through User#getUuid
+     * Gets a users "external", server assigned unique id, from the internal
+     * one used within LuckPerms.
+     *
+     * @param internalUuid the UUID used within LuckPerms, through
+     *                     <code>User#getUuid</code>
     * @return the corresponding external UUID
     */
-    UUID getExternalUUID(UUID internal);
+    @Nonnull
+    @Deprecated
+    UUID getExternalUUID(@Nonnull UUID internalUuid);

 }
@@ -0,0 +1,409 @@
+/*
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api.caching;
+
+import me.lucko.luckperms.api.Contexts;
+import me.lucko.luckperms.api.PermissionHolder;
+
+import java.util.Set;
+import java.util.concurrent.CompletableFuture;
+
+import javax.annotation.Nonnull;
+
+/**
+ * Holds cached permission and meta lookup data for a {@link PermissionHolder}.
+ *
+ * <p>All calls will account for inheritance, as well as any default data provided by
+ * the platform. This calls are heavily cached and are therefore fast.</p>
+ *
+ * <p>For meta, both methods accepting {@link Contexts} and {@link MetaContexts} are provided. The only difference is that
+ * the latter allows you to define how the meta stack should be structured internally. Where {@link Contexts} are passed, the
+ * values from the configuration are used.</p>
+ *
+ * @since 4.0
+ */
+public interface CachedData {
+
+    /**
+     * Gets PermissionData from the cache, given a specified context.
+     *
+     * @param contexts the contexts to get the permission data in
+     * @return a permission data instance
+     * @throws NullPointerException if contexts is null
+     */
+    @Nonnull
+    PermissionData getPermissionData(@Nonnull Contexts contexts);
+
+    /**
+     * Gets MetaData from the cache, given a specified context.
+     *
+     * @param contexts the contexts to get the permission data in
+     * @return a meta data instance
+     * @throws NullPointerException if contexts is null
+     * @since 3.2
+     */
+    @Nonnull
+    MetaData getMetaData(@Nonnull MetaContexts contexts);
+
+    /**
+     * Gets MetaData from the cache, given a specified context.
+     *
+     * @param contexts the contexts to get the permission data in
+     * @return a meta data instance
+     * @throws NullPointerException if contexts is null
+     */
+    @Nonnull
+    MetaData getMetaData(@Nonnull Contexts contexts);
+
+    /**
+     * Calculates permission data, bypassing the cache.
+     *
+     * <p>The result of this operation is calculated each time the method is called.
+     * The result is not added to the internal cache.</p>
+     *
+     * <p>It is therefore highly recommended to use {@link #getPermissionData(Contexts)} instead.</p>
+     *
+     * <p>The use cases of this method are more around constructing one-time
+     * instances of {@link PermissionData}, without adding the result to the cache.</p>
+     *
+     * @param contexts the contexts to get permission data in
+     * @return a permission data instance
+     * @throws NullPointerException if contexts is null
+     */
+    @Nonnull
+    PermissionData calculatePermissions(@Nonnull Contexts contexts);
+
+    /**
+     * Calculates meta data, bypassing the cache.
+     *
+     * <p>The result of this operation is calculated each time the method is called.
+     * The result is not added to the internal cache.</p>
+     *
+     * <p>It is therefore highly recommended to use {@link #getMetaData(MetaContexts)} instead.</p>
+     *
+     * <p>The use cases of this method are more around constructing one-time
+     * instances of {@link MetaData}, without adding the result to the cache.</p>
+     *
+     * @param contexts the contexts to get meta data in
+     * @return a meta data instance
+     * @throws NullPointerException if contexts is null
+     * @since 3.2
+     */
+    @Nonnull
+    MetaData calculateMeta(@Nonnull MetaContexts contexts);
+
+    /**
+     * Calculates meta data, bypassing the cache.
+     *
+     * <p>The result of this operation is calculated each time the method is called.
+     * The result is not added to the internal cache.</p>
+     *
+     * <p>It is therefore highly recommended to use {@link #getMetaData(Contexts)} instead.</p>
+     *
+     * <p>The use cases of this method are more around constructing one-time
+     * instances of {@link MetaData}, without adding the result to the cache.</p>
+     *
+     * @param contexts the contexts to get meta data in
+     * @return a meta data instance
+     * @throws NullPointerException if contexts is null
+     */
+    @Nonnull
+    MetaData calculateMeta(@Nonnull Contexts contexts);
+
+    /**
+     * (Re)calculates permission data for a given context.
+     *
+     * <p>This method returns immediately in all cases. The (re)calculation is
+     * performed asynchronously and applied to the cache in the background.</p>
+     *
+     * <p>If there was a previous {@link PermissionData} instance associated with
+     * the given {@link Contexts}, then that instance will continue to be returned by
+     * {@link #getPermissionData(Contexts)} until the recalculation is completed.</p>
+     *
+     * <p>If there was no value calculated and cached prior to the call of this
+     * method, then one will be calculated.</p>
+     *
+     * @param contexts the contexts to recalculate in.
+     * @throws NullPointerException if contexts is null
+     */
+    void recalculatePermissions(@Nonnull Contexts contexts);
+
+    /**
+     * (Re)calculates meta data for a given context.
+     *
+     * <p>This method returns immediately in all cases. The (re)calculation is
+     * performed asynchronously and applied to the cache in the background.</p>
+     *
+     * <p>If there was a previous {@link MetaData} instance associated with
+     * the given {@link MetaContexts}, then that instance will continue to be returned by
+     * {@link #getMetaData(MetaContexts)} until the recalculation is completed.</p>
+     *
+     * <p>If there was no value calculated and cached prior to the call of this
+     * method, then one will be calculated.</p>
+     *
+     * @param contexts the contexts to recalculate in.
+     * @throws NullPointerException if contexts is null
+     * @since 3.2
+     */
+    void recalculateMeta(@Nonnull MetaContexts contexts);
+
+    /**
+     * (Re)calculates meta data for a given context.
+     *
+     * <p>This method returns immediately in all cases. The (re)calculation is
+     * performed asynchronously and applied to the cache in the background.</p>
+     *
+     * <p>If there was a previous {@link MetaData} instance associated with
+     * the given {@link Contexts}, then that instance will continue to be returned by
+     * {@link #getMetaData(Contexts)} until the recalculation is completed.</p>
+     *
+     * <p>If there was no value calculated and cached prior to the call of this
+     * method, then one will be calculated.</p>
+     *
+     * @param contexts the contexts to recalculate in.
+     * @throws NullPointerException if contexts is null
+     */
+    void recalculateMeta(@Nonnull Contexts contexts);
+
+    /**
+     * (Re)loads permission data for a given context.
+     *
+     * <p>Unlike {@link #recalculatePermissions(Contexts)}, this method immediately
+     * invalidates any previous {@link PermissionData} values contained within the cache,
+     * and then schedules a task to reload a new {@link PermissionData} instance to
+     * replace the one which was invalidated.</p>
+     *
+     * <p>The invalidation happens immediately during the execution of this method.
+     * The result of the re-computation encapsulated by the future.</p>
+     *
+     * <p>Subsequent calls to {@link #getPermissionData(Contexts)} will block until
+     * the result of this operation is complete.</p>
+     *
+     * <p>If there was no value calculated and cached prior to the call of this
+     * method, then one will be calculated.</p>
+     *
+     * <p>This method returns a Future so users can optionally choose to wait
+     * until the recalculation has been performed.</p>
+     *
+     * @param contexts the contexts to reload in.
+     * @throws NullPointerException if contexts is null
+     * @return a future
+     * @since 4.0
+     */
+    @Nonnull
+    CompletableFuture<? extends PermissionData> reloadPermissions(@Nonnull Contexts contexts);
+
+    /**
+     * (Re)loads meta data for a given context.
+     *
+     * <p>Unlike {@link #recalculateMeta(MetaContexts)}, this method immediately
+     * invalidates any previous {@link MetaData} values contained within the cache,
+     * and then schedules a task to reload a new {@link MetaData} instance to
+     * replace the one which was invalidated.</p>
+     *
+     * <p>The invalidation happens immediately during the execution of this method.
+     * The result of the re-computation encapsulated by the future.</p>
+     *
+     * <p>Subsequent calls to {@link #getMetaData(MetaContexts)} will block until
+     * the result of this operation is complete.</p>
+     *
+     * <p>If there was no value calculated and cached prior to the call of this
+     * method, then one will be calculated.</p>
+     *
+     * <p>This method returns a Future so users can optionally choose to wait
+     * until the recalculation has been performed.</p>
+     *
+     * @param contexts the contexts to reload in.
+     * @throws NullPointerException if contexts is null
+     * @return a future
+     * @since 4.0
+     */
+    @Nonnull
+    CompletableFuture<? extends MetaData> reloadMeta(@Nonnull MetaContexts contexts);
+
+    /**
+     * (Re)loads meta data for a given context.
+     *
+     * <p>Unlike {@link #recalculateMeta(Contexts)}, this method immediately
+     * invalidates any previous {@link MetaData} values contained within the cache,
+     * and then schedules a task to reload a new {@link MetaData} instance to
+     * replace the one which was invalidated.</p>
+     *
+     * <p>The invalidation happens immediately during the execution of this method.
+     * The result of the re-computation encapsulated by the future.</p>
+     *
+     * <p>Subsequent calls to {@link #getMetaData(Contexts)} will block until
+     * the result of this operation is complete.</p>
+     *
+     * <p>If there was no value calculated and cached prior to the call of this
+     * method, then one will be calculated.</p>
+     *
+     * <p>This method returns a Future so users can optionally choose to wait
+     * until the recalculation has been performed.</p>
+     *
+     * @param contexts the contexts to reload in.
+     * @throws NullPointerException if contexts is null
+     * @return a future
+     * @since 4.0
+     */
+    @Nonnull
+    CompletableFuture<? extends MetaData> reloadMeta(@Nonnull Contexts contexts);
+
+    /**
+     * Recalculates permission data for all known contexts.
+     *
+     * <p>This method returns immediately. The recalculation is performed
+     * asynchronously and applied to the cache in the background.</p>
+     *
+     * <p>The previous {@link PermissionData} instances will continue to be returned
+     * by {@link #getPermissionData(Contexts)} until the recalculation is completed.</p>
+     */
+    void recalculatePermissions();
+
+    /**
+     * Recalculates meta data for all known contexts.
+     *
+     * <p>This method returns immediately. The recalculation is performed
+     * asynchronously and applied to the cache in the background.</p>
+     *
+     * <p>The previous {@link MetaData} instances will continue to be returned
+     * by {@link #getMetaData(MetaContexts)} and {@link #getMetaData(Contexts)}
+     * until the recalculation is completed.</p>
+     */
+    void recalculateMeta();
+
+    /**
+     * Reloads permission data for all known contexts.
+     *
+     * <p>Unlike {@link #recalculatePermissions()}, this method immediately
+     * invalidates all previous {@link PermissionData} values contained within the cache,
+     * and then schedules a task to reload a new {@link PermissionData} instances to
+     * replace the ones which were invalidated.</p>
+     *
+     * <p>The invalidation happens immediately during the execution of this method.
+     * The result of the re-computation encapsulated by the future.</p>
+     *
+     * <p>Subsequent calls to {@link #getPermissionData(Contexts)} will block until
+     * the result of this operation is complete.</p>
+     *
+     * <p>This method returns a Future so users can optionally choose to wait
+     * until the recalculation has been performed.</p>
+     *
+     * @return a future
+     * @since 4.0
+     */
+    @Nonnull
+    CompletableFuture<Void> reloadPermissions();
+
+    /**
+     * Reloads meta data for all known contexts.
+     *
+     * <p>Unlike {@link #recalculateMeta()}, this method immediately
+     * invalidates all previous {@link MetaData} values contained within the cache,
+     * and then schedules a task to reload a new {@link MetaData} instances to
+     * replace the ones which were invalidated.</p>
+     *
+     * <p>The invalidation happens immediately during the execution of this method.
+     * The result of the re-computation encapsulated by the future.</p>
+     *
+     * <p>Subsequent calls to {@link #getMetaData(MetaContexts)} and
+     * {@link #getMetaData(Contexts)} will block until the result of this operation
+     * is complete.</p>
+     *
+     * <p>This method returns a Future so users can optionally choose to wait
+     * until the recalculation has been performed.</p>
+     *
+     * @return a future
+     * @since 4.0
+     */
+    @Nonnull
+    CompletableFuture<Void> reloadMeta();
+
+    /**
+     * Pre-calculates and caches {@link PermissionData} and {@link MetaData}
+     * instances for the given contexts.
+     *
+     * <p>If the cache already contains a value for the given context,
+     * no action is taken.</p>
+     *
+     * <p>This method blocks until the calculation is completed.</p>
+     *
+     * @param contexts a set of contexts
+     * @throws NullPointerException if contexts is null
+     */
+    default void preCalculate(@Nonnull Set<Contexts> contexts) {
+        contexts.forEach(this::preCalculate);
+    }
+
+    /**
+     * Pre-calculates and caches {@link PermissionData} and {@link MetaData}
+     * instances for a given context.
+     *
+     * <p>If the cache already contains a value for the given context,
+     * no action is taken.</p>
+     *
+     * <p>This method blocks until the calculation is completed.</p>
+     *
+     * @param contexts the contexts to pre-calculate for
+     * @throws NullPointerException if contexts is null
+     */
+    void preCalculate(@Nonnull Contexts contexts);
+
+    /**
+     * Invalidates any cached {@link PermissionData} instances mapped to the given
+     * {@link Contexts}.
+     *
+     * @param contexts the contexts to invalidate for
+     * @since 4.0
+     */
+    void invalidatePermissions(@Nonnull Contexts contexts);
+
+    /**
+     * Invalidates any cached {@link MetaData} instances mapped to the given
+     * {@link MetaContexts}.
+     *
+     * @param contexts the contexts to invalidate for
+     * @since 4.0
+     */
+    void invalidateMeta(@Nonnull MetaContexts contexts);
+
+    /**
+     * Invalidates any cached {@link MetaData} instances mapped to the given
+     * {@link Contexts}.
+     *
+     * @param contexts the contexts to invalidate for
+     * @since 4.0
+     */
+    void invalidateMeta(@Nonnull Contexts contexts);
+
+    /**
+     * Invalidates all of the underlying Permission calculators.
+     *
+     * <p>Can be called to allow for an update in defaults.</p>
+     */
+    void invalidatePermissionCalculators();
+
+}
@@ -0,0 +1,47 @@
+/*
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api.caching;
+
+import me.lucko.luckperms.api.Contexts;
+
+import javax.annotation.Nonnull;
+
+/**
+ * Holds cached lookup data in a specific set of contexts.
+ *
+ * @since 4.1
+ */
+public interface CachedDataContainer {
+
+    /**
+     * Gets the contexts this container is holding data for.
+     *
+     * @return the contexts this container is caching
+     */
+    @Nonnull
+    Contexts getContexts();
+
+}
@@ -0,0 +1,45 @@
+/*
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api.caching;
+
+import me.lucko.luckperms.api.Contexts;
+import me.lucko.luckperms.api.Group;
+
+/**
+ * Holds cached permission and meta lookup data for a {@link Group}.
+ *
+ * <p>All calls will account for inheritance, as well as any default data provided
+ * by the platform. This calls are heavily cached and are therefore fast.</p>
+ *
+ * <p>For meta, both methods accepting {@link Contexts} and {@link MetaContexts} are provided. The only difference is that
+ * the latter allows you to define how the meta stack should be structured internally. Where {@link Contexts} are passed, the
+ * values from the configuration are used.</p>
+ *
+ * @since 4.0
+ */
+public interface GroupData extends CachedData {
+
+}
@@ -0,0 +1,123 @@
+/*
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api.caching;
+
+import me.lucko.luckperms.api.Contexts;
+import me.lucko.luckperms.api.metastacking.MetaStackDefinition;
+
+import java.util.Objects;
+
+import javax.annotation.Nonnull;
+import javax.annotation.concurrent.Immutable;
+
+/**
+ * Encapsulates the options and settings for a meta lookup.
+ *
+ * <p>Consists of a standard {@link Contexts} element, plus options to define how
+ * the meta stack should be constructed.</p>
+ *
+ * @since 3.2
+ */
+@Immutable
+public final class MetaContexts {
+
+    /**
+     * Creates a new meta contexts instance
+     *
+     * @param contexts the standard contexts for the query
+     * @param prefixStackDefinition the prefix stack definition to be used
+     * @param suffixStackDefinition the suffix stack definition to be used
+     * @return the new instance
+     */
+    public static MetaContexts of(@Nonnull Contexts contexts, @Nonnull MetaStackDefinition prefixStackDefinition, @Nonnull MetaStackDefinition suffixStackDefinition) {
+        return new MetaContexts(contexts, prefixStackDefinition, suffixStackDefinition);
+    }
+
+    private final Contexts contexts;
+    private final MetaStackDefinition prefixStackDefinition;
+    private final MetaStackDefinition suffixStackDefinition;
+
+    // cache hashcode - this class is immutable, and is used as an index in the permission cache.
+    private final int hashCode;
+
+    /**
+     * Creates a new meta contexts instance
+     *
+     * @param contexts the standard contexts for the query
+     * @param prefixStackDefinition the prefix stack definition to be used
+     * @param suffixStackDefinition the suffix stack definition to be used
+     */
+    public MetaContexts(@Nonnull Contexts contexts, @Nonnull MetaStackDefinition prefixStackDefinition, @Nonnull MetaStackDefinition suffixStackDefinition) {
+        this.contexts = Objects.requireNonNull(contexts, "contexts");
+        this.prefixStackDefinition = Objects.requireNonNull(prefixStackDefinition, "prefixStackDefinition");
+        this.suffixStackDefinition = Objects.requireNonNull(suffixStackDefinition, "suffixStackDefinition");
+        this.hashCode = calculateHashCode();
+    }
+
+    @Nonnull
+    public Contexts getContexts() {
+        return this.contexts;
+    }
+
+    @Nonnull
+    public MetaStackDefinition getPrefixStackDefinition() {
+        return this.prefixStackDefinition;
+    }
+
+    @Nonnull
+    public MetaStackDefinition getSuffixStackDefinition() {
+        return this.suffixStackDefinition;
+    }
+
+    @Override
+    @Nonnull
+    public String toString() {
+        return "MetaContexts(" +
+                "contexts=" + this.getContexts() + ", " +
+                "prefixStackDefinition=" + this.getPrefixStackDefinition() + ", " +
+                "suffixStackDefinition=" + this.getSuffixStackDefinition() +
+                ")";
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (o == this) return true;
+        if (!(o instanceof MetaContexts)) return false;
+        final MetaContexts that = (MetaContexts) o;
+        return this.contexts.equals(that.contexts) &&
+                this.prefixStackDefinition.equals(that.prefixStackDefinition) &&
+                this.suffixStackDefinition.equals(that.suffixStackDefinition);
+    }
+
+    private int calculateHashCode() {
+        return Objects.hash(this.contexts, this.prefixStackDefinition, this.suffixStackDefinition);
+    }
+
+    @Override
+    public int hashCode() {
+        return this.hashCode;
+    }
+}
@@ -0,0 +1,131 @@
+/*
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api.caching;
+
+import com.google.common.collect.ListMultimap;
+
+import me.lucko.luckperms.api.metastacking.MetaStackDefinition;
+
+import java.util.Map;
+import java.util.SortedMap;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
+/**
+ * Holds cached meta lookup data for a specific set of contexts.
+ *
+ * @since 2.13
+ */
+public interface MetaData extends CachedDataContainer {
+
+    /**
+     * Gets the contexts this container is holding data for.
+     *
+     * @return the contexts this container is caching
+     */
+    @Nonnull
+    MetaContexts getMetaContexts();
+
+    /**
+     * Gets an immutable copy of the meta this user has.
+     *
+     * <p>A list multimap is used because when inherited values are included, each key can be
+     * mapped to multiple values.</p>
+     *
+     * <p>The first value to be accumulated (and used to represent the key in {@link #getMeta()} is at index 0
+     * in the list. Any additional values are stored in order of accumulation.</p>
+     *
+     * @return an immutable multimap of meta
+     * @since 3.3
+     */
+    @Nonnull
+    ListMultimap<String, String> getMetaMultimap();
+
+    /**
+     * Gets an immutable copy of the meta this user has.
+     *
+     * <p>This map is formed by taking the entries in {@link #getMetaMultimap()}, and mapping each key
+     * to the value at index 0 in the corresponding list.</p>
+     *
+     * @return an immutable map of meta
+     */
+    @Nonnull
+    Map<String, String> getMeta();
+
+    /**
+     * Gets an immutable sorted map of all of the prefixes the user has, whereby the first value is the highest priority
+     * prefix.
+     *
+     * @return a sorted map of prefixes
+     */
+    @Nonnull
+    SortedMap<Integer, String> getPrefixes();
+
+    /**
+     * Gets an immutable sorted map of all of the suffixes the user has, whereby the first value is the highest priority
+     * suffix.
+     *
+     * @return a sorted map of suffixes
+     */
+    @Nonnull
+    SortedMap<Integer, String> getSuffixes();
+
+    /**
+     * Gets the user's highest priority prefix, or null if the user has no prefixes
+     *
+     * @return a prefix string, or null
+     */
+    @Nullable
+    String getPrefix();
+
+    /**
+     * Gets the user's highest priority suffix, or null if the user has no suffixes
+     *
+     * @return a suffix string, or null
+     */
+    @Nullable
+    String getSuffix();
+
+    /**
+     * Gets the definition used for the prefix stack
+     *
+     * @return the definition used for the prefix stack
+     * @since 3.2
+     */
+    @Nonnull
+    MetaStackDefinition getPrefixStackDefinition();
+
+    /**
+     * Gets the definition used for the suffix stack
+     *
+     * @return the definition used for the suffix stack
+     * @since 3.2
+     */
+    @Nonnull
+    MetaStackDefinition getSuffixStackDefinition();
+
+}
@@ -0,0 +1,66 @@
+/*
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api.caching;
+
+import me.lucko.luckperms.api.Tristate;
+
+import java.util.Map;
+
+import javax.annotation.Nonnull;
+
+/**
+ * Holds cached permission lookup data for a specific set of contexts.
+ *
+ * @since 2.13
+ */
+public interface PermissionData extends CachedDataContainer {
+
+    /**
+     * Gets a permission check result for the given permission node.
+     *
+     * @param permission the permission node
+     * @return a tristate result
+     * @throws NullPointerException if permission is null
+     */
+    @Nonnull
+    Tristate getPermissionValue(@Nonnull String permission);
+
+    /**
+     * Invalidates the underlying permission calculator cache.
+     *
+     * <p>Can be called to allow for an update in defaults.</p>
+     */
+    void invalidateCache();
+
+    /**
+     * Gets an immutable copy of the permission map backing the permission calculator
+     *
+     * @return an immutable set of permissions
+     */
+    @Nonnull
+    Map<String, Boolean> getImmutableBacking();
+
+}
@@ -0,0 +1,45 @@
+/*
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api.caching;
+
+import me.lucko.luckperms.api.Contexts;
+import me.lucko.luckperms.api.User;
+
+/**
+ * Holds cached permission and meta lookup data for a {@link User}.
+ *
+ * <p>All calls will account for inheritance, as well as any default data provided by
+ * the platform. This calls are heavily cached and are therefore fast.</p>
+ *
+ * <p>For meta, both methods accepting {@link Contexts} and {@link MetaContexts} are provided. The only difference is that
+ * the latter allows you to define how the meta stack should be structured internally. Where {@link Contexts} are passed, the
+ * values from the configuration are used.</p>
+ *
+ * @since 2.13
+ */
+public interface UserData extends CachedData {
+
+}
@@ -0,0 +1,154 @@
+/*
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api.context;
+
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Multimap;
+
+import java.util.Collection;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+
+import javax.annotation.Nonnull;
+
+abstract class AbstractContextSet implements ContextSet {
+
+    protected abstract Multimap<String, String> backing();
+
+    @Nonnull
+    @Override
+    @Deprecated
+    public Map<String, String> toMap() {
+        ImmutableMap.Builder<String, String> m = ImmutableMap.builder();
+        for (Map.Entry<String, String> e : backing().entries()) {
+            m.put(e.getKey(), e.getValue());
+        }
+        return m.build();
+    }
+
+    @Override
+    public boolean containsKey(@Nonnull String key) {
+        return backing().containsKey(sanitizeKey(key));
+    }
+
+    @Nonnull
+    @Override
+    public Set<String> getValues(@Nonnull String key) {
+        Collection<String> values = backing().asMap().get(sanitizeKey(key));
+        return values != null ? ImmutableSet.copyOf(values) : ImmutableSet.of();
+    }
+
+    @Override
+    public boolean has(@Nonnull String key, @Nonnull String value) {
+        return backing().containsEntry(sanitizeKey(key), sanitizeValue(value));
+    }
+
+    @Override
+    public boolean hasIgnoreCase(@Nonnull String key, @Nonnull String value) {
+        String v = sanitizeValue(value);
+
+        Collection<String> values = backing().asMap().get(sanitizeKey(key));
+        if (values == null || values.isEmpty()) {
+            return false;
+        }
+
+        if (values.contains(v)) {
+            return true;
+        }
+
+        for (String val : values) {
+            if (val.equalsIgnoreCase(v)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return backing().isEmpty();
+    }
+
+    @Override
+    public int size() {
+        return backing().size();
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (o == this) return true;
+        if (!(o instanceof ContextSet)) return false;
+        final ContextSet that = (ContextSet) o;
+
+        final Multimap<String, String> otherContexts;
+
+        if (that instanceof AbstractContextSet) {
+            otherContexts = ((AbstractContextSet) that).backing();
+        } else {
+            otherContexts = that.toMultimap();
+        }
+
+        return backing().equals(otherContexts);
+    }
+
+    @Override
+    public int hashCode() {
+        return backing().hashCode();
+    }
+
+    static String sanitizeKey(String key) {
+        Objects.requireNonNull(key, "key is null");
+        if (stringIsEmpty(key)) {
+            throw new IllegalArgumentException("key is (effectively) empty");
+        }
+
+        return key.toLowerCase().intern();
+    }
+
+    static String sanitizeValue(String value) {
+        Objects.requireNonNull(value, "value is null");
+        if (stringIsEmpty(value)) {
+            throw new IllegalArgumentException("value is (effectively) empty");
+        }
+
+        return value.intern();
+    }
+
+    private static boolean stringIsEmpty(String s) {
+        if (s.isEmpty()) {
+            return true;
+        }
+        for (char c : s.toCharArray()) {
+            if (c != ' ') {
+                return false;
+            }
+        }
+        return true;
+    }
+
+}
@@ -1,5 +1,8 @@
 /*
- * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
 *
 *  Permission is hereby granted, free of charge, to any person obtaining a copy
 *  of this software and associated documentation files (the "Software"), to deal
@@ -22,53 +25,26 @@

 package me.lucko.luckperms.api.context;

-import java.util.List;
-import java.util.Map;
-import java.util.concurrent.CopyOnWriteArrayList;
+import javax.annotation.Nonnull;

 /**
- * A simple implementation of the listener aspects of {@link IContextCalculator<T>}
- * @param <T> the subject type
+ * Calculates whether contexts are applicable to {@link T}
+ *
+ * @param <T> the subject type. Is ALWAYS the player class of the platform.
+ * @since 2.13
 */
-public abstract class ContextCalculator<T> implements IContextCalculator<T> {
-    private final List<ContextListener<T>> listeners = new CopyOnWriteArrayList<>();
+@FunctionalInterface
+public interface ContextCalculator<T> {

    /**
-     * Pushes an update to all registered {@link ContextListener}s.
-     * Make sure any changes are applied internally before this method is called.
-     * @param subject the subject that changed
-     * @param before the context state before the change
-     * @param current the context state after the change (now)
-     * @throws NullPointerException if any parameters are null
+     * Gives the subject all of the applicable contexts they meet
+     *
+     * @param subject     the subject to add contexts to
+     * @param accumulator a map of contexts to add to
+     * @return the map
+     * @since 2.13
     */
-    protected void pushUpdate(T subject, Map.Entry<String, String> before, Map.Entry<String, String> current) {
-        if (subject == null) {
-            throw new NullPointerException("subject");
-        }
-        if (before == null) {
-            throw new NullPointerException("before");
-        }
-        if (current == null) {
-            throw new NullPointerException("current");
-        }
-
-        for (ContextListener<T> listener : listeners) {
-            try {
-                listener.onContextChange(subject, before, current);
-            } catch (Exception e) {
-                System.out.println("Exception whilst passing context change to listener: " + listener);
-                e.printStackTrace();
-            }
-        }
-    }
-
-    @Override
-    public void addListener(ContextListener<T> listener) {
-        if (listener == null) {
-            throw new NullPointerException("listener");
-        }
-
-        listeners.add(listener);
-    }
+    @Nonnull
+    MutableContextSet giveApplicableContext(@Nonnull T subject, @Nonnull MutableContextSet accumulator);

 }
@@ -0,0 +1,174 @@
+/*
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api.context;
+
+import me.lucko.luckperms.api.Contexts;
+import me.lucko.luckperms.api.User;
+
+import java.util.Optional;
+
+import javax.annotation.Nonnull;
+
+/**
+ * Manages {@link ContextCalculator}s, and calculates applicable contexts for a
+ * given type.
+ *
+ * This interface accepts {@link Object} types as a parameter to avoid having to depend
+ * on specific server implementations. In all cases, the "player" or "subject" type for
+ * the platform must be used.
+ *
+ * Specifically:
+ *
+ * <p></p>
+ * <ul>
+ *     <li>{@code org.bukkit.entity.Player}</li>
+ *     <li>{@code net.md_5.bungee.api.connection.ProxiedPlayer}</li>
+ *     <li>{@code org.spongepowered.api.service.permission.Subject}</li>
+ * </ul>
+ *
+ * @since 4.0
+ */
+public interface ContextManager {
+
+    /**
+     * Queries the ContextManager for current context values for the subject.
+     *
+     * @param subject the subject
+     * @return the applicable context for the subject
+     */
+    @Nonnull
+    ImmutableContextSet getApplicableContext(@Nonnull Object subject);
+
+    /**
+     * Queries the ContextManager for current context values for the subject.
+     *
+     * @param subject the subject
+     * @return the applicable context for the subject
+     */
+    @Nonnull
+    Contexts getApplicableContexts(@Nonnull Object subject);
+
+    /**
+     * Queries the ContextManager for current context values for the given User.
+     *
+     * <p>This will only return a value if the player corresponding to the
+     * {@link User} is online.</p>
+     *
+     * <p>If you need to be a {@link Contexts} instance regardless, you should
+     * initially try this method, and then fallback on {@link #getStaticContext()}.</p>
+     *
+     * @param user the user
+     * @return the applicable context for the subject
+     */
+    @Nonnull
+    Optional<ImmutableContextSet> lookupApplicableContext(@Nonnull User user);
+
+    /**
+     * Queries the ContextManager for current context values for the given User.
+     *
+     * <p>This will only return a value if the player corresponding to the
+     * {@link User} is online.</p>
+     *
+     * <p>If you need to be a {@link Contexts} instance regardless, you should
+     * initially try this method, and then fallback on {@link #getStaticContexts()}.</p>
+     *
+     * @param user the user
+     * @return the applicable context for the subject
+     */
+    @Nonnull
+    Optional<Contexts> lookupApplicableContexts(@Nonnull User user);
+
+    /**
+     * Gets the contexts from the static calculators in this manager.
+     *
+     * <p>Static calculators provide the same context for all subjects, and are
+     * marked as such when registered.</p>
+     *
+     * @return the current active static contexts
+     */
+    @Nonnull
+    ImmutableContextSet getStaticContext();
+
+    /**
+     * Gets the contexts from the static calculators in this manager.
+     *
+     * <p>Static calculators provide the same context for all subjects, and are
+     * marked as such when registered.</p>
+     *
+     * @return the current active static contexts
+     */
+    @Nonnull
+    Contexts getStaticContexts();
+
+    /**
+     * Forms a {@link Contexts} instance from an {@link ImmutableContextSet}.
+     *
+     * <p>This method relies on the plugins configuration to form the
+     * {@link Contexts} instance.</p>
+     *
+     * @param subject the reference subject
+     * @param contextSet the context set
+     * @return a contexts instance
+     */
+    @Nonnull
+    Contexts formContexts(@Nonnull Object subject, @Nonnull ImmutableContextSet contextSet);
+
+    /**
+     * Forms a {@link Contexts} instance from an {@link ImmutableContextSet}.
+     *
+     * <p>This method relies on the plugins configuration to form the
+     * {@link Contexts} instance.</p>
+     *
+     * @param contextSet the context set
+     * @return a contexts instance
+     */
+    @Nonnull
+    Contexts formContexts(@Nonnull ImmutableContextSet contextSet);
+
+    /**
+     * Registers a context calculator with the manager.
+     *
+     * @param calculator the calculator
+     */
+    void registerCalculator(@Nonnull ContextCalculator<?> calculator);
+
+    /**
+     * Registers a static context calculator with the manager.
+     *
+     * <p>Static calculators provide the same context for all subjects.</p>
+     *
+     * @param calculator the calculator
+     */
+    void registerStaticCalculator(@Nonnull StaticContextCalculator calculator);
+
+    /**
+     * Invalidates the lookup cache for a given subject
+     *
+     * @param subject the subject
+     */
+    void invalidateCache(@Nonnull Object subject);
+
+}
@@ -0,0 +1,404 @@
+/*
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api.context;
+
+import com.google.common.collect.Multimap;
+
+import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.Set;
+
+import javax.annotation.Nonnull;
+
+/**
+ * A set of contexts.
+ *
+ * <p>Context in the most basic sense simply means the circumstances where
+ * something will apply.</p>
+ *
+ * <p>A single "context" consists of a key and a value, both strings. The key
+ * represents the type of context, and the value represents the setting of the
+ * context key.</p>
+ *
+ * <p>Contexts can be combined with each other to form so called
+ * "context sets" - simply a collection of context pairs.</p>
+ *
+ * <p>Context keys are case-insensitive, and will be converted to
+ * {@link String#toLowerCase() lowercase} by all implementations.
+ * Values however are case-sensitive.</p>
+ *
+ * <p>Context keys and values may not be null or empty. A key/value will be
+ * deemed empty if it's length is zero, or if it consists of only space
+ * characters.</p>
+ *
+ * <p>Two default ContextSet implementations are provided.
+ * {@link MutableContextSet} allows the addition and removal of context keys
+ * after construction, and {@link ImmutableContextSet} does not.</p>
+ *
+ * @since 2.13
+ */
+public interface ContextSet {
+
+    /**
+     * Creates an {@link ImmutableContextSet} from a context pair.
+     *
+     * @param key   the key
+     * @param value the value
+     * @return a new ImmutableContextSet containing one context pair
+     * @throws NullPointerException if key or value is null
+     */
+    @Nonnull
+    static ImmutableContextSet singleton(@Nonnull String key, @Nonnull String value) {
+        return ImmutableContextSet.singleton(key, value);
+    }
+
+    /**
+     * Creates an {@link ImmutableContextSet} from two context pairs.
+     *
+     * @param key1 the first key
+     * @param value1 the first value
+     * @param key2 the second key
+     * @param value2 the second value
+     * @return a new ImmutableContextSet containing the two pairs
+     * @throws NullPointerException if any of the keys or values are null
+     * @since 3.1
+     */
+    @Nonnull
+    static ImmutableContextSet of(@Nonnull String key1, @Nonnull String value1, @Nonnull String key2, @Nonnull String value2) {
+        return ImmutableContextSet.of(key1, value1, key2, value2);
+    }
+
+    /**
+     * Creates an {@link ImmutableContextSet} from an existing {@link Iterable} of {@link Map.Entry}s.
+     *
+     * @param iterable the iterable to copy from
+     * @return a new ImmutableContextSet representing the pairs in the iterable
+     * @throws NullPointerException if the iterable is null
+     */
+    @Nonnull
+    static ImmutableContextSet fromEntries(@Nonnull Iterable<? extends Map.Entry<String, String>> iterable) {
+        return ImmutableContextSet.fromEntries(iterable);
+    }
+
+    /**
+     * Creates an {@link ImmutableContextSet} from an existing {@link Map}.
+     *
+     * @param map the map to copy from
+     * @return a new ImmutableContextSet representing the pairs from the map
+     * @throws NullPointerException if the map is null
+     */
+    @Nonnull
+    static ImmutableContextSet fromMap(@Nonnull Map<String, String> map) {
+        return ImmutableContextSet.fromMap(map);
+    }
+
+    /**
+     * Creates an {@link ImmutableContextSet} from an existing {@link Multimap}.
+     *
+     * @param multimap the multimap to copy from
+     * @return a new ImmutableContextSet representing the pairs in the multimap
+     * @throws NullPointerException if the multimap is null
+     * @since 2.16
+     */
+    @Nonnull
+    static ImmutableContextSet fromMultimap(@Nonnull Multimap<String, String> multimap) {
+        return ImmutableContextSet.fromMultimap(multimap);
+    }
+
+    /**
+     * Creates an new {@link ImmutableContextSet} from an existing {@link Set}.
+     *
+     * <p>Only really useful for converting between mutable and immutable types.</p>
+     *
+     * @param contextSet the context set to copy from
+     * @return a new ImmutableContextSet with the same content and the one provided
+     * @throws NullPointerException if contextSet is null
+     */
+    @Nonnull
+    static ImmutableContextSet fromSet(@Nonnull ContextSet contextSet) {
+        return ImmutableContextSet.fromSet(contextSet);
+    }
+
+    /**
+     * Returns an empty {@link ImmutableContextSet}.
+     *
+     * @return an empty ImmutableContextSet
+     */
+    @Nonnull
+    static ImmutableContextSet empty() {
+        return ImmutableContextSet.empty();
+    }
+
+    /**
+     * Gets if this {@link ContextSet} is immutable.
+     *
+     * <p>The state of immutable instances will never change.</p>
+     *
+     * @return true if the set is immutable
+     */
+    boolean isImmutable();
+
+    /**
+     * Returns an immutable representation of this {@link ContextSet}.
+     *
+     * <p>If the set is already immutable, the same object will be returned.
+     * If the set is mutable, an immutable copy will be made.</p>
+     *
+     * @return an immutable representation of this set
+     */
+    @Nonnull
+    ImmutableContextSet makeImmutable();
+
+    /**
+     * Creates a mutable copy of this {@link ContextSet}.
+     *
+     * <p>A new copy is returned regardless of the
+     * {@link #isImmutable() mutability} of this set.</p>
+     *
+     * @return a mutable ContextSet
+     * @since 2.16
+     */
+    @Nonnull
+    MutableContextSet mutableCopy();
+
+    /**
+     * Returns a {@link Set} of {@link Map.Entry}s representing the current
+     * state of this {@link ContextSet}.
+     *
+     * <p>The returned set is immutable, and is a copy of the current set.
+     * (will not update live)</p>
+     *
+     * @return an immutable set
+     */
+    @Nonnull
+    Set<Map.Entry<String, String>> toSet();
+
+    /**
+     * Returns a {@link Map} <b>loosely</b> representing the current state of
+     * this {@link ContextSet}.
+     *
+     * <p>The returned map is immutable, and is a copy of the current set.
+     * (will not update live)</p>
+     *
+     * <p>As a single context key can be mapped to multiple values, this method
+     * may not be a true representation of the set.</p>
+     *
+     * <p>If you need a representation of the set in a Java collection instance,
+     * use {@link #toSet()} or {@link #toMultimap()} followed by
+     * {@link Multimap#asMap()}.</p>
+     *
+     * @return an immutable map
+     * @deprecated because the resultant map may not contain all data in the ContextSet
+     */
+    @Nonnull
+    @Deprecated
+    Map<String, String> toMap();
+
+    /**
+     * Returns a {@link Multimap} representing the current state of this
+     * {@link ContextSet}.
+     *
+     * <p>The returned multimap is immutable, and is a copy of the current set.
+     * (will not update live)</p>
+     *
+     * @return a multimap
+     * @since 2.16
+     */
+    @Nonnull
+    Multimap<String, String> toMultimap();
+
+    /**
+     * Returns if the {@link ContextSet} contains at least one value for the
+     * given key.
+     *
+     * @param key the key to check for
+     * @return true if the set contains a value for the key
+     * @throws NullPointerException if the key is null
+     */
+    boolean containsKey(@Nonnull String key);
+
+    /**
+     * Returns a {@link Set} of the values mapped to the given key.
+     *
+     * <p>The returned set is immutable, and only represents the current state
+     * of the {@link ContextSet}. (will not update live)</p>
+     *
+     * @param key the key to get values for
+     * @return a set of values
+     * @throws NullPointerException if the key is null
+     */
+    @Nonnull
+    Set<String> getValues(@Nonnull String key);
+
+    /**
+     * Returns any value from this {@link ContextSet} matching the key, if present.
+     *
+     * <p>Note that context keys can be mapped to multiple values.
+     * Use {@link #getValues(String)} to retrieve all associated values.</p>
+     *
+     * @param key the key to find values for
+     * @return an optional containing any match
+     * @since 3.1
+     */
+    @Nonnull
+    default Optional<String> getAnyValue(@Nonnull String key) {
+        return getValues(key).stream().findAny();
+    }
+
+    /**
+     * Returns if the {@link ContextSet} contains a given context pairing.
+     *
+     * <p>This lookup is case-sensitive on the value.</p>
+     *
+     * @param key   the key to look for
+     * @param value the value to look for (case sensitive)
+     * @return true if the set contains the context pair
+     * @throws NullPointerException if the key or value is null
+     */
+    boolean has(@Nonnull String key, @Nonnull String value);
+
+    /**
+     * Returns if the {@link ContextSet} contains a given context pairing,
+     * ignoring the case of values.
+     *
+     * <p>This lookup is case-insensitive on the value.</p>
+     *
+     * @param key   the key to look for
+     * @param value the value to look for
+     * @return true if the set contains the context pair
+     * @throws NullPointerException if the key or value is null
+     */
+    boolean hasIgnoreCase(@Nonnull String key, @Nonnull String value);
+
+    /**
+     * Returns if the {@link ContextSet} contains a given context pairing.
+     *
+     * <p>This lookup is case-sensitive on the value.</p>
+     *
+     * @param entry the entry to look for
+     * @return true if the set contains the context pair
+     * @throws NullPointerException if the key or value is null
+     */
+    default boolean has(@Nonnull Map.Entry<String, String> entry) {
+        Objects.requireNonNull(entry, "entry");
+        return has(entry.getKey(), entry.getValue());
+    }
+
+    /**
+     * Returns if the {@link ContextSet} contains a given context pairing,
+     * ignoring the case of values.
+     *
+     * <p>This lookup is case-insensitive on the value.</p>
+     *
+     * @param entry the entry to look for
+     * @return true if the set contains the context pair
+     * @throws NullPointerException if the key or value is null
+     */
+    default boolean hasIgnoreCase(@Nonnull Map.Entry<String, String> entry) {
+        Objects.requireNonNull(entry, "entry");
+        return hasIgnoreCase(entry.getKey(), entry.getValue());
+    }
+
+    /**
+     * Returns if this {@link ContextSet} is fully "satisfied" by another set.
+     *
+     * <p>For a context set to "satisfy" another, it must itself contain all of
+     * the context pairings in the other set.</p>
+     *
+     * <p>Mathematically, this method returns true if this set is a <b>subset</b> of the other.</p>
+     *
+     * <p>This check is case-sensitive. For a case-insensitive check,
+     * use {@link #isSatisfiedBy(ContextSet, boolean)}.</p>
+     *
+     * @param other the other set to check
+     * @return true if all entries in this set are also in the other set
+     * @since 3.1
+     */
+    default boolean isSatisfiedBy(@Nonnull ContextSet other) {
+        return isSatisfiedBy(other, true);
+    }
+
+    /**
+     * Returns if this {@link ContextSet} is fully "satisfied" by another set.
+     *
+     * <p>For a context set to "satisfy" another, it must itself contain all of
+     * the context pairings in the other set.</p>
+     *
+     * <p>Mathematically, this method returns true if this set is a <b>subset</b> of the other.</p>
+     *
+     * @param other the other set to check
+     * @param caseSensitive if the check should be case sensitive
+     * @return true if all entries in this set are also in the other set
+     * @since 3.4
+     */
+    default boolean isSatisfiedBy(@Nonnull ContextSet other, boolean caseSensitive) {
+        if (this == other) {
+            return true;
+        }
+
+        Objects.requireNonNull(other, "other");
+        if (this.isEmpty()) {
+            // this is empty, so is therefore always satisfied.
+            return true;
+        } else if (other.isEmpty()) {
+            // this set isn't empty, but the other one is
+            return false;
+        } else if (this.size() > other.size()) {
+            // this set has more unique entries than the other set, so there's no way this can be satisfied.
+            return false;
+        } else {
+            // neither are empty, we need to compare the individual entries
+            for (Map.Entry<String, String> context : toSet()) {
+                if (caseSensitive) {
+                    if (!other.has(context)) {
+                        return false;
+                    }
+                } else {
+                    if (!other.hasIgnoreCase(context)) {
+                        return false;
+                    }
+                }
+            }
+            return true;
+        }
+    }
+
+    /**
+     * Returns if the {@link ContextSet} is empty.
+     *
+     * @return true if the set is empty
+     */
+    boolean isEmpty();
+
+    /**
+     * Gets the number of context pairs in the {@link ContextSet}.
+     *
+     * @return the size of the set
+     */
+    int size();
+
+}
@@ -0,0 +1,346 @@
+/*
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api.context;
+
+import com.google.common.collect.ImmutableSetMultimap;
+import com.google.common.collect.Multimap;
+
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+
+import javax.annotation.Nonnull;
+import javax.annotation.concurrent.Immutable;
+
+/**
+ * An immutable implementation of {@link ContextSet}.
+ *
+ * @since 2.16
+ */
+@Immutable
+public final class ImmutableContextSet extends AbstractContextSet implements ContextSet {
+    private static final ImmutableContextSet EMPTY = new ImmutableContextSet(ImmutableSetMultimap.of());
+
+    /**
+     * Creates an {@link ImmutableContextSet.Builder}.
+     *
+     * @return a new ImmutableContextSet builder
+     * @since 4.1
+     */
+    @Nonnull
+    public static Builder builder() {
+        return new Builder();
+    }
+
+    /**
+     * Creates an {@link ImmutableContextSet} from a context pair.
+     *
+     * @param key   the key
+     * @param value the value
+     * @return a new ImmutableContextSet containing one context pair
+     * @throws NullPointerException if key or value is null
+     */
+    @Nonnull
+    public static ImmutableContextSet singleton(@Nonnull String key, @Nonnull String value) {
+        return new ImmutableContextSet(ImmutableSetMultimap.of(sanitizeKey(key), sanitizeValue(value)));
+    }
+
+    /**
+     * Creates an {@link ImmutableContextSet} from two context pairs.
+     *
+     * @param key1 the first key
+     * @param value1 the first value
+     * @param key2 the second key
+     * @param value2 the second value
+     * @return a new ImmutableContextSet containing the two pairs
+     * @throws NullPointerException if any of the keys or values are null
+     * @since 3.1
+     */
+    @Nonnull
+    public static ImmutableContextSet of(@Nonnull String key1, @Nonnull String value1, @Nonnull String key2, @Nonnull String value2) {
+        return new ImmutableContextSet(ImmutableSetMultimap.of(
+                sanitizeKey(key1),
+                sanitizeValue(value1),
+                sanitizeKey(key2),
+                sanitizeValue(value2)
+        ));
+    }
+
+    /**
+     * Creates an {@link ImmutableContextSet} from an existing {@link Iterable} of {@link Map.Entry}s.
+     *
+     * @param iterable the iterable to copy from
+     * @return a new ImmutableContextSet representing the pairs in the iterable
+     * @throws NullPointerException if the iterable is null
+     */
+    @Nonnull
+    public static ImmutableContextSet fromEntries(@Nonnull Iterable<? extends Map.Entry<String, String>> iterable) {
+        Objects.requireNonNull(iterable, "iterable");
+        ImmutableContextSet.Builder builder = builder();
+        for (Map.Entry<String, String> entry : iterable) {
+            builder.add(entry);
+        }
+        return builder.build();
+    }
+
+    /**
+     * Creates an {@link ImmutableContextSet} from an existing {@link Map}.
+     *
+     * @param map the map to copy from
+     * @return a new ImmutableContextSet representing the pairs from the map
+     * @throws NullPointerException if the map is null
+     */
+    @Nonnull
+    public static ImmutableContextSet fromMap(@Nonnull Map<String, String> map) {
+        return fromEntries(Objects.requireNonNull(map, "map").entrySet());
+    }
+
+    /**
+     * Creates an {@link ImmutableContextSet} from an existing {@link Multimap}.
+     *
+     * @param multimap the multimap to copy from
+     * @return a new ImmutableContextSet representing the pairs in the multimap
+     * @throws NullPointerException if the multimap is null
+     * @since 2.16
+     */
+    @Nonnull
+    public static ImmutableContextSet fromMultimap(@Nonnull Multimap<String, String> multimap) {
+        return fromEntries(Objects.requireNonNull(multimap, "multimap").entries());
+    }
+
+    /**
+     * Creates an new {@link ImmutableContextSet} from an existing {@link Set}.
+     *
+     * <p>Only really useful for converting between mutable and immutable types.</p>
+     *
+     * @param contextSet the context set to copy from
+     * @return a new ImmutableContextSet with the same content and the one provided
+     * @throws NullPointerException if contextSet is null
+     */
+    @Nonnull
+    public static ImmutableContextSet fromSet(@Nonnull ContextSet contextSet) {
+        return Objects.requireNonNull(contextSet, "contextSet").makeImmutable();
+    }
+
+    /**
+     * Returns an empty {@link ImmutableContextSet}.
+     *
+     * @return an empty ImmutableContextSet
+     */
+    @Nonnull
+    public static ImmutableContextSet empty() {
+        return EMPTY;
+    }
+
+    private final ImmutableSetMultimap<String, String> map;
+    private final int hashCode;
+
+    ImmutableContextSet(ImmutableSetMultimap<String, String> contexts) {
+        this.map = contexts;
+        this.hashCode = this.map.hashCode();
+    }
+
+    @Override
+    protected Multimap<String, String> backing() {
+        return this.map;
+    }
+
+    @Override
+    public boolean isImmutable() {
+        return true;
+    }
+
+    @Nonnull
+    @Override
+    @Deprecated // This set is already immutable!
+    public ImmutableContextSet makeImmutable() {
+        return this;
+    }
+
+    @Nonnull
+    @Override
+    public MutableContextSet mutableCopy() {
+        return MutableContextSet.fromSet(this);
+    }
+
+    @Nonnull
+    @Override
+    public Set<Map.Entry<String, String>> toSet() {
+        return this.map.entries();
+    }
+
+    @Nonnull
+    @Override
+    public Multimap<String, String> toMultimap() {
+        return this.map;
+    }
+
+    @Override
+    public int hashCode() {
+        return this.hashCode;
+    }
+
+    @Override
+    public String toString() {
+        return "ImmutableContextSet(contexts=" + this.map + ")";
+    }
+
+    /**
+     * A builder for {@link ImmutableContextSet}.
+     *
+     * @since 4.1
+     */
+    public static final class Builder {
+        private ImmutableSetMultimap.Builder<String, String> builder;
+
+        private Builder() {
+
+        }
+
+        private synchronized ImmutableSetMultimap.Builder<String, String> builder() {
+            if (this.builder == null) {
+                this.builder = ImmutableSetMultimap.builder();
+            }
+            return this.builder;
+        }
+
+        private void put(String key, String value) {
+            builder().put(key, value);
+        }
+
+        /**
+         * Adds a context to the set.
+         *
+         * @param key   the key to add
+         * @param value the value to add
+         * @return the builder
+         * @throws NullPointerException if the key or value is null
+         * @see MutableContextSet#add(String, String)
+         */
+        @Nonnull
+        public Builder add(@Nonnull String key, @Nonnull String value) {
+            put(sanitizeKey(key), sanitizeValue(value));
+            return this;
+        }
+
+        /**
+         * Adds a context to the set.
+         *
+         * @param entry the entry to add
+         * @return the builder
+         * @throws NullPointerException if the entry is null
+         * @see MutableContextSet#add(Map.Entry)
+         */
+        @Nonnull
+        public Builder add(@Nonnull Map.Entry<String, String> entry) {
+            Objects.requireNonNull(entry, "entry");
+            add(entry.getKey(), entry.getValue());
+            return this;
+        }
+
+        /**
+         * Adds the contexts contained in the given {@link Iterable} to the set.
+         *
+         * @param iterable an iterable of key value context pairs
+         * @return the builder
+         * @throws NullPointerException if iterable is null
+         * @see MutableContextSet#addAll(Iterable)
+         */
+        @Nonnull
+        public Builder addAll(@Nonnull Iterable<? extends Map.Entry<String, String>> iterable) {
+            for (Map.Entry<String, String> e : Objects.requireNonNull(iterable, "iterable")) {
+                add(e);
+            }
+            return this;
+        }
+
+        /**
+         * Adds the contexts contained in the given {@link Map} to the set.
+         *
+         * @param map the map to add from
+         * @return the builder
+         * @throws NullPointerException if the map is null
+         * @see MutableContextSet#addAll(Map)
+         */
+        @Nonnull
+        public Builder addAll(@Nonnull Map<String, String> map) {
+            addAll(Objects.requireNonNull(map, "map").entrySet());
+            return this;
+        }
+
+        /**
+         * Adds the contexts contained in the given {@link Multimap} to the set.
+         *
+         * @param multimap the multimap to add from
+         * @return the builder
+         * @throws NullPointerException if the map is null
+         * @since 3.4
+         * @see MutableContextSet#addAll(Multimap)
+         */
+        @Nonnull
+        public Builder addAll(@Nonnull Multimap<String, String> multimap) {
+            addAll(Objects.requireNonNull(multimap, "multimap").entries());
+            return this;
+        }
+
+        /**
+         * Adds of of the contexts in another {@link ContextSet} to the set.
+         *
+         * @param contextSet the set to add from
+         * @return the builder
+         * @throws NullPointerException if the contextSet is null
+         * @see MutableContextSet#addAll(ContextSet)
+         */
+        @Nonnull
+        public Builder addAll(@Nonnull ContextSet contextSet) {
+            Objects.requireNonNull(contextSet, "contextSet");
+            if (contextSet instanceof AbstractContextSet) {
+                AbstractContextSet other = ((AbstractContextSet) contextSet);
+                if (!other.isEmpty()) {
+                    builder().putAll(other.backing());
+                }
+            } else {
+                addAll(contextSet.toMultimap());
+            }
+            return this;
+        }
+
+        /**
+         * Creates a {@link ImmutableContextSet} from the values previously
+         * added to the builder.
+         *
+         * @return an {@link ImmutableContextSet} from the builder
+         */
+        @Nonnull
+        public ImmutableContextSet build() {
+            if (this.builder == null) {
+                return empty();
+            } else {
+                return new ImmutableContextSet(this.builder.build());
+            }
+        }
+    }
+}
@@ -0,0 +1,328 @@
+/*
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api.context;
+
+import com.google.common.collect.HashMultimap;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.ImmutableSetMultimap;
+import com.google.common.collect.Multimap;
+import com.google.common.collect.Multimaps;
+import com.google.common.collect.SetMultimap;
+
+import java.util.Collection;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+
+import javax.annotation.Nonnull;
+
+/**
+ * A mutable implementation of {@link ContextSet}.
+ *
+ * @since 2.16
+ */
+public final class MutableContextSet extends AbstractContextSet implements ContextSet {
+
+    /**
+     * Creates a {@link MutableContextSet} from a context pair.
+     *
+     * @param key   the key
+     * @param value the value
+     * @return a new MutableContextSet containing one context pair
+     * @throws NullPointerException if key or value is null
+     */
+    @Nonnull
+    public static MutableContextSet singleton(@Nonnull String key, @Nonnull String value) {
+        Objects.requireNonNull(key, "key");
+        Objects.requireNonNull(value, "value");
+        MutableContextSet set = MutableContextSet.create();
+        set.add(key, value);
+        return set;
+    }
+
+    /**
+     * Creates a {@link MutableContextSet} from two context pairs.
+     *
+     * @param key1 the first key
+     * @param value1 the first value
+     * @param key2 the second key
+     * @param value2 the second value
+     * @return a new MutableContextSet containing the two pairs
+     * @throws NullPointerException if any of the keys or values are null
+     * @since 3.1
+     */
+    @Nonnull
+    public static MutableContextSet of(@Nonnull String key1, @Nonnull String value1, @Nonnull String key2, @Nonnull String value2) {
+        Objects.requireNonNull(key1, "key1");
+        Objects.requireNonNull(value1, "value1");
+        Objects.requireNonNull(key2, "key2");
+        Objects.requireNonNull(value2, "value2");
+        MutableContextSet set = create();
+        set.add(key1, value1);
+        set.add(key2, value2);
+        return set;
+    }
+
+    /**
+     * Creates a {@link MutableContextSet} from an existing {@link Iterable} of {@link Map.Entry}s.
+     *
+     * @param iterable the iterable to copy from
+     * @return a new MutableContextSet representing the pairs in the iterable
+     * @throws NullPointerException if the iterable is null
+     */
+    @Nonnull
+    public static MutableContextSet fromEntries(@Nonnull Iterable<? extends Map.Entry<String, String>> iterable) {
+        Objects.requireNonNull(iterable, "iterable");
+        MutableContextSet set = create();
+        set.addAll(iterable);
+        return set;
+    }
+
+    /**
+     * Creates a {@link MutableContextSet} from an existing {@link Map}.
+     *
+     * @param map the map to copy from
+     * @return a new MutableContextSet representing the pairs from the map
+     * @throws NullPointerException if the map is null
+     */
+    @Nonnull
+    public static MutableContextSet fromMap(@Nonnull Map<String, String> map) {
+        Objects.requireNonNull(map, "map");
+        MutableContextSet set = create();
+        set.addAll(map);
+        return set;
+    }
+
+    /**
+     * Creates a {@link MutableContextSet} from an existing {@link Multimap}.
+     *
+     * @param multimap the multimap to copy from
+     * @return a new MutableContextSet representing the pairs in the multimap
+     * @throws NullPointerException if the multimap is null
+     * @since 2.16
+     */
+    @Nonnull
+    public static MutableContextSet fromMultimap(@Nonnull Multimap<String, String> multimap) {
+        Objects.requireNonNull(multimap, "multimap");
+        MutableContextSet set = create();
+        set.addAll(multimap);
+        return set;
+    }
+
+    /**
+     * Creates a new {@link MutableContextSet} from an existing {@link Set}.
+     *
+     * <p>Only really useful for converting between mutable and immutable types.</p>
+     *
+     * @param contextSet the context set to copy from
+     * @return a new MutableContextSet with the same content and the one provided
+     * @throws NullPointerException if contextSet is null
+     */
+    @Nonnull
+    public static MutableContextSet fromSet(@Nonnull ContextSet contextSet) {
+        Objects.requireNonNull(contextSet, "contextSet");
+        MutableContextSet set = create();
+        set.addAll(contextSet);
+        return set;
+    }
+
+    /**
+     * Creates a new empty MutableContextSet.
+     *
+     * @return a new MutableContextSet
+     */
+    @Nonnull
+    public static MutableContextSet create() {
+        return new MutableContextSet();
+    }
+
+    private final SetMultimap<String, String> map;
+
+    public MutableContextSet() {
+        this.map = Multimaps.synchronizedSetMultimap(HashMultimap.create());
+    }
+
+    private MutableContextSet(MutableContextSet other) {
+        this.map = Multimaps.synchronizedSetMultimap(HashMultimap.create(other.map));
+    }
+
+    @Override
+    protected Multimap<String, String> backing() {
+        return this.map;
+    }
+
+    @Override
+    public boolean isImmutable() {
+        return false;
+    }
+
+    @Nonnull
+    @Override
+    public ImmutableContextSet makeImmutable() {
+        // if the map is empty, don't create a new instance
+        if (this.map.isEmpty()) {
+            return ImmutableContextSet.empty();
+        }
+        return new ImmutableContextSet(ImmutableSetMultimap.copyOf(this.map));
+    }
+
+    @Nonnull
+    @Override
+    public MutableContextSet mutableCopy() {
+        return new MutableContextSet(this);
+    }
+
+    @Nonnull
+    @Override
+    public Set<Map.Entry<String, String>> toSet() {
+        return ImmutableSet.copyOf(this.map.entries());
+    }
+
+    @Nonnull
+    @Override
+    public Multimap<String, String> toMultimap() {
+        return ImmutableSetMultimap.copyOf(this.map);
+    }
+
+    /**
+     * Adds a context to this set.
+     *
+     * @param key   the key to add
+     * @param value the value to add
+     * @throws NullPointerException if the key or value is null
+     */
+    public void add(@Nonnull String key, @Nonnull String value) {
+        this.map.put(sanitizeKey(key), sanitizeValue(value));
+    }
+
+    /**
+     * Adds a context to this set.
+     *
+     * @param entry the entry to add
+     * @throws NullPointerException if the entry is null
+     */
+    public void add(@Nonnull Map.Entry<String, String> entry) {
+        Objects.requireNonNull(entry, "entry");
+        add(entry.getKey(), entry.getValue());
+    }
+
+    /**
+     * Adds the contexts contained in the given {@link Iterable} to this set.
+     *
+     * @param iterable an iterable of key value context pairs
+     * @throws NullPointerException if iterable is null
+     */
+    public void addAll(@Nonnull Iterable<? extends Map.Entry<String, String>> iterable) {
+        for (Map.Entry<String, String> e : Objects.requireNonNull(iterable, "iterable")) {
+            add(e);
+        }
+    }
+
+    /**
+     * Adds the contexts contained in the given {@link Map} to this set.
+     *
+     * @param map the map to add from
+     * @throws NullPointerException if the map is null
+     */
+    public void addAll(@Nonnull Map<String, String> map) {
+        addAll(Objects.requireNonNull(map, "map").entrySet());
+    }
+
+    /**
+     * Adds the contexts contained in the given {@link Multimap} to this set.
+     *
+     * @param multimap the multimap to add from
+     * @throws NullPointerException if the map is null
+     * @since 3.4
+     */
+    public void addAll(@Nonnull Multimap<String, String> multimap) {
+        addAll(Objects.requireNonNull(multimap, "multimap").entries());
+    }
+
+    /**
+     * Adds of of the contexts in another {@link ContextSet} to this set.
+     *
+     * @param contextSet the set to add from
+     * @throws NullPointerException if the contextSet is null
+     */
+    public void addAll(@Nonnull ContextSet contextSet) {
+        Objects.requireNonNull(contextSet, "contextSet");
+        if (contextSet instanceof AbstractContextSet) {
+            AbstractContextSet other = ((AbstractContextSet) contextSet);
+            this.map.putAll(other.backing());
+        } else {
+            addAll(contextSet.toMultimap());
+        }
+    }
+
+    /**
+     * Removes a context from this set.
+     *
+     * @param key   the key to remove
+     * @param value the value to remove (case sensitive)
+     * @throws NullPointerException if the key or value is null
+     */
+    public void remove(@Nonnull String key, @Nonnull String value) {
+        this.map.remove(sanitizeKey(key), sanitizeValue(value));
+    }
+
+    /**
+     * Removes a context from this set. (case-insensitive)
+     *
+     * @param key   the key to remove
+     * @param value the value to remove
+     * @throws NullPointerException if the key or value is null
+     */
+    public void removeIgnoreCase(@Nonnull String key, @Nonnull String value) {
+        String v = sanitizeValue(value);
+        Collection<String> strings = this.map.asMap().get(sanitizeKey(key));
+        if (strings != null) {
+            strings.removeIf(e -> e.equalsIgnoreCase(v));
+        }
+    }
+
+    /**
+     * Removes all contexts from this set with the given key.
+     *
+     * @param key the key to remove
+     * @throws NullPointerException if the key is null
+     */
+    public void removeAll(@Nonnull String key) {
+        this.map.removeAll(sanitizeKey(key));
+    }
+
+    /**
+     * Removes all contexts from the set.
+     */
+    public void clear() {
+        this.map.clear();
+    }
+
+    @Override
+    public String toString() {
+        return "MutableContextSet(contexts=" + this.map + ")";
+    }
+}
@@ -1,5 +1,8 @@
 /*
- * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
 *
 *  Permission is hereby granted, free of charge, to any person obtaining a copy
 *  of this software and associated documentation files (the "Software"), to deal
@@ -22,37 +25,39 @@

 package me.lucko.luckperms.api.context;

-import java.util.Map;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;

 /**
- * Calculates whether contexts are applicable to {@link T}
+ * Extension of {@link ContextCalculator} which provides the same context
+ * regardless of the subject.
 *
- * <p>Somewhat inspired by the system used on Sponge.
- * @param <T> the subject type. Is ALWAYS the player class of the platform.
+ * @since 4.0
 */
-public interface IContextCalculator<T> {
+@FunctionalInterface
+public interface StaticContextCalculator extends ContextCalculator<Object> {

    /**
-     * Gives the subject all of the applicable contexts they meet
-     * @param subject the subject to add contexts tp
+     * Adds this calculators context to the given accumulator.
+     *
     * @param accumulator a map of contexts to add to
     * @return the map
     */
-    Map<String, String> giveApplicableContext(T subject, Map<String, String> accumulator);
+    @Nonnull
+    MutableContextSet giveApplicableContext(@Nonnull MutableContextSet accumulator);

    /**
-     * Checks to see if a context is applicable to a subject
-     * @param subject the subject to check against
-     * @param context the context to check for
-     * @return true if met, or false if not. If this calculator does not calculate the given context, return false.
+     * Gives the subject all of the applicable contexts they meet
+     *
+     * @param subject the subject to add contexts to
+     * @param accumulator a map of contexts to add to
+     * @return the map
     */
-    boolean isContextApplicable(T subject, Map.Entry<String, String> context);
-
-    /**
-     * Adds a listener to be called whenever a context handled by this calculator changes
-     * @param listener the listener instance
-     * @throws NullPointerException if listener is null
-     */
-    void addListener(ContextListener<T> listener);
+    @Nonnull
+    @Override
+    @Deprecated
+    default MutableContextSet giveApplicableContext(@Nullable Object subject, @Nonnull MutableContextSet accumulator) {
+        return giveApplicableContext(accumulator);
+    }

 }
@@ -0,0 +1,76 @@
+/*
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api.event;
+
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import javax.annotation.Nonnull;
+
+/**
+ * Represents an event that can be cancelled
+ */
+public interface Cancellable {
+
+    /**
+     * Gets an {@link AtomicBoolean} holding the cancellation state of the event
+     *
+     * @return the cancellation
+     */
+    @Nonnull
+    AtomicBoolean getCancellationState();
+
+    /**
+     * Returns true if the event is currently cancelled.
+     *
+     * @return if the event is cancelled
+     * @since 4.1
+     */
+    default boolean isCancelled() {
+        return getCancellationState().get();
+    }
+
+    /**
+     * Returns true if the event is not currently cancelled.
+     *
+     * @return if the event is not cancelled
+     * @since 4.1
+     */
+    default boolean isNotCancelled() {
+        return !isCancelled();
+    }
+
+    /**
+     * Sets the cancellation state of the event.
+     *
+     * @param cancelled the new state
+     * @return the previous state
+     * @since 4.1
+     */
+    default boolean setCancelled(boolean cancelled) {
+        return getCancellationState().getAndSet(cancelled);
+    }
+
+}
@@ -0,0 +1,63 @@
+/*
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api.event;
+
+import java.util.Set;
+import java.util.function.Consumer;
+
+import javax.annotation.Nonnull;
+
+/**
+ * The internal LuckPerms event bus.
+ *
+ * <p>LuckPerms events are posted to any listeners registered with the bus.</p>
+ *
+ * @since 3.0
+ */
+public interface EventBus {
+
+    /**
+     * Subscribes to an event.
+     *
+     * @param eventClass the event class
+     * @param handler    the event handler
+     * @param <T>        the event class
+     * @return an event handler instance representing this subscription
+     */
+    @Nonnull
+    <T extends LuckPermsEvent> EventHandler<T> subscribe(@Nonnull Class<T> eventClass, @Nonnull Consumer<T> handler);
+
+    /**
+     * Gets a set of all registered handlers for a given event.
+     *
+     * @param eventClass the event to find handlers for
+     * @param <T>        the event class
+     * @return an immutable set of event handlers
+     */
+    @Nonnull
+    <T extends LuckPermsEvent> Set<EventHandler<T>> getHandlers(@Nonnull Class<T> eventClass);
+
+}
@@ -0,0 +1,80 @@
+/*
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api.event;
+
+import java.util.function.Consumer;
+
+import javax.annotation.Nonnull;
+
+/**
+ * Represents a handler for a LuckPerms event
+ *
+ * @param <T> the event class
+ */
+public interface EventHandler<T extends LuckPermsEvent> extends AutoCloseable {
+
+    /**
+     * Gets the class this handler is listening to
+     *
+     * @return the event class
+     */
+    @Nonnull
+    Class<T> getEventClass();
+
+    /**
+     * Returns true if this handler is active
+     *
+     * @return true if this handler is still active
+     */
+    boolean isActive();
+
+    /**
+     * Unregisters this handler from the event bus
+     *
+     * @return true if the handler wasn't already unregistered
+     */
+    boolean unregister();
+
+    /**
+     * Gets the event consumer responsible for handling the event
+     *
+     * @return the event consumer
+     */
+    @Nonnull
+    Consumer<T> getConsumer();
+
+    /**
+     * Gets the number of times this handler has been called
+     *
+     * @return the number of times this handler has been called
+     */
+    int getCallCount();
+
+    @Override
+    default void close() {
+        unregister();
+    }
+}
@@ -1,5 +1,8 @@
 /*
- * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
 *
 *  Permission is hereby granted, free of charge, to any person obtaining a copy
 *  of this software and associated documentation files (the "Software"), to deal
@@ -22,22 +25,23 @@

 package me.lucko.luckperms.api.event;

+import me.lucko.luckperms.api.LuckPermsApi;
+
+import javax.annotation.Nonnull;
+
 /**
- * Event that allows listeners to set the cancelled state of an event.
+ * A superinterface for all LuckPerms events.
+ *
+ * @since 3.0
 */
-public abstract class CancellableEvent extends LPEvent {
+public interface LuckPermsEvent {

-    private boolean cancelled = false;
+    /**
+     * Get the API instance this event was dispatched from
+     *
+     * @return the api instance
+     */
+    @Nonnull
+    LuckPermsApi getApi();

-    protected CancellableEvent(String eventName) {
-        super(eventName);
-    }
-
-    public boolean isCancelled() {
-        return cancelled;
-    }
-
-    public void setCancelled(boolean cancelled) {
-        this.cancelled = cancelled;
-    }
 }
@@ -0,0 +1,50 @@
+/*
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api.event;
+
+import me.lucko.luckperms.api.event.source.Source;
+
+import javax.annotation.Nonnull;
+
+/**
+ * Represents an event with a {@link Source}.
+ *
+ * @since 4.1
+ */
+public interface Sourced {
+
+    /**
+     * Gets the events source.
+     *
+     * <p>Never returns null. In situations where the source is unknown, a
+     * {@link Source} with type {@link Source.Type#UNKNOWN} is returned.</p>
+     *
+     * @return the source
+     */
+    @Nonnull
+    Source getSource();
+
+}
@@ -0,0 +1,48 @@
+/*
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api.event.cause;
+
+/**
+ * The cause of a group/track creation
+ */
+public enum CreationCause {
+
+    /**
+     * The creation was caused by a command
+     */
+    COMMAND,
+
+    /**
+     * The creation was caused by an API call
+     */
+    API,
+
+    /**
+     * The creation was caused by a LuckPerms internal
+     */
+    INTERNAL
+
+}
@@ -0,0 +1,48 @@
+/*
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api.event.cause;
+
+/**
+ * The cause of a group/track deletion
+ */
+public enum DeletionCause {
+
+    /**
+     * The deletion was caused by a command
+     */
+    COMMAND,
+
+    /**
+     * The deletion was caused by an API call
+     */
+    API,
+
+    /**
+     * The deletion was caused by a LuckPerms internal
+     */
+    INTERNAL
+
+}
@@ -1,47 +0,0 @@
-/*
- * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
- *
- *  Permission is hereby granted, free of charge, to any person obtaining a copy
- *  of this software and associated documentation files (the "Software"), to deal
- *  in the Software without restriction, including without limitation the rights
- *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- *  copies of the Software, and to permit persons to whom the Software is
- *  furnished to do so, subject to the following conditions:
- *
- *  The above copyright notice and this permission notice shall be included in all
- *  copies or substantial portions of the Software.
- *
- *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- *  SOFTWARE.
- */
-
-package me.lucko.luckperms.api.event.events;
-
-import me.lucko.luckperms.api.PermissionHolder;
-import me.lucko.luckperms.api.event.AbstractPermissionRemoveEvent;
-
-/**
- * Called whenever a user or group is removed from / stops inheriting another group
- */
-public class GroupRemoveEvent extends AbstractPermissionRemoveEvent {
-
-    /**
-     * The name of group being removed from the target.
-     * Be aware that this group may have already been deleted, and and instance may therefore not exist internally.
-     */
-    private final String group;
-
-    public GroupRemoveEvent(PermissionHolder target, String group, String server, String world, boolean temporary) {
-        super("Group Remove Event", target, server, world, temporary);
-        this.group = group;
-    }
-
-    public String getGroup() {
-        return group;
-    }
-}
@@ -1,37 +0,0 @@
-/*
- * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
- *
- *  Permission is hereby granted, free of charge, to any person obtaining a copy
- *  of this software and associated documentation files (the "Software"), to deal
- *  in the Software without restriction, including without limitation the rights
- *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- *  copies of the Software, and to permit persons to whom the Software is
- *  furnished to do so, subject to the following conditions:
- *
- *  The above copyright notice and this permission notice shall be included in all
- *  copies or substantial portions of the Software.
- *
- *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- *  SOFTWARE.
- */
-
-package me.lucko.luckperms.api.event.events;
-
-import me.lucko.luckperms.api.Node;
-import me.lucko.luckperms.api.PermissionHolder;
-import me.lucko.luckperms.api.event.AbstractPermissionEvent;
-
-/**
- * Called when a permission node is unset from a holder
- * @since 2.6
- */
-public class PermissionNodeUnsetEvent extends AbstractPermissionEvent {
-    public PermissionNodeUnsetEvent(PermissionHolder target, Node node) {
-        super("Permission Node Unset Event", target, node);
-    }
-}
@@ -1,45 +0,0 @@
-/*
- * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
- *
- *  Permission is hereby granted, free of charge, to any person obtaining a copy
- *  of this software and associated documentation files (the "Software"), to deal
- *  in the Software without restriction, including without limitation the rights
- *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- *  copies of the Software, and to permit persons to whom the Software is
- *  furnished to do so, subject to the following conditions:
- *
- *  The above copyright notice and this permission notice shall be included in all
- *  copies or substantial portions of the Software.
- *
- *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- *  SOFTWARE.
- */
-
-package me.lucko.luckperms.api.event.events;
-
-import me.lucko.luckperms.api.PermissionHolder;
-import me.lucko.luckperms.api.event.AbstractPermissionRemoveEvent;
-
-/**
- * Called whenever a user or group has a permission unset.
- * @deprecated in favour of {@link PermissionNodeUnsetEvent}
- */
-@Deprecated
-public class PermissionUnsetEvent extends AbstractPermissionRemoveEvent {
-
-    private final String node;
-
-    public PermissionUnsetEvent(PermissionHolder target, String node, String server, String world, boolean temporary) {
-        super("Permission Unset Event", target, server, world, temporary);
-        this.node = node;
-    }
-
-    public String getNode() {
-        return node;
-    }
-}
@@ -0,0 +1,57 @@
+/*
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api.event.group;
+
+import me.lucko.luckperms.api.Group;
+import me.lucko.luckperms.api.caching.GroupData;
+import me.lucko.luckperms.api.event.LuckPermsEvent;
+
+import javax.annotation.Nonnull;
+
+/**
+ * Called when a groups {@link GroupData} is loaded.
+ *
+ * @since 4.0
+ */
+public interface GroupCacheLoadEvent extends LuckPermsEvent {
+
+    /**
+     * Gets the group whose data was loaded
+     *
+     * @return the group
+     */
+    @Nonnull
+    Group getGroup();
+
+    /**
+     * Gets the data that was loaded
+     *
+     * @return the loaded data
+     */
+    @Nonnull
+    GroupData getLoadedData();
+
+}
@@ -0,0 +1,55 @@
+/*
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api.event.group;
+
+import me.lucko.luckperms.api.Group;
+import me.lucko.luckperms.api.event.LuckPermsEvent;
+import me.lucko.luckperms.api.event.cause.CreationCause;
+
+import javax.annotation.Nonnull;
+
+/**
+ * Called when a group is created
+ */
+public interface GroupCreateEvent extends LuckPermsEvent {
+
+    /**
+     * Gets the new group
+     *
+     * @return the new group
+     */
+    @Nonnull
+    Group getGroup();
+
+    /**
+     * Gets the cause of the creation
+     *
+     * @return the cause of the creation
+     */
+    @Nonnull
+    CreationCause getCause();
+
+}
@@ -0,0 +1,57 @@
+/*
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api.event.group;
+
+import me.lucko.luckperms.api.Group;
+import me.lucko.luckperms.api.caching.GroupData;
+import me.lucko.luckperms.api.event.LuckPermsEvent;
+
+import javax.annotation.Nonnull;
+
+/**
+ * Called when a groups cached data is refreshed
+ *
+ * @since 4.0
+ */
+public interface GroupDataRecalculateEvent extends LuckPermsEvent {
+
+    /**
+     * Gets the group whose data was recalculated
+     *
+     * @return the group
+     */
+    @Nonnull
+    Group getGroup();
+
+    /**
+     * Gets the data that was recalculated
+     *
+     * @return the data
+     */
+    @Nonnull
+    GroupData getData();
+
+}
@@ -1,5 +1,8 @@
 /*
- * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
 *
 *  Permission is hereby granted, free of charge, to any person obtaining a copy
 *  of this software and associated documentation files (the "Software"), to deal
@@ -20,18 +23,43 @@
 *  SOFTWARE.
 */

-package me.lucko.luckperms.api.event.events;
+package me.lucko.luckperms.api.event.group;

 import me.lucko.luckperms.api.Node;
-import me.lucko.luckperms.api.PermissionHolder;
-import me.lucko.luckperms.api.event.AbstractPermissionEvent;
+import me.lucko.luckperms.api.event.LuckPermsEvent;
+import me.lucko.luckperms.api.event.cause.DeletionCause;
+
+import java.util.Set;
+
+import javax.annotation.Nonnull;

 /**
- * Called when a temporary permission node expires
- * @since 2.6
+ * Called when a group is deleted
 */
-public class PermissionNodeExpireEvent extends AbstractPermissionEvent {
-    public PermissionNodeExpireEvent(PermissionHolder target, Node node) {
-        super("Permission Node Expire Event", target, node);
-    }
+public interface GroupDeleteEvent extends LuckPermsEvent {
+
+    /**
+     * Gets the name of the deleted group
+     *
+     * @return the name of the deleted group
+     */
+    @Nonnull
+    String getGroupName();
+
+    /**
+     * Gets an immutable copy of the groups existing data
+     *
+     * @return a copy of the groups existing data
+     */
+    @Nonnull
+    Set<Node> getExistingData();
+
+    /**
+     * Gets the cause of the deletion
+     *
+     * @return the cause of the deletion
+     */
+    @Nonnull
+    DeletionCause getCause();
+
 }
@@ -1,5 +1,8 @@
 /*
- * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
 *
 *  Permission is hereby granted, free of charge, to any person obtaining a copy
 *  of this software and associated documentation files (the "Software"), to deal
@@ -20,18 +23,15 @@
 *  SOFTWARE.
 */

-package me.lucko.luckperms.api.data;
+package me.lucko.luckperms.api.event.group;
+
+import me.lucko.luckperms.api.event.LuckPermsEvent;

 /**
- * Represents the data section of the main LuckPerms configuration.
- * All methods could return null.
+ * Called when all groups have been loaded in from storage.
+ *
+ * <p>Usually only called on startup and in sync tasks.</p>
 */
-@SuppressWarnings("deprecation")
-public interface DatastoreConfiguration extends MySQLConfiguration {
-
-    String getAddress();
-    String getDatabase();
-    String getUsername();
-    String getPassword();
+public interface GroupLoadAllEvent extends LuckPermsEvent {

 }
@@ -0,0 +1,48 @@
+/*
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api.event.group;
+
+import me.lucko.luckperms.api.Group;
+import me.lucko.luckperms.api.event.LuckPermsEvent;
+
+import javax.annotation.Nonnull;
+
+/**
+ * Called when a group is loaded into memory from the storage.
+ *
+ * Note that this event is not the same as {@link GroupCreateEvent}
+ */
+public interface GroupLoadEvent extends LuckPermsEvent {
+
+    /**
+     * Gets the group that was loaded
+     *
+     * @return the group that was loaded
+     */
+    @Nonnull
+    Group getGroup();
+
+}
@@ -0,0 +1,79 @@
+/*
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api.event.log;
+
+import me.lucko.luckperms.api.LogEntry;
+import me.lucko.luckperms.api.event.Cancellable;
+import me.lucko.luckperms.api.event.LuckPermsEvent;
+
+import javax.annotation.Nonnull;
+
+/**
+ * Called when a log entry is about to be sent to notifiable players on the platform
+ */
+public interface LogBroadcastEvent extends LuckPermsEvent, Cancellable {
+
+    /**
+     * Gets the log entry to be broadcasted
+     *
+     * @return the log entry to be broadcasted
+     */
+    @Nonnull
+    LogEntry getEntry();
+
+    /**
+     * Gets where the log entry originated from.
+     *
+     * @return the origin of the log
+     * @since 3.3
+     */
+    @Nonnull
+    Origin getOrigin();
+
+    /**
+     * Represents where a log entry is from
+     *
+     * @since 3.3
+     */
+    enum Origin {
+
+        /**
+         * Marks a log entry which originated from the current server instance
+         */
+        LOCAL,
+
+        /**
+         * Marks a log entry which originated from an API call on the current server instance
+         */
+        LOCAL_API,
+
+        /**
+         * Marks a log entry which was sent to this server via the messaging service
+         */
+        REMOTE
+    }
+
+}
@@ -0,0 +1,59 @@
+/*
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api.event.log;
+
+import me.lucko.luckperms.api.LogEntry;
+import me.lucko.luckperms.api.event.Cancellable;
+import me.lucko.luckperms.api.event.LuckPermsEvent;
+
+import java.util.UUID;
+
+import javax.annotation.Nonnull;
+
+/**
+ * Called when a log is about to be published to the network via the MessagingService
+ *
+ * @since 3.3
+ */
+public interface LogNetworkPublishEvent extends LuckPermsEvent, Cancellable {
+
+    /**
+     * Gets the ID of the log entry being published
+     *
+     * @return the id of the log entry being published
+     */
+    @Nonnull
+    UUID getLogId();
+
+    /**
+     * Gets the log entry to be published
+     *
+     * @return the log entry to be published
+     */
+    @Nonnull
+    LogEntry getEntry();
+
+}
@@ -0,0 +1,92 @@
+/*
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api.event.log;
+
+import me.lucko.luckperms.api.Entity;
+import me.lucko.luckperms.api.LogEntry;
+import me.lucko.luckperms.api.event.Cancellable;
+import me.lucko.luckperms.api.event.LuckPermsEvent;
+
+import javax.annotation.Nonnull;
+
+/**
+ * Called when a log entry is about to be sent to specific notifiable object on
+ * the platform.
+ *
+ * <p>This event is not called for players without the notify permission,
+ * but is called for objects which are ignoring log notifications (called with
+ * the cancelled flag set to true).</p>
+ *
+ * @since 4.1
+ */
+public interface LogNotifyEvent extends LuckPermsEvent, Cancellable {
+
+    /**
+     * Gets the log entry to be sent
+     *
+     * @return the log entry to be sent
+     */
+    @Nonnull
+    LogEntry getEntry();
+
+    /**
+     * Gets where the log entry originated from.
+     *
+     * @return the origin of the log
+     */
+    @Nonnull
+    Origin getOrigin();
+
+    /**
+     * Gets the object to be notified.
+     *
+     * @return the object to notify
+     */
+    @Nonnull
+    Entity getNotifiable();
+
+    /**
+     * Represents where a log entry is from
+     */
+    enum Origin {
+
+        /**
+         * Marks a log entry which originated from the current server instance
+         */
+        LOCAL,
+
+        /**
+         * Marks a log entry which originated from an API call on the current server instance
+         */
+        LOCAL_API,
+
+        /**
+         * Marks a log entry which was sent to this server via the messaging service
+         */
+        REMOTE
+    }
+
+}
@@ -0,0 +1,47 @@
+/*
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api.event.log;
+
+import me.lucko.luckperms.api.LogEntry;
+import me.lucko.luckperms.api.event.Cancellable;
+import me.lucko.luckperms.api.event.LuckPermsEvent;
+
+import javax.annotation.Nonnull;
+
+/**
+ * Called when a log is about to be published to the storage file/table
+ */
+public interface LogPublishEvent extends LuckPermsEvent, Cancellable {
+
+    /**
+     * Gets the log entry to be published
+     *
+     * @return the log entry to be published
+     */
+    @Nonnull
+    LogEntry getEntry();
+
+}
@@ -1,5 +1,8 @@
 /*
- * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
 *
 *  Permission is hereby granted, free of charge, to any person obtaining a copy
 *  of this software and associated documentation files (the "Software"), to deal
@@ -20,30 +23,36 @@
 *  SOFTWARE.
 */

-package me.lucko.luckperms.api.event.events;
+package me.lucko.luckperms.api.event.log;

 import me.lucko.luckperms.api.LogEntry;
-import me.lucko.luckperms.api.event.CancellableEvent;
+import me.lucko.luckperms.api.event.LuckPermsEvent;
+
+import java.util.UUID;
+
+import javax.annotation.Nonnull;

 /**
- * Called before a LogEntry is broadcasted to players only with the notify permission.
- * The log entry will still be recorded in the datastore, regardless of the cancellation state of this event.
- * Cancelling this event only stops the broadcast.
+ * Called when a log entry is received via the MessagingService
+ *
+ * @since 3.3
 */
-public class LogNotifyEvent extends CancellableEvent {
+public interface LogReceiveEvent extends LuckPermsEvent {

    /**
-     * The log entry to be broadcasted
+     * Gets the ID of the log entry being received
+     *
+     * @return the id of the log entry being received
     */
-    private final LogEntry entry;
+    @Nonnull
+    UUID getLogId();

-    public LogNotifyEvent(LogEntry entry) {
-        super("Log Notify Event");
-        this.entry = entry;
-    }
-
-    public LogEntry getEntry() {
-        return entry;
-    }
+    /**
+     * Gets the log entry being received
+     *
+     * @return the log entry being received
+     */
+    @Nonnull
+    LogEntry getEntry();

 }
@@ -1,5 +1,8 @@
 /*
- * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
 *
 *  Permission is hereby granted, free of charge, to any person obtaining a copy
 *  of this software and associated documentation files (the "Software"), to deal
@@ -20,24 +23,23 @@
 *  SOFTWARE.
 */

-package me.lucko.luckperms.api.event;
+package me.lucko.luckperms.api.event.node;

 import me.lucko.luckperms.api.Node;
-import me.lucko.luckperms.api.PermissionHolder;
+
+import javax.annotation.Nonnull;

 /**
- * @since 2.6
+ * Called when a node is added to a holder
 */
-public class AbstractPermissionEvent extends TargetedEvent<PermissionHolder> {
+public interface NodeAddEvent extends NodeMutateEvent {

-    private final Node node;
+    /**
+     * Gets the node that was added
+     *
+     * @return the node that was added
+     */
+    @Nonnull
+    Node getNode();

-    protected AbstractPermissionEvent(String eventName, PermissionHolder target, Node node) {
-        super(eventName, target);
-        this.node = node;
-    }
-
-    public Node getNode() {
-        return node;
-    }
 }
@@ -1,5 +1,8 @@
 /*
- * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
 *
 *  Permission is hereby granted, free of charge, to any person obtaining a copy
 *  of this software and associated documentation files (the "Software"), to deal
@@ -20,11 +23,11 @@
 *  SOFTWARE.
 */

-package me.lucko.luckperms.exceptions;
+package me.lucko.luckperms.api.event.node;

 /**
- * Thrown when a permission holding object already has a permission, is already a member of a group, or when a track
- * already contains a group.
+ * Called when a holder has their nodes cleared
 */
-public class ObjectAlreadyHasException extends MembershipException {
+public interface NodeClearEvent extends NodeMutateEvent {
+
 }
@@ -0,0 +1,83 @@
+/*
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api.event.node;
+
+import me.lucko.luckperms.api.Node;
+import me.lucko.luckperms.api.PermissionHolder;
+import me.lucko.luckperms.api.event.LuckPermsEvent;
+
+import java.util.Set;
+
+import javax.annotation.Nonnull;
+
+/**
+ * Called when a node is added to/removed from a user/group
+ */
+public interface NodeMutateEvent extends LuckPermsEvent {
+
+    /**
+     * Gets the target of the event
+     *
+     * @return the event target
+     */
+    @Nonnull
+    PermissionHolder getTarget();
+
+    /**
+     * Gets an immutable copy of the holders data before the change
+     *
+     * @return the data before the change
+     */
+    @Nonnull
+    Set<Node> getDataBefore();
+
+    /**
+     * Gets an immutable copy of the holders data after the change
+     *
+     * @return the data after the change
+     */
+    @Nonnull
+    Set<Node> getDataAfter();
+
+    /**
+     * Gets whether the target of this event is a {@link me.lucko.luckperms.api.User}
+     *
+     * <p>This is equivalent to checking if getTarget() instanceof User</p>
+     *
+     * @return if the event is targeting a user
+     */
+    boolean isUser();
+
+    /**
+     * Gets whether the target of this event is a {@link me.lucko.luckperms.api.Group}
+     *
+     * <p>This is equivalent to checking if getTarget() instanceof Group</p>
+     *
+     * @return if the event is targeting a group
+     */
+    boolean isGroup();
+
+}
@@ -1,5 +1,8 @@
 /*
- * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
 *
 *  Permission is hereby granted, free of charge, to any person obtaining a copy
 *  of this software and associated documentation files (the "Software"), to deal
@@ -20,18 +23,23 @@
 *  SOFTWARE.
 */

-package me.lucko.luckperms.api.event.events;
+package me.lucko.luckperms.api.event.node;

 import me.lucko.luckperms.api.Node;
-import me.lucko.luckperms.api.PermissionHolder;
-import me.lucko.luckperms.api.event.AbstractPermissionEvent;
+
+import javax.annotation.Nonnull;

 /**
- * Called when a permission node is set on a holder
- * @since 2.6
+ * Called when a node is removed from a holder
 */
-public class PermissionNodeSetEvent extends AbstractPermissionEvent {
-    public PermissionNodeSetEvent(PermissionHolder target, Node node) {
-        super("Permission Node Set Event", target, node);
-    }
+public interface NodeRemoveEvent extends NodeMutateEvent {
+
+    /**
+     * Gets the node that was removed
+     *
+     * @return the node that was removed
+     */
+    @Nonnull
+    Node getNode();
+
 }
@@ -0,0 +1,47 @@
+/*
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api.event.source;
+
+import me.lucko.luckperms.api.Entity;
+
+import javax.annotation.Nonnull;
+
+/**
+ * Represents an {@link Entity} which was the {@link Source} of something.
+ *
+ * @since 4.1
+ */
+public interface EntitySource extends Source {
+
+    /**
+     * Gets the entity.
+     *
+     * @return the entity
+     */
+    @Nonnull
+    Entity getEntity();
+
+}
@@ -0,0 +1,67 @@
+/*
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api.event.source;
+
+import me.lucko.luckperms.api.Entity;
+
+import javax.annotation.Nonnull;
+
+/**
+ * Represents the source of an event.
+ *
+ * <p>Could also be described as the "thing" that caused an event to occur.</p>
+ *
+ * @since 4.1
+ */
+public interface Source {
+
+    /**
+     * Gets the source type
+     *
+     * @return the type
+     */
+    @Nonnull
+    Type getType();
+
+    /**
+     * Represents a type of source
+     */
+    enum Type {
+
+        /**
+         * Represents an {@link Entity} source
+         *
+         * @see EntitySource
+         */
+        ENTITY,
+
+        /**
+         * Represents an unknown source
+         */
+        UNKNOWN
+    }
+
+}
@@ -1,5 +1,8 @@
 /*
- * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
 *
 *  Permission is hereby granted, free of charge, to any person obtaining a copy
 *  of this software and associated documentation files (the "Software"), to deal
@@ -20,16 +23,13 @@
 *  SOFTWARE.
 */

-package me.lucko.luckperms.api.data;
+package me.lucko.luckperms.api.event.sync;
+
+import me.lucko.luckperms.api.event.LuckPermsEvent;

 /**
- * @deprecated Use {@link DatastoreConfiguration}. This is now used by multiple datastores, not just MySQL.
+ * Called when the configuration is reloaded
 */
-@Deprecated
-public interface MySQLConfiguration {
+public interface ConfigReloadEvent extends LuckPermsEvent {

-    String getAddress();
-    String getDatabase();
-    String getUsername();
-    String getPassword();
 }
@@ -1,5 +1,8 @@
 /*
- * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
 *
 *  Permission is hereby granted, free of charge, to any person obtaining a copy
 *  of this software and associated documentation files (the "Software"), to deal
@@ -20,17 +23,13 @@
 *  SOFTWARE.
 */

-package me.lucko.luckperms.api.event.events;
+package me.lucko.luckperms.api.event.sync;

-import me.lucko.luckperms.api.event.LPEvent;
+import me.lucko.luckperms.api.event.LuckPermsEvent;

 /**
- * Called after the sync task has ran.
+ * Called when an sync task has been completed
 */
-public class PostSyncEvent extends LPEvent {
-
-    public PostSyncEvent() {
-        super("Post Sync Event");
-    }
+public interface PostSyncEvent extends LuckPermsEvent {

 }
@@ -1,5 +1,8 @@
 /*
- * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
 *
 *  Permission is hereby granted, free of charge, to any person obtaining a copy
 *  of this software and associated documentation files (the "Software"), to deal
@@ -20,22 +23,26 @@
 *  SOFTWARE.
 */

-package me.lucko.luckperms.commands;
+package me.lucko.luckperms.api.event.sync;

-import me.lucko.luckperms.LuckPermsPlugin;
-import me.lucko.luckperms.constants.Permission;
+import me.lucko.luckperms.api.event.Cancellable;
+import me.lucko.luckperms.api.event.LuckPermsEvent;

 import java.util.UUID;

-/**
- * Wrapper interface to represent a CommandSender/CommandSource within the luckperms-common command implementations.
- */
-public interface Sender {
+import javax.annotation.Nonnull;

-    LuckPermsPlugin getPlatform();
-    String getName();
-    UUID getUuid();
-    void sendMessage(String s);
-    boolean hasPermission(Permission permission);
+/**
+ * Called before a received network sync task runs
+ */
+public interface PreNetworkSyncEvent extends LuckPermsEvent, Cancellable {
+
+    /**
+     * Gets the ID of the sync request
+     *
+     * @return the id of the sync request
+     */
+    @Nonnull
+    UUID getSyncId();

 }
@@ -1,5 +1,8 @@
 /*
- * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
 *
 *  Permission is hereby granted, free of charge, to any person obtaining a copy
 *  of this software and associated documentation files (the "Software"), to deal
@@ -20,18 +23,14 @@
 *  SOFTWARE.
 */

-package me.lucko.luckperms.api.event.events;
+package me.lucko.luckperms.api.event.sync;

-import me.lucko.luckperms.api.event.CancellableEvent;
+import me.lucko.luckperms.api.event.Cancellable;
+import me.lucko.luckperms.api.event.LuckPermsEvent;

 /**
- * Called before the sync task is about to run.
- * Set this event to cancelled to prevent the sync task from running.
+ * Called before a sync task runs
 */
-public class PreSyncEvent extends CancellableEvent {
-
-    public PreSyncEvent() {
-        super("Pre Sync Event");
-    }
+public interface PreSyncEvent extends LuckPermsEvent, Cancellable {

 }
@@ -0,0 +1,55 @@
+/*
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api.event.track;
+
+import me.lucko.luckperms.api.Track;
+import me.lucko.luckperms.api.event.LuckPermsEvent;
+import me.lucko.luckperms.api.event.cause.CreationCause;
+
+import javax.annotation.Nonnull;
+
+/**
+ * Called when a track is created
+ */
+public interface TrackCreateEvent extends LuckPermsEvent {
+
+    /**
+     * Gets the new track
+     *
+     * @return the new track
+     */
+    @Nonnull
+    Track getTrack();
+
+    /**
+     * Gets the cause of the creation
+     *
+     * @return the cause of the creation
+     */
+    @Nonnull
+    CreationCause getCause();
+
+}
@@ -0,0 +1,64 @@
+/*
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api.event.track;
+
+import me.lucko.luckperms.api.event.LuckPermsEvent;
+import me.lucko.luckperms.api.event.cause.DeletionCause;
+
+import java.util.List;
+
+import javax.annotation.Nonnull;
+
+/**
+ * Called when a track is deleted
+ */
+public interface TrackDeleteEvent extends LuckPermsEvent {
+
+    /**
+     * Gets the name of the deleted track
+     *
+     * @return the name of the deleted track
+     */
+    @Nonnull
+    String getTrackName();
+
+    /**
+     * Gets an immutable copy of the tracks existing data
+     *
+     * @return a copy of the tracks existing data
+     */
+    @Nonnull
+    List<String> getExistingData();
+
+    /**
+     * Gets the cause of the deletion
+     *
+     * @return the cause of the deletion
+     */
+    @Nonnull
+    DeletionCause getCause();
+
+}
@@ -0,0 +1,37 @@
+/*
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api.event.track;
+
+import me.lucko.luckperms.api.event.LuckPermsEvent;
+
+/**
+ * Called when all tracks have been loaded in from storage.
+ *
+ * <p>Usually only called on startup and in sync tasks.</p>
+ */
+public interface TrackLoadAllEvent extends LuckPermsEvent {
+
+}
@@ -1,5 +1,8 @@
 /*
- * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
 *
 *  Permission is hereby granted, free of charge, to any person obtaining a copy
 *  of this software and associated documentation files (the "Software"), to deal
@@ -20,19 +23,26 @@
 *  SOFTWARE.
 */

-package me.lucko.luckperms.api.event.events;
+package me.lucko.luckperms.api.event.track;

 import me.lucko.luckperms.api.Track;
-import me.lucko.luckperms.api.User;
-import me.lucko.luckperms.api.event.TrackEvent;
+import me.lucko.luckperms.api.event.LuckPermsEvent;
+
+import javax.annotation.Nonnull;

 /**
- * Called whenever a user is promoted up a track
+ * Called when a track is loaded into memory from the storage.
+ *
+ * Note that this event is not the same as {@link TrackCreateEvent}
 */
-public class UserPromoteEvent extends TrackEvent {
+public interface TrackLoadEvent extends LuckPermsEvent {

-    public UserPromoteEvent(Track track, User user, String from, String to) {
-        super("User Promote Event", track, user, from, to);
-    }
+    /**
+     * Gets the track that was loaded
+     *
+     * @return the track that was loaded
+     */
+    @Nonnull
+    Track getTrack();

 }
@@ -0,0 +1,43 @@
+/*
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api.event.track.mutate;
+
+import javax.annotation.Nonnull;
+
+/**
+ * Called when a group is added to a track
+ */
+public interface TrackAddGroupEvent extends TrackMutateEvent {
+
+    /**
+     * Gets the group that was added
+     *
+     * @return the group that was added
+     */
+    @Nonnull
+    String getGroup();
+
+}
@@ -1,5 +1,8 @@
 /*
- * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
 *
 *  Permission is hereby granted, free of charge, to any person obtaining a copy
 *  of this software and associated documentation files (the "Software"), to deal
@@ -20,11 +23,11 @@
 *  SOFTWARE.
 */

-package me.lucko.luckperms.exceptions;
+package me.lucko.luckperms.api.event.track.mutate;

 /**
- * Thrown when a permission holding object doesn't / already has a permission or isn't / is already is a member of a group
- * @since 2.7
+ * Called when a track is cleared
 */
-public abstract class MembershipException extends Exception {
+public interface TrackClearEvent extends TrackMutateEvent {
+
 }
@@ -0,0 +1,64 @@
+/*
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api.event.track.mutate;
+
+import me.lucko.luckperms.api.Track;
+import me.lucko.luckperms.api.event.LuckPermsEvent;
+
+import java.util.List;
+
+import javax.annotation.Nonnull;
+
+/**
+ * Called when a track is changed
+ */
+public interface TrackMutateEvent extends LuckPermsEvent {
+
+    /**
+     * Gets the track that was mutated
+     *
+     * @return the track that was mutated
+     */
+    @Nonnull
+    Track getTrack();
+
+    /**
+     * Gets an immutable copy of the tracks data before the change
+     *
+     * @return the data before the change
+     */
+    @Nonnull
+    List<String> getDataBefore();
+
+    /**
+     * Gets an immutable copy of the tracks data after the change
+     *
+     * @return the data after the change
+     */
+    @Nonnull
+    List<String> getDataAfter();
+
+}
@@ -0,0 +1,43 @@
+/*
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api.event.track.mutate;
+
+import javax.annotation.Nonnull;
+
+/**
+ * Called when a group is removed from a track
+ */
+public interface TrackRemoveGroupEvent extends TrackMutateEvent {
+
+    /**
+     * Gets the group that was removed
+     *
+     * @return the group that was removed
+     */
+    @Nonnull
+    String getGroup();
+
+}
@@ -0,0 +1,55 @@
+/*
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api.event.user;
+
+import me.lucko.luckperms.api.User;
+import me.lucko.luckperms.api.caching.UserData;
+import me.lucko.luckperms.api.event.LuckPermsEvent;
+
+import javax.annotation.Nonnull;
+
+/**
+ * Called when a users {@link me.lucko.luckperms.api.caching.UserData} is loaded.
+ */
+public interface UserCacheLoadEvent extends LuckPermsEvent {
+
+    /**
+     * Gets the user whose data was loaded
+     *
+     * @return the user
+     */
+    @Nonnull
+    User getUser();
+
+    /**
+     * Gets the data that was loaded
+     *
+     * @return the loaded data
+     */
+    @Nonnull
+    UserData getLoadedData();
+
+}
@@ -0,0 +1,55 @@
+/*
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api.event.user;
+
+import me.lucko.luckperms.api.User;
+import me.lucko.luckperms.api.caching.UserData;
+import me.lucko.luckperms.api.event.LuckPermsEvent;
+
+import javax.annotation.Nonnull;
+
+/**
+ * Called when a users cached data is refreshed
+ */
+public interface UserDataRecalculateEvent extends LuckPermsEvent {
+
+    /**
+     * Gets the user whose data was recalculated
+     *
+     * @return the user
+     */
+    @Nonnull
+    User getUser();
+
+    /**
+     * Gets the data that was recalculated
+     *
+     * @return the data
+     */
+    @Nonnull
+    UserData getData();
+
+}
@@ -0,0 +1,63 @@
+/*
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api.event.user;
+
+import me.lucko.luckperms.api.event.LuckPermsEvent;
+
+import java.util.UUID;
+
+import javax.annotation.Nonnull;
+
+/**
+ * Called when the user logs into the network for the first time.
+ *
+ * <p>Particularly useful for networks with multiple
+ * lobbies, who want to welcome a user when they join for the first time.</p>
+ *
+ * <p>This event is fired before the player has actually joined the game on the async login / auth event. If you want to
+ * do something with the user, store the UUID in a set, and then check the set in the PlayerJoinEvent o.e.</p>
+ *
+ * <p>The users data will not be loaded when this event is called.</p>
+ */
+public interface UserFirstLoginEvent extends LuckPermsEvent {
+
+    /**
+     * Gets the UUID of the user
+     *
+     * @return the uuid of the user
+     */
+    @Nonnull
+    UUID getUuid();
+
+    /**
+     * Gets the username of the user
+     *
+     * @return the username of the user
+     */
+    @Nonnull
+    String getUsername();
+
+}
@@ -1,5 +1,8 @@
 /*
- * Copyright (c) 2016 Lucko (Luck) <luck@lucko.me>
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
 *
 *  Permission is hereby granted, free of charge, to any person obtaining a copy
 *  of this software and associated documentation files (the "Software"), to deal
@@ -20,19 +23,24 @@
 *  SOFTWARE.
 */

-package me.lucko.luckperms.api.event.events;
+package me.lucko.luckperms.api.event.user;

 import me.lucko.luckperms.api.User;
-import me.lucko.luckperms.api.event.UserEvent;
+import me.lucko.luckperms.api.event.LuckPermsEvent;
+
+import javax.annotation.Nonnull;

 /**
- * Called after a user has their permissions refreshed.
- * If you cache user permissions within your own plugin, it's a good idea to update said cache whenever this event is called.
+ * Called when a user is loaded into memory from the storage.
 */
-public class UserPermissionRefreshEvent extends UserEvent {
+public interface UserLoadEvent extends LuckPermsEvent {

-    public UserPermissionRefreshEvent(User user) {
-        super("User Permission Refresh Event", user);
-    }
+    /**
+     * Gets the user that was loaded
+     *
+     * @return the user that was loaded
+     */
+    @Nonnull
+    User getUser();

 }
@@ -0,0 +1,72 @@
+/*
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api.event.user;
+
+import me.lucko.luckperms.api.User;
+import me.lucko.luckperms.api.event.LuckPermsEvent;
+
+import java.util.UUID;
+
+import javax.annotation.Nonnull;
+
+/**
+ * Called when LuckPerms has finished processing a certain Player's connection.
+ *
+ * <p>This event will always execute during the platforms async login/auth event.
+ * All handlers will be called instantly.</p>
+ *
+ * <p>This, among other things, allows you to wait until permission data is loaded
+ * for a User during the BungeeCord 'LoginEvent', as event priorities are ignored
+ * by the current implementation.</p>
+ *
+ * @since 3.4
+ */
+public interface UserLoginProcessEvent extends LuckPermsEvent {
+
+    /**
+     * Gets the UUID of the connection which was processed
+     *
+     * @return the uuid of the connection which was processed
+     */
+    @Nonnull
+    UUID getUuid();
+
+    /**
+     * Gets the username of the connection which was processed
+     *
+     * @return the username of the connection which was processed
+     */
+    @Nonnull
+    String getUsername();
+
+    /**
+     * Gets the resultant User instance which was loaded.
+     *
+     * @return the user instance
+     */
+    User getUser();
+
+}
@@ -0,0 +1,43 @@
+/*
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api.event.user.track;
+
+/**
+ * Represents the type of action performed in a {@link UserTrackEvent}
+ */
+public enum TrackAction {
+
+    /**
+     * The user was promoted up a track
+     */
+    PROMOTION,
+
+    /**
+     * The user was demoted down a track
+     */
+    DEMOTION
+
+}
@@ -0,0 +1,35 @@
+/*
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api.event.user.track;
+
+/**
+ * Called when a user is demoted down a track.
+ *
+ * <p>{@link #getAction()} is always {@link TrackAction#DEMOTION}</p>
+ */
+public interface UserDemoteEvent extends UserTrackEvent {
+
+}
@@ -0,0 +1,35 @@
+/*
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api.event.user.track;
+
+/**
+ * Called when a user is promoted up a track.
+ *
+ * <p>{@link #getAction()} is always {@link TrackAction#PROMOTION}</p>
+ */
+public interface UserPromoteEvent extends UserTrackEvent {
+
+}
@@ -0,0 +1,84 @@
+/*
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api.event.user.track;
+
+import me.lucko.luckperms.api.Track;
+import me.lucko.luckperms.api.User;
+import me.lucko.luckperms.api.event.LuckPermsEvent;
+import me.lucko.luckperms.api.event.Sourced;
+
+import java.util.Optional;
+
+import javax.annotation.Nonnull;
+
+/**
+ * Called when a user interacts with a track through a promotion or demotion
+ */
+public interface UserTrackEvent extends LuckPermsEvent, Sourced {
+
+    /**
+     * Gets the track involved in the event
+     *
+     * @return the track involved in the event
+     */
+    @Nonnull
+    Track getTrack();
+
+    /**
+     * Gets the user who was promoted or demoted
+     *
+     * @return the user involved in the event
+     */
+    @Nonnull
+    User getUser();
+
+    /**
+     * Gets the action performed
+     *
+     * @return the action performed
+     */
+    @Nonnull
+    TrackAction getAction();
+
+    /**
+     * Gets the group the user was promoted/demoted from.
+     *
+     * <p>May be {@link Optional#empty()} if the user wasn't already placed on the track.</p>
+     *
+     * @return the group the user was promoted/demoted from
+     */
+    @Nonnull
+    Optional<String> getGroupFrom();
+
+    /**
+     * Gets the group the user was promoted/demoted to
+     *
+     * @return the group the user was promoted/demoted to
+     */
+    @Nonnull
+    Optional<String> getGroupTo();
+
+}
@@ -0,0 +1,182 @@
+/*
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api.manager;
+
+import me.lucko.luckperms.api.Group;
+import me.lucko.luckperms.api.Storage;
+
+import java.util.Optional;
+import java.util.Set;
+import java.util.concurrent.CompletableFuture;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
+/**
+ * Represents the object responsible for managing {@link Group} instances.
+ *
+ * @since 4.0
+ */
+public interface GroupManager {
+
+    /**
+     * Creates a new group in the plugin's storage provider and then loads it
+     * into memory.
+     *
+     * <p>If a group by the same name already exists, it will be loaded.</p>
+     *
+     * <p>This method is effectively the same as
+     * {@link Storage#createAndLoadGroup(String)}, however, the Future returns
+     * the resultant group instance instead of a boolean flag.</p>
+     *
+     * <p>Unlike the method in {@link Storage}, when a group cannot be loaded,
+     * the future will be {@link CompletableFuture completed exceptionally}.</p>
+     *
+     * @param name the name of the group
+     * @return the resultant group
+     * @throws NullPointerException if the name is null
+     * @since 4.1
+     */
+    @Nonnull
+    CompletableFuture<Group> createAndLoadGroup(@Nonnull String name);
+
+    /**
+     * Loads a group from the plugin's storage provider into memory.
+     *
+     * <p>Returns an {@link Optional#empty() empty optional} if the group does
+     * not exist.</p>
+     *
+     * <p>This method is effectively the same as
+     * {@link Storage#loadGroup(String)}, however, the Future returns
+     * the resultant group instance instead of a boolean flag.</p>
+     *
+     * <p>Unlike the method in {@link Storage}, when a group cannot be loaded,
+     * the future will be {@link CompletableFuture completed exceptionally}.</p>
+     *
+     * @param name the name of the group
+     * @return the resultant group
+     * @throws NullPointerException if the name is null
+     * @since 4.1
+     */
+    @Nonnull
+    CompletableFuture<Optional<Group>> loadGroup(@Nonnull String name);
+
+    /**
+     * Saves a group's data back to the plugin's storage provider.
+     *
+     * <p>You should call this after you make any changes to a group.</p>
+     *
+     * <p>This method is effectively the same as {@link Storage#saveGroup(Group)},
+     * however, the Future returns void instead of a boolean flag.</p>
+     *
+     * <p>Unlike the method in {@link Storage}, when a group cannot be saved,
+     * the future will be {@link CompletableFuture completed exceptionally}.</p>
+     *
+     * @param group the group to save
+     * @return a future to encapsulate the operation.
+     * @throws NullPointerException  if group is null
+     * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
+     * @since 4.1
+     */
+    @Nonnull
+    CompletableFuture<Void> saveGroup(@Nonnull Group group);
+
+    /**
+     * Permanently deletes a group from the plugin's storage provider.
+     *
+     * <p>This method is effectively the same as {@link Storage#deleteGroup(Group)},
+     * however, the Future returns void instead of a boolean flag.</p>
+     *
+     * <p>Unlike the method in {@link Storage}, when a group cannot be deleted,
+     * the future will be {@link CompletableFuture completed exceptionally}.</p>
+     *
+     *
+     * @param group the group to delete
+     * @return a future to encapsulate the operation.
+     * @throws NullPointerException  if group is null
+     * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
+     * @since 4.1
+     */
+    @Nonnull
+    CompletableFuture<Void> deleteGroup(@Nonnull Group group);
+
+    /**
+     * Loads all groups into memory.
+     *
+     * <p>This method is effectively the same as {@link Storage#loadAllTracks()},
+     * however, the Future returns void instead of a boolean flag.</p>
+     *
+     * <p>Unlike the method in {@link Storage}, when a group cannot be loaded,
+     * the future will be {@link CompletableFuture completed exceptionally}.</p>
+     *
+     * @return a future to encapsulate the operation.
+     * @since 4.1
+     */
+    @Nonnull
+    CompletableFuture<Void> loadAllGroups();
+
+    /**
+     * Gets a loaded group.
+     *
+     * @param name the name of the group to get
+     * @return a {@link Group} object, if one matching the name exists, or null if not
+     * @throws NullPointerException if the name is null
+     */
+    @Nullable
+    Group getGroup(@Nonnull String name);
+
+    /**
+     * Gets a loaded group.
+     *
+     * <p>This method does not return null, unlike {@link #getGroup}</p>
+     *
+     * @param name the name of the group to get
+     * @return an optional {@link Group} object
+     * @throws NullPointerException if the name is null
+     */
+    @Nonnull
+    default Optional<Group> getGroupOpt(@Nonnull String name) {
+        return Optional.ofNullable(getGroup(name));
+    }
+
+    /**
+     * Gets a set of all loaded groups.
+     *
+     * @return a {@link Set} of {@link Group} objects
+     */
+    @Nonnull
+    Set<Group> getLoadedGroups();
+
+    /**
+     * Check if a group is loaded in memory
+     *
+     * @param name the name to check for
+     * @return true if the group is loaded
+     * @throws NullPointerException if the name is null
+     */
+    boolean isLoaded(@Nonnull String name);
+
+}
@@ -0,0 +1,182 @@
+/*
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api.manager;
+
+import me.lucko.luckperms.api.Storage;
+import me.lucko.luckperms.api.Track;
+
+import java.util.Optional;
+import java.util.Set;
+import java.util.concurrent.CompletableFuture;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
+/**
+ * Represents the object responsible for managing {@link Track} instances.
+ *
+ * @since 4.0
+ */
+public interface TrackManager {
+
+    /**
+     * Creates a new track in the plugin's storage provider and then loads it
+     * into memory.
+     *
+     * <p>If a track by the same name already exists, it will be loaded.</p>
+     *
+     * <p>This method is effectively the same as
+     * {@link Storage#createAndLoadTrack(String)}, however, the Future returns
+     * the resultant track instance instead of a boolean flag.</p>
+     *
+     * <p>Unlike the method in {@link Storage}, when a track cannot be loaded,
+     * the future will be {@link CompletableFuture completed exceptionally}.</p>
+     *
+     * @param name the name of the track
+     * @return the resultant track
+     * @throws NullPointerException if the name is null
+     * @since 4.1
+     */
+    @Nonnull
+    CompletableFuture<Track> createAndLoadTrack(@Nonnull String name);
+
+    /**
+     * Loads a track from the plugin's storage provider into memory.
+     *
+     * <p>Returns an {@link Optional#empty() empty optional} if the track does
+     * not exist.</p>
+     *
+     * <p>This method is effectively the same as
+     * {@link Storage#loadTrack(String)}, however, the Future returns
+     * the resultant track instance instead of a boolean flag.</p>
+     *
+     * <p>Unlike the method in {@link Storage}, when a track cannot be loaded,
+     * the future will be {@link CompletableFuture completed exceptionally}.</p>
+     *
+     * @param name the name of the track
+     * @return the resultant track
+     * @throws NullPointerException if the name is null
+     * @since 4.1
+     */
+    @Nonnull
+    CompletableFuture<Optional<Track>> loadTrack(@Nonnull String name);
+
+    /**
+     * Saves a track's data back to the plugin's storage provider.
+     *
+     * <p>You should call this after you make any changes to a track.</p>
+     *
+     * <p>This method is effectively the same as {@link Storage#saveTrack(Track)},
+     * however, the Future returns void instead of a boolean flag.</p>
+     *
+     * <p>Unlike the method in {@link Storage}, when a track cannot be saved,
+     * the future will be {@link CompletableFuture completed exceptionally}.</p>
+     *
+     * @param track the track to save
+     * @return a future to encapsulate the operation.
+     * @throws NullPointerException  if track is null
+     * @throws IllegalStateException if the track instance was not obtained from LuckPerms.
+     * @since 4.1
+     */
+    @Nonnull
+    CompletableFuture<Void> saveTrack(@Nonnull Track track);
+
+    /**
+     * Permanently deletes a track from the plugin's storage provider.
+     *
+     * <p>This method is effectively the same as {@link Storage#deleteTrack(Track)},
+     * however, the Future returns void instead of a boolean flag.</p>
+     *
+     * <p>Unlike the method in {@link Storage}, when a track cannot be deleted,
+     * the future will be {@link CompletableFuture completed exceptionally}.</p>
+     *
+     *
+     * @param track the track to delete
+     * @return a future to encapsulate the operation.
+     * @throws NullPointerException  if track is null
+     * @throws IllegalStateException if the track instance was not obtained from LuckPerms.
+     * @since 4.1
+     */
+    @Nonnull
+    CompletableFuture<Void> deleteTrack(@Nonnull Track track);
+
+    /**
+     * Loads all tracks into memory.
+     *
+     * <p>This method is effectively the same as {@link Storage#loadAllTracks()},
+     * however, the Future returns void instead of a boolean flag.</p>
+     *
+     * <p>Unlike the method in {@link Storage}, when a track cannot be loaded,
+     * the future will be {@link CompletableFuture completed exceptionally}.</p>
+     *
+     * @return a future to encapsulate the operation.
+     * @since 4.1
+     */
+    @Nonnull
+    CompletableFuture<Void> loadAllTracks();
+
+    /**
+     * Gets a loaded track.
+     *
+     * @param name the name of the track to get
+     * @return a {@link Track} object, if one matching the name exists, or null if not
+     * @throws NullPointerException if the name is null
+     */
+    @Nullable
+    Track getTrack(@Nonnull String name);
+
+    /**
+     * Gets a loaded track.
+     *
+     * <p>This method does not return null, unlike {@link #getTrack}</p>
+     *
+     * @param name the name of the track to get
+     * @return an optional {@link Track} object
+     * @throws NullPointerException if the name is null
+     */
+    @Nonnull
+    default Optional<Track> getTrackOpt(@Nonnull String name) {
+        return Optional.ofNullable(getTrack(name));
+    }
+
+    /**
+     * Gets a set of all loaded tracks.
+     *
+     * @return a {@link Set} of {@link Track} objects
+     */
+    @Nonnull
+    Set<Track> getLoadedTracks();
+
+    /**
+     * Check if a track is loaded in memory
+     *
+     * @param name the name to check for
+     * @return true if the track is loaded
+     * @throws NullPointerException if the name is null
+     */
+    boolean isLoaded(@Nonnull String name);
+
+}
@@ -0,0 +1,177 @@
+/*
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api.manager;
+
+import me.lucko.luckperms.api.Storage;
+import me.lucko.luckperms.api.User;
+
+import java.util.Optional;
+import java.util.Set;
+import java.util.UUID;
+import java.util.concurrent.CompletableFuture;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
+/**
+ * Represents the object responsible for managing {@link User} instances.
+ *
+ * <p>Note that User instances are automatically loaded for online players.
+ * It's likely that offline players will not have an instance pre-loaded.</p>
+ *
+ * @since 4.0
+ */
+public interface UserManager {
+
+    /**
+     * Loads a user from the plugin's storage provider into memory.
+     *
+     * <p>This method is effectively the same as
+     * {@link Storage#loadUser(UUID, String)}, however, the Future returns the
+     * resultant user instance instead of a boolean flag.</p>
+     *
+     * <p>Unlike the method in {@link Storage}, when a user cannot be loaded,
+     * the future will be {@link CompletableFuture completed exceptionally}.</p>
+     *
+     * @param uuid the uuid of the user
+     * @param username the username, if known
+     * @return the resultant user
+     * @throws NullPointerException if the uuid is null
+     * @since 4.1
+     */
+    @Nonnull
+    CompletableFuture<User> loadUser(@Nonnull UUID uuid, @Nullable String username);
+
+    /**
+     * Loads a user from the plugin's storage provider into memory.
+     *
+     * <p>This method is effectively the same as {@link Storage#loadUser(UUID)},
+     * however, the Future returns the resultant user instance instead of a
+     * boolean flag.</p>
+     *
+     * <p>Unlike the method in {@link Storage}, when a user cannot be loaded,
+     * the future will be {@link CompletableFuture completed exceptionally}.</p>
+     *
+     * @param uuid the uuid of the user
+     * @return the resultant user
+     * @throws NullPointerException if the uuid is null
+     * @since 4.1
+     */
+    @Nonnull
+    default CompletableFuture<User> loadUser(@Nonnull UUID uuid) {
+        return loadUser(uuid, null);
+    }
+
+    /**
+     * Saves a user's data back to the plugin's storage provider.
+     *
+     * <p>You should call this after you make any changes to a user.</p>
+     *
+     * <p>This method is effectively the same as {@link Storage#saveUser(User)},
+     * however, the Future returns void instead of a boolean flag.</p>
+     *
+     * <p>Unlike the method in {@link Storage}, when a user cannot be saved,
+     * the future will be {@link CompletableFuture completed exceptionally}.</p>
+     *
+     * @param user the user to save
+     * @return a future to encapsulate the operation.
+     * @throws NullPointerException  if user is null
+     * @throws IllegalStateException if the user instance was not obtained from LuckPerms.
+     * @since 4.1
+     */
+    @Nonnull
+    CompletableFuture<Void> saveUser(@Nonnull User user);
+
+    /**
+     * Gets a loaded user.
+     *
+     * @param uuid the uuid of the user to get
+     * @return a {@link User} object, if one matching the uuid is loaded, or null if not
+     * @throws NullPointerException if the uuid is null
+     */
+    @Nullable
+    User getUser(@Nonnull UUID uuid);
+
+    /**
+     * Gets a loaded user.
+     *
+     * @param uuid the uuid of the user to get
+     * @return an optional {@link User} object
+     * @throws NullPointerException if the uuid is null
+     */
+    @Nonnull
+    default Optional<User> getUserOpt(@Nonnull UUID uuid) {
+        return Optional.ofNullable(getUser(uuid));
+    }
+
+    /**
+     * Gets a loaded user.
+     *
+     * @param name the username of the user to get
+     * @return a {@link User} object, if one matching the uuid is loaded, or null if not
+     * @throws NullPointerException if the name is null
+     */
+    @Nullable
+    User getUser(@Nonnull String name);
+
+    /**
+     * Gets a loaded user.
+     *
+     * @param name the username of the user to get
+     * @return an optional {@link User} object
+     * @throws NullPointerException if the name is null
+     */
+    @Nonnull
+    default Optional<User> getUserOpt(@Nonnull String name) {
+        return Optional.ofNullable(getUser(name));
+    }
+
+    /**
+     * Gets a set of all loaded users.
+     *
+     * @return a {@link Set} of {@link User} objects
+     */
+    @Nonnull
+    Set<User> getLoadedUsers();
+
+    /**
+     * Check if a user is loaded in memory
+     *
+     * @param uuid the uuid to check for
+     * @return true if the user is loaded
+     * @throws NullPointerException if the uuid is null
+     */
+    boolean isLoaded(@Nonnull UUID uuid);
+
+    /**
+     * Unload a user from the internal storage, if they're not currently online.
+     *
+     * @param user the user to unload
+     * @throws NullPointerException if the user is null
+     */
+    void cleanupUser(@Nonnull User user);
+
+}
@@ -0,0 +1,78 @@
+/*
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api.messenger;
+
+import me.lucko.luckperms.api.messenger.message.Message;
+import me.lucko.luckperms.api.messenger.message.OutgoingMessage;
+
+import javax.annotation.Nonnull;
+
+/**
+ * Encapsulates the LuckPerms system which accepts incoming {@link Message}s
+ * from implementations of {@link MessengerProvider}.
+ *
+ * @since 4.1
+ */
+public interface IncomingMessageConsumer {
+
+    /**
+     * Consumes a message instance.
+     *
+     * <p>The boolean returned from this method indicates whether or not the
+     * platform accepted the message. Some implementations which have multiple
+     * distribution channels may wish to use this result to dispatch the same
+     * message back to additional receivers.</p>
+     *
+     * <p>The implementation will usually return <code>false</code> if a message
+     * with the same ping id has already been processed.</p>
+     *
+     * @param message the message
+     * @return true if the message was accepted by the plugin
+     */
+    boolean consumeIncomingMessage(@Nonnull Message message);
+
+    /**
+     * Consumes a message in an encoded string format.
+     *
+     * <p>This method will decode strings obtained by calling
+     * {@link OutgoingMessage#asEncodedString()}. This means that basic
+     * implementations can successfully implement {@link Messenger} without
+     * providing their own serialisation.</p>
+     *
+     * <p>The boolean returned from this method indicates whether or not the
+     * platform accepted the message. Some implementations which have multiple
+     * distribution channels may wish to use this result to dispatch the same
+     * message back to additional receivers.</p>
+     *
+     * <p>The implementation will usually return <code>false</code> if a message
+     * with the same ping id has already been processed.</p>
+     *
+     * @param encodedString the encoded string
+     * @return true if the message was accepted by the plugin
+     */
+    boolean consumeIncomingMessageAsString(@Nonnull String encodedString);
+
+}
@@ -0,0 +1,58 @@
+/*
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api.messenger;
+
+import me.lucko.luckperms.api.messenger.message.Message;
+import me.lucko.luckperms.api.messenger.message.OutgoingMessage;
+
+import javax.annotation.Nonnull;
+
+/**
+ * Represents an object which dispatches {@link OutgoingMessage}s.
+ *
+ * @since 4.1
+ */
+public interface Messenger extends AutoCloseable {
+
+    /**
+     * Performs the necessary action to dispatch the message using the means
+     * of the messenger.
+     *
+     * <p>The outgoing message instance is guaranteed to be an instance of one
+     * of the interfaces extending {@link Message} in the
+     * 'api.messenger.message.type' package.</p>
+     *
+     * <p>This call is always made async.</p>
+     *
+     * @param outgoingMessage the outgoing message
+     */
+    void sendOutgoingMessage(@Nonnull OutgoingMessage outgoingMessage);
+
+    @Override
+    default void close() {
+
+    }
+}
@@ -0,0 +1,65 @@
+/*
+ * This file is part of LuckPerms, licensed under the MIT License.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+package me.lucko.luckperms.api.messenger;
+
+import me.lucko.luckperms.api.LuckPermsApi;
+
+import javax.annotation.Nonnull;
+
+/**
+ * Represents a provider for {@link Messenger} instances.
+ *
+ * <p>Users wishing to provide their own implementation for the plugins
+ * "Messaging Service" should implement and register this interface.</p>
+ *
+ * @since 4.1
+ * @see LuckPermsApi#registerMessengerProvider(MessengerProvider)
+ */
+public interface MessengerProvider {
+
+    /**
+     * Gets the name of this provider.
+     *
+     * @return the provider name
+     */
+    @Nonnull
+    String getName();
+
+    /**
+     * Creates and returns a new {@link Messenger} instance, which passes
+     * incoming messages to the provided {@link IncomingMessageConsumer}.
+     *
+     * <p>As the agent should pass incoming messages to the given consumer,
+     * this method should always return a new object.</p>
+     *
+     * @param incomingMessageConsumer the consumer the new instance should pass
+     *                                incoming messages to
+     * @return a new messenger agent instance
+     */
+    @Nonnull
+    Messenger obtain(@Nonnull IncomingMessageConsumer incomingMessageConsumer);
+
+}