Events rewrite, remove most deprecated API methods (v3.0)

Fix bukkit child permission handling to not include permissions with no children & cleanup permission registration
ensure all bukkit permissions are registered on startup
2017-02-19 14:57:20 +00:00 · 2017-02-18 21:01:09 +00:00 · 2017-02-18 08:50:06 +00:00 · 2017-02-16 21:45:43 +00:00 · 2017-02-16 21:43:27 +00:00 · 2017-02-15 19:39:24 +00:00
555 changed files with 53657 additions and 7645 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*
@@ -1,6 +1,6 @@
 MIT License

-Copyright (c) 2016 Luck
+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
@@ -1,142 +0,0 @@
-= LuckPerms
-A (fairly bad) permissions implementation for Bukkit/BungeeCord.
-
-== Features
-* **Group inheritance** - users can be members of multiple groups, groups can inherit other groups
-* **Temporary permissions** - users/groups can be given permissions that expire after a given time
-* **Temporary groups** - users/groups can be added to/inherit other groups temporarily
-* **Multi-server support** - data is synced across all servers/platforms
-* **Per-server permissions/groups** - define user/group permissions that only apply on certain servers
-* **Server-specific groups** - define groups that only apply on certain servers
-* **Tracks / paths** - users can be promoted/demoted along multiple group tracks
-* **Vault Support** - hooks into Vault to integrate with other plugins
-* **Easy and simple setup and configuration using commands** - no editing yml files, yuck
-* **Efficient/lightweight** - maybe? Who knows, it might be.
-* **BungeeCord compatible** - permissions, users and groups are synced across Bukkit/BungeeCord instances
-* **Support for MySQL, SQLite & Flatfile (JSON)** - other storage methods coming soon (maybe)
-
-===== Possible Caveats
-* Currently only supports MySQL, SQLite & Flatfile (JSON) (support for more methods might come in the future)
-* Not at all tested and could produce unexpected/buggy results and errors
-
-== Setup
-All configuration options are in the **config.yml** file, which is generated automagically when the plugin first starts.
-
-You can define the settings for per-server permissions, the storage method and credentials within this file.
-
-== Info
-=== Permission Calculation
-Permissions are calculated based on a priority system as follows.
-
-* Temporary permissions will override non-temporary permissions.
-
-Example: if a user has a false permission set for "test.node", and a temporary true permission set for "test.node", the temporary permission will override the permanent one, and the user will be granted the true node.
-
-* Server specific permissions will override generic/global permissions.
-
-Example: if a user has a global "fly.use" permission, and then has a negated "fly.use" permission on the "factions" server, the server specific permission will override the globally defined one, and the user will be granted the negated node.
-
-* Inherited permissions will be overridden by an objects own permissions.
-
-Example: A user is a member of the default group, which grants "some.thing.perm", but the users own permissions has "some.thing.perm" set to false. The inherited permission will be overridden by the users own permissions, and the user will be granted the negative node.
-
-=== Temporary Permissions
-Temporary permissions are checked each time a user/group is loaded, and when the sync task runs. This means if you set a temporary permission to expire after 30 seconds, it won't actually be removed until the sync task runs.
-
-The only way around this is to decrease the sync interval.
-
-== Commands
-
-Command usage is printed to the console/chat whenever invalid arguments are provided. Simply typing /perms will list all commands a user has permission to use.
-
-=== Aliases
-| Bukkit | /luckperms |
-| | /perms |
-| | /permissions |
-| | /lp |
-| | /perm |
-| Bungee | /luckpermsbungee |
-| | /bperms |
-| | /bpermissions |
-| | /lpb |
-| | /bperm |
-
-Arguments: <required> [optional]
-
-Users with OP have access to all commands.
-
-Additionally, you can use wildcards to grant users access to a selection of commands.
-* **All commands** - luckperms.*
-* **All user commands** - luckperms.user.*
-* **All group commands** - luckperms.group.*
-* **All track commands** - luckperms.track.*
-
-
-|  **Command**  |  **Description**  |  **Permission**  |
-| /perms | Sends plugin info and usage | N/A |
-| /perms sync | Runs an update task and reloads the data of all online users | luckperms.sync |
-| /perms info | Shows information about the plugin | luckperms.info |
-| /perms debug | Shows some very brief debug info about the number of users/groups loaded | luckperms.debug |
-|  |  |  |
-|  |  |  |
-|  |  |  |
-| /perms creategroup <group> | Creates a new group with the given name | luckperms.creategroup |
-| /perms deletegroup <group> | Deletes an existing group | luckperms.deletegroup |
-| /perms listgroups | Shows a list of the groups registered within the system | luckperms.listgroups |
-|  |  |  |
-|  |  |  |
-|  |  |  |
-| /perms createtrack <track> | Creates a new track with the given name | luckperms.createtrack |
-| /perms deletetrack <track> | Deletes an existing track | luckperms.deletetrack |
-| /perms listtracks | Shows a list of the tracks registered within the system | luckperms.listtracks |
-|  |  |  |
-|  |  |  |
-|  |  |  |
-| /perms user <user> info | Shows info about the user | luckperms.user.info |
-| /perms user <user> getuuid | Shows the users Mojang UUID | luckperms.user.getuuid |
-| /perms user <user> listnodes | Lists all of the permission nodes the user has | luckperms.user.listnodes |
-| /perms user <user> haspermission <node> [server] | Checks if the user has a permission on a certain server | luckperms.user.haspermission |
-| /perms user <user> inheritspermission <node> [server] | Checks if the user inherits a permission on a certain server. (This checks all parent groups unlike haspermission) | luckperms.user.inheritspermission |
-| /perms user <user> set <node> <true/false> [server]| Sets a permission for the user | luckperms.user.setpermission |
-| /perms user <user> unset <node> [server] | Unsets a permission for the user | luckperms.user.unsetpermission |
-| /perms user <user> addgroup <group> [server] | Adds the user to a group | luckperms.user.addgroup |
-| /perms user <user> removegroup <group> [server] | Removes the user from a group | luckperms.user.removegroup |
-| /perms user <user> settemp <node> <true/false> <duration> [server]| Sets a temporary permission for the user | luckperms.user.settemppermission |
-| /perms user <user> unsettemp <node> [server] | Unsets a temporary permission for the user | luckperms.user.unsettemppermission |
-| /perms user <user> addtempgroup <group> <duration> [server] | Adds the user to a group temporarily | luckperms.user.addtempgroup |
-| /perms user <user> removetempgroup <group> [server] | Removes the user from a temporary group | luckperms.user.removetempgroup |
-| /perms user <user> setprimarygroup <group> | Sets the users primary group | luckperms.user.setprimarygroup |
-| /perms user <user> showtracks | Shows a list of the tracks the user can be promoted/demoted on | luckperms.user.showtracks |
-| /perms user <user> promote <track> | Promotes the user along a given track | luckperms.user.promote |
-| /perms user <user> demote <track> | Demotes the user along a given track | luckperms.user.demote |
-| /perms user <user> showpos <track> | Shows the users position on a given track | luckperms.user.showpos |
-| /perms user <user> clear | Clears all permissions the user has | luckperms.user.clear |
-|  |  |  |
-|  |  |  |
-|  |  |  |
-| /perms group <group> info | Shows info about the group | luckperms.group.info |
-| /perms group <group> listnodes | Lists all of the permission nodes the group has | luckperms.group.listnodes |
-| /perms group <group> haspermission <node> [server] | Checks if the group has a permission on a certain server | luckperms.group.haspermission |
-| /perms group <group> inheritspermission <node> [server] | Checks if the group inherits a permission on a certain server. (This checks all parent groups unlike haspermission) | luckperms.group.inheritspermission |
-| /perms group <group> set <node> <true/false> [server]| Sets a permission for the group | luckperms.group.setpermission |
-| /perms group <group> unset <node> [server] | Unsets a permission for the group | luckperms.group.unsetpermission |
-| /perms group <group> setinherit <group> [server]| Sets the group to inherit all permissions from another group | luckperms.group.setinherit |
-| /perms group <group> unsetinherit <group> [server] | Unsets a previously defined inheritance rule | luckperms.group.unsetinherit |
-| /perms group <group> settemp <node> <true/false> <duration> [server] | Sets a temporary permission for the group | luckperms.group.settemppermission |
-| /perms group <group> unsettemp <node> [server] | Unsets a temporary permission for the group | luckperms.group.unsettemppermission |
-| /perms group <group> settempinherit <group> <duration> [server] | Sets the group to inherit all permissions from another group temporarily | luckperms.group.settempinherit |
-| /perms group <group> unsettempinherit <group> [server] | Unsets a previously defined temporary inheritance rule | luckperms.group.unsettempinherit |
-| /perms group <group> showtracks | Shows a list of the tracks that the users in the group can be promoted/demoted on | luckperms.group.showtracks |
-| /perms group <group> clear | Clears all permissions the group has | luckperms.group.clear |
-|  |  |  |
-|  |  |  |
-|  |  |  |
-| /perms track <track> info | Shows info about the track | luckperms.track.info |
-| /perms track <track> append <group> | Appends a group to the end of the track | luckperms.track.append |
-| /perms track <track> insert <group> <position> | Inserts a group at the given position on the track | luckperms.track.insert |
-| /perms track <track> remove <group> | Removes a group from the track | luckperms.track.remove |
-| /perms track <track> clear | Clears all groups on the track | luckperms.track.clear |
-
-
-== License
-See LICENSE.md.
@@ -0,0 +1,44 @@
+![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/)
+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.
+
+[See the charts below](https://github.com/lucko/LuckPerms#luckperms-vs-other-plugins) for a partial list of features & comparison with other providers.
+
+* [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
+* **Development Builds** - <https://ci.lucko.me/job/LuckPerms>
+* **Javadocs** - <https://jd.lucko.me/LuckPerms>
+* **Wiki** - <https://github.com/lucko/LuckPerms/wiki>
+
+## Building
+LuckPerms uses Maven to handle dependencies.
+
+#### Requirements
+* Maven 3.3.x (the older versions will not work.)
+* Git
+
+#### Then run
+```sh
+git clone https://github.com/lucko/LuckPerms.git
+mvn clean package
+```
+
+## License
+LuckPerms is licensed under the permissive MIT license. Please see [`LICENSE.txt`](https://github.com/lucko/LuckPerms/blob/master/LICENSE.txt) for more info.
+
+## LuckPerms vs Other Plugins
+### Bukkit
+![alt text](https://static.lucko.me/luckperms-compare-copy.png "Feature comparison")
+###### _Features checked on 23rd Aug 2016. If you find any inaccuracies, please let me know._
+### Sponge
+![alt text](https://static.lucko.me/luckperms-compare-sponge.png "Feature comparison")
+###### _Features checked on 8th Oct 2016. If you find any inaccuracies, please let me know._
+
+## Thanks
+[![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").
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<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>3.0-SNAPSHOT</version>
+    </parent>
+    <modelVersion>4.0.0</modelVersion>
+
+    <artifactId>luckperms-api</artifactId>
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <version>3.5.1</version>
+                <configuration>
+                    <source>1.8</source>
+                    <target>1.8</target>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+
+    <dependencies>
+        <!-- guava -->
+        <dependency>
+            <groupId>com.google.guava</groupId>
+            <artifactId>guava</artifactId>
+            <version>19.0</version>
+            <scope>provided</scope>
+        </dependency>
+    </dependencies>
+
+</project>
@@ -0,0 +1,75 @@
+/*
+ * 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;
+
+import me.lucko.luckperms.api.LuckPermsApi;
+
+import java.util.Optional;
+
+/**
+ * Singleton for the {@link LuckPermsApi}.
+ *
+ * <p> Ideally, the ServiceManager for the platform should be used to obtain and cache an instance, however, this can be
+ * used if you need static access.
+ */
+public final class LuckPerms {
+    private static LuckPermsApi api = null;
+
+    /**
+     * Gets an instance of {@link LuckPermsApi}, throwing {@link IllegalStateException} if the API is not loaded.
+     *
+     * @return an api instance
+     * @throws IllegalStateException if the api is not loaded
+     */
+    public static LuckPermsApi getApi() {
+        if (api == null) {
+            throw new IllegalStateException("API is not loaded.");
+        }
+        return api;
+    }
+
+    /**
+     * Gets an instance of {@link LuckPermsApi} safely.
+     *
+     * <p> Unlike {@link LuckPerms#getApi}, this method will not throw an {@link IllegalStateException} if the API is
+     * not loaded, rather return an empty {@link Optional}.
+     *
+     * @return an optional api instance
+     */
+    public static Optional<LuckPermsApi> getApiSafe() {
+        return Optional.ofNullable(api);
+    }
+
+    static void registerProvider(LuckPermsApi luckPermsApi) {
+        api = luckPermsApi;
+    }
+
+    static void unregisterProvider() {
+        api = null;
+    }
+
+    private LuckPerms() {
+        throw new UnsupportedOperationException("This class cannot be instantiated.");
+    }
+
+}
@@ -0,0 +1,227 @@
+/*
+ * 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.context.ContextSet;
+
+/**
+ * Context and options for a permission lookup.
+ *
+ * <p> All values are immutable.
+ *
+ * @since 2.11
+ */
+public class Contexts {
+    public static final String SERVER_KEY = "server";
+    public static final String WORLD_KEY = "world";
+    private static final Contexts ALLOW_ALL = new Contexts(ContextSet.empty(), true, true, true, true, true, true);
+
+    /**
+     * Gets a context that will allow all nodes
+     *
+     * @return a context that will not apply any filters
+     */
+    public static Contexts allowAll() {
+        return ALLOW_ALL;
+    }
+
+    public static Contexts of(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
+     * The keys for servers and worlds are defined as static values.
+     */
+    private final ContextSet context;
+
+    /**
+     * The mode to parse defaults on Bukkit
+     *
+     * @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;
+
+    public Contexts(ContextSet context, boolean includeGlobal, boolean includeGlobalWorld, boolean applyGroups, boolean applyGlobalGroups, boolean applyGlobalWorldGroups, boolean op) {
+        if (context == null) {
+            throw new NullPointerException("context");
+        }
+
+        this.context = context.makeImmutable();
+        this.includeGlobal = includeGlobal;
+        this.includeGlobalWorld = includeGlobalWorld;
+        this.applyGroups = applyGroups;
+        this.applyGlobalGroups = applyGlobalGroups;
+        this.applyGlobalWorldGroups = applyGlobalWorldGroups;
+        this.op = op;
+    }
+
+    /**
+     * Gets the contexts that apply for this lookup
+     *
+     * @return an immutable set of context key value pairs
+     * @since 2.13
+     */
+    public ContextSet getContexts() {
+        return this.context;
+    }
+
+    /**
+     * Gets if OP defaults should be included
+     *
+     * @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;
+    }
+
+    public String toString() {
+        return "Contexts(" +
+                "context=" + this.getContexts() + ", " +
+                "op=" + this.isOp() + ", " +
+                "includeGlobal=" + this.isIncludeGlobal() + ", " +
+                "includeGlobalWorld=" + this.isIncludeGlobalWorld() + ", " +
+                "applyGroups=" + this.isApplyGroups() + ", " +
+                "applyGlobalGroups=" + this.isApplyGlobalGroups() + ", " +
+                "applyGlobalWorldGroups=" + this.isApplyGlobalWorldGroups() +
+                ")";
+    }
+
+    /*
+     * Ugly auto-generated lombok code
+     */
+
+    /**
+     * Check for equality
+     *
+     * @param o the other
+     * @return true if equal
+     * @since 2.12
+     */
+    public boolean equals(Object o) {
+        if (o == this) return true;
+        if (!(o instanceof Contexts)) return false;
+        final Contexts other = (Contexts) o;
+        final Object this$context = this.getContexts();
+        final Object other$context = other.getContexts();
+        if (this$context == null ? other$context != null : !this$context.equals(other$context)) return false;
+        if (this.isOp() != other.isOp()) return false;
+        if (this.isIncludeGlobal() != other.isIncludeGlobal()) return false;
+        if (this.isIncludeGlobalWorld() != other.isIncludeGlobalWorld()) return false;
+        if (this.isApplyGroups() != other.isApplyGroups()) return false;
+        if (this.isApplyGlobalGroups() != other.isApplyGlobalGroups()) return false;
+        if (this.isApplyGlobalWorldGroups() != other.isApplyGlobalWorldGroups()) return false;
+        return true;
+    }
+
+    /**
+     * Gets the hashcode
+     *
+     * @return the hashcode
+     * @since 2.12
+     */
+    public int hashCode() {
+        final int PRIME = 59;
+        int result = 1;
+        final Object $context = this.getContexts();
+        result = result * PRIME + ($context == null ? 43 : $context.hashCode());
+        result = result * PRIME + (this.isOp() ? 79 : 97);
+        result = result * PRIME + (this.isIncludeGlobal() ? 79 : 97);
+        result = result * PRIME + (this.isIncludeGlobalWorld() ? 79 : 97);
+        result = result * PRIME + (this.isApplyGroups() ? 79 : 97);
+        result = result * PRIME + (this.isApplyGlobalGroups() ? 79 : 97);
+        result = result * PRIME + (this.isApplyGlobalWorldGroups() ? 79 : 97);
+        return result;
+    }
+
+}
@@ -0,0 +1,262 @@
+/*
+ * 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.exceptions.ObjectAlreadyHasException;
+import me.lucko.luckperms.exceptions.ObjectLacksException;
+
+import java.util.List;
+import java.util.OptionalInt;
+
+/**
+ * A group which holds permission data.
+ */
+public interface Group extends PermissionHolder {
+
+    /**
+     * Get the name of the group
+     *
+     * @return the name of the group
+     */
+    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.
+     */
+    boolean inheritsGroup(Group group);
+
+    /**
+     * 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
+     */
+    boolean inheritsGroup(Group group, String server);
+
+    /**
+     * 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;
+
+    /**
+     * 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
+     * @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);
+
+
+    /**
+     * Get a {@link List} of the groups the group inherits on a specific server and world
+     *
+     * @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);
+
+    /**
+     * Gets the weight of this group, is present.
+     *
+     * @return the group weight
+     * @since 2.17
+     */
+    OptionalInt getWeight();
+
+}
@@ -0,0 +1,94 @@
+/*
+ * 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 com.google.common.collect.Multimap;
+
+import java.util.Optional;
+import java.util.OptionalLong;
+
+/**
+ * A relationship between a Holder and a permission
+ *
+ * @param <T> the identifier type of the holder
+ * @since 2.17
+ */
+public interface HeldPermission<T> {
+
+    /**
+     * Gets the holder of the permission
+     *
+     * @return the holder
+     */
+    T getHolder();
+
+    /**
+     * Gets the permission being held
+     *
+     * @return the permission
+     */
+    String getPermission();
+
+    /**
+     * Gets the value of the permission
+     *
+     * @return the value
+     */
+    boolean getValue();
+
+    /**
+     * Gets the server where the permission is held
+     *
+     * @return the server
+     */
+    Optional<String> getServer();
+
+    /**
+     * Gets the world where the permission is held
+     *
+     * @return the world
+     */
+    Optional<String> getWorld();
+
+    /**
+     * Gets the time in unix time when the permission will expire
+     *
+     * @return the expiry time
+     */
+    OptionalLong getExpiry();
+
+    /**
+     * Gets the context for the permission.
+     *
+     * @return the context
+     */
+    Multimap<String, String> getContext();
+
+    /**
+     * Converts this permission into a Node
+     *
+     * @return a Node copy of this permission
+     */
+    Node asNode();
+
+}
@@ -0,0 +1,166 @@
+/*
+ * 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.DatastoreConfiguration;
+
+import java.util.Map;
+
+/**
+ * Read-only access to the LuckPerms configuration settings
+ */
+public interface LPConfiguration {
+
+    /**
+     * Returns the name of this server
+     * @return the name of this server
+     */
+    String getServer();
+
+    /**
+     * Returns how often a sync task will run in minutes
+     * @return how often a sync task will run in minutes
+     */
+    int getSyncTime();
+
+    /**
+     * Returns 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();
+
+    /**
+     * Returns 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();
+
+    /**
+     * Returns true if the platform is applying global groups
+     * @return true if the platform is applying global groups
+     * @since 2.9
+     */
+    boolean getApplyGlobalGroups();
+
+    /**
+     * Returns true if the platform is applying global world groups
+     * @return true if the platform is applying global world groups
+     * @since 2.9
+     */
+    boolean getApplyGlobalWorldGroups();
+
+    /**
+     * Returns the online mode setting
+     * @return the online mode setting
+     */
+    boolean getOnlineMode();
+
+    /**
+     * Returns if LuckPerms is applying wildcard permissions
+     * @return if LuckPerms is applying wildcard permissions
+     */
+    boolean getApplyWildcards();
+
+    /**
+     * Returns if LuckPerms is resolving and applying regex permissions
+     * @return if LuckPerms is resolving and applying regex permissions
+     */
+    boolean getApplyRegex();
+
+    /**
+     * Returns if LuckPerms is expanding shorthand permissions
+     * @return if LuckPerms is expanding shorthand permissions
+     */
+    boolean getApplyShorthand();
+
+    /**
+     * Returns if LuckPerms will send notifications to users when permissions are modified
+     * @return if LuckPerms will send notifications to users when permissions are modified
+     * @since 2.7
+     */
+    boolean getLogNotify();
+
+    /**
+     * Returns true if the vanilla op system is enabled
+     * @return true if the vanilla op system is enabled
+     * @since 2.8
+     */
+    boolean getEnableOps();
+
+    /**
+     * Returns true if opped players are allowed to use LuckPerms commands
+     * @return true if opped players are allowed to use LuckPerms commands
+     * @since 2.8
+     */
+    boolean getCommandsAllowOp();
+
+    /**
+     * Returns true if auto op is enabled
+     * @return true if auto op is enabled
+     * @since 2.9
+     */
+    boolean getAutoOp();
+
+    /**
+     * Returns the name of the server used within Vault operations
+     * @return the name of the server used within Vault operations
+     * @since 2.7
+     */
+    String getVaultServer();
+
+    /**
+     * Returns true if global permissions should be considered when retrieving meta or player groups
+     * @return true if global permissions should be considered when retrieving meta or player groups
+     * @since 2.7
+     */
+    boolean getVaultIncludeGlobal();
+
+    /**
+     * Returns the values set for data storage in the configuration
+     * @return the values set for data storage in the configuration
+     */
+    DatastoreConfiguration getDatastoreConfig();
+
+    /**
+     * Returns the storage method string from the configuration
+     * @return the storage method string from the configuration
+     */
+    String getStorageMethod();
+
+    /**
+     * Returns true if split storage is enabled
+     * @return true if split storage is enabled
+     * @since 2.7
+     */
+    boolean getSplitStorage();
+
+    /**
+     * Returns 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
+     */
+    Map<String, String> getSplitStorageOptions();
+
+}
@@ -0,0 +1,47 @@
+/*
+ * 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;
+
+/**
+ * A node with a traceable origin
+ *
+ * @since 2.11
+ */
+public interface LocalizedNode extends Node {
+
+    /**
+     * Gets the delegate node
+     *
+     * @return the node this instance is representing
+     */
+    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()
+     */
+    String getLocation();
+
+}
@@ -0,0 +1,181 @@
+/*
+ * 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 java.util.SortedMap;
+import java.util.SortedSet;
+import java.util.UUID;
+
+/**
+ * Represents the internal LuckPerms log.
+ *
+ * <p> The returned instance provides a copy of the data at the time of retrieval. 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.
+ */
+public interface Log {
+
+    /**
+     * @return a {@link SortedSet} of all of the {@link LogEntry} objects in this {@link Log}
+     */
+    SortedSet<LogEntry> getContent();
+
+    /**
+     * @return all content in this log
+     */
+    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()}}
+     */
+    SortedMap<Integer, LogEntry> getRecent(int pageNo);
+
+    /**
+     * @return the max page number allowed in the {@link #getRecent(int)} method
+     */
+    int getRecentMaxPages();
+
+
+    /**
+     * @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);
+
+    /**
+     * Gets the recent content for the uuid, separated into pages
+     *
+     * @param pageNo the page number
+     * @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);
+
+    /**
+     * @param actor the actor to filter by
+     * @return the max page number allowed in the {@link #getRecent(int, UUID)} method
+     */
+    int getRecentMaxPages(UUID actor);
+
+
+    /**
+     * @param uuid the uuid to filter by
+     * @return all content in this log where the user = uuid
+     */
+    SortedSet<LogEntry> getUserHistory(UUID uuid);
+
+    /**
+     * Gets the user history content, separated by pages
+     *
+     * @param pageNo the page number
+     * @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);
+
+    /**
+     * @param uuid the uuid to filter by
+     * @return the max page number allowed in the {@link #getUserHistory(int, UUID)} method
+     */
+    int getUserHistoryMaxPages(UUID uuid);
+
+
+    /**
+     * @param name the name to filter by
+     * @return all content in this log where the group = name
+     */
+    SortedSet<LogEntry> getGroupHistory(String name);
+
+    /**
+     * Gets the group history content, separated by pages
+     *
+     * @param pageNo the page number
+     * @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);
+
+    /**
+     * @param name the name to filter by
+     * @return the max page number allowed in the {@link #getGroupHistory(int, String)} method
+     */
+    int getGroupHistoryMaxPages(String name);
+
+
+    /**
+     * @param name the name to filter by
+     * @return all content in this log where the track = name
+     */
+    SortedSet<LogEntry> getTrackHistory(String name);
+
+    /**
+     * Gets the track history content, separated by pages
+     *
+     * @param pageNo the page number
+     * @param name   the name of the acted track to filter by
+     * @return the page content
+     */
+    SortedMap<Integer, LogEntry> getTrackHistory(int pageNo, String name);
+
+    /**
+     * @param name the name to filter by
+     * @return the max page number allowed in the {@link #getTrackHistory(int, String)} method
+     * @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)}}
+     */
+    int getTrackHistoryMaxPages(String name);
+
+
+    /**
+     * @param query the query to filter by
+     * @return all content in this log where the content matches query
+     */
+    SortedSet<LogEntry> getSearch(String query);
+
+    /**
+     * Gets the search content, separated by pages
+     *
+     * @param pageNo the page number
+     * @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);
+
+    /**
+     * @param query the query to filter by
+     * @return the max page number allowed in the {@link #getSearch(int, String)} method
+     */
+    int getSearchMaxPages(String query);
+}
@@ -0,0 +1,318 @@
+/*
+ * 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 java.util.UUID;
+
+/**
+ * A single entry in the log
+ *
+ * <p> Implements {@link Comparable} ordering based upon the timestamp of the entry.
+ */
+public class LogEntry implements Comparable<LogEntry> {
+    private static final String FORMAT = "&8(&e%s&8) [&a%s&8] (&b%s&8) &7--> &f%s";
+
+    public static LogEntryBuilder builder() {
+        return new LogEntryBuilder();
+    }
+
+    private long timestamp;
+    private UUID actor;
+    private String actorName;
+    private char type;
+    private UUID acted;
+    private String actedName;
+    private String action;
+
+    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");
+        }
+
+        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;
+    }
+
+    void setTimestamp(long timestamp) {
+        this.timestamp = timestamp;
+    }
+
+    public UUID getActor() {
+        return actor;
+    }
+
+    void setActor(UUID actor) {
+        this.actor = actor;
+    }
+
+    public String getActorName() {
+        return actorName;
+    }
+
+    void setActorName(String actorName) {
+        this.actorName = actorName;
+    }
+
+    public char getType() {
+        return type;
+    }
+
+    void setType(char type) {
+        this.type = type;
+    }
+
+    public UUID getActed() {
+        return acted;
+    }
+
+    void setActed(UUID acted) {
+        this.acted = acted;
+    }
+
+    public String getActedName() {
+        return actedName;
+    }
+
+    void setActedName(String actedName) {
+        this.actedName = actedName;
+    }
+
+    public String getAction() {
+        return action;
+    }
+
+    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;
+        if (this.getActor() == null ? other.getActor() != null : !this.getActor().equals(other.getActor())) return false;
+        if (this.getActorName() == null ? other.getActorName() != null : !this.getActorName().equals(other.getActorName())) return false;
+        if (this.getType() != other.getType()) return false;
+        if (this.getActed() == null ? other.getActed() != null : !this.getActed().equals(other.getActed())) return false;
+        if (this.getActedName() == null ? other.getActedName() != null : !this.getActedName().equals(other.getActedName())) return false;
+        return this.getAction() == null ? other.getAction() == null : this.getAction().equals(other.getAction());
+    }
+
+    @Override
+    public int hashCode() {
+        final int PRIME = 59;
+        int result = 1;
+        result = result * PRIME + (int) (this.getTimestamp() >>> 32 ^ this.getTimestamp());
+        result = result * PRIME + (this.getActor() == null ? 43 : this.getActor().hashCode());
+        result = result * PRIME + (this.getActorName() == null ? 43 : this.getActorName().hashCode());
+        result = result * PRIME + this.getType();
+        result = result * PRIME + (this.getActed() == null ? 43 : this.getActed().hashCode());
+        result = result * PRIME + (this.getActedName() == null ? 43 : this.getActedName().hashCode());
+        result = result * PRIME + (this.getAction() == null ? 43 : this.getAction().hashCode());
+        return result;
+    }
+
+    public static class LogEntryBuilder extends AbstractLogEntryBuilder<LogEntry, LogEntry.LogEntryBuilder> {
+
+        @Override
+        protected LogEntry createObj() {
+            return new LogEntry();
+        }
+
+        @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");
+            }
+            if (getActorName() == null) {
+                throw new NullPointerException("actorName");
+            }
+            if (getActedName() == null) {
+                throw new NullPointerException("actedName");
+            }
+            if (getAction() == null) {
+                throw new NullPointerException("action");
+            }
+
+            return obj;
+        }
+
+        @Override
+        public String toString() {
+            return "LogEntry.LogEntryBuilder(" +
+                    "timestamp=" + this.getTimestamp() + ", " +
+                    "actor=" + this.getActor() + ", " +
+                    "actorName=" + this.getActorName() + ", " +
+                    "type=" + this.getType() + ", " +
+                    "acted=" + this.getActed() + ", " +
+                    "actedName=" + this.getActedName() + ", " +
+                    "action=" + this.getAction() +
+                    ")";
+        }
+    }
+
+}
@@ -0,0 +1,39 @@
+/*
+ * 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;
+
+/**
+ * A wrapper interface for platform logger instances
+ *
+ * <p> Bukkit/Bungee both use java.util.logging, and Sponge uses org.slf4j. This class wraps those classes so the
+ * commons module can access a logger.
+ */
+public interface Logger {
+
+    void info(String s);
+
+    void warn(String s);
+
+    void severe(String s);
+
+}
@@ -0,0 +1,281 @@
+/*
+ * 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.context.ContextCalculator;
+import me.lucko.luckperms.api.context.ContextSet;
+import me.lucko.luckperms.api.event.EventBus;
+
+import java.util.Optional;
+import java.util.Set;
+import java.util.UUID;
+
+/**
+ * The root API interface for LuckPerms
+ */
+public interface LuckPermsApi {
+
+    /**
+     * Schedules an update task to run
+     */
+    void runUpdateTask();
+
+    /**
+     * Gets the API version
+     * @return the version of the API running on the platform
+     * @since 2.6
+     */
+    double getApiVersion();
+
+    /**
+     * Gets the plugin version
+     * @return the version of the plugin running on the platform
+     */
+    String getVersion();
+
+    /**
+     * Gets the platform LuckPerms is running on
+     * @return the platform LuckPerms is running on
+     * @since 2.7
+     */
+    PlatformType getPlatformType();
+
+    /**
+     * Gets the event bus, used for subscribing to events
+     * @return the event bus
+     * @since 3.0
+     */
+    EventBus getEventBus();
+
+    /**
+     * Gets a wrapped {@link LPConfiguration} instance, with read only access
+     *
+     * @return a configuration instance
+     */
+    LPConfiguration getConfiguration();
+
+    /**
+     * Gets a wrapped {@link Storage} instance.
+     *
+     * @return a storage instance
+     * @since 2.14
+     */
+    Storage getStorage();
+
+    /**
+     * Gets the messaging service in use on the platform, if present.
+     *
+     * @return an optional that may contain a messaging service instance.
+     */
+    Optional<MessagingService> getMessagingService();
+
+    /**
+     * Gets the {@link Logger} wrapping used by the platform
+     *
+     * @return the logger instance
+     */
+    Logger getLogger();
+
+    /**
+     * Gets a wrapped {@link UuidCache} instance, providing read access to the LuckPerms internal uuid caching system
+     *
+     * @return a uuid cache instance
+     */
+    UuidCache getUuidCache();
+
+    /**
+     * 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);
+
+    /**
+     * Gets a wrapped user object from the user storage. This method does not return null, unlike {@link #getUser(UUID)}
+     *
+     * @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);
+
+    /**
+     * 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);
+
+    /**
+     * Gets a wrapped user object from the user storage. This method does not return null, unlike {@link
+     * #getUser(String)}
+     *
+     * @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);
+
+    /**
+     * Gets a set of all loaded users.
+     *
+     * @return a {@link Set} of {@link User} objects
+     */
+    Set<User> getUsers();
+
+    /**
+     * 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);
+
+    /**
+     * 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);
+
+    /**
+     * 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);
+
+    /**
+     * Gets a wrapped group object from the group storage. This method does not return null, unlike {@link #getGroup}
+     *
+     * @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);
+
+    /**
+     * Gets a set of all loaded groups.
+     *
+     * @return a {@link Set} of {@link Group} objects
+     */
+    Set<Group> getGroups();
+
+    /**
+     * 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);
+
+    /**
+     * 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
+     * @throws NullPointerException if the name is null
+     */
+    Track getTrack(String name);
+
+    /**
+     * Gets a wrapped track object from the track storage. This method does not return null, unlike {@link #getTrack}
+     *
+     * @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);
+
+    /**
+     * Gets a set of all loaded tracks.
+     *
+     * @return a {@link Set} of {@link Track} objects
+     */
+    Set<Track> getTracks();
+
+    /**
+     * 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);
+
+    /**
+     * Gets the node factory instance for the platform
+     *
+     * @return the node factory
+     */
+    NodeFactory getNodeFactory();
+
+    /**
+     * 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
+     * @since 2.6
+     */
+    Node.Builder buildNode(String permission) throws IllegalArgumentException;
+
+    /**
+     * 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.
+     * @throws ClassCastException if the type is not the player class of the platform.
+     */
+    void registerContextCalculator(ContextCalculator<?> contextCalculator);
+
+    /**
+     * 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.
+     */
+    Optional<Contexts> getContextForUser(User 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
+     */
+    ContextSet getContextForPlayer(Object player);
+
+}
@@ -0,0 +1,40 @@
+/*
+ * 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;
+
+/**
+ * A means to push changes to other servers using the platforms networking
+ *
+ * @since 2.14
+ */
+public interface MessagingService {
+
+    /**
+     * Uses the messaging service to inform other servers about changes.
+     *
+     * <p> This will push the update asynchronously, and this method will return immediately. Calling this method is
+     * equivalent to running "/lp networksync", except will not sync this server.
+     */
+    void pushUpdate();
+
+}
@@ -0,0 +1,340 @@
+/*
+ * 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 static String escapeDelimiters(String s, String... delims) {
+        for (String delim : delims) {
+            s = s.replace(delim, "\\" + delim);
+        }
+        return s;
+    }
+
+    private static String unescapeDelimiters(String s, String... delims) {
+        for (String delim : delims) {
+            s = s.replace("\\" + delim, delim);
+        }
+        return s;
+    }
+
+    /**
+     * 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();
+        }
+
+        return escapeDelimiters(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}", "$");
+        s = unescapeDelimiters(s, ".", "/", "-", "$");
+
+        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(Contexts.allowAll())) {
+            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);
+    }
+
+    private MetaUtils() {
+    }
+
+}
@@ -0,0 +1,348 @@
+/*
+ * 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.context.ContextSet;
+
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+
+/**
+ * An immutable permission node
+ *
+ * <p> Use {@link LuckPermsApi#buildNode(String)} to get an instance.
+ *
+ * @since 2.6
+ */
+public interface Node extends Map.Entry<String, Boolean> {
+
+    /**
+     * @return the actual permission node
+     */
+    String getPermission();
+
+    /**
+     * Get what value the permission is set to. A negated node would return <code>false</code>.
+     *
+     * @return the permission's value
+     */
+    @Override
+    Boolean getValue();
+
+    /**
+     * @return the value of this node as a Tristate
+     */
+    Tristate getTristate();
+
+    /**
+     * @return true if the node is negated
+     */
+    boolean isNegated();
+
+    /**
+     * If this node is set to override explicitly.
+     * This value does not persist across saves, and is therefore only useful for transient nodes
+     *
+     * @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
+     */
+    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
+     */
+    Optional<String> getWorld();
+
+    /**
+     * @return true if this node is server specific
+     */
+    boolean isServerSpecific();
+
+    /**
+     * @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
+     */
+    boolean shouldApplyOnServer(String server, boolean includeGlobal, boolean applyRegex);
+
+    /**
+     * 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
+     */
+    boolean shouldApplyOnWorld(String world, boolean includeGlobal, boolean applyRegex);
+
+    /**
+     * 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
+     * @since 2.13
+     */
+    boolean shouldApplyWithContext(ContextSet context, boolean worldAndServer);
+
+    /**
+     * 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(ContextSet 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);
+
+    /**
+     * Resolves any shorthand parts of this node and returns the full list
+     *
+     * @return a list of full nodes
+     */
+    List<String> resolveShorthand();
+
+    /**
+     * @return true if this node will expire in the future
+     */
+    boolean isTemporary();
+
+    /**
+     * @return true if this node will not expire
+     */
+    boolean isPermanent();
+
+    /**
+     * @return the time in Unix time when this node will expire
+     * @throws IllegalStateException if the node is not temporary
+     */
+    long getExpiryUnixTime();
+
+    /**
+     * @return the {@link Date} when this node will expire
+     * @throws IllegalStateException if the node is not temporary
+     */
+    Date getExpiry();
+
+    /**
+     * @return the number of seconds until this permission will expire
+     * @throws IllegalStateException if the node is not temporary
+     */
+    long getSecondsTilExpiry();
+
+    /**
+     * Return true if the node has expired.
+     * This also returns false if the node is not temporary
+     *
+     * @return true if this node has expired
+     */
+    boolean hasExpired();
+
+    /**
+     * @return the extra contexts required for this node to apply
+     * @since 2.13
+     */
+    ContextSet getContexts();
+
+    /**
+     * Converts this node into a serialized form
+     *
+     * @return a serialized node string
+     */
+    String toSerializedNode();
+
+    /**
+     * @return true if this is a group node
+     */
+    boolean isGroupNode();
+
+    /**
+     * @return the name of the group
+     * @throws IllegalStateException if this is not a group node. See {@link #isGroupNode()}
+     */
+    String getGroupName();
+
+    /**
+     * @return true is 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();
+
+    /**
+     * @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();
+
+    /**
+     * @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();
+
+    /**
+     * @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();
+
+    /**
+     * Checks 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
+     */
+    boolean equals(Object obj);
+
+    /**
+     * 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
+     */
+    boolean equalsIgnoringValue(Node other);
+
+    /**
+     * 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
+     */
+    boolean almostEquals(Node other);
+
+    /**
+     * 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
+     */
+    boolean equalsIgnoringValueOrTemp(Node other);
+
+    /**
+     * Builds a Node instance
+     */
+    interface Builder {
+        Builder setNegated(boolean negated);
+
+        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.
+         */
+        Builder setOverride(boolean override);
+
+        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(Set<Map.Entry<String, String>> context);
+
+        Builder withExtraContext(Map.Entry<String, String> entry);
+
+        Builder withExtraContext(ContextSet set);
+
+        Node build();
+    }
+
+}
@@ -0,0 +1,101 @@
+/*
+ * 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;
+
+/**
+ * Builds {@link Node} instances
+ *
+ * @since 2.17
+ */
+public interface NodeFactory {
+
+    /**
+     * Creates a node from a serialised node string
+     *
+     * @param serialisedPermission the serialised permission string
+     * @param value the value of the node
+     * @return a node instance
+     * @throws NullPointerException if the permission is null
+     */
+    Node fromSerialisedNode(String serialisedPermission, boolean value);
+
+
+    /**
+     * 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
+     */
+    Node.Builder newBuilder(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
+     */
+    Node.Builder newBuilderFromExisting(Node other);
+
+    /**
+     * Creates a node builder from a serialised node string
+     * @param serialisedPermission the serialised permission string
+     * @param value the value of the node
+     * @return a node builder instance
+     * @throws NullPointerException if the permission is null
+     */
+    Node.Builder newBuilderFromSerialisedNode(String serialisedPermission, boolean value);
+
+
+    /**
+     * 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
+     */
+    Node.Builder makeMetaNode(String key, 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
+     */
+    Node.Builder makePrefixNode(int priority, 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
+     */
+    Node.Builder makeSuffixNode(int priority, String suffix);
+
+}
@@ -0,0 +1,613 @@
+/*
+ * 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.exceptions.ObjectAlreadyHasException;
+import me.lucko.luckperms.exceptions.ObjectLacksException;
+
+import java.util.Map;
+import java.util.Set;
+import java.util.SortedSet;
+
+/**
+ * An object capable of holding permissions
+ *
+ * <p> Any changes made will be lost unless the instance is saved back to the {@link Storage}.
+ */
+public interface PermissionHolder {
+
+    /**
+     * Gets the objects name
+     *
+     * <p> {@link User#getUuid()}, {@link User#getName()} or {@link Group#getName()} should normally be used instead of
+     * this method.
+     *
+     * @return the identifier for this object. Either a uuid string or name.
+     */
+    String getObjectName();
+
+    /**
+     * Gets a sorted set of all held permissions.
+     *
+     * @return an immutable set of permissions in priority order
+     * @since 2.6
+     */
+    SortedSet<? extends Node> getPermissions();
+
+    /**
+     * Similar to {@link #getPermissions()}, except without transient permissions
+     *
+     * @return a set of nodes
+     * @since 2.6
+     */
+    Set<? extends Node> getEnduringPermissions();
+
+    /**
+     * Gets an immutable set of all transiently held permissions.
+     *
+     * <p> Transient permissions only exist for the duration of the session.
+     *
+     * @return a set of nodes
+     * @since 2.6
+     */
+    Set<? extends Node> getTransientPermissions();
+
+    /**
+     * Gets a mutable sorted set of the nodes that this object has and inherits, filtered by context
+     * Unlike {@link #getAllNodesFiltered(Contexts)}, this method will not filter individual nodes. The context is only
+     * used to determine which groups should apply.
+     * Nodes are sorted into priority order.
+     *
+     * @param contexts the context for the lookup,
+     * @return a mutable sorted set of permissions
+     * @throws NullPointerException if the context is null
+     * @since 2.11
+     */
+    SortedSet<LocalizedNode> getAllNodes(Contexts contexts);
+
+    /**
+     * Gets a mutable set of the nodes that this object has and inherits, filtered by context.
+     * Unlike {@link #getAllNodes(Contexts)}, this method WILL filter individual nodes, and only return ones that fully
+     * meet the context provided.
+     *
+     * @param contexts the context for the lookup
+     * @return a mutable set of permissions
+     * @throws NullPointerException if the context is null
+     * @since 2.11
+     */
+    Set<LocalizedNode> getAllNodesFiltered(Contexts contexts);
+
+    /**
+     * Converts the output of {@link #getAllNodesFiltered(Contexts)}, and expands shorthand permissions.
+     * @param contexts the context for the lookup
+     * @param lowerCase if the keys should be made lowercase whilst being exported
+     * @return a mutable map of permissions
+     */
+    Map<String, Boolean> exportNodes(Contexts contexts, boolean lowerCase);
+
+    /**
+     * Removes temporary permissions that have expired
+     */
+    void auditTemporaryPermissions();
+
+    /**
+     * Checks to see if the object has a certain permission
+     *
+     * @param node the node to check for
+     * @return a Tristate for the holders permission status for the node
+     * @throws NullPointerException if the node is null
+     * @since 2.6
+     */
+    Tristate hasPermission(Node node);
+
+    /**
+     * Checks to see if the object has a certain permission
+     *
+     * @param node the node to check for
+     * @return a Tristate for the holders permission status for the node
+     * @throws NullPointerException if the node is null
+     * @since 2.6
+     */
+    Tristate hasTransientPermission(Node node);
+
+    /**
+     * Checks to see if the object has a certain permission
+     *
+     * @param node The permission node
+     * @param b    If the node is true/false(negated)
+     * @return true if the object has the permission
+     * @throws NullPointerException     if the node is null
+     * @throws IllegalArgumentException if the node is invalid
+     */
+    boolean hasPermission(String node, boolean b);
+
+    /**
+     * Checks to see the the object has a permission on a certain server
+     *
+     * @param node   The permission node
+     * @param b      If the node is true/false(negated)
+     * @param server The server
+     * @return true if the object has the permission
+     * @throws NullPointerException     if the node or server is null
+     * @throws IllegalArgumentException if the node or server is invalid
+     */
+    boolean hasPermission(String node, boolean b, String server);
+
+    /**
+     * Checks to see the the object has a permission on a certain server and world
+     *
+     * @param node   The permission node
+     * @param b      If the node is true/false(negated)
+     * @param server The server
+     * @param world  The world
+     * @return true if the object has the permission
+     * @throws NullPointerException     if the node, server or world is null
+     * @throws IllegalArgumentException if the node, server or world is invalid
+     */
+    boolean hasPermission(String node, boolean b, String server, String world);
+
+    /**
+     * Checks to see the the object has a permission
+     *
+     * @param node      The permission node
+     * @param b         If the node is true/false(negated)
+     * @param temporary if the permission is temporary
+     * @return true if the object has the permission
+     * @throws NullPointerException     if the node is null
+     * @throws IllegalArgumentException if the node is invalid
+     */
+    boolean hasPermission(String node, boolean b, boolean temporary);
+
+    /**
+     * Checks to see the the object has a permission on a certain server
+     *
+     * @param node      The permission node
+     * @param b         If the node is true/false(negated)
+     * @param server    The server to check on
+     * @param temporary if the permission is temporary
+     * @return true if the object has the permission
+     * @throws NullPointerException     if the node or server is null
+     * @throws IllegalArgumentException if the node or server is invalid
+     */
+    boolean hasPermission(String node, boolean b, String server, boolean temporary);
+
+    /**
+     * Checks to see the the object has a permission on a certain server and world
+     *
+     * @param node      The permission node
+     * @param b         If the node is true/false(negated)
+     * @param server    The server to check on
+     * @param world     The world to check on
+     * @param temporary if the permission is temporary
+     * @return true if the object has the permission
+     * @throws NullPointerException     if the node, server or world is null
+     * @throws IllegalArgumentException if the node, server or world is invalid
+     */
+    boolean hasPermission(String node, boolean b, String server, String world, boolean temporary);
+
+    /**
+     * Cheks to see if the object inherits a certain permission
+     *
+     * @param node the node to check for
+     * @return a Tristate for the holders inheritance status for the node
+     * @throws NullPointerException if the node is null
+     * @since 2.6
+     */
+    Tristate inheritsPermission(Node node);
+
+    /**
+     * Checks to see if the object inherits a certain permission
+     *
+     * @param node The permission node
+     * @param b    If the node is true/false(negated)
+     * @return true if the object inherits the permission
+     * @throws NullPointerException     if the node is null
+     * @throws IllegalArgumentException if the node is invalid
+     */
+    boolean inheritsPermission(String node, boolean b);
+
+    /**
+     * Checks to see the the object inherits a permission on a certain server
+     *
+     * @param node   The permission node
+     * @param b      If the node is true/false(negated)
+     * @param server The server
+     * @return true if the object inherits the permission
+     * @throws NullPointerException     if the node or server is null
+     * @throws IllegalArgumentException if the node or server is invalid
+     */
+    boolean inheritsPermission(String node, boolean b, String server);
+
+    /**
+     * Checks to see the the object inherits a permission on a certain server and world
+     *
+     * @param node   The permission node
+     * @param b      If the node is true/false(negated)
+     * @param server The server
+     * @param world  The world
+     * @return true if the object inherits the permission
+     * @throws NullPointerException     if the node, server or world is null
+     * @throws IllegalArgumentException if the node server or world is invalid
+     */
+    boolean inheritsPermission(String node, boolean b, String server, String world);
+
+    /**
+     * Checks to see if the object inherits a permission
+     *
+     * @param node      The permission node
+     * @param b         If the node is true/false(negated)
+     * @param temporary if the permission is temporary
+     * @return true if the object inherits the permission
+     * @throws NullPointerException     if the node is null
+     * @throws IllegalArgumentException if the node is invalid
+     */
+    boolean inheritsPermission(String node, boolean b, boolean temporary);
+
+    /**
+     * Checks to see if the object inherits a permission on a certain server
+     *
+     * @param node      The permission node
+     * @param b         If the node is true/false(negated)
+     * @param server    The server
+     * @param temporary if the permission is temporary
+     * @return true if the object inherits the permission
+     * @throws NullPointerException     if the node or server is null
+     * @throws IllegalArgumentException if the node or server is invalid
+     */
+    boolean inheritsPermission(String node, boolean b, String server, boolean temporary);
+
+    /**
+     * Checks to see if the object inherits a permission on a certain server and world
+     *
+     * @param node      The permission node
+     * @param b         If the node is true/false(negated)
+     * @param server    The server
+     * @param world     The world
+     * @param temporary if the permission is temporary
+     * @return true if the object inherits the permission
+     * @throws NullPointerException     if the node, server or world is null
+     * @throws IllegalArgumentException if the node, server or world if invalid
+     */
+    boolean inheritsPermission(String node, boolean b, String server, String world, boolean temporary);
+
+    /**
+     * Sets a permission for the object
+     *
+     * @param node The node to be set
+     * @throws ObjectAlreadyHasException if the object already has the permission
+     * @throws NullPointerException      if the node is null
+     * @since 2.6
+     */
+    void setPermission(Node node) throws ObjectAlreadyHasException;
+
+    /**
+     * Sets a transient permission for the object
+     *
+     * <p> A transient node is a permission that does not persist.
+     * Whenever a user logs out of the server, or the server restarts, this permission will disappear.
+     * It is never saved to the datastore, and therefore will not apply on other servers.
+     *
+     * <p> This is useful if you want to temporarily set a permission for a user while they're online, but don't
+     * want it to persist, and have to worry about removing it when they log out.
+     *
+     * <p> For unsetting a transient permission, see {@link #unsetTransientPermission(Node)}
+     *
+     * @param node The node to be set
+     * @throws ObjectAlreadyHasException if the object already has the permission
+     * @throws NullPointerException      if the node is null
+     * @since 2.6
+     */
+    void setTransientPermission(Node node) throws ObjectAlreadyHasException;
+
+    /**
+     * Sets a permission for the object
+     *
+     * @param node  The node to be set
+     * @param value What to set the node to - true/false(negated)
+     * @throws ObjectAlreadyHasException if the object already has the permission
+     * @throws NullPointerException      if the node is null
+     * @throws IllegalArgumentException  if the node is invalid
+     * @deprecated in favour of {@link #setPermission(Node)}
+     */
+    @Deprecated
+    void setPermission(String node, boolean value) throws ObjectAlreadyHasException;
+
+    /**
+     * Sets a permission for the object on a specific server
+     *
+     * @param node   The node to set
+     * @param value  What to set the node to - true/false(negated)
+     * @param server The server to set the permission on
+     * @throws ObjectAlreadyHasException if the object already has the permission
+     * @throws NullPointerException      if the node or server is null
+     * @throws IllegalArgumentException  if the node or server is invalid
+     * @deprecated in favour of {@link #setPermission(Node)}
+     */
+    @Deprecated
+    void setPermission(String node, boolean value, String server) throws ObjectAlreadyHasException;
+
+    /**
+     * Sets a permission for the object on a specific server and world
+     *
+     * @param node   The node to set
+     * @param value  What to set the node to - true/false(negated)
+     * @param server The server to set the permission on
+     * @param world  The world to set the permission on
+     * @throws ObjectAlreadyHasException if the object already has the permission
+     * @throws NullPointerException      if the node, server or world is null
+     * @throws IllegalArgumentException  if the node, server or world is invalid
+     * @deprecated in favour of {@link #setPermission(Node)}
+     */
+    @Deprecated
+    void setPermission(String node, boolean value, String server, String world) throws ObjectAlreadyHasException;
+
+    /**
+     * Sets a temporary permission for the object
+     *
+     * @param node     The node to set
+     * @param value    What to set the node to - true/false(negated)
+     * @param expireAt The time in unixtime when the permission will expire
+     * @throws ObjectAlreadyHasException if the object already has the permission
+     * @throws NullPointerException      if the node is null
+     * @throws IllegalArgumentException  if the node is invalid or if the expiry time is in the past
+     * @deprecated in favour of {@link #setPermission(Node)}
+     */
+    @Deprecated
+    void setPermission(String node, boolean value, long expireAt) throws ObjectAlreadyHasException;
+
+    /**
+     * Sets a temporary permission for the object on a specific server
+     *
+     * @param node     The node to set
+     * @param value    What to set the node to - true/false(negated)
+     * @param server   The server to set the permission on
+     * @param expireAt The time in unixtime when the permission will expire
+     * @throws ObjectAlreadyHasException if the object already has the permission
+     * @throws NullPointerException      if the node or server is null
+     * @throws IllegalArgumentException  if the node/server is invalid or if the expiry time is in the past
+     * @deprecated in favour of {@link #setPermission(Node)}
+     */
+    @Deprecated
+    void setPermission(String node, boolean value, String server, long expireAt) throws ObjectAlreadyHasException;
+
+    /**
+     * Sets a temporary permission for the object on a specific server and world
+     *
+     * @param node     The node to set
+     * @param value    What to set the node to - true/false(negated)
+     * @param server   The server to set the permission on
+     * @param world    The world to set the permission on
+     * @param expireAt The time in unixtime when the permission will expire
+     * @throws ObjectAlreadyHasException if the object already has the permission
+     * @throws NullPointerException      if the node, server or world is null
+     * @throws IllegalArgumentException  if the node/server/world is invalid, or if the expiry time is in the past
+     * @deprecated in favour of {@link #setPermission(Node)}
+     */
+    @Deprecated
+    void setPermission(String node, boolean value, String server, String world, long expireAt) throws ObjectAlreadyHasException;
+
+    /**
+     * Unsets a permission for the object
+     *
+     * @param node The node to be unset
+     * @throws ObjectLacksException if the node wasn't already set
+     * @throws NullPointerException if the node is null
+     * @since 2.6
+     */
+    void unsetPermission(Node node) throws ObjectLacksException;
+
+    /**
+     * Unsets a transient permission for the object
+     *
+     * @param node The node to be unset
+     * @throws ObjectLacksException if the node wasn't already set
+     * @throws NullPointerException if the node is null
+     * @since 2.6
+     */
+    void unsetTransientPermission(Node node) throws ObjectLacksException;
+
+    /**
+     * Unsets a permission for the object
+     *
+     * @param node      The node to be unset
+     * @param temporary if the permission being removed is temporary
+     * @throws ObjectLacksException     if the node wasn't already set
+     * @throws NullPointerException     if the node is null
+     * @throws IllegalArgumentException if the node is invalid
+     * @deprecated in favour of {@link #unsetPermission(Node)}
+     */
+    @Deprecated
+    void unsetPermission(String node, boolean temporary) throws ObjectLacksException;
+
+    /**
+     * Unsets a permission for the object
+     *
+     * @param node The node to be unset
+     * @throws ObjectLacksException     if the node wasn't already set
+     * @throws NullPointerException     if the node is null
+     * @throws IllegalArgumentException if the node is invalid
+     * @deprecated in favour of {@link #unsetPermission(Node)}
+     */
+    @Deprecated
+    void unsetPermission(String node) throws ObjectLacksException;
+
+    /**
+     * Unsets a permission for the object on a specific server
+     *
+     * @param node   The node to be unset
+     * @param server The server to unset the node on
+     * @throws ObjectLacksException     if the node wasn't already set
+     * @throws NullPointerException     if the node or server is null
+     * @throws IllegalArgumentException if the node or server is invalid
+     * @deprecated in favour of {@link #unsetPermission(Node)}
+     */
+    @Deprecated
+    void unsetPermission(String node, String server) throws ObjectLacksException;
+
+    /**
+     * Unsets a permission for the object on a specific server and world
+     *
+     * @param node   The node to be unset
+     * @param server The server to unset the node on
+     * @param world  The world to unset the node on
+     * @throws ObjectLacksException     if the node wasn't already set
+     * @throws NullPointerException     if the node, server or world is null
+     * @throws IllegalArgumentException if the node, server or world is invalid
+     * @deprecated in favour of {@link #unsetPermission(Node)}
+     */
+    @Deprecated
+    void unsetPermission(String node, String server, String world) throws ObjectLacksException;
+
+    /**
+     * Unsets a permission for the object on a specific server
+     *
+     * @param node      The node to be unset
+     * @param server    The server to unset the node on
+     * @param temporary if the permission being unset is temporary
+     * @throws ObjectLacksException     if the node wasn't already set
+     * @throws NullPointerException     if the node or server is null
+     * @throws IllegalArgumentException if the node or server is invalid
+     * @deprecated in favour of {@link #unsetPermission(Node)}
+     */
+    @Deprecated
+    void unsetPermission(String node, String server, boolean temporary) throws ObjectLacksException;
+
+    /**
+     * Unsets a permission for the object on a specific server and world
+     *
+     * @param node      The node to be unset
+     * @param server    The server to unset the node on
+     * @param world     The world to unset the node on
+     * @param temporary if the permission being unset is temporary
+     * @throws ObjectLacksException     if the node wasn't already set
+     * @throws NullPointerException     if the node, server or world is null
+     * @throws IllegalArgumentException if the node, server or world is invalid
+     * @deprecated in favour of {@link #unsetPermission(Node)}
+     */
+    @Deprecated
+    void unsetPermission(String node, String server, String world, boolean temporary) throws ObjectLacksException;
+
+    /**
+     * Clears all nodes held by the object
+     *
+     * @since 2.17
+     */
+    void clearNodes();
+
+    /**
+     * Clears all nodes held by the object on a specific server
+     *
+     * @param server the server to filter by, can be null
+     * @since 2.17
+     */
+    void clearNodes(String server);
+
+    /**
+     * Clears all nodes held by the object on a specific server and world
+     *
+     * @param server the server to filter by, can be null
+     * @param world the world to filter by, can be null
+     * @since 2.17
+     */
+    void clearNodes(String server, String world);
+
+    /**
+     * Clears all parent groups
+     *
+     * @since 2.17
+     */
+    void clearParents();
+
+    /**
+     * Clears all parents on a specific server
+     *
+     * @param server the server to filter by, can be null
+     * @since 2.17
+     */
+    void clearParents(String server);
+
+    /**
+     * Clears all parents on a specific server and world
+     *
+     * @param server the server to filter by, can be null
+     * @param world the world to filter by, can be null
+     * @since 2.17
+     */
+    void clearParents(String server, String world);
+
+    /**
+     * Clears all meta held by the object
+     *
+     * @since 2.17
+     */
+    void clearMeta();
+
+    /**
+     * Clears all meta held by the object on a specific server
+     *
+     * @param server the server to filter by, can be null
+     * @since 2.17
+     */
+    void clearMeta(String server);
+
+    /**
+     * Clears all meta held by the object on a specific server and world
+     *
+     * @param server the server to filter by, can be null
+     * @param world the world to filter by, can be null
+     * @since 2.17
+     */
+    void clearMeta(String server, String world);
+
+    /**
+     * Clears all meta for a given key.
+     *
+     * @param key the meta key
+     * @param server the server to filter by, can be null
+     * @param world the world to filter by, can be null
+     * @param temporary whether the query is for temporary nodes or not.
+     */
+    void clearMetaKeys(String key, String server, String world, boolean temporary);
+
+    /**
+     * Clears all transient permissions the holder has.
+     */
+    void clearTransientNodes();
+
+    /**
+     * Processes the nodes and returns the non-temporary ones.
+     *
+     * @return a set of permanent nodes
+     * @since 2.6
+     */
+    Set<Node> getPermanentPermissionNodes();
+
+    /**
+     * Processes the nodes and returns the temporary ones.
+     *
+     * @return a set of temporary nodes
+     * @since 2.6
+     */
+    Set<Node> getTemporaryPermissionNodes();
+
+}
@@ -0,0 +1,45 @@
+/*
+ * 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;
+
+/**
+ * The platforms which LuckPerms can run on
+ *
+ * @since 2.7
+ */
+public enum PlatformType {
+
+    BUKKIT("Bukkit"),
+    BUNGEE("Bungee"),
+    SPONGE("Sponge");
+
+    private final String friendlyName;
+
+    PlatformType(String friendlyName) {
+        this.friendlyName = friendlyName;
+    }
+
+    public String getFriendlyName() {
+        return friendlyName;
+    }
+}
@@ -0,0 +1,273 @@
+/*
+ * 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 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;
+
+/**
+ * A means of loading and saving data to/from the Storage provider.
+ *
+ * <p>All methods return {@link CompletableFuture}s, which will be populated with the result once the data has been
+ * loaded asynchronously. Care should be taken when using the methods to ensure that the main server thread is not
+ * blocked.
+ *
+ * <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, please register a
+ * callback using {@link CompletableFuture#thenAcceptAsync(Consumer, Executor)} and {@link #getSyncExecutor()}.
+ *
+ * @since 2.14
+ */
+public interface Storage {
+
+    /**
+     * Get the name of the storage implementation.
+     *
+     * @return the name of the implementation
+     */
+    String getName();
+
+    /**
+     * Return whether the storage instance is allowing logins on the platform.
+     *
+     * @return true if logins are enabled
+     */
+    boolean isAcceptingLogins();
+
+    /**
+     * Returns an executor which will run all passed runnables on the main server thread.
+     *
+     * @return an executor instance
+     */
+    Executor getSyncExecutor();
+
+    /**
+     * Returns an executor which will run all passed runnables asynchronously using the platforms scheduler and thread
+     * pools.
+     *
+     * @return an executor instance
+     */
+    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
+     */
+    CompletableFuture<Boolean> logAction(LogEntry entry);
+
+    /**
+     * Loads and returns the entire log from storage
+     *
+     * @return a log instance, could be null if loading failed
+     */
+    CompletableFuture<Log> getLog();
+
+    /**
+     * 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. (if you want to specify <code>null</code> here, just input "null" as a
+     *                 string.)
+     * @return if the operation completed successfully
+     * @throws NullPointerException if uuid or username is null
+     */
+    CompletableFuture<Boolean> loadUser(UUID uuid, String username);
+
+    /**
+     * Saves a user object back to storage. 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.
+     */
+    CompletableFuture<Boolean> saveUser(User user);
+
+    /**
+     * Removes users from the main storage who are "default". This is called every time the plugin loads.
+     *
+     * @return true if the operation completed successfully
+     */
+    CompletableFuture<Boolean> cleanupUsers();
+
+    /**
+     * Gets a set all "unique" user UUIDs.
+     * "Unique" meaning the user isn't just a member of the "default" group.
+     *
+     * @return a set of uuids, or null if the operation failed.
+     */
+    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
+     */
+    CompletableFuture<List<HeldPermission<UUID>>> getUsersWithPermission(String permission);
+
+    /**
+     * 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
+     */
+    CompletableFuture<Boolean> createAndLoadGroup(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
+     */
+    CompletableFuture<Boolean> loadGroup(String name);
+
+    /**
+     * Loads all groups from the storage into memory
+     *
+     * @return true if the operation completed successfully.
+     */
+    CompletableFuture<Boolean> loadAllGroups();
+
+    /**
+     * Saves a group back to storage. 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.
+     */
+    CompletableFuture<Boolean> saveGroup(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.
+     */
+    CompletableFuture<Boolean> deleteGroup(Group group);
+
+    /**
+     * 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
+     */
+    CompletableFuture<List<HeldPermission<String>>> getGroupsWithPermission(String permission);
+
+    /**
+     * 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
+     */
+    CompletableFuture<Boolean> createAndLoadTrack(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
+     */
+    CompletableFuture<Boolean> loadTrack(String name);
+
+    /**
+     * Loads all tracks from the storage into memory
+     *
+     * @return true if the operation completed successfully.
+     */
+    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.
+     */
+    CompletableFuture<Boolean> saveTrack(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.
+     */
+    CompletableFuture<Boolean> deleteTrack(Track track);
+
+    /**
+     * 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
+     */
+    CompletableFuture<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
+     */
+    CompletableFuture<UUID> getUUID(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
+     */
+    CompletableFuture<String> getName(UUID uuid);
+
+}
@@ -0,0 +1,144 @@
+/*
+ * 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.exceptions.ObjectAlreadyHasException;
+import me.lucko.luckperms.exceptions.ObjectLacksException;
+
+import java.util.List;
+
+/**
+ * An ordered collection of groups for easy promotions and demotions
+ */
+public interface Track {
+
+    /**
+     * Gets the name of this track
+     * @return the name of this track
+     */
+    String getName();
+
+    /**
+     * Gets an ordered list of the groups on this track
+     *
+     * <p> Index 0 is the first/lowest group in (or start of) the track
+     *
+     * @return an ordered {@link List} of the groups on this track
+     */
+    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
+     *
+     * @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 IllegalStateException if the group instance was not obtained from LuckPerms.
+     */
+    String getNext(Group current) throws ObjectLacksException;
+
+    /**
+     * Gets the previous group on the track, before the one provided
+     *
+     * @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 IllegalStateException if the group instance was not obtained from LuckPerms.
+     */
+    String getPrevious(Group current) throws ObjectLacksException;
+
+    /**
+     * 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.
+     */
+    void appendGroup(Group group) throws ObjectAlreadyHasException;
+
+    /**
+     * Inserts a group at a certain position on this track
+     *
+     * @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
+     * @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.
+     */
+    void insertGroup(Group group, int position) throws ObjectAlreadyHasException, 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
+     * @throws IllegalStateException if the group instance was not obtained from LuckPerms.
+     */
+    void removeGroup(Group group) throws ObjectLacksException;
+
+    /**
+     * 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
+     */
+    void removeGroup(String group) throws ObjectLacksException;
+
+    /**
+     * 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 IllegalStateException if the group instance was not obtained from LuckPerms.
+     */
+    boolean containsGroup(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);
+
+    /**
+     * Clear all of the groups from this track
+     */
+    void clearGroups();
+
+}
@@ -0,0 +1,73 @@
+/*
+ * 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;
+
+/**
+ * Represents a permission setting.
+ *
+ * <p> Consider a value of {@link #FALSE} to be a "negated" setting, and a value of {@link #UNDEFINED} to be a
+ * non-existent value.
+ */
+public enum Tristate {
+
+    /**
+     * A value indicating a holder has a permission set.
+     */
+    TRUE(true),
+
+    /**
+     * A value indicating a holder has a negated value for a permission.
+     */
+    FALSE(false),
+
+    /**
+     * A value indicating a holder doesn't have a value for a permission set.
+     */
+    UNDEFINED(false);
+
+    /**
+     * Converts from {@link Boolean} a boolean
+     *
+     * @param b the boolean
+     * @return {@link #TRUE} or {@link #FALSE}, depending on the value of the boolean.
+     */
+    public static Tristate fromBoolean(boolean b) {
+        return b ? 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.
+     *
+     * @return a boolean representation of the Tristate.
+     */
+    public boolean asBoolean() {
+        return booleanValue;
+    }
+}
@@ -0,0 +1,299 @@
+/*
+ * 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.caching.UserData;
+import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
+import me.lucko.luckperms.exceptions.ObjectLacksException;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.UUID;
+
+/**
+ * A player holding permission data
+ */
+public interface User extends PermissionHolder {
+
+    /**
+     * Gets the users unique ID
+     *
+     * @return the users Mojang assigned unique id
+     */
+    UUID getUuid();
+
+    /**
+     * Gets the users username
+     *
+     * @return the Users Username
+     */
+    String getName();
+
+    /**
+     * Gets the users primary group
+     *
+     * @return the users primary group
+     */
+    String getPrimaryGroup();
+
+    /**
+     * Sets a users primary group
+     *
+     * @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
+     */
+    void setPrimaryGroup(String group) throws ObjectAlreadyHasException;
+
+    /**
+     * Refresh and re-assign the users permissions.
+     *
+     * <p> This request is not buffered, and the refresh call will be ran directly. This should ideally be called on
+     * an asynchronous thread.
+     */
+    void refreshPermissions();
+
+    /**
+     * Gets the user's {@link UserData} cache, if they have one setup.
+     *
+     * @return an optional, possibly containing the user's cached lookup data.
+     * @since 2.13
+     */
+    Optional<UserData> getUserDataCache();
+
+    /**
+     * Sets up the users data cache, if the don't have one setup already.
+     *
+     * @since 2.17
+     */
+    void setupDataCache();
+
+    /**
+     * 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
+     */
+    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;
+
+    /**
+     * 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);
+
+}
@@ -0,0 +1,58 @@
+/*
+ * 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 java.util.UUID;
+
+/**
+ * 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 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 Storage using the api on a server in offline mode, you will need to use
+ * this cache, OR use Storage#getUUID, for users that are not online.
+ *
+ * <p> THIS IS ONLY EFFECTIVE FOR ONLINE PLAYERS. USE THE DATASTORE METHODS FOR OFFLINE PLAYERS.
+ */
+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
+     * @return the corresponding internal UUID
+     */
+    UUID getUUID(UUID external);
+
+    /**
+     * 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
+     * @return the corresponding external UUID
+     */
+    UUID getExternalUUID(UUID internal);
+
+}
@@ -0,0 +1,72 @@
+/*
+ * 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.caching;
+
+import java.util.Map;
+import java.util.SortedMap;
+
+/**
+ * Holds cached Meta lookup data for a specific set of contexts
+ *
+ * @since 2.13
+ */
+public interface MetaData {
+
+    /**
+     * Gets an immutable copy of the meta this user has
+     *
+     * @return an immutable map of meta
+     */
+    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
+     */
+    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
+     */
+    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
+     */
+    String getPrefix();
+
+    /**
+     * Gets the user's highest priority suffix, or null if the user has no suffixes
+     *
+     * @return a suffix string, or null
+     */
+    String getSuffix();
+
+}
@@ -0,0 +1,59 @@
+/*
+ * 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.caching;
+
+import me.lucko.luckperms.api.Tristate;
+
+import java.util.Map;
+
+/**
+ * Holds cached Permission lookup data for a specific set of contexts
+ *
+ * @since 2.13
+ */
+public interface PermissionData {
+
+    /**
+     * Gets a permission value for the given permission node
+     *
+     * @param permission the permission node
+     * @return a tristate result
+     * @throws NullPointerException if permission is null
+     */
+    Tristate getPermissionValue(String permission);
+
+    /**
+     * Invalidates the underlying permission calculator cache.
+     *
+     * <p> Can be called to allow for an update in defaults.
+     */
+    void invalidateCache();
+
+    /**
+     * Gets an immutable copy of the permission map backing the permission calculator
+     *
+     * @return an immutable set of permissions
+     */
+    Map<String, Boolean> getImmutableBacking();
+
+}
@@ -0,0 +1,135 @@
+/*
+ * 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.caching;
+
+import me.lucko.luckperms.api.Contexts;
+
+import java.util.Set;
+
+/**
+ * Holds cached permission and meta lookup data for a {@link me.lucko.luckperms.api.User}.
+ *
+ * <p>Data is only likely to be available for online users. 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.
+ *
+ * @since 2.13
+ */
+public interface UserData {
+
+    /**
+     * Gets PermissionData from the cache, given a specified context.
+     *
+     * <p> If the data is not cached, it is calculated. Therefore, this call could be costly.
+     *
+     * @param contexts the contexts to get the permission data in
+     * @return a permission data instance
+     * @throws NullPointerException if contexts is null
+     */
+    PermissionData getPermissionData(Contexts contexts);
+
+    /**
+     * Gets MetaData from the cache, given a specified context.
+     *
+     * <p> If the data is not cached, it is calculated. Therefore, this call could be costly.
+     *
+     * @param contexts the contexts to get the permission data in
+     * @return a meta data instance
+     * @throws NullPointerException if contexts is null
+     */
+    MetaData getMetaData(Contexts contexts);
+
+    /**
+     * Calculates permission data, bypassing the cache.
+     *
+     * @param contexts the contexts to get permission data in
+     * @return a permission data instance
+     * @throws NullPointerException if contexts is null
+     */
+    PermissionData calculatePermissions(Contexts contexts);
+
+    /**
+     * Calculates meta data, bypassing the cache.
+     *
+     * @param contexts the contexts to get meta data in
+     * @return a meta data instance
+     * @throws NullPointerException if contexts is null
+     */
+    MetaData calculateMeta(Contexts contexts);
+
+    /**
+     * Calculates permission data and stores it in the cache.
+     *
+     * <p> If there is already data cached for the given contexts, and if the resultant output is different,
+     * the cached value is updated.
+     *
+     * @param contexts the contexts to recalculate in.
+     * @throws NullPointerException if contexts is null
+     */
+    void recalculatePermissions(Contexts contexts);
+
+    /**
+     * Calculates meta data and stores it in the cache.
+     *
+     * <p> If there is already data cached for the given contexts, and if the resultant output is different,
+     * the cached value is updated.
+     *
+     * @param contexts the contexts to recalculate in.
+     * @throws NullPointerException if contexts is null
+     */
+    void recalculateMeta(Contexts contexts);
+
+    /**
+     * Calls {@link #recalculatePermissions(Contexts)} for all current loaded contexts
+     */
+    void recalculatePermissions();
+
+    /**
+     * Calls {@link #recalculateMeta(Contexts)} for all current loaded contexts
+     */
+    void recalculateMeta();
+
+    /**
+     * Calls {@link #preCalculate(Contexts)} for the given contexts
+     *
+     * @param contexts a set of contexts
+     * @throws NullPointerException if contexts is null
+     */
+    void preCalculate(Set<Contexts> contexts);
+
+    /**
+     * Ensures that PermissionData and MetaData is cached for a context.
+     *
+     * <p> If the cache does not contain any data for the context, it will be calculated and saved.
+     *
+     * @param contexts the contexts to pre-calculate for
+     * @throws NullPointerException if contexts is null
+     */
+    void preCalculate(Contexts contexts);
+
+    /**
+     * Invalidates all of the underlying Permission calculators.
+     * Can be called to allow for an update in defaults.
+     */
+    void invalidatePermissionCalculators();
+
+}
@@ -0,0 +1,55 @@
+/*
+ * 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.context;
+
+import java.util.Map;
+
+/**
+ * Calculates whether contexts are applicable to {@link T}
+ *
+ * <p>Somewhat inspired by the system used on Sponge.
+ *
+ * @param <T> the subject type. Is ALWAYS the player class of the platform.
+ */
+public interface ContextCalculator<T> {
+
+    /**
+     * 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
+     */
+    MutableContextSet giveApplicableContext(T subject, 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.
+     */
+    boolean isContextApplicable(T subject, Map.Entry<String, String> context);
+
+}
@@ -0,0 +1,204 @@
+/*
+ * 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.context;
+
+import com.google.common.collect.Multimap;
+
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * Holds contexts.
+ * Implementations may be either mutable or immutable.
+ *
+ * @since 2.13
+ */
+public interface ContextSet {
+
+    /**
+     * Make a singleton ImmutableContextSet from a context pair
+     *
+     * @param key   the key
+     * @param value the value
+     * @return a new ImmutableContextSet containing one KV pair
+     * @throws NullPointerException if key or value is null
+     */
+    static ImmutableContextSet singleton(String key, String value) {
+        return ImmutableContextSet.singleton(key, value);
+    }
+
+    /**
+     * Creates a ImmutableContextSet from an existing 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
+     */
+    static ImmutableContextSet fromMap(Map<String, String> map) {
+        return ImmutableContextSet.fromMap(map);
+    }
+
+    /**
+     * Creates a ImmutableContextSet from an existing iterable of Map Entries
+     *
+     * @param iterable the iterable to copy from
+     * @return a new ImmutableContextSet representing the pairs in the iterable
+     * @throws NullPointerException if the iterable is null
+     */
+    static ImmutableContextSet fromEntries(Iterable<? extends Map.Entry<String, String>> iterable) {
+        return ImmutableContextSet.fromEntries(iterable);
+    }
+
+    /**
+     * Creates a ImmutableContextSet from an existing 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
+     */
+    static ImmutableContextSet fromMultimap(Multimap<String, String> multimap) {
+        return ImmutableContextSet.fromMultimap(multimap);
+    }
+
+    /**
+     * Creates a new ImmutableContextSet from an existing set.
+     * Only really useful for converting between mutable and immutable types.
+     *
+     * @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
+     */
+    static ImmutableContextSet fromSet(ContextSet contextSet) {
+        return ImmutableContextSet.fromSet(contextSet);
+    }
+
+    /**
+     * Creates a new empty ImmutableContextSet.
+     *
+     * @return a new ImmutableContextSet
+     */
+    static ImmutableContextSet empty() {
+        return ImmutableContextSet.empty();
+    }
+
+    /**
+     * Check to see if this set is in an immutable form
+     *
+     * @return true if the set is immutable
+     */
+    boolean isImmutable();
+
+    /**
+     * If the set is mutable, this method will return an immutable copy. Otherwise just returns itself.
+     *
+     * @return an immutable ContextSet
+     */
+    ImmutableContextSet makeImmutable();
+
+    /**
+     * Creates a mutable copy of this set.
+     *
+     * @return a mutable ContextSet
+     * @since 2.16
+     */
+    MutableContextSet mutableCopy();
+
+    /**
+     * Converts this ContextSet to an immutable {@link Set} of {@link Map.Entry}s.
+     *
+     * @return an immutable set
+     */
+    Set<Map.Entry<String, String>> toSet();
+
+    /**
+     * Converts this ContextSet to an immutable {@link Map}
+     *
+     * <b>NOTE: Use of this method may result in data being lost. ContextSets can contain lots of different values for
+     * one key.</b>
+     *
+     * @return an immutable map
+     */
+    Map<String, String> toMap();
+
+    /**
+     * Converts this ContextSet to an immutable {@link Multimap}
+     *
+     * @return a multimap
+     * @since 2.16
+     */
+    Multimap<String, String> toMultimap();
+
+    /**
+     * Check if the set 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(String key);
+
+    /**
+     * Gets a set of all of the values mapped to the given key
+     *
+     * @param key the key to find values for
+     * @return a set of values
+     * @throws NullPointerException if the key is null
+     */
+    Set<String> getValues(String key);
+
+    /**
+     * Check if thr set contains a given key mapped to a given value
+     *
+     * @param key   the key to look for
+     * @param value the value to look for (case sensitive)
+     * @return true if the set contains the KV pair
+     * @throws NullPointerException if the key or value is null
+     */
+    boolean has(String key, String value);
+
+    /**
+     * Same as {@link #has(String, String)}, except ignores the case of the value.
+     *
+     * @param key   the key to look for
+     * @param value the value to look for
+     * @return true if the set contains the KV pair
+     * @throws NullPointerException if the key or value is null
+     */
+    boolean hasIgnoreCase(String key, String value);
+
+    /**
+     * Check if the set is empty
+     *
+     * @return true if the set is empty
+     */
+    boolean isEmpty();
+
+    /**
+     * Gets the number of key-value context pairs in the set
+     *
+     * @return the size of the set
+     */
+    int size();
+
+}
@@ -0,0 +1,257 @@
+/*
+ * 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.context;
+
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableMultimap;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Multimap;
+
+import java.util.Collection;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * An immutable implementation of {@link ContextSet}.
+ *
+ * @since 2.16
+ */
+public final class ImmutableContextSet implements ContextSet {
+    private static final ImmutableContextSet EMPTY = new ImmutableContextSet(ImmutableMultimap.of());
+
+    /**
+     * Make a singleton ImmutableContextSet from a context pair
+     *
+     * @param key   the key
+     * @param value the value
+     * @return a new ImmutableContextSet containing one KV pair
+     * @throws NullPointerException if key or value is null
+     */
+    public static ImmutableContextSet singleton(String key, String value) {
+        if (key == null) {
+            throw new NullPointerException("key");
+        }
+        if (value == null) {
+            throw new NullPointerException("value");
+        }
+
+        return new ImmutableContextSet(ImmutableMultimap.of(key.toLowerCase(), value));
+    }
+
+    /**
+     * Creates a ImmutableContextSet from an existing 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
+     */
+    public static ImmutableContextSet fromMap(Map<String, String> map) {
+        if (map == null) {
+            throw new NullPointerException("map");
+        }
+
+        ImmutableMultimap.Builder<String, String> b = ImmutableMultimap.builder();
+        for (Map.Entry<String, String> e : map.entrySet()) {
+            b.put(e.getKey(), e.getValue());
+        }
+
+        return new ImmutableContextSet(b.build());
+    }
+
+    /**
+     * Creates a ImmutableContextSet from an existing iterable of Map Entries
+     *
+     * @param iterable the iterable to copy from
+     * @return a new ImmutableContextSet representing the pairs in the iterable
+     * @throws NullPointerException if the iterable is null
+     */
+    public static ImmutableContextSet fromEntries(Iterable<? extends Map.Entry<String, String>> iterable) {
+        if (iterable == null) {
+            throw new NullPointerException("iterable");
+        }
+
+        return MutableContextSet.fromEntries(iterable).makeImmutable();
+    }
+
+    /**
+     * Creates a ImmutableContextSet from an existing 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
+     */
+    public static ImmutableContextSet fromMultimap(Multimap<String, String> multimap) {
+        if (multimap == null) {
+            throw new NullPointerException("multimap");
+        }
+
+        return MutableContextSet.fromMultimap(multimap).makeImmutable();
+    }
+
+    /**
+     * Creates a new ImmutableContextSet from an existing set.
+     * Only really useful for converting between mutable and immutable types.
+     *
+     * @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
+     */
+    public static ImmutableContextSet fromSet(ContextSet contextSet) {
+        return contextSet.makeImmutable();
+    }
+
+    /**
+     * Creates a new empty ContextSet.
+     *
+     * @return a new ContextSet
+     */
+    public static ImmutableContextSet empty() {
+        return EMPTY;
+    }
+
+    private final Multimap<String, String> map;
+
+    ImmutableContextSet(Multimap<String, String> contexts) {
+        this.map = ImmutableMultimap.copyOf(contexts);
+    }
+
+    @Override
+    public boolean isImmutable() {
+        return true;
+    }
+
+    @Override
+    @Deprecated // This set is already immutable!
+    public ImmutableContextSet makeImmutable() {
+        return this;
+    }
+
+    @Override
+    public MutableContextSet mutableCopy() {
+        return MutableContextSet.fromSet(this);
+    }
+
+    @Override
+    public Set<Map.Entry<String, String>> toSet() {
+        return ImmutableSet.copyOf(map.entries());
+    }
+
+    @Override
+    public Map<String, String> toMap() {
+        ImmutableMap.Builder<String, String> m = ImmutableMap.builder();
+        for (Map.Entry<String, String> e : map.entries()) {
+            m.put(e.getKey(), e.getValue());
+        }
+
+        return m.build();
+    }
+
+    @Override
+    public Multimap<String, String> toMultimap() {
+        return map;
+    }
+
+    @Override
+    public boolean containsKey(String key) {
+        if (key == null) {
+            throw new NullPointerException("key");
+        }
+
+        return map.containsKey(key);
+    }
+
+    @Override
+    public Set<String> getValues(String key) {
+        if (key == null) {
+            throw new NullPointerException("key");
+        }
+
+        Collection<String> c = map.get(key);
+        return c != null && !c.isEmpty() ? ImmutableSet.copyOf(c) : ImmutableSet.of();
+    }
+
+    @Override
+    public boolean has(String key, String value) {
+        if (key == null) {
+            throw new NullPointerException("key");
+        }
+        if (value == null) {
+            throw new NullPointerException("value");
+        }
+
+        return map.containsEntry(key, value);
+    }
+
+    @Override
+    public boolean hasIgnoreCase(String key, String value) {
+        if (key == null) {
+            throw new NullPointerException("key");
+        }
+        if (value == null) {
+            throw new NullPointerException("value");
+        }
+
+        Collection<String> c = map.get(key);
+        if (c == null || c.isEmpty()) {
+            return false;
+        }
+
+        for (String val : c) {
+            if (val.equalsIgnoreCase(value)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return map.isEmpty();
+    }
+
+    @Override
+    public int size() {
+        return map.size();
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (o == this) return true;
+        if (!(o instanceof ContextSet)) return false;
+        final ContextSet other = (ContextSet) o;
+
+        final Multimap<String, String> thisContexts = this.toMultimap();
+        final Multimap<String, String> otherContexts = other.toMultimap();
+        return thisContexts == null ? otherContexts == null : thisContexts.equals(otherContexts);
+    }
+
+    @Override
+    public int hashCode() {
+        return 59 + (this.map == null ? 43 : this.map.hashCode());
+    }
+
+    @Override
+    public String toString() {
+        return "ImmutableContextSet(contexts=" + this.map + ")";
+    }
+}
@@ -0,0 +1,399 @@
+/*
+ * 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.context;
+
+import com.google.common.collect.HashMultimap;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Multimap;
+import com.google.common.collect.Multimaps;
+
+import java.util.Collection;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * A mutable implementation of {@link ContextSet}.
+ *
+ * @since 2.16
+ */
+public final class MutableContextSet implements ContextSet {
+
+    /**
+     * Make a singleton MutableContextSet from a context pair
+     *
+     * @param key   the key
+     * @param value the value
+     * @return a new MutableContextSet containing one KV pair
+     * @throws NullPointerException if key or value is null
+     */
+    public static MutableContextSet singleton(String key, String value) {
+        if (key == null) {
+            throw new NullPointerException("key");
+        }
+        if (value == null) {
+            throw new NullPointerException("value");
+        }
+
+        MutableContextSet set = new MutableContextSet();
+        set.add(key, value);
+        return set;
+    }
+
+    /**
+     * Creates a MutableContextSet from an existing 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
+     */
+    public static MutableContextSet fromMap(Map<String, String> map) {
+        if (map == null) {
+            throw new NullPointerException("map");
+        }
+
+        MutableContextSet set = new MutableContextSet();
+        set.addAll(map);
+        return set;
+    }
+
+    /**
+     * Creates a MutableContextSet from an existing iterable of Map Entries
+     *
+     * @param iterable the iterable to copy from
+     * @return a new MutableContextSet representing the pairs in the iterable
+     * @throws NullPointerException if the iterable is null
+     */
+    public static MutableContextSet fromEntries(Iterable<? extends Map.Entry<String, String>> iterable) {
+        if (iterable == null) {
+            throw new NullPointerException("iterable");
+        }
+
+        MutableContextSet set = new MutableContextSet();
+        set.addAll(iterable);
+        return set;
+    }
+
+    /**
+     * Creates a MutableContextSet from an existing 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
+     */
+    public static MutableContextSet fromMultimap(Multimap<String, String> multimap) {
+        if (multimap == null) {
+            throw new NullPointerException("multimap");
+        }
+
+        return fromEntries(multimap.entries());
+    }
+
+    /**
+     * Creates a new MutableContextSet from an existing set.
+     * Only really useful for converting between mutable and immutable types.
+     *
+     * @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
+     */
+    public static MutableContextSet fromSet(ContextSet contextSet) {
+        if (contextSet == null) {
+            throw new NullPointerException("contextSet");
+        }
+
+        MutableContextSet set = new MutableContextSet();
+        set.addAll(contextSet.toSet());
+        return set;
+    }
+
+    /**
+     * Creates a new empty MutableContextSet.
+     *
+     * @return a new MutableContextSet
+     */
+    public static MutableContextSet create() {
+        return new MutableContextSet();
+    }
+
+    private final Multimap<String, String> map;
+
+    public MutableContextSet() {
+        this.map = Multimaps.synchronizedMultimap(HashMultimap.create());
+    }
+
+    private MutableContextSet(Multimap<String, String> contexts) {
+        this.map = Multimaps.synchronizedMultimap(HashMultimap.create(contexts));
+    }
+
+    @Override
+    public boolean isImmutable() {
+        return false;
+    }
+
+    @Override
+    public ImmutableContextSet makeImmutable() {
+        return new ImmutableContextSet(map);
+    }
+
+    @Override
+    public MutableContextSet mutableCopy() {
+        return new MutableContextSet(map);
+    }
+
+    @Override
+    public Set<Map.Entry<String, String>> toSet() {
+        return ImmutableSet.copyOf(map.entries());
+    }
+
+    @Override
+    public Map<String, String> toMap() {
+        ImmutableMap.Builder<String, String> m = ImmutableMap.builder();
+        for (Map.Entry<String, String> e : map.entries()) {
+            m.put(e.getKey(), e.getValue());
+        }
+
+        return m.build();
+    }
+
+    @Override
+    public Multimap<String, String> toMultimap() {
+        return map;
+    }
+
+    @Override
+    public boolean containsKey(String key) {
+        if (key == null) {
+            throw new NullPointerException("key");
+        }
+
+        return map.containsKey(key);
+    }
+
+    @Override
+    public Set<String> getValues(String key) {
+        if (key == null) {
+            throw new NullPointerException("key");
+        }
+
+        Collection<String> c = map.get(key);
+        return c != null && !c.isEmpty() ? ImmutableSet.copyOf(c) : ImmutableSet.of();
+    }
+
+    @Override
+    public boolean has(String key, String value) {
+        if (key == null) {
+            throw new NullPointerException("key");
+        }
+        if (value == null) {
+            throw new NullPointerException("value");
+        }
+
+        return map.containsEntry(key, value);
+    }
+
+    @Override
+    public boolean hasIgnoreCase(String key, String value) {
+        if (key == null) {
+            throw new NullPointerException("key");
+        }
+        if (value == null) {
+            throw new NullPointerException("value");
+        }
+
+        Collection<String> c = map.get(key);
+        if (c == null || c.isEmpty()) {
+            return false;
+        }
+
+        for (String val : c) {
+            if (val.equalsIgnoreCase(value)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return map.isEmpty();
+    }
+
+    @Override
+    public int size() {
+        return map.size();
+    }
+
+    /**
+     * Adds a new key value pair to the 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(String key, String value) {
+        if (key == null) {
+            throw new NullPointerException("key");
+        }
+        if (value == null) {
+            throw new NullPointerException("value");
+        }
+
+        map.put(key.toLowerCase(), value);
+    }
+
+    /**
+     * Adds a new key value pair to the set
+     *
+     * @param entry the entry to add
+     * @throws NullPointerException if the entry is null
+     */
+    public void add(Map.Entry<String, String> entry) {
+        if (entry == null) {
+            throw new NullPointerException("context");
+        }
+
+        map.put(entry.getKey().toLowerCase(), entry.getValue());
+    }
+
+    /**
+     * Adds an iterable containing contexts to the set
+     *
+     * @param iterable an iterable of key value context pairs
+     * @throws NullPointerException if iterable is null
+     */
+    public void addAll(Iterable<? extends Map.Entry<String, String>> iterable) {
+        if (iterable == null) {
+            throw new NullPointerException("contexts");
+        }
+
+        for (Map.Entry<String, String> e : iterable) {
+            this.map.put(e.getKey().toLowerCase(), e.getValue());
+        }
+    }
+
+    /**
+     * Adds the entry set of a map to the set
+     *
+     * @param map the map to add from
+     * @throws NullPointerException if the map is null
+     */
+    public void addAll(Map<String, String> map) {
+        if (map == null) {
+            throw new NullPointerException("contexts");
+        }
+        addAll(map.entrySet());
+    }
+
+    /**
+     * Adds of of the values in another ContextSet to this set
+     *
+     * @param contextSet the set to add from
+     * @throws NullPointerException if the contextSet is null
+     */
+    public void addAll(ContextSet contextSet) {
+        if (contextSet == null) {
+            throw new NullPointerException("contextSet");
+        }
+
+        this.map.putAll(contextSet.toMultimap());
+    }
+
+    /**
+     * Remove a key value pair 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(String key, String value) {
+        if (key == null) {
+            throw new NullPointerException("key");
+        }
+        if (value == null) {
+            throw new NullPointerException("value");
+        }
+
+        map.entries().removeIf(entry -> entry.getKey().equalsIgnoreCase(key) && entry.getValue().equals(value));
+    }
+
+    /**
+     * Same as {@link #remove(String, String)}, except ignores the case of the value
+     *
+     * @param key   the key to remove
+     * @param value the value to remove
+     * @throws NullPointerException if the key or value is null
+     */
+    public void removeIgnoreCase(String key, String value) {
+        if (key == null) {
+            throw new NullPointerException("key");
+        }
+        if (value == null) {
+            throw new NullPointerException("value");
+        }
+
+        map.entries().removeIf(e -> e.getKey().equalsIgnoreCase(key) && e.getValue().equalsIgnoreCase(value));
+    }
+
+    /**
+     * Removes all pairs with the given key
+     *
+     * @param key the key to remove
+     * @throws NullPointerException if the key is null
+     */
+    public void removeAll(String key) {
+        if (key == null) {
+            throw new NullPointerException("key");
+        }
+
+        map.removeAll(key.toLowerCase());
+    }
+
+    /**
+     * Clears the set
+     */
+    public void clear() {
+        map.clear();
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (o == this) return true;
+        if (!(o instanceof ContextSet)) return false;
+        final ContextSet other = (ContextSet) o;
+
+        final Multimap<String, String> thisContexts = this.toMultimap();
+        final Multimap<String, String> otherContexts = other.toMultimap();
+        return thisContexts == null ? otherContexts == null : thisContexts.equals(otherContexts);
+    }
+
+    @Override
+    public int hashCode() {
+        return 59 + (this.map == null ? 43 : this.map.hashCode());
+    }
+
+    @Override
+    public String toString() {
+        return "MutableContextSet(contexts=" + this.map + ")";
+    }
+}
@@ -0,0 +1,39 @@
+/*
+ * 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.data;
+
+/**
+ * Represents the data section of the main LuckPerms configuration.
+ * All methods could return null.
+ */
+public interface DatastoreConfiguration {
+
+    String getAddress();
+
+    String getDatabase();
+
+    String getUsername();
+
+    String getPassword();
+
+}
@@ -0,0 +1,39 @@
+/*
+ * 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;
+
+import java.util.concurrent.atomic.AtomicBoolean;
+
+/**
+ * Represents an event that can be cancelled
+ */
+public interface Cancellable {
+
+    /**
+     * Gets an {@link AtomicBoolean} holding the cancellation state of the event
+     *
+     * @return the cancellation
+     */
+    AtomicBoolean getCancellationState();
+
+}
@@ -0,0 +1,54 @@
+/*
+ * 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;
+
+import java.util.Set;
+import java.util.function.Consumer;
+
+/**
+ * The LuckPerms event bus. Used for subscribing (or registering listeners) to events.
+ *
+ * @since 3.0
+ */
+public interface EventBus {
+
+    /**
+     * Subscribe 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
+     */
+    <T extends LuckPermsEvent> EventHandler<T> subscribe(Class<T> eventClass, 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
+     */
+    <T extends LuckPermsEvent> Set<EventHandler<T>> getHandlers(Class<T> eventClass);
+
+}
@@ -0,0 +1,69 @@
+/*
+ * 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;
+
+import java.util.function.Consumer;
+
+/**
+ * Represents a handler for a LuckPerms event
+ *
+ * @param <T> the event class
+ */
+public interface EventHandler<T extends LuckPermsEvent> {
+
+    /**
+     * Gets the class this handler is listening to
+     *
+     * @return the event class
+     */
+    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
+     */
+    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();
+
+}
@@ -0,0 +1,41 @@
+/*
+ * 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;
+
+import me.lucko.luckperms.api.LuckPermsApi;
+
+/**
+ * The base event interface
+ *
+ * @since 3.0
+ */
+public interface LuckPermsEvent {
+
+    /**
+     * Get the API instance this event was dispatched from
+     *
+     * @return the api instance
+     */
+    LuckPermsApi getApi();
+
+}
@@ -0,0 +1,45 @@
+/*
+ * 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.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,45 @@
+/*
+ * 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.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;
+
+}
@@ -0,0 +1,48 @@
+/*
+ * 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.group;
+
+import me.lucko.luckperms.api.Group;
+import me.lucko.luckperms.api.event.LuckPermsEvent;
+import me.lucko.luckperms.api.event.cause.CreationCause;
+
+/**
+ * Called when a group is created
+ */
+public interface GroupCreateEvent extends LuckPermsEvent {
+
+    /**
+     * Gets the new group
+     *
+     * @return the new group
+     */
+    Group getGroup();
+
+    /**
+     * Gets the cause of the creation
+     *
+     * @return the cause of the creation
+     */
+    CreationCause getCause();
+
+}
@@ -0,0 +1,57 @@
+/*
+ * 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.group;
+
+import me.lucko.luckperms.api.Node;
+import me.lucko.luckperms.api.event.LuckPermsEvent;
+import me.lucko.luckperms.api.event.cause.DeletionCause;
+
+import java.util.Set;
+
+/**
+ * Called when a group is deleted
+ */
+public interface GroupDeleteEvent extends LuckPermsEvent {
+
+    /**
+     * Gets the name of the deleted group
+     *
+     * @return the name of the deleted group
+     */
+    String getGroupName();
+
+    /**
+     * Gets an immutable copy of the groups existing data
+     *
+     * @return a copy of the groups existing data
+     */
+    Set<Node> getExistingData();
+
+    /**
+     * Gets the cause of the deletion
+     *
+     * @return the cause of the deletion
+     */
+    DeletionCause getCause();
+
+}
@@ -0,0 +1,34 @@
+/*
+ * 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.group;
+
+import me.lucko.luckperms.api.event.LuckPermsEvent;
+
+/**
+ * Called when all groups have been loaded in from storage.
+ *
+ * <p>Usually only called on startup and in sync tasks.</p>
+ */
+public interface GroupLoadAllEvent extends LuckPermsEvent {
+
+}
@@ -0,0 +1,42 @@
+/*
+ * 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.group;
+
+import me.lucko.luckperms.api.Group;
+import me.lucko.luckperms.api.event.LuckPermsEvent;
+
+/**
+ * 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
+     */
+    Group getGroup();
+
+}
@@ -0,0 +1,41 @@
+/*
+ * 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.log;
+
+import me.lucko.luckperms.api.LogEntry;
+import me.lucko.luckperms.api.event.Cancellable;
+import me.lucko.luckperms.api.event.LuckPermsEvent;
+
+/**
+ * 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
+     */
+    LogEntry getEntry();
+
+}
@@ -0,0 +1,41 @@
+/*
+ * 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.log;
+
+import me.lucko.luckperms.api.LogEntry;
+import me.lucko.luckperms.api.event.Cancellable;
+import me.lucko.luckperms.api.event.LuckPermsEvent;
+
+/**
+ * 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
+     */
+    LogEntry getEntry();
+
+}
@@ -0,0 +1,39 @@
+/*
+ * 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.node;
+
+import me.lucko.luckperms.api.Node;
+
+/**
+ * Called when a node is added to a holder
+ */
+public interface NodeAddEvent extends NodeMutateEvent {
+
+    /**
+     * Gets the node that was added
+     *
+     * @return the node that was added
+     */
+    Node getNode();
+
+}
@@ -0,0 +1,30 @@
+/*
+ * 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.node;
+
+/**
+ * Called when a holder has their nodes cleared
+ */
+public interface NodeClearEvent extends NodeMutateEvent {
+
+}
@@ -0,0 +1,75 @@
+/*
+ * 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.node;
+
+import me.lucko.luckperms.api.Node;
+import me.lucko.luckperms.api.PermissionHolder;
+import me.lucko.luckperms.api.event.LuckPermsEvent;
+
+import java.util.Set;
+
+/**
+ * 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
+     */
+    PermissionHolder getTarget();
+
+    /**
+     * Gets an immutable copy of the holders data before the change
+     *
+     * @return the data before the change
+     */
+    Set<Node> getDataBefore();
+
+    /**
+     * Gets an immutable copy of the holders data after the change
+     *
+     * @return the data after the change
+     */
+    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();
+
+}
@@ -0,0 +1,39 @@
+/*
+ * 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.node;
+
+import me.lucko.luckperms.api.Node;
+
+/**
+ * Called when a node is removed from a holder
+ */
+public interface NodeRemoveEvent extends NodeMutateEvent {
+
+    /**
+     * Gets the node that was removed
+     *
+     * @return the node that was removed
+     */
+    Node getNode();
+
+}
@@ -0,0 +1,32 @@
+/*
+ * 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.sync;
+
+import me.lucko.luckperms.api.event.LuckPermsEvent;
+
+/**
+ * Called when the configuration is reloaded
+ */
+public interface ConfigReloadEvent extends LuckPermsEvent {
+
+}
@@ -0,0 +1,32 @@
+/*
+ * 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.sync;
+
+import me.lucko.luckperms.api.event.LuckPermsEvent;
+
+/**
+ * Called when an sync task has been completed
+ */
+public interface PostSyncEvent extends LuckPermsEvent {
+
+}
@@ -0,0 +1,42 @@
+/*
+ * 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.sync;
+
+import me.lucko.luckperms.api.event.Cancellable;
+import me.lucko.luckperms.api.event.LuckPermsEvent;
+
+import java.util.UUID;
+
+/**
+ * Called before a network sync task runs
+ */
+public interface PreNetworkSyncEvent extends LuckPermsEvent, Cancellable {
+
+    /**
+     * Gets the ID of the sync request
+     *
+     * @return the id of the sync request
+     */
+    UUID getSyncId();
+
+}
@@ -0,0 +1,33 @@
+/*
+ * 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.sync;
+
+import me.lucko.luckperms.api.event.Cancellable;
+import me.lucko.luckperms.api.event.LuckPermsEvent;
+
+/**
+ * Called before a sync task runs
+ */
+public interface PreSyncEvent extends LuckPermsEvent, Cancellable {
+
+}
@@ -0,0 +1,48 @@
+/*
+ * 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.track;
+
+import me.lucko.luckperms.api.Track;
+import me.lucko.luckperms.api.event.LuckPermsEvent;
+import me.lucko.luckperms.api.event.cause.CreationCause;
+
+/**
+ * Called when a track is created
+ */
+public interface TrackCreateEvent extends LuckPermsEvent {
+
+    /**
+     * Gets the new track
+     *
+     * @return the new track
+     */
+    Track getTrack();
+
+    /**
+     * Gets the cause of the creation
+     *
+     * @return the cause of the creation
+     */
+    CreationCause getCause();
+
+}
@@ -0,0 +1,56 @@
+/*
+ * 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.track;
+
+import me.lucko.luckperms.api.event.LuckPermsEvent;
+import me.lucko.luckperms.api.event.cause.DeletionCause;
+
+import java.util.List;
+
+/**
+ * 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
+     */
+    String getTrackName();
+
+    /**
+     * Gets an immutable copy of the tracks existing data
+     *
+     * @return a copy of the tracks existing data
+     */
+    List<String> getExistingData();
+
+    /**
+     * Gets the cause of the deletion
+     *
+     * @return the cause of the deletion
+     */
+    DeletionCause getCause();
+
+}
@@ -0,0 +1,34 @@
+/*
+ * 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.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 {
+
+}
@@ -0,0 +1,42 @@
+/*
+ * 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.track;
+
+import me.lucko.luckperms.api.Track;
+import me.lucko.luckperms.api.event.LuckPermsEvent;
+
+/**
+ * Called when a track is loaded into memory from the storage.
+ *
+ * Note that this event is not the same as {@link TrackCreateEvent}
+ */
+public interface TrackLoadEvent extends LuckPermsEvent {
+
+    /**
+     * Gets the track that was loaded
+     *
+     * @return the track that was loaded
+     */
+    Track getTrack();
+
+}
@@ -0,0 +1,37 @@
+/*
+ * 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.track.mutate;
+
+/**
+ * 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
+     */
+    String getGroup();
+
+}
@@ -0,0 +1,30 @@
+/*
+ * 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.track.mutate;
+
+/**
+ * Called when a track is cleared
+ */
+public interface TrackClearEvent extends TrackMutateEvent {
+
+}
@@ -0,0 +1,56 @@
+/*
+ * 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.track.mutate;
+
+import me.lucko.luckperms.api.Track;
+import me.lucko.luckperms.api.event.LuckPermsEvent;
+
+import java.util.List;
+
+/**
+ * Called when a track is changed
+ */
+public interface TrackMutateEvent extends LuckPermsEvent {
+
+    /**
+     * Gets the track that was mutated
+     *
+     * @return the track that was mutated
+     */
+    Track getTrack();
+
+    /**
+     * Gets an immutable copy of the tracks data before the change
+     *
+     * @return the data before the change
+     */
+    List<String> getDataBefore();
+
+    /**
+     * Gets an immutable copy of the tracks data after the change
+     *
+     * @return the data after the change
+     */
+    List<String> getDataAfter();
+
+}
@@ -0,0 +1,37 @@
+/*
+ * 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.track.mutate;
+
+/**
+ * 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
+     */
+    String getGroup();
+
+}
@@ -0,0 +1,48 @@
+/*
+ * 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.user;
+
+import me.lucko.luckperms.api.User;
+import me.lucko.luckperms.api.caching.UserData;
+import me.lucko.luckperms.api.event.LuckPermsEvent;
+
+/**
+ * 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
+     */
+    User getUser();
+
+    /**
+     * Gets the data that was loaded
+     *
+     * @return the loaded data
+     */
+    UserData getLoadedData();
+
+}
@@ -0,0 +1,48 @@
+/*
+ * 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.user;
+
+import me.lucko.luckperms.api.User;
+import me.lucko.luckperms.api.caching.UserData;
+import me.lucko.luckperms.api.event.LuckPermsEvent;
+
+/**
+ * Called when a users cached data is refreshed
+ */
+public interface UserDataRecalculateEvent extends LuckPermsEvent {
+
+    /**
+     * Gets the user whose data was recalculated
+     *
+     * @return the user
+     */
+    User getUser();
+
+    /**
+     * Gets the data that was recalculated
+     *
+     * @return the data
+     */
+    UserData getData();
+
+}
@@ -0,0 +1,56 @@
+/*
+ * 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.user;
+
+import me.lucko.luckperms.api.event.LuckPermsEvent;
+
+import java.util.UUID;
+
+/**
+ * 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
+     */
+    UUID getUuid();
+
+    /**
+     * Gets the username of the user
+     *
+     * @return the username of the user
+     */
+    String getUsername();
+
+}
@@ -0,0 +1,40 @@
+/*
+ * 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.user;
+
+import me.lucko.luckperms.api.User;
+import me.lucko.luckperms.api.event.LuckPermsEvent;
+
+/**
+ * Called when a user is loaded into memory from the storage.
+ */
+public interface UserLoadEvent extends LuckPermsEvent {
+
+    /**
+     * Gets the user that was loaded
+     *
+     * @return the user that was loaded
+     */
+    User getUser();
+
+}
@@ -0,0 +1,40 @@
+/*
+ * 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.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,32 @@
+/*
+ * 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.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,32 @@
+/*
+ * 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.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,73 @@
+/*
+ * 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.user.track;
+
+import me.lucko.luckperms.api.Track;
+import me.lucko.luckperms.api.User;
+import me.lucko.luckperms.api.event.LuckPermsEvent;
+
+import java.util.Optional;
+
+/**
+ * Called when a user interacts with a track through a promotion or demotion
+ */
+public interface UserTrackEvent extends LuckPermsEvent {
+
+    /**
+     * Gets the track involved in the event
+     *
+     * @return the track involved in the event
+     */
+    Track getTrack();
+
+    /**
+     * Gets the user who was promoted or demoted
+     *
+     * @return the user involved in the event
+     */
+    User getUser();
+
+    /**
+     * Gets the action performed
+     *
+     * @return the action performed
+     */
+    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
+     */
+    Optional<String> getGroupFrom();
+
+    /**
+     * Gets the group the user was promoted/demoted to
+     *
+     * @return the group the user was promoted/demoted to
+     */
+    Optional<String> getGroupTo();
+
+}
@@ -0,0 +1,32 @@
+/*
+ * 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.exceptions;
+
+/**
+ * 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
+ */
+public abstract class MembershipException extends Exception {
+}
@@ -0,0 +1,30 @@
+/*
+ * 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.exceptions;
+
+/**
+ * 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.
+ */
+public class ObjectAlreadyHasException extends MembershipException {
+}
@@ -0,0 +1,30 @@
+/*
+ * 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.exceptions;
+
+/**
+ * Thrown when a permission holding object does not already have a permission, is not already a member of a group,
+ * or when a track doesn't contain a group.
+ */
+public class ObjectLacksException extends MembershipException {
+}
@@ -0,0 +1,99 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<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>3.0-SNAPSHOT</version>
+    </parent>
+    <modelVersion>4.0.0</modelVersion>
+
+    <artifactId>luckperms-bukkit-legacy</artifactId>
+    <build>
+        <defaultGoal>clean package</defaultGoal>
+        <finalName>LuckPerms-Bukkit-Legacy-${release.version}.${patch.version}</finalName>
+        <resources>
+            <resource>
+                <directory>src/main/resources</directory>
+                <filtering>true</filtering>
+            </resource>
+            <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>
+                <configuration>
+                    <source>1.8</source>
+                    <target>1.8</target>
+                </configuration>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-shade-plugin</artifactId>
+                <version>2.4.3</version>
+                <executions>
+                    <execution>
+                        <phase>package</phase>
+                        <goals>
+                            <goal>shade</goal>
+                        </goals>
+                        <configuration>
+                            <minimizeJar>false</minimizeJar>
+                            <createDependencyReducedPom>false</createDependencyReducedPom>
+                            <relocations>
+                                <relocation>
+                                    <pattern>com.google.common</pattern>
+                                    <shadedPattern>me.lucko.luckperms.lib.guava</shadedPattern>
+                                </relocation>
+                                <relocation>
+                                    <pattern>com.google.gson</pattern>
+                                    <shadedPattern>me.lucko.luckperms.lib.gson</shadedPattern>
+                                </relocation>
+                                <relocation>
+                                    <pattern>io.github.mkremins.fanciful</pattern>
+                                    <shadedPattern>me.lucko.luckperms.lib.fanciful</shadedPattern>
+                                </relocation>
+                            </relocations>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
+        </plugins>
+    </build>
+
+    <dependencies>
+        <!-- LuckPerms Bukkit -->
+        <dependency>
+            <groupId>me.lucko.luckperms</groupId>
+            <artifactId>luckperms-bukkit</artifactId>
+            <version>${project.version}</version>
+            <scope>compile</scope>
+        </dependency>
+
+        <!-- Shade gson and guava, as they are not included in earlier Bukkit releases -->
+        <!-- gson -->
+        <dependency>
+            <groupId>com.google.code.gson</groupId>
+            <artifactId>gson</artifactId>
+            <version>2.7</version>
+            <scope>compile</scope>
+        </dependency>
+        <!-- guava -->
+        <dependency>
+            <groupId>com.google.guava</groupId>
+            <artifactId>guava</artifactId>
+            <version>19.0</version>
+            <scope>compile</scope>
+        </dependency>
+    </dependencies>
+
+</project>
@@ -0,0 +1,61 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<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>3.0-SNAPSHOT</version>
+    </parent>
+    <modelVersion>4.0.0</modelVersion>
+
+    <artifactId>luckperms-bukkit-placeholders</artifactId>
+    <build>
+        <finalName>LuckPermsPlaceholderExpansion</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>
+                <configuration>
+                    <source>1.8</source>
+                    <target>1.8</target>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+
+    <dependencies>
+        <!-- LuckPerms API -->
+        <dependency>
+            <groupId>me.lucko.luckperms</groupId>
+            <artifactId>luckperms-api</artifactId>
+            <version>${project.version}</version>
+            <scope>provided</scope>
+        </dependency>
+        <!-- BukkitAPI -->
+        <dependency>
+            <groupId>org.bukkit</groupId>
+            <artifactId>bukkit</artifactId>
+            <version>1.8.8-R0.1-SNAPSHOT</version>
+            <scope>provided</scope>
+        </dependency>
+        <!-- PlaceholderAPI -->
+        <dependency>
+            <groupId>me.clip</groupId>
+            <artifactId>placeholderapi</artifactId>
+            <version>2.2.0</version>
+            <scope>provided</scope>
+        </dependency>
+    </dependencies>
+
+</project>
@@ -0,0 +1,220 @@
+/*
+ * 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.placeholders;
+
+import me.clip.placeholderapi.PlaceholderAPIPlugin;
+import me.clip.placeholderapi.expansion.PlaceholderExpansion;
+import me.clip.placeholderapi.util.TimeUtil;
+import me.lucko.luckperms.api.Contexts;
+import me.lucko.luckperms.api.LuckPermsApi;
+import me.lucko.luckperms.api.Node;
+import me.lucko.luckperms.api.Track;
+import me.lucko.luckperms.api.User;
+import me.lucko.luckperms.api.caching.UserData;
+import me.lucko.luckperms.api.context.MutableContextSet;
+
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+/*
+ * PlaceholderAPI Expansion for LuckPerms, implemented using the LuckPerms API.
+ *
+ * Placeholders:
+ * - group_name
+ * - groups
+ * - has_permission_<node>
+ * - inherits_permission_<node>
+ * - in_group_<name>
+ * - inherits_group_<name>
+ * - on_track_<track>
+ * - expiry_time_<node>
+ * - group_expiry_time_<group>
+ * - prefix
+ * - suffix
+ * - meta_<node>
+ */
+public class LuckPermsPlaceholderExpansion extends PlaceholderExpansion {
+    private static final String IDENTIFIER = "luckperms";
+    private static final String PLUGIN_NAME = "LuckPerms";
+    private static final String AUTHOR = "Luck";
+
+    private static String formatBoolean(boolean b) {
+        return b ? PlaceholderAPIPlugin.booleanTrue() : PlaceholderAPIPlugin.booleanFalse();
+    }
+
+    private LuckPermsApi api = null;
+
+    @Override
+    public boolean canRegister() {
+        return Bukkit.getServicesManager().isProvidedFor(LuckPermsApi.class);
+    }
+
+    @Override
+    public boolean register() {
+        if (!canRegister()) {
+            return false;
+        }
+
+        api = Bukkit.getServicesManager().getRegistration(LuckPermsApi.class).getProvider();
+        return super.register();
+    }
+
+    @Override
+    public String getVersion() {
+        return "2.13";
+    }
+
+    private Contexts makeContexts(Player player) {
+        MutableContextSet contextSet = new MutableContextSet();
+        contextSet.add("server", api.getConfiguration().getVaultServer());
+        contextSet.add("world", player.getWorld().getName());// ignore world?
+        return Contexts.of(contextSet.makeImmutable(), api.getConfiguration().getVaultIncludeGlobal(), true, true, true, true, player.isOp());
+    }
+
+    @Override
+    public String onPlaceholderRequest(Player player, String identifier) {
+        if (player == null || api == null) {
+            return "";
+        }
+
+        Optional<User> u = api.getUserSafe(api.getUuidCache().getUUID(player.getUniqueId()));
+        if (!u.isPresent()) {
+            return "";
+        }
+        final User user = u.get();
+
+        Optional<UserData> d = user.getUserDataCache();
+        if (!d.isPresent()) {
+            return "";
+        }
+        final UserData data = d.get();
+
+        identifier = identifier.toLowerCase();
+
+        if (identifier.equalsIgnoreCase("group_name")) {
+            return user.getPrimaryGroup();
+        }
+
+        if (identifier.equalsIgnoreCase("groups")) {
+            return user.getGroupNames().stream().collect(Collectors.joining(", "));
+        }
+
+        if (identifier.startsWith("has_permission_") && identifier.length() > "has_permission_".length()) {
+            String node = identifier.substring("has_permission_".length());
+            return formatBoolean(user.hasPermission(node, true));
+        }
+
+        if (identifier.startsWith("inherits_permission_") && identifier.length() > "inherits_permission_".length()) {
+            String node = identifier.substring("inherits_permission_".length());
+            return formatBoolean(data.getPermissionData(makeContexts(player)).getPermissionValue(node).asBoolean());
+        }
+
+        if (identifier.startsWith("in_group_") && identifier.length() > "in_group_".length()) {
+            String groupName = identifier.substring("in_group_".length());
+            return formatBoolean(user.getGroupNames().contains(groupName));
+        }
+
+        if (identifier.startsWith("inherits_group_") && identifier.length() > "inherits_group_".length()) {
+            String groupName = identifier.substring("inherits_group_".length());
+            return formatBoolean(data.getPermissionData(makeContexts(player)).getPermissionValue("group." + groupName).asBoolean());
+        }
+
+        if (identifier.startsWith("on_track_") && identifier.length() > "on_track_".length()) {
+            String trackName = identifier.substring("on_track_".length());
+
+            Optional<Track> track = api.getTrackSafe(trackName);
+            if (!track.isPresent()) return "";
+
+            return formatBoolean(track.get().containsGroup(user.getPrimaryGroup()));
+        }
+
+        if (identifier.startsWith("expiry_time_") && identifier.length() > "expiry_time_".length()) {
+            String node = identifier.substring("expiry_time_".length());
+            long currentTime = System.currentTimeMillis() / 1000L;
+            for (Node n : user.getTemporaryPermissionNodes()) {
+                if (n.toSerializedNode().equalsIgnoreCase(node)) {
+                    return TimeUtil.getTime((int) (n.getExpiryUnixTime() - currentTime));
+                }
+            }
+
+            return "";
+        }
+
+        if (identifier.startsWith("group_expiry_time_") && identifier.length() > "group_expiry_time_".length()) {
+            String node = "group." + identifier.substring("group_expiry_time_".length());
+            long currentTime = System.currentTimeMillis() / 1000L;
+            for (Node n : user.getTemporaryPermissionNodes()) {
+                if (n.getPermission().equalsIgnoreCase(node)) {
+                    return TimeUtil.getTime((int) (n.getExpiryUnixTime() - currentTime));
+                }
+            }
+
+            return "";
+        }
+
+        if (identifier.equalsIgnoreCase("prefix")) {
+            String prefix = data.calculateMeta(makeContexts(player)).getPrefix();
+            if (prefix == null) {
+                prefix = "";
+            }
+            return prefix;
+        }
+
+        if (identifier.equalsIgnoreCase("suffix")) {
+            String suffix = data.calculateMeta(makeContexts(player)).getSuffix();
+            if (suffix == null) {
+                suffix = "";
+            }
+            return suffix;
+        }
+
+        if (identifier.startsWith("meta_") && identifier.length() > "meta_".length()) {
+            String node = identifier.substring("meta_".length());
+            String meta = data.getMetaData(makeContexts(player)).getMeta().get(node);
+            if (meta == null) {
+                meta = "";
+            }
+            return meta;
+        }
+
+        return null;
+    }
+
+    @Override
+    public String getIdentifier() {
+        return IDENTIFIER;
+    }
+
+    @Override
+    public String getPlugin() {
+        return PLUGIN_NAME;
+    }
+
+    @Override
+    public String getAuthor() {
+        return AUTHOR;
+    }
+}
@@ -1,28 +1,33 @@
 <?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</groupId>
-        <version>1.2</version>
+        <groupId>me.lucko.luckperms</groupId>
+        <version>3.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>luckperms-bukkit</artifactId>
-    <version>$(project.parent.version)</version>
    <packaging>jar</packaging>
-    <name>LuckPerms</name>

    <build>
        <defaultGoal>clean package</defaultGoal>
-        <finalName>LuckPerms</finalName>
+        <finalName>LuckPerms-Bukkit-${release.version}.${patch.version}</finalName>
        <sourceDirectory>${basedir}/src/main/java</sourceDirectory>
        <resources>
            <resource>
                <directory>src/main/resources</directory>
                <filtering>true</filtering>
            </resource>
+            <resource>
+                <directory>../</directory>
+                <filtering>false</filtering>
+                <includes>
+                    <include>LICENSE.txt</include>
+                </includes>
+            </resource>
        </resources>
        <plugins>
            <plugin>
@@ -45,7 +50,14 @@
                            <goal>shade</goal>
                        </goals>
                        <configuration>
-                            <minimizeJar>true</minimizeJar>
+                            <minimizeJar>false</minimizeJar>
+                            <createDependencyReducedPom>false</createDependencyReducedPom>
+                            <relocations>
+                                <relocation>
+                                    <pattern>io.github.mkremins.fanciful</pattern>
+                                    <shadedPattern>me.lucko.luckperms.lib.fanciful</shadedPattern>
+                                </relocation>
+                            </relocations>
                        </configuration>
                    </execution>
                </executions>
@@ -56,8 +68,8 @@
    <dependencies>
        <!-- BukkitAPI -->
        <dependency>
-            <groupId>org.bukkit</groupId>
-            <artifactId>bukkit</artifactId>
+            <groupId>org.spigotmc</groupId>
+            <artifactId>spigot-api</artifactId>
            <version>1.8.8-R0.1-SNAPSHOT</version>
            <scope>provided</scope>
        </dependency>
@@ -65,15 +77,84 @@
        <dependency>
            <groupId>net.milkbowl.vault</groupId>
            <artifactId>VaultAPI</artifactId>
-            <version>1.5</version>
+            <version>1.6</version>
            <scope>provided</scope>
        </dependency>
        <!-- LuckPerms Common -->
        <dependency>
-            <groupId>me.lucko</groupId>
+            <groupId>me.lucko.luckperms</groupId>
            <artifactId>luckperms-common</artifactId>
-            <version>${project.parent.version}</version>
+            <version>${project.version}</version>
            <scope>compile</scope>
        </dependency>
+        <!-- LuckPerms API -->
+        <dependency>
+            <groupId>me.lucko.luckperms</groupId>
+            <artifactId>luckperms-api</artifactId>
+            <version>${project.version}</version>
+            <scope>compile</scope>
+        </dependency>
+        <!-- LilyPad - used as a messaging service -->
+        <dependency>
+            <groupId>lilypad.client.connect</groupId>
+            <artifactId>api</artifactId>
+            <version>0.0.1-SNAPSHOT</version>
+            <scope>provided</scope>
+        </dependency>
+        <!-- HikariCP - needed as source -->
+        <dependency>
+            <groupId>com.zaxxer</groupId>
+            <artifactId>HikariCP</artifactId>
+            <version>2.5.1</version>
+            <scope>provided</scope>
+        </dependency>
+        <!-- Lombok -->
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+            <version>1.16.10</version>
+            <scope>provided</scope>
+        </dependency>
+        <!-- **************Migration Plugins************** -->
+        <dependency>
+            <groupId>org.tyrannyofheaven.bukkit</groupId>
+            <artifactId>zPermissions</artifactId>
+            <version>1.3</version>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>ru.tehkode</groupId>
+            <artifactId>PermissionsEx</artifactId>
+            <version>1.23</version>
+            <scope>provided</scope>
+            <exclusions>
+                <exclusion>
+                    <groupId>org.bukkit</groupId>
+                    <artifactId>bukkit</artifactId>
+                </exclusion>
+                <exclusion>
+                    <groupId>net.gravitydevelopment.updater</groupId>
+                    <artifactId>updater</artifactId>
+                </exclusion>
+            </exclusions>
+        </dependency>
+        <dependency>
+            <groupId>com.github.cheesesoftware</groupId>
+            <artifactId>PowerfulPermsAPI</artifactId>
+            <version>1.0.1</version>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.anjocaido</groupId>
+            <artifactId>GroupManager</artifactId>
+            <version>1.4</version>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>de.bananaco</groupId>
+            <artifactId>bpermissions-api</artifactId>
+            <version>2.12</version>
+            <scope>provided</scope>
+        </dependency>
    </dependencies>
-</project>
+</project>
@@ -1,72 +0,0 @@
-package me.lucko.luckperms;
-
-import me.lucko.luckperms.utils.LPConfiguration;
-import org.bukkit.configuration.InvalidConfigurationException;
-import org.bukkit.configuration.file.YamlConfiguration;
-
-import java.io.File;
-import java.io.IOException;
-
-public class BukkitConfig implements LPConfiguration {
-    private final LPBukkitPlugin plugin;
-    private YamlConfiguration configuration;
-
-    public BukkitConfig(LPBukkitPlugin plugin) {
-        this.plugin = plugin;
-        create();
-    }
-
-    @SuppressWarnings("ResultOfMethodCallIgnored")
-    private void create() {
-        File configFile = new File(plugin.getDataFolder(), "config.yml");
-
-        if (!configFile.exists()) {
-            configFile.getParentFile().mkdirs();
-            plugin.saveResource("config.yml", false);
-        }
-
-        configuration = new YamlConfiguration();
-
-        try {
-            configuration.load(configFile);
-
-        } catch (InvalidConfigurationException | IOException e) {
-            e.printStackTrace();
-        }
-    }
-
-    @Override
-    public String getServer() {
-        return configuration.getString("server", "global");
-    }
-
-    @Override
-    public int getSyncTime() {
-        return configuration.getInt("sql.sync-minutes", 3);
-    }
-
-    @Override
-    public String getDefaultGroupNode() {
-        return "group." + configuration.getString("default-group", "default");
-    }
-
-    @Override
-    public String getDefaultGroupName() {
-        return configuration.getString("default-group", "default");
-    }
-
-    @Override
-    public boolean getIncludeGlobalPerms() {
-        return configuration.getBoolean("include-global", true);
-    }
-
-    @Override
-    public String getDatabaseValue(String value) {
-        return configuration.getString("sql." + value);
-    }
-
-    @Override
-    public String getStorageMethod() {
-        return configuration.getString("storage-method", "sqlite");
-    }
-}
@@ -1,49 +0,0 @@
-package me.lucko.luckperms;
-
-import me.lucko.luckperms.commands.CommandManager;
-import me.lucko.luckperms.commands.Sender;
-import org.bukkit.command.Command;
-import org.bukkit.command.CommandExecutor;
-import org.bukkit.command.CommandSender;
-import org.bukkit.command.TabExecutor;
-
-import java.lang.ref.WeakReference;
-import java.util.Arrays;
-import java.util.List;
-
-class CommandManagerBukkit extends CommandManager implements CommandExecutor, TabExecutor {
-    CommandManagerBukkit(LuckPermsPlugin plugin) {
-        super(plugin);
-    }
-
-    @Override
-    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
-        return onCommand(makeSender(sender), label, Arrays.asList(args));
-    }
-
-
-    @Override
-    public List<String> onTabComplete(CommandSender sender, Command command, String label, String[] args) {
-        return onTabComplete(makeSender(sender), Arrays.asList(args));
-    }
-
-    private static Sender makeSender(CommandSender sender) {
-        return new Sender() {
-            final WeakReference<CommandSender> cs = new WeakReference<>(sender);
-
-            @Override
-            public void sendMessage(String s) {
-                final CommandSender c = cs.get();
-                if (c != null) {
-                    c.sendMessage(s);
-                }
-            }
-
-            @Override
-            public boolean hasPermission(String node) {
-                final CommandSender c = cs.get();
-                return c != null && c.hasPermission(node);
-            }
-        };
-    }
-}
@@ -1,139 +0,0 @@
-package me.lucko.luckperms;
-
-import lombok.Getter;
-import me.lucko.luckperms.data.Datastore;
-import me.lucko.luckperms.data.MySQLConfiguration;
-import me.lucko.luckperms.data.methods.FlatfileDatastore;
-import me.lucko.luckperms.data.methods.MySQLDatastore;
-import me.lucko.luckperms.data.methods.SQLiteDatastore;
-import me.lucko.luckperms.groups.GroupManager;
-import me.lucko.luckperms.listeners.PlayerListener;
-import me.lucko.luckperms.runnables.UpdateTask;
-import me.lucko.luckperms.tracks.TrackManager;
-import me.lucko.luckperms.users.BukkitUserManager;
-import me.lucko.luckperms.users.UserManager;
-import me.lucko.luckperms.utils.LPConfiguration;
-import me.lucko.luckperms.vaulthooks.VaultHook;
-import org.bukkit.Bukkit;
-import org.bukkit.command.PluginCommand;
-import org.bukkit.entity.Player;
-import org.bukkit.plugin.PluginManager;
-import org.bukkit.plugin.java.JavaPlugin;
-
-import java.io.File;
-import java.util.Arrays;
-import java.util.List;
-import java.util.UUID;
-import java.util.stream.Collectors;
-
-@Getter
-public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {
-    public static final String VERSION = "v1.2";
-
-    private LPConfiguration configuration;
-    private UserManager userManager;
-    private GroupManager groupManager;
-    private TrackManager trackManager;
-    private Datastore datastore;
-
-    @Override
-    public void onEnable() {
-        configuration = new BukkitConfig(this);
-
-        // register events
-        PluginManager pm = Bukkit.getPluginManager();
-        pm.registerEvents(new PlayerListener(this), this);
-
-        // register commands
-        CommandManagerBukkit commandManager = new CommandManagerBukkit(this);
-        PluginCommand main = getServer().getPluginCommand("luckperms");
-        main.setExecutor(commandManager);
-        main.setTabCompleter(commandManager);
-        main.setAliases(Arrays.asList("perms", "lp", "permissions", "p", "perm"));
-
-        final String storageMethod = configuration.getStorageMethod();
-
-        if (storageMethod.equalsIgnoreCase("mysql")) {
-            getLogger().info("Using MySQL as storage method.");
-            datastore = new MySQLDatastore(this, new MySQLConfiguration(
-                    configuration.getDatabaseValue("address"),
-                    configuration.getDatabaseValue("database"),
-                    configuration.getDatabaseValue("username"),
-                    configuration.getDatabaseValue("password")
-            ));
-        } else if (storageMethod.equalsIgnoreCase("sqlite")) {
-            getLogger().info("Using SQLite as storage method.");
-            datastore = new SQLiteDatastore(this, new File(getDataFolder(), "luckperms.sqlite"));
-        } else if (storageMethod.equalsIgnoreCase("flatfile")) {
-            getLogger().info("Using Flatfile (JSON) as storage method.");
-            datastore = new FlatfileDatastore(this, getDataFolder());
-        } else {
-            getLogger().warning("Storage method '" + storageMethod + "' was not recognised. Using SQLite as fallback.");
-            datastore = new SQLiteDatastore(this, new File(getDataFolder(), "luckperms.sqlite"));
-        }
-
-        datastore.init();
-
-        userManager = new BukkitUserManager(this);
-        groupManager = new GroupManager(this);
-        trackManager = new TrackManager(this);
-
-        // Run update task to refresh any online users
-        runUpdateTask();
-
-        int mins = getConfiguration().getSyncTime();
-        if (mins > 0) {
-            long ticks = mins * 60 * 20;
-            getServer().getScheduler().runTaskTimerAsynchronously(this, new UpdateTask(this), ticks, ticks);
-        }
-
-        // Provide vault support
-        if (getServer().getPluginManager().isPluginEnabled("Vault")) {
-            VaultHook.hook(this);
-            getLogger().info("Registered Vault permission & chat hook.");
-        } else {
-            getLogger().info("Vault not found.");
-        }
-
-    }
-
-    @Override
-    public void onDisable() {
-        datastore.shutdown();
-    }
-
-    @Override
-    public void doAsync(Runnable r) {
-        Bukkit.getScheduler().runTaskAsynchronously(this, r);
-    }
-
-    @Override
-    public void doSync(Runnable r) {
-        Bukkit.getScheduler().runTask(this, r);
-    }
-
-    @Override
-    public String getVersion() {
-        return VERSION;
-    }
-
-    @Override
-    public String getPlayerStatus(UUID uuid) {
-        return getServer().getPlayer(uuid) != null ? "&aOnline" : "&cOffline";
-    }
-
-    @Override
-    public int getPlayerCount() {
-        return getServer().getOnlinePlayers().size();
-    }
-
-    @Override
-    public List<String> getPlayerList() {
-        return getServer().getOnlinePlayers().stream().map(Player::getName).collect(Collectors.toList());
-    }
-
-    @Override
-    public void runUpdateTask() {
-        getServer().getScheduler().runTaskAsynchronously(this, new UpdateTask(this));
-    }
-}
@@ -0,0 +1,71 @@
+/*
+ * 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.bukkit;
+
+import lombok.AllArgsConstructor;
+
+import com.google.common.collect.ImmutableList;
+
+import me.lucko.luckperms.api.Contexts;
+import me.lucko.luckperms.bukkit.calculators.AttachmentProcessor;
+import me.lucko.luckperms.bukkit.calculators.ChildProcessor;
+import me.lucko.luckperms.bukkit.calculators.DefaultsProcessor;
+import me.lucko.luckperms.bukkit.model.Injector;
+import me.lucko.luckperms.bukkit.model.LPPermissible;
+import me.lucko.luckperms.common.calculators.AbstractCalculatorFactory;
+import me.lucko.luckperms.common.calculators.PermissionCalculator;
+import me.lucko.luckperms.common.calculators.PermissionProcessor;
+import me.lucko.luckperms.common.calculators.processors.MapProcessor;
+import me.lucko.luckperms.common.calculators.processors.RegexProcessor;
+import me.lucko.luckperms.common.calculators.processors.WildcardProcessor;
+import me.lucko.luckperms.common.config.ConfigKeys;
+import me.lucko.luckperms.common.core.model.User;
+
+import java.util.UUID;
+
+@AllArgsConstructor
+public class BukkitCalculatorFactory extends AbstractCalculatorFactory {
+    private final LPBukkitPlugin plugin;
+
+    @Override
+    public PermissionCalculator build(Contexts contexts, User user) {
+        UUID uuid = plugin.getUuidCache().getExternalUUID(user.getUuid());
+
+        ImmutableList.Builder<PermissionProcessor> processors = ImmutableList.builder();
+        processors.add(new MapProcessor());
+        processors.add(new ChildProcessor(plugin.getChildPermissionProvider()));
+        processors.add(new AttachmentProcessor(() -> {
+            LPPermissible permissible = Injector.getPermissible(uuid);
+            return permissible == null ? null : permissible.getAttachmentPermissions();
+        }));
+        if (plugin.getConfiguration().get(ConfigKeys.APPLYING_REGEX)) {
+            processors.add(new RegexProcessor());
+        }
+        if (plugin.getConfiguration().get(ConfigKeys.APPLYING_WILDCARDS)) {
+            processors.add(new WildcardProcessor());
+        }
+        processors.add(new DefaultsProcessor(contexts.isOp(), plugin.getDefaultsProvider()));
+
+        return registerCalculator(new PermissionCalculator(plugin, user.getName(), processors.build()));
+    }
+}
@@ -0,0 +1,62 @@
+/*
+ * 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.bukkit;
+
+import com.google.common.base.Joiner;
+import com.google.common.base.Splitter;
+
+import me.lucko.luckperms.common.commands.CommandManager;
+import me.lucko.luckperms.common.commands.utils.Util;
+import me.lucko.luckperms.common.constants.Patterns;
+
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabExecutor;
+
+import java.util.Arrays;
+import java.util.List;
+
+public class BukkitCommand extends CommandManager implements CommandExecutor, TabExecutor {
+    private final LPBukkitPlugin plugin;
+
+    BukkitCommand(LPBukkitPlugin plugin) {
+        super(plugin);
+        this.plugin = plugin;
+    }
+
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        onCommand(
+                plugin.getSenderFactory().wrap(sender),
+                label,
+                Util.stripQuotes(Splitter.on(Patterns.COMMAND_SEPARATOR).omitEmptyStrings().splitToList(Joiner.on(' ').join(args)))
+        );
+        return true;
+    }
+
+    @Override
+    public List<String> onTabComplete(CommandSender sender, Command command, String label, String[] args) {
+        return onTabComplete(plugin.getSenderFactory().wrap(sender), Arrays.asList(args));
+    }
+}
@@ -0,0 +1,104 @@
+/*
+ * 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.bukkit;
+
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+
+import me.lucko.luckperms.common.config.AbstractConfiguration;
+
+import org.bukkit.configuration.ConfigurationSection;
+import org.bukkit.configuration.file.YamlConfiguration;
+
+import java.io.File;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+@RequiredArgsConstructor
+public class BukkitConfig extends AbstractConfiguration {
+
+    @Getter
+    private final LPBukkitPlugin plugin;
+
+    private YamlConfiguration configuration;
+
+    @Override
+    public void init() {
+        File configFile = new File(plugin.getDataFolder(), "config.yml");
+
+        if (!configFile.exists()) {
+            configFile.getParentFile().mkdirs();
+            plugin.saveResource("config.yml", false);
+        }
+
+        configuration = YamlConfiguration.loadConfiguration(configFile);
+    }
+
+    @Override
+    public String getString(String path, String def) {
+        return configuration.getString(path, def);
+    }
+
+    @Override
+    public int getInt(String path, int def) {
+        return configuration.getInt(path, def);
+    }
+
+    @Override
+    public boolean getBoolean(String path, boolean def) {
+        return configuration.getBoolean(path, def);
+    }
+
+    @Override
+    public List<String> getList(String path, List<String> def) {
+        return Optional.ofNullable(configuration.getStringList(path)).orElse(def);
+    }
+
+    @Override
+    public List<String> getObjectList(String path, List<String> def) {
+        ConfigurationSection section = configuration.getConfigurationSection(path);
+        if (section == null) {
+            return def;
+        }
+
+        return Optional.ofNullable(section.getKeys(false).stream().collect(Collectors.toList())).orElse(def);
+    }
+
+    @Override
+    public Map<String, String> getMap(String path, Map<String, String> def) {
+        Map<String, String> map = new HashMap<>();
+        ConfigurationSection section = configuration.getConfigurationSection(path);
+        if (section == null) {
+            return def;
+        }
+
+        for (String key : section.getKeys(false)) {
+            map.put(key, section.getString(key));
+        }
+
+        return map;
+    }
+}
@@ -0,0 +1,190 @@
+/*
+ * 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.bukkit;
+
+import me.lucko.luckperms.bukkit.model.Injector;
+import me.lucko.luckperms.bukkit.model.LPPermissible;
+import me.lucko.luckperms.common.config.ConfigKeys;
+import me.lucko.luckperms.common.constants.Message;
+import me.lucko.luckperms.common.core.model.User;
+import me.lucko.luckperms.common.utils.AbstractListener;
+
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.AsyncPlayerPreLoginEvent;
+import org.bukkit.event.player.PlayerChangedWorldEvent;
+import org.bukkit.event.player.PlayerCommandPreprocessEvent;
+import org.bukkit.event.player.PlayerLoginEvent;
+import org.bukkit.event.player.PlayerQuitEvent;
+import org.bukkit.event.server.PluginEnableEvent;
+
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.UUID;
+
+class BukkitListener extends AbstractListener implements Listener {
+    private final LPBukkitPlugin plugin;
+    private final Set<UUID> deniedAsyncLogin = Collections.synchronizedSet(new HashSet<>());
+    private final Set<UUID> deniedLogin = new HashSet<>();
+
+    BukkitListener(LPBukkitPlugin plugin) {
+        super(plugin);
+        this.plugin = plugin;
+    }
+
+    @EventHandler(priority = EventPriority.LOW)
+    public void onPlayerPreLogin(AsyncPlayerPreLoginEvent e) {
+        if (e.getLoginResult() != AsyncPlayerPreLoginEvent.Result.ALLOWED) {
+            deniedAsyncLogin.add(e.getUniqueId());
+            return;
+        }
+
+        if (!plugin.isStarted() || !plugin.getStorage().isAcceptingLogins()) {
+            deniedAsyncLogin.add(e.getUniqueId());
+
+            // The datastore is disabled, prevent players from joining the server
+            e.disallow(AsyncPlayerPreLoginEvent.Result.KICK_OTHER, Message.LOADING_ERROR.toString());
+            return;
+        }
+
+        // Process login
+        onAsyncLogin(e.getUniqueId(), e.getName());
+    }
+
+    @EventHandler(priority = EventPriority.MONITOR)
+    public void onPlayerPreLoginMonitor(AsyncPlayerPreLoginEvent e) {
+        // If they were denied before/at LOW, then don't bother handling here.
+        if (deniedAsyncLogin.remove(e.getUniqueId())) {
+            return;
+        }
+
+        if (plugin.isStarted() && plugin.getStorage().isAcceptingLogins() && e.getLoginResult() != AsyncPlayerPreLoginEvent.Result.ALLOWED) {
+
+            // Login event was cancelled by another plugin
+            onLeave(e.getUniqueId());
+        }
+    }
+
+    @EventHandler(priority = EventPriority.LOW)
+    public void onPlayerLogin(PlayerLoginEvent e) {
+        if (e.getResult() != PlayerLoginEvent.Result.ALLOWED) {
+            deniedLogin.add(e.getPlayer().getUniqueId());
+            return;
+        }
+
+        final Player player = e.getPlayer();
+        final User user = plugin.getUserManager().get(plugin.getUuidCache().getUUID(player.getUniqueId()));
+
+        if (user == null) {
+            deniedLogin.add(e.getPlayer().getUniqueId());
+
+            // User wasn't loaded for whatever reason.
+            e.disallow(PlayerLoginEvent.Result.KICK_OTHER, Message.LOADING_ERROR.toString());
+            return;
+        }
+
+        try {
+            // Make a new permissible for the user
+            LPPermissible lpPermissible = new LPPermissible(player, user, plugin);
+
+            // Inject into the player
+            Injector.inject(player, lpPermissible);
+
+        } catch (Throwable t) {
+            t.printStackTrace();
+        }
+
+        plugin.refreshAutoOp(player);
+
+        if (player.isOp()) {
+
+            // We assume all users are not op, but those who are need extra calculation.
+            plugin.doAsync(() -> user.getUserData().preCalculate(plugin.getPreProcessContexts(true)));
+        }
+    }
+
+    @EventHandler(priority = EventPriority.MONITOR)
+    public void onPlayerLoginMonitor(PlayerLoginEvent e) {
+        if (e.getResult() != PlayerLoginEvent.Result.ALLOWED) {
+
+            // If they were denied before/at LOW, then don't bother handling here.
+            if (deniedLogin.remove(e.getPlayer().getUniqueId())) {
+                return;
+            }
+
+            // The player got denied on sync login.
+            plugin.getServer().getScheduler().runTaskLater(plugin, () -> onLeave(e.getPlayer().getUniqueId()), 20L);
+        } else {
+            plugin.refreshAutoOp(e.getPlayer());
+        }
+    }
+
+    @EventHandler(priority = EventPriority.MONITOR) // Allow other plugins to see data when this event gets called.
+    public void onPlayerQuit(PlayerQuitEvent e) {
+        final Player player = e.getPlayer();
+
+        // Remove the custom permissible
+        Injector.unInject(player, true, true);
+
+        // Handle auto op
+        if (plugin.getConfiguration().get(ConfigKeys.AUTO_OP)) {
+            player.setOp(false);
+        }
+
+        // Call internal leave handling
+        onLeave(player.getUniqueId());
+    }
+
+    @EventHandler
+    public void onPlayerCommand(PlayerCommandPreprocessEvent e) {
+        if (plugin.getConfiguration().get(ConfigKeys.OPS_ENABLED)) {
+            return;
+        }
+
+        String s = e.getMessage()
+                .replace("/", "")
+                .replace("bukkit:", "")
+                .replace("spigot:", "")
+                .replace("minecraft:", "");
+
+        if (s.equals("op") || s.startsWith("op ") || s.equals("deop") || s.startsWith("deop ")) {
+            e.setCancelled(true);
+            e.getPlayer().sendMessage(Message.OP_DISABLED.toString());
+        }
+    }
+
+    @EventHandler
+    public void onPluginEnable(PluginEnableEvent e) {
+        if (e.getPlugin().getName().equalsIgnoreCase("Vault")) {
+            plugin.tryVaultHook(true);
+        }
+    }
+
+    @EventHandler
+    public void onWorldChange(PlayerChangedWorldEvent e) {
+        plugin.refreshAutoOp(e.getPlayer());
+    }
+}
@@ -0,0 +1,75 @@
+/*
+ * 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.bukkit;
+
+import me.lucko.luckperms.bukkit.compat.MessageHandler;
+import me.lucko.luckperms.common.commands.sender.SenderFactory;
+import me.lucko.luckperms.common.constants.Constants;
+import me.lucko.luckperms.common.plugin.LuckPermsPlugin;
+
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import io.github.mkremins.fanciful.FancyMessage;
+
+import java.util.UUID;
+
+public class BukkitSenderFactory extends SenderFactory<CommandSender> {
+    private final MessageHandler messageHandler;
+
+    public BukkitSenderFactory(LuckPermsPlugin plugin) {
+        super(plugin);
+        messageHandler = new MessageHandler();
+    }
+
+    @Override
+    protected String getName(CommandSender sender) {
+        if (sender instanceof Player) {
+            return sender.getName();
+        }
+        return Constants.CONSOLE_NAME;
+    }
+
+    @Override
+    protected UUID getUuid(CommandSender sender) {
+        if (sender instanceof Player) {
+            return ((Player) sender).getUniqueId();
+        }
+        return Constants.CONSOLE_UUID;
+    }
+
+    @Override
+    protected void sendMessage(CommandSender sender, String s) {
+        sender.sendMessage(s);
+    }
+
+    @Override
+    protected void sendMessage(CommandSender sender, FancyMessage message) {
+        messageHandler.sendJsonMessage(sender, message);
+    }
+
+    @Override
+    protected boolean hasPermission(CommandSender sender, String node) {
+        return sender.hasPermission(node);
+    }
+}
@@ -0,0 +1,619 @@
+/*
+ * 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.bukkit;
+
+import lombok.Getter;
+
+import me.lucko.luckperms.api.Contexts;
+import me.lucko.luckperms.api.Logger;
+import me.lucko.luckperms.api.LuckPermsApi;
+import me.lucko.luckperms.api.PlatformType;
+import me.lucko.luckperms.api.context.ContextSet;
+import me.lucko.luckperms.api.context.MutableContextSet;
+import me.lucko.luckperms.bukkit.messaging.BungeeMessagingService;
+import me.lucko.luckperms.bukkit.messaging.LilyPadMessagingService;
+import me.lucko.luckperms.bukkit.model.ChildPermissionProvider;
+import me.lucko.luckperms.bukkit.model.DefaultsProvider;
+import me.lucko.luckperms.bukkit.model.Injector;
+import me.lucko.luckperms.bukkit.model.LPPermissible;
+import me.lucko.luckperms.bukkit.vault.VaultHook;
+import me.lucko.luckperms.common.api.ApiHandler;
+import me.lucko.luckperms.common.api.ApiProvider;
+import me.lucko.luckperms.common.caching.handlers.CachedStateManager;
+import me.lucko.luckperms.common.calculators.CalculatorFactory;
+import me.lucko.luckperms.common.commands.sender.Sender;
+import me.lucko.luckperms.common.config.ConfigKeys;
+import me.lucko.luckperms.common.config.LuckPermsConfiguration;
+import me.lucko.luckperms.common.constants.Permission;
+import me.lucko.luckperms.common.contexts.ContextManager;
+import me.lucko.luckperms.common.contexts.ServerCalculator;
+import me.lucko.luckperms.common.core.UuidCache;
+import me.lucko.luckperms.common.core.model.User;
+import me.lucko.luckperms.common.data.Importer;
+import me.lucko.luckperms.common.debug.DebugHandler;
+import me.lucko.luckperms.common.dependencies.DependencyManager;
+import me.lucko.luckperms.common.locale.LocaleManager;
+import me.lucko.luckperms.common.locale.NoopLocaleManager;
+import me.lucko.luckperms.common.locale.SimpleLocaleManager;
+import me.lucko.luckperms.common.managers.GroupManager;
+import me.lucko.luckperms.common.managers.TrackManager;
+import me.lucko.luckperms.common.managers.UserManager;
+import me.lucko.luckperms.common.managers.impl.GenericGroupManager;
+import me.lucko.luckperms.common.managers.impl.GenericTrackManager;
+import me.lucko.luckperms.common.managers.impl.GenericUserManager;
+import me.lucko.luckperms.common.messaging.InternalMessagingService;
+import me.lucko.luckperms.common.messaging.RedisMessaging;
+import me.lucko.luckperms.common.plugin.LuckPermsPlugin;
+import me.lucko.luckperms.common.storage.Storage;
+import me.lucko.luckperms.common.storage.StorageFactory;
+import me.lucko.luckperms.common.storage.StorageType;
+import me.lucko.luckperms.common.tasks.CacheHousekeepingTask;
+import me.lucko.luckperms.common.tasks.ExpireTemporaryTask;
+import me.lucko.luckperms.common.tasks.UpdateTask;
+import me.lucko.luckperms.common.treeview.PermissionVault;
+import me.lucko.luckperms.common.utils.BufferedRequest;
+import me.lucko.luckperms.common.utils.LoggerImpl;
+
+import org.bukkit.World;
+import org.bukkit.command.PluginCommand;
+import org.bukkit.entity.Player;
+import org.bukkit.event.HandlerList;
+import org.bukkit.permissions.PermissionDefault;
+import org.bukkit.plugin.PluginManager;
+import org.bukkit.plugin.ServicePriority;
+import org.bukkit.plugin.java.JavaPlugin;
+
+import java.io.File;
+import java.io.InputStream;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import java.util.UUID;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.stream.Collectors;
+
+@Getter
+public class LPBukkitPlugin extends JavaPlugin implements LuckPermsPlugin {
+    private Set<UUID> ignoringLogs;
+    private LPBukkitScheduler scheduler;
+    private BukkitCommand commandManager;
+    private VaultHook vaultHook = null;
+    private LuckPermsConfiguration configuration;
+    private UserManager userManager;
+    private GroupManager groupManager;
+    private TrackManager trackManager;
+    private Storage storage;
+    private InternalMessagingService messagingService = null;
+    private UuidCache uuidCache;
+    private BukkitListener listener;
+    private ApiProvider apiProvider;
+    private Logger log;
+    private Importer importer;
+    private DefaultsProvider defaultsProvider;
+    private ChildPermissionProvider childPermissionProvider;
+    private LocaleManager localeManager;
+    private CachedStateManager cachedStateManager;
+    private ContextManager<Player> contextManager;
+    private WorldCalculator worldCalculator;
+    private CalculatorFactory calculatorFactory;
+    private BufferedRequest<Void> updateTaskBuffer;
+    private boolean started = false;
+    private DebugHandler debugHandler;
+    private BukkitSenderFactory senderFactory;
+    private PermissionVault permissionVault;
+
+    @Override
+    public void onEnable() {
+        scheduler = new LPBukkitScheduler(this);
+
+        localeManager = new NoopLocaleManager();
+        senderFactory = new BukkitSenderFactory(this);
+        log = new LoggerImpl(getConsoleSender());
+        LuckPermsPlugin.sendStartupBanner(getConsoleSender(), this);
+
+        ignoringLogs = ConcurrentHashMap.newKeySet();
+        debugHandler = new DebugHandler(scheduler.getAsyncBukkitExecutor(), getVersion());
+        permissionVault = new PermissionVault(scheduler.getAsyncBukkitExecutor());
+
+        getLog().info("Loading configuration...");
+        configuration = new BukkitConfig(this);
+        configuration.init();
+        configuration.loadAll();
+
+        Set<StorageType> storageTypes = StorageFactory.getRequiredTypes(this, StorageType.H2);
+        DependencyManager.loadDependencies(this, storageTypes);
+
+        // setup the Bukkit defaults hook
+        defaultsProvider = new DefaultsProvider();
+        childPermissionProvider = new ChildPermissionProvider();
+
+        // give all plugins a chance to load their permissions, then refresh.
+        scheduler.doSyncLater(() -> {
+            defaultsProvider.refresh();
+            childPermissionProvider.setup();
+
+            Set<String> perms = new HashSet<>();
+            getServer().getPluginManager().getPermissions().forEach(p -> {
+                perms.add(p.getName());
+                perms.addAll(p.getChildren().keySet());
+            });
+
+            perms.forEach(p -> permissionVault.offer(p));
+        }, 1L);
+
+        // register events
+        PluginManager pm = getServer().getPluginManager();
+        listener = new BukkitListener(this);
+        pm.registerEvents(listener, this);
+
+        // initialise datastore
+        storage = StorageFactory.getInstance(this, StorageType.H2);
+
+        // initialise messaging
+        String messagingType = getConfiguration().get(ConfigKeys.MESSAGING_SERVICE).toLowerCase();
+        if (messagingType.equals("none") && getConfiguration().get(ConfigKeys.REDIS_ENABLED)) {
+            messagingType = "redis";
+        }
+        if (messagingType.equals("redis")) {
+            getLog().info("Loading redis...");
+            if (getConfiguration().get(ConfigKeys.REDIS_ENABLED)) {
+                RedisMessaging redis = new RedisMessaging(this);
+                try {
+                    redis.init(getConfiguration().get(ConfigKeys.REDIS_ADDRESS), getConfiguration().get(ConfigKeys.REDIS_PASSWORD));
+                    getLog().info("Loaded redis successfully...");
+
+                    messagingService = redis;
+                } catch (Exception e) {
+                    getLog().warn("Couldn't load redis...");
+                    e.printStackTrace();
+                }
+            } else {
+                getLog().warn("Messaging Service was set to redis, but redis is not enabled!");
+            }
+        } else if (messagingType.equals("bungee")) {
+            getLog().info("Loading bungee messaging service...");
+            BungeeMessagingService bungeeMessaging = new BungeeMessagingService(this);
+            bungeeMessaging.init();
+            messagingService = bungeeMessaging;
+        } else if (messagingType.equals("lilypad")) {
+            getLog().info("Loading LilyPad messaging service...");
+            if (getServer().getPluginManager().getPlugin("LilyPad-Connect") == null) {
+                getLog().warn("LilyPad-Connect plugin not present.");
+            } else {
+                LilyPadMessagingService lilyPadMessaging = new LilyPadMessagingService(this);
+                lilyPadMessaging.init();
+                messagingService = lilyPadMessaging;
+            }
+        } else if (!messagingType.equals("none")) {
+            getLog().warn("Messaging service '" + messagingType + "' not recognised.");
+        }
+
+        // setup the update task buffer
+        updateTaskBuffer = new BufferedRequest<Void>(1000L, this::doAsync) {
+            @Override
+            protected Void perform() {
+                new UpdateTask(LPBukkitPlugin.this).run();
+                return null;
+            }
+        };
+
+        // load locale
+        localeManager = new SimpleLocaleManager();
+        File locale = new File(getDataFolder(), "lang.yml");
+        if (locale.exists()) {
+            getLog().info("Found locale file. Attempting to load from it.");
+            try {
+                localeManager.loadFromFile(locale);
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+
+        // register commands
+        getLog().info("Registering commands...");
+        commandManager = new BukkitCommand(this);
+        PluginCommand main = getServer().getPluginCommand("luckperms");
+        main.setExecutor(commandManager);
+        main.setTabCompleter(commandManager);
+        main.setAliases(Arrays.asList("perms", "lp", "permissions", "perm"));
+
+        // load internal managers
+        getLog().info("Loading internal permission managers...");
+        uuidCache = new UuidCache(this);
+        userManager = new GenericUserManager(this);
+        groupManager = new GenericGroupManager(this);
+        trackManager = new GenericTrackManager(this);
+        importer = new Importer(commandManager);
+        calculatorFactory = new BukkitCalculatorFactory(this);
+        cachedStateManager = new CachedStateManager(this);
+
+        contextManager = new ContextManager<>();
+        worldCalculator = new WorldCalculator(this);
+        contextManager.registerCalculator(worldCalculator);
+        contextManager.registerCalculator(new ServerCalculator<>(getConfiguration()));
+
+        // Provide vault support
+        tryVaultHook(false);
+
+        // register with the LP API
+        getLog().info("Registering API...");
+        apiProvider = new ApiProvider(this);
+        ApiHandler.registerProvider(apiProvider);
+        getServer().getServicesManager().register(LuckPermsApi.class, apiProvider, this, ServicePriority.Normal);
+
+
+        // schedule update tasks
+        int mins = getConfiguration().get(ConfigKeys.SYNC_TIME);
+        if (mins > 0) {
+            long ticks = mins * 60 * 20;
+            scheduler.doAsyncRepeating(() -> updateTaskBuffer.request(), ticks);
+        }
+        scheduler.doAsyncLater(() -> updateTaskBuffer.request(), 40L);
+
+        // run an update instantly.
+        updateTaskBuffer.requestDirectly();
+
+        // register tasks
+        scheduler.doAsyncRepeating(new ExpireTemporaryTask(this), 60L);
+        scheduler.doAsyncRepeating(new CacheHousekeepingTask(this), 2400L);
+
+        // register permissions
+        registerPermissions(getConfiguration().get(ConfigKeys.COMMANDS_ALLOW_OP) ? PermissionDefault.OP : PermissionDefault.FALSE);
+        if (!getConfiguration().get(ConfigKeys.OPS_ENABLED)) {
+            scheduler.doSync(() -> getServer().getOperators().forEach(o -> o.setOp(false)));
+        }
+
+        // replace the temporary executor when the Bukkit one starts
+        getServer().getScheduler().runTaskAsynchronously(this, () -> {
+            scheduler.setUseBukkitAsync(true);
+        });
+
+        // Load any online users (in the case of a reload)
+        for (Player player : getServer().getOnlinePlayers()) {
+            scheduler.doAsync(() -> {
+                listener.onAsyncLogin(player.getUniqueId(), player.getName());
+                User user = getUserManager().get(getUuidCache().getUUID(player.getUniqueId()));
+                if (user != null) {
+                    scheduler.doSync(() -> {
+                        try {
+                            LPPermissible lpPermissible = new LPPermissible(player, user, this);
+                            Injector.inject(player, lpPermissible);
+                        } catch (Throwable t) {
+                            t.printStackTrace();
+                        }
+                    });
+                }
+            });
+        }
+
+        started = true;
+        getLog().info("Successfully loaded.");
+    }
+
+    @Override
+    public void onDisable() {
+        // Switch back to the LP executor, the bukkit one won't allow new tasks
+        scheduler.setUseBukkitAsync(false);
+
+        started = false;
+
+        defaultsProvider.close();
+        permissionVault.setShutdown(true);
+        debugHandler.setShutdown(true);
+
+        for (Player player : getServer().getOnlinePlayers()) {
+            Injector.unInject(player, false, false);
+            if (getConfiguration().get(ConfigKeys.AUTO_OP)) {
+                player.setOp(false);
+            }
+
+            final User user = getUserManager().get(getUuidCache().getUUID(player.getUniqueId()));
+            if (user != null) {
+                user.unregisterData();
+                getUserManager().unload(user);
+            }
+        }
+
+        getLog().info("Closing datastore...");
+        storage.shutdown();
+
+        if (messagingService != null) {
+            getLog().info("Closing messaging service...");
+            messagingService.close();
+        }
+
+        getLog().info("Unregistering API...");
+        ApiHandler.unregisterProvider();
+        getServer().getServicesManager().unregisterAll(this);
+
+        if (vaultHook != null) {
+            vaultHook.unhook(this);
+        }
+
+        scheduler.shutdown();
+
+        // Bukkit will do this again when #onDisable completes, but we do it early to prevent NPEs elsewhere.
+        getServer().getScheduler().cancelTasks(this);
+        HandlerList.unregisterAll(this);
+
+        // Null everything
+        ignoringLogs = null;
+        vaultHook = null;
+        configuration = null;
+        userManager = null;
+        groupManager = null;
+        trackManager = null;
+        storage = null;
+        messagingService = null;
+        uuidCache = null;
+        listener = null;
+        apiProvider = null;
+        log = null;
+        importer = null;
+        defaultsProvider = null;
+        childPermissionProvider = null;
+        localeManager = null;
+        cachedStateManager = null;
+        contextManager = null;
+        worldCalculator = null;
+        calculatorFactory = null;
+        updateTaskBuffer = null;
+        debugHandler = null;
+        senderFactory = null;
+        permissionVault = null;
+    }
+
+    public void tryVaultHook(boolean force) {
+        if (vaultHook != null) {
+            return;
+        }
+
+        getLog().info("Attempting to hook with Vault...");
+        try {
+            if (force || getServer().getPluginManager().isPluginEnabled("Vault")) {
+                vaultHook = new VaultHook();
+                vaultHook.hook(this);
+                getLog().info("Registered Vault permission & chat hook.");
+            } else {
+                getLog().info("Vault not found.");
+            }
+        } catch (Exception e) {
+            vaultHook = null;
+            getLog().severe("Error occurred whilst hooking into Vault.");
+            e.printStackTrace();
+        }
+    }
+
+    @Override
+    public void onUserRefresh(User user) {
+        LPPermissible lpp = Injector.getPermissible(uuidCache.getExternalUUID(user.getUuid()));
+        if (lpp != null) {
+            lpp.updateSubscriptions();
+        }
+    }
+
+    public void refreshAutoOp(Player player) {
+        if (getConfiguration().get(ConfigKeys.AUTO_OP)) {
+            try {
+                LPPermissible permissible = Injector.getPermissible(player.getUniqueId());
+                if (permissible == null) {
+                    return;
+                }
+
+                Map<String, Boolean> backing = permissible.getUser().getUserData().getPermissionData(permissible.calculateContexts()).getImmutableBacking();
+                boolean op = Optional.ofNullable(backing.get("luckperms.autoop")).orElse(false);
+                player.setOp(op);
+            } catch (Exception ignored) {}
+        }
+    }
+
+    @Override
+    public String getVersion() {
+        return getDescription().getVersion();
+    }
+
+    @Override
+    public PlatformType getServerType() {
+        return PlatformType.BUKKIT;
+    }
+
+    @Override
+    public String getServerName() {
+        return getServer().getName();
+    }
+
+    @Override
+    public String getServerVersion() {
+        return getServer().getVersion();
+    }
+
+    @Override
+    public File getDataDirectory() {
+        return super.getDataFolder();
+    }
+
+    @Override
+    public InputStream getResourceStream(String path) {
+        return getResource(path);
+    }
+
+    @Override
+    public Player getPlayer(User user) {
+        return getServer().getPlayer(uuidCache.getExternalUUID(user.getUuid()));
+    }
+
+    @Override
+    public Contexts getContextForUser(User user) {
+        Player player = getPlayer(user);
+        if (player == null) {
+            return null;
+        }
+        return new Contexts(
+                getContextManager().getApplicableContext(player),
+                getConfiguration().get(ConfigKeys.INCLUDING_GLOBAL_PERMS),
+                getConfiguration().get(ConfigKeys.INCLUDING_GLOBAL_WORLD_PERMS),
+                true,
+                getConfiguration().get(ConfigKeys.APPLYING_GLOBAL_GROUPS),
+                getConfiguration().get(ConfigKeys.APPLYING_GLOBAL_WORLD_GROUPS),
+                player.isOp()
+        );
+    }
+
+    @Override
+    public int getPlayerCount() {
+        return getServer().getOnlinePlayers().size();
+    }
+
+    @Override
+    public List<String> getPlayerList() {
+        return getServer().getOnlinePlayers().stream().map(Player::getName).collect(Collectors.toList());
+    }
+
+    @Override
+    public Set<UUID> getOnlinePlayers() {
+        return getServer().getOnlinePlayers().stream().map(Player::getUniqueId).collect(Collectors.toSet());
+    }
+
+    @Override
+    public boolean isPlayerOnline(UUID external) {
+        return getServer().getPlayer(external) != null;
+    }
+
+    @Override
+    public List<Sender> getOnlineSenders() {
+        return getServer().getOnlinePlayers().stream()
+                .map(p -> getSenderFactory().wrap(p))
+                .collect(Collectors.toList());
+    }
+
+    @Override
+    public Sender getConsoleSender() {
+        return getSenderFactory().wrap(getServer().getConsoleSender());
+    }
+
+    @Override
+    public Set<Contexts> getPreProcessContexts(boolean op) {
+        Set<ContextSet> c = new HashSet<>();
+        c.add(ContextSet.empty());
+        c.add(ContextSet.singleton("server", getConfiguration().get(ConfigKeys.SERVER)));
+
+        // Pre process all worlds
+        c.addAll(getServer().getWorlds().stream()
+                .map(World::getName)
+                .map(s -> {
+                    MutableContextSet set = MutableContextSet.create();
+                    set.add("server", getConfiguration().get(ConfigKeys.SERVER));
+                    set.add("world", s);
+                    return set.makeImmutable();
+                })
+                .collect(Collectors.toList())
+        );
+
+        // Pre process the separate Vault server, if any
+        if (!getConfiguration().get(ConfigKeys.SERVER).equals(getConfiguration().get(ConfigKeys.VAULT_SERVER))) {
+            c.add(ContextSet.singleton("server", getConfiguration().get(ConfigKeys.VAULT_SERVER)));
+            c.addAll(getServer().getWorlds().stream()
+                    .map(World::getName)
+                    .map(s -> {
+                        MutableContextSet set = MutableContextSet.create();
+                        set.add("server", getConfiguration().get(ConfigKeys.VAULT_SERVER));
+                        set.add("world", s);
+                        return set.makeImmutable();
+                    })
+                    .collect(Collectors.toList())
+            );
+        }
+
+        Set<Contexts> contexts = new HashSet<>();
+
+        // Convert to full Contexts
+        contexts.addAll(c.stream()
+                .map(set -> new Contexts(
+                        set,
+                        getConfiguration().get(ConfigKeys.INCLUDING_GLOBAL_PERMS),
+                        getConfiguration().get(ConfigKeys.INCLUDING_GLOBAL_WORLD_PERMS),
+                        true,
+                        getConfiguration().get(ConfigKeys.APPLYING_GLOBAL_GROUPS),
+                        getConfiguration().get(ConfigKeys.APPLYING_GLOBAL_WORLD_GROUPS),
+                        op
+                ))
+                .collect(Collectors.toSet())
+        );
+
+        // Check for and include varying Vault config options
+        boolean vaultDiff = getConfiguration().get(ConfigKeys.VAULT_INCLUDING_GLOBAL) != getConfiguration().get(ConfigKeys.INCLUDING_GLOBAL_PERMS) ||
+                !getConfiguration().get(ConfigKeys.INCLUDING_GLOBAL_WORLD_PERMS) ||
+                !getConfiguration().get(ConfigKeys.APPLYING_GLOBAL_GROUPS) ||
+                !getConfiguration().get(ConfigKeys.APPLYING_GLOBAL_WORLD_GROUPS);
+
+        if (vaultDiff) {
+            contexts.addAll(c.stream()
+                    .map(map -> new Contexts(map, getConfiguration().get(ConfigKeys.VAULT_INCLUDING_GLOBAL), true, true, true, true, op))
+                    .collect(Collectors.toSet())
+            );
+        }
+
+        return contexts;
+    }
+
+    @Override
+    public LinkedHashMap<String, Object> getExtraInfo() {
+        LinkedHashMap<String, Object> map = new LinkedHashMap<>();
+        map.put("Vault Enabled", vaultHook != null);
+        map.put("Vault Server", configuration.get(ConfigKeys.VAULT_SERVER));
+        map.put("Bukkit Defaults count", defaultsProvider.size());
+        map.put("Bukkit Child Permissions count", childPermissionProvider.getPermissions().size());
+        map.put("Vault Including Global", configuration.get(ConfigKeys.VAULT_INCLUDING_GLOBAL));
+        map.put("Vault Ignoring World", configuration.get(ConfigKeys.VAULT_IGNORE_WORLD));
+        map.put("Vault Primary Group Overrides", configuration.get(ConfigKeys.VAULT_PRIMARY_GROUP_OVERRIDES));
+        map.put("Vault Debug", configuration.get(ConfigKeys.VAULT_DEBUG));
+        map.put("OPs Enabled", configuration.get(ConfigKeys.OPS_ENABLED));
+        map.put("Auto OP", configuration.get(ConfigKeys.AUTO_OP));
+        map.put("Commands Allow OPs", configuration.get(ConfigKeys.COMMANDS_ALLOW_OP));
+        return map;
+    }
+
+    @SuppressWarnings("deprecation")
+    @Override
+    public UUID getUuidFromUsername(String playerName) {
+        try {
+            return getServer().getOfflinePlayer(playerName).getUniqueId();
+        } catch (Exception e) {
+            return null;
+        }
+    }
+
+    private void registerPermissions(PermissionDefault def) {
+        PluginManager pm = getServer().getPluginManager();
+
+        for (Permission p : Permission.values()) {
+            for (String node : p.getNodes()) {
+                pm.addPermission(new org.bukkit.permissions.Permission(node, def));
+            }
+        }
+    }
+}
@@ -0,0 +1,116 @@
+/*
+ * 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.bukkit;
+
+import lombok.Getter;
+import lombok.Setter;
+
+import me.lucko.luckperms.common.plugin.LuckPermsScheduler;
+
+import org.bukkit.scheduler.BukkitTask;
+
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.Executor;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+
+public class LPBukkitScheduler implements LuckPermsScheduler {
+    private final LPBukkitPlugin plugin;
+
+    @Getter
+    private ExecutorService asyncLpExecutor;
+    @Getter
+    private Executor asyncBukkitExecutor;
+    private Executor syncExecutor;
+
+    @Getter
+    @Setter
+    private boolean useBukkitAsync = false;
+
+    private Set<BukkitTask> tasks = ConcurrentHashMap.newKeySet();
+
+    public LPBukkitScheduler(LPBukkitPlugin plugin) {
+        this.plugin = plugin;
+
+        this.asyncLpExecutor = Executors.newCachedThreadPool();
+        this.asyncBukkitExecutor = r -> plugin.getServer().getScheduler().runTaskAsynchronously(plugin, r);
+        this.syncExecutor = r -> plugin.getServer().getScheduler().runTask(plugin, r);
+    }
+
+    @Override
+    public Executor getAsyncExecutor() {
+        return useBukkitAsync ? asyncBukkitExecutor : asyncLpExecutor;
+    }
+
+    @Override
+    public Executor getSyncExecutor() {
+        return syncExecutor;
+    }
+
+    @Override
+    public void doAsync(Runnable r) {
+        getAsyncExecutor().execute(r);
+    }
+
+    @Override
+    public void doSync(Runnable r) {
+        getSyncExecutor().execute(r);
+    }
+
+    @Override
+    public void doAsyncRepeating(Runnable r, long interval) {
+        BukkitTask task = plugin.getServer().getScheduler().runTaskTimerAsynchronously(plugin, r, interval, interval);
+        tasks.add(task);
+    }
+
+    @Override
+    public void doSyncRepeating(Runnable r, long interval) {
+        BukkitTask task = plugin.getServer().getScheduler().runTaskTimer(plugin, r, interval, interval);
+        tasks.add(task);
+    }
+
+    @Override
+    public void doAsyncLater(Runnable r, long delay) {
+        plugin.getServer().getScheduler().runTaskLaterAsynchronously(plugin, r, delay);
+    }
+
+    @Override
+    public void doSyncLater(Runnable r, long delay) {
+        plugin.getServer().getScheduler().runTaskLater(plugin, r, delay);
+    }
+
+    @Override
+    public void shutdown() {
+        tasks.forEach(BukkitTask::cancel);
+        // wait for executor
+        asyncLpExecutor.shutdown();
+        try {
+            asyncLpExecutor.awaitTermination(30, TimeUnit.SECONDS);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+
+    }
+}
@@ -0,0 +1,69 @@
+/*
+ * 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.bukkit;
+
+import lombok.RequiredArgsConstructor;
+
+import com.google.common.collect.Maps;
+
+import me.lucko.luckperms.api.context.ContextCalculator;
+import me.lucko.luckperms.api.context.MutableContextSet;
+import me.lucko.luckperms.common.config.ConfigKeys;
+import me.lucko.luckperms.common.plugin.LuckPermsPlugin;
+
+import org.bukkit.entity.Player;
+
+import java.util.Map;
+
+@RequiredArgsConstructor
+public class WorldCalculator implements ContextCalculator<Player> {
+    private static final String WORLD_KEY = "world";
+
+    private final LuckPermsPlugin plugin;
+
+    @Override
+    public MutableContextSet giveApplicableContext(Player subject, MutableContextSet accumulator) {
+        String world = getWorld(subject);
+
+        if (world != null) {
+            accumulator.add(Maps.immutableEntry(WORLD_KEY, world));
+        }
+
+        return accumulator;
+    }
+
+    @Override
+    public boolean isContextApplicable(Player subject, Map.Entry<String, String> context) {
+        if (!context.getKey().equals(WORLD_KEY)) {
+            return false;
+        }
+
+        String world = getWorld(subject);
+        return world != null && world.equals(context.getValue());
+    }
+
+    private String getWorld(Player player) {
+        String world = player.getWorld().getName();
+        return plugin.getConfiguration().get(ConfigKeys.WORLD_REWRITES).getOrDefault(world, world);
+    }
+}
@@ -0,0 +1,58 @@
+/*
+ * 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.bukkit.calculators;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+import me.lucko.luckperms.api.Tristate;
+import me.lucko.luckperms.common.calculators.PermissionProcessor;
+
+import org.bukkit.permissions.PermissionAttachmentInfo;
+
+import java.util.Map;
+import java.util.function.Supplier;
+
+@AllArgsConstructor
+public class AttachmentProcessor implements PermissionProcessor {
+
+    @Getter
+    private final Supplier<Map<String, PermissionAttachmentInfo>> map;
+
+    @Override
+    public Tristate hasPermission(String permission) {
+        Map<String, PermissionAttachmentInfo> m = map.get();
+        if (m == null) {
+            return Tristate.UNDEFINED;
+        }
+
+        PermissionAttachmentInfo pai = m.get(permission);
+        return pai == null ? Tristate.UNDEFINED : Tristate.fromBoolean(pai.getValue());
+    }
+
+    @Override
+    public void updateBacking(Map<String, Boolean> map) {
+        // Do nothing, this doesn't use the backing
+    }
+
+}
@@ -0,0 +1,55 @@
+/*
+ * 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.bukkit.calculators;
+
+import lombok.RequiredArgsConstructor;
+
+import me.lucko.luckperms.api.Tristate;
+import me.lucko.luckperms.bukkit.model.ChildPermissionProvider;
+import me.lucko.luckperms.common.calculators.PermissionProcessor;
+
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+@RequiredArgsConstructor
+public class ChildProcessor implements PermissionProcessor {
+    private final ChildPermissionProvider provider;
+    private Map<String, Boolean> childPermissions = new ConcurrentHashMap<>();
+
+    @Override
+    public Tristate hasPermission(String permission) {
+        Boolean b = childPermissions.get(permission);
+        return b == null ? Tristate.UNDEFINED : Tristate.fromBoolean(b);
+    }
+
+    @Override
+    public void updateBacking(Map<String, Boolean> map) {
+        childPermissions.clear();
+        for (Map.Entry<String, Boolean> e : map.entrySet()) {
+            Map<String, Boolean> children = provider.getPermissions().get(e);
+            if (children != null) {
+                childPermissions.putAll(children);
+            }
+        }
+    }
+}
@@ -0,0 +1,56 @@
+/*
+ * 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.bukkit.calculators;
+
+import lombok.AllArgsConstructor;
+
+import me.lucko.luckperms.api.Tristate;
+import me.lucko.luckperms.bukkit.model.DefaultsProvider;
+import me.lucko.luckperms.common.calculators.PermissionProcessor;
+
+import org.bukkit.Bukkit;
+import org.bukkit.permissions.Permission;
+
+import java.util.Map;
+
+@AllArgsConstructor
+public class DefaultsProcessor implements PermissionProcessor {
+    private final boolean isOp;
+    private final DefaultsProvider defaultsProvider;
+
+    @Override
+    public Tristate hasPermission(String permission) {
+        Tristate t = defaultsProvider.hasDefault(permission, isOp);
+        if (t != Tristate.UNDEFINED) {
+            return t;
+        }
+
+        Permission defPerm = Bukkit.getServer().getPluginManager().getPermission(permission);
+        return defPerm == null ? Tristate.UNDEFINED : Tristate.fromBoolean(defPerm.getDefault().getValue(isOp));
+    }
+
+    @Override
+    public void updateBacking(Map<String, Boolean> map) {
+        // Do nothing, this doesn't use the backing
+    }
+}
@@ -0,0 +1,122 @@
+/*
+ * 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.bukkit.compat;
+
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+
+public class BukkitJsonMessageHandler {
+    private static boolean setup = false;
+    private static boolean triedAndFailed = false;
+
+    private static Method GET_HANDLE_METHOD;
+    private static Field PLAYER_CONNECTION_FIELD;
+    private static Method SEND_PACKET_METHOD;
+    private static Constructor<?> PACKET_CHAT_CONSTRUCTOR;
+    private static Method SERIALIZE_METHOD;
+
+    private static void setup(Object player) throws Exception {
+        Class<?> craftPlayerClass = player.getClass();
+        GET_HANDLE_METHOD = craftPlayerClass.getDeclaredMethod("getHandle");
+
+        Object handleObject = GET_HANDLE_METHOD.invoke(player);
+        Class<?> handleClass = handleObject.getClass();
+
+        PLAYER_CONNECTION_FIELD = handleClass.getDeclaredField("playerConnection");
+
+        Object playerConnectionObject = PLAYER_CONNECTION_FIELD.get(handleObject);
+
+        Method[] playerConnectionMethods = playerConnectionObject.getClass().getDeclaredMethods();
+        for (Method m : playerConnectionMethods) {
+            if (m.getName().equals("sendPacket")) {
+                SEND_PACKET_METHOD = m;
+                break;
+            }
+        }
+
+        Class<?> packetChatClass = Class.forName(getVersionedClassName("PacketPlayOutChat"));
+        Constructor[] packetConstructors = packetChatClass.getDeclaredConstructors();
+        for (Constructor c : packetConstructors) {
+            Class<?>[] parameters = c.getParameterTypes();
+            if (parameters.length == 1 && parameters[0].getName().endsWith("IChatBaseComponent")) {
+                PACKET_CHAT_CONSTRUCTOR = c;
+                break;
+            }
+        }
+
+        Class<?> baseComponentClass = Class.forName(getVersionedClassName("IChatBaseComponent"));
+        Class<?> chatSerializerClass = baseComponentClass.getClasses()[0];
+
+        SERIALIZE_METHOD = chatSerializerClass.getDeclaredMethod("a", String.class);
+    }
+
+    private static String getVersionedClassName(String className) {
+        Class server = Bukkit.getServer().getClass();
+        if (!server.getSimpleName().equals("CraftServer")) {
+            throw new RuntimeException("Couldn't reflect into server " + server);
+        }
+
+        String version;
+        if (server.getName().equals("org.bukkit.craftbukkit.CraftServer")) {
+            // Non versioned class
+            version = ".";
+        } else {
+            version = server.getName().substring("org.bukkit.craftbukkit".length());
+            version = version.substring(0, version.length() - "CraftServer".length());
+        }
+
+        return "net.minecraft.server" + version + className;
+    }
+
+    private static synchronized boolean trySetup(Object player) {
+        if (setup) return true;
+        if (triedAndFailed) return false;
+
+        try {
+            setup(player);
+            setup = true;
+            return true;
+        } catch (Exception e) {
+            triedAndFailed = true;
+            return false;
+        }
+    }
+
+    public boolean sendJsonMessage(Player player, String json) {
+        if (!trySetup(player)) {
+            return false;
+        }
+
+        try {
+            Object connection = PLAYER_CONNECTION_FIELD.get(GET_HANDLE_METHOD.invoke(player));
+            SEND_PACKET_METHOD.invoke(connection, PACKET_CHAT_CONSTRUCTOR.newInstance(SERIALIZE_METHOD.invoke(null, json)));
+            return true;
+        } catch (Exception e) {
+            return false;
+        }
+    }
+}
@@ -0,0 +1,68 @@
+/*
+ * 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.bukkit.compat;
+
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import io.github.mkremins.fanciful.FancyMessage;
+
+public class MessageHandler {
+    private final BukkitJsonMessageHandler bukkitHandler;
+    private final SpigotJsonMessageHandler spigotHandler;
+
+    public MessageHandler() {
+        bukkitHandler = new BukkitJsonMessageHandler();
+        spigotHandler = isSpigot() ? new SpigotJsonMessageHandler() : null;
+    }
+
+    public void sendJsonMessage(CommandSender sender, FancyMessage message) {
+        if (sender instanceof Player) {
+            Player player = (Player) sender;
+            String json = message.toJSONString();
+
+            // Try Bukkit.
+            if (bukkitHandler.sendJsonMessage(player, json)) {
+                return;
+            }
+
+            // Try Spigot.
+            if (spigotHandler != null && spigotHandler.sendJsonMessage(player, json)) {
+                return;
+            }
+        }
+
+        // Fallback to Bukkit
+        sender.sendMessage(message.toOldMessageFormat());
+    }
+
+    private static boolean isSpigot() {
+        try {
+            Class.forName("net.md_5.bungee.chat.ComponentSerializer");
+            return true;
+        } catch (ClassNotFoundException e) {
+            return false;
+        }
+    }
+
+}
@@ -0,0 +1,40 @@
+/*
+ * 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.bukkit.compat;
+
+import net.md_5.bungee.chat.ComponentSerializer;
+
+import org.bukkit.entity.Player;
+
+public class SpigotJsonMessageHandler {
+
+    public boolean sendJsonMessage(Player player, String json) {
+        try {
+            player.spigot().sendMessage(ComponentSerializer.parse(json));
+            return true;
+        } catch (Exception e) {
+            return false;
+        }
+    }
+
+}
@@ -0,0 +1,95 @@
+/*
+ * 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.bukkit.messaging;
+
+import com.google.common.collect.Iterables;
+import com.google.common.io.ByteArrayDataInput;
+import com.google.common.io.ByteArrayDataOutput;
+import com.google.common.io.ByteStreams;
+
+import me.lucko.luckperms.bukkit.LPBukkitPlugin;
+import me.lucko.luckperms.common.messaging.AbstractMessagingService;
+
+import org.bukkit.entity.Player;
+import org.bukkit.plugin.messaging.PluginMessageListener;
+import org.bukkit.scheduler.BukkitRunnable;
+
+import java.util.Collection;
+
+/**
+ * An implementation of {@link me.lucko.luckperms.api.MessagingService} using the plugin messaging channels.
+ */
+public class BungeeMessagingService extends AbstractMessagingService implements PluginMessageListener {
+    private final LPBukkitPlugin plugin;
+
+    public BungeeMessagingService(LPBukkitPlugin plugin) {
+        super(plugin, "Bungee");
+        this.plugin = plugin;
+    }
+
+    public void init() {
+        plugin.getServer().getMessenger().registerOutgoingPluginChannel(plugin, CHANNEL);
+        plugin.getServer().getMessenger().registerIncomingPluginChannel(plugin, CHANNEL, this);
+    }
+
+    @Override
+    public void close() {
+        plugin.getServer().getMessenger().unregisterIncomingPluginChannel(plugin, CHANNEL);
+        plugin.getServer().getMessenger().unregisterOutgoingPluginChannel(plugin, CHANNEL);
+    }
+
+    @Override
+    protected void sendMessage(String channel, String message) {
+        new BukkitRunnable() {
+            @Override
+            public void run() {
+                Collection<? extends Player> players = plugin.getServer().getOnlinePlayers();
+                if (players.isEmpty()) {
+                    return;
+                }
+
+                Player p = Iterables.getFirst(players, null);
+
+                ByteArrayDataOutput out = ByteStreams.newDataOutput();
+                out.writeUTF(message);
+
+                byte[] data = out.toByteArray();
+
+                p.sendPluginMessage(plugin, channel, data);
+                cancel();
+            }
+        }.runTaskTimer(plugin, 1L, 100L);
+    }
+
+    @Override
+    public void onPluginMessageReceived(String s, Player player, byte[] bytes) {
+        if (!s.equals(CHANNEL)) {
+            return;
+        }
+
+        ByteArrayDataInput in = ByteStreams.newDataInput(bytes);
+        String msg = in.readUTF();
+
+        onMessage(s, msg, null);
+    }
+}
@@ -0,0 +1,90 @@
+/*
+ * 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.bukkit.messaging;
+
+import me.lucko.luckperms.bukkit.LPBukkitPlugin;
+import me.lucko.luckperms.common.messaging.AbstractMessagingService;
+
+import lilypad.client.connect.api.Connect;
+import lilypad.client.connect.api.event.EventListener;
+import lilypad.client.connect.api.event.MessageEvent;
+import lilypad.client.connect.api.request.RequestException;
+import lilypad.client.connect.api.request.impl.MessageRequest;
+
+import java.io.UnsupportedEncodingException;
+import java.util.Collections;
+
+/**
+ * An implementation of {@link me.lucko.luckperms.api.MessagingService} using LilyPad.
+ */
+public class LilyPadMessagingService extends AbstractMessagingService {
+    private final LPBukkitPlugin plugin;
+    private Connect connect;
+
+    public LilyPadMessagingService(LPBukkitPlugin plugin) {
+        super(plugin, "LilyPad");
+        this.plugin = plugin;
+    }
+
+    public void init() {
+        connect = plugin.getServer().getServicesManager().getRegistration(Connect.class).getProvider();
+        connect.registerEvents(this);
+    }
+
+    @Override
+    public void close() {
+        connect.unregisterEvents(this);
+    }
+
+    @Override
+    protected void sendMessage(String channel, String message) {
+        MessageRequest request;
+
+        try {
+            request = new MessageRequest(Collections.emptyList(), channel, message);
+        } catch (UnsupportedEncodingException e) {
+            e.printStackTrace();
+            return;
+        }
+
+        try {
+            connect.request(request);
+        } catch (RequestException e) {
+            e.printStackTrace();
+        }
+    }
+
+    @EventListener
+    public void onMessage(MessageEvent event) {
+        plugin.doAsync(() -> {
+            try {
+                String channel = event.getChannel();
+                String message = event.getMessageAsString();
+
+                onMessage(channel, message, null);
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        });
+    }
+}
@@ -0,0 +1,238 @@
+/*
+ * 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.bukkit.migration;
+
+import de.bananaco.bpermissions.api.Calculable;
+import de.bananaco.bpermissions.api.CalculableType;
+import de.bananaco.bpermissions.api.Group;
+import de.bananaco.bpermissions.api.Permission;
+import de.bananaco.bpermissions.api.World;
+import de.bananaco.bpermissions.api.WorldManager;
+
+import me.lucko.luckperms.api.MetaUtils;
+import me.lucko.luckperms.api.event.cause.CreationCause;
+import me.lucko.luckperms.common.commands.CommandException;
+import me.lucko.luckperms.common.commands.CommandResult;
+import me.lucko.luckperms.common.commands.SubCommand;
+import me.lucko.luckperms.common.commands.sender.Sender;
+import me.lucko.luckperms.common.core.model.PermissionHolder;
+import me.lucko.luckperms.common.core.model.User;
+import me.lucko.luckperms.common.plugin.LuckPermsPlugin;
+import me.lucko.luckperms.common.utils.Predicates;
+import me.lucko.luckperms.common.utils.ProgressLogger;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import static me.lucko.luckperms.common.constants.Permission.MIGRATION;
+
+public class MigrationBPermissions extends SubCommand<Object> {
+    private static Field uConfigField;
+    private static Method getConfigurationSectionMethod = null;
+    private static Method getKeysMethod = null;
+
+    static {
+        try {
+            uConfigField = Class.forName("de.bananaco.bpermissions.imp.YamlWorld").getDeclaredField("uconfig");
+            uConfigField.setAccessible(true);
+        } catch (Throwable t) {
+            t.printStackTrace();
+        }
+    }
+
+    public MigrationBPermissions() {
+        super("bpermissions", "Migration from bPermissions", MIGRATION, Predicates.alwaysFalse(), null);
+    }
+
+    @Override
+    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Object o, List<String> args, String label) throws CommandException {
+        ProgressLogger log = new ProgressLogger("bPermissions");
+        log.addListener(plugin.getConsoleSender());
+        log.addListener(sender);
+
+        log.log("Starting.");
+
+        WorldManager worldManager = WorldManager.getInstance();
+        if (worldManager == null) {
+            log.logErr("Plugin not loaded.");
+            return CommandResult.STATE_ERROR;
+        }
+
+        log.log("Forcing the plugin to load all data. This could take a while.");
+        for (World world : worldManager.getAllWorlds()) {
+            log.log("Loading users in world " + world.getName());
+            Set<String> users = getUsers(world);
+            if (users == null) {
+                log.logErr("Couldn't get a list of users.");
+                return CommandResult.FAILURE;
+            }
+            AtomicInteger userLoadCount = new AtomicInteger(0);
+            users.forEach(s -> {
+                world.loadOne(s, CalculableType.USER);
+                log.logProgress("Forcefully loaded {} users so far.", userLoadCount.incrementAndGet());
+            });
+        }
+        log.log("Forcefully loaded all users.");
+
+        // Migrate one world at a time.
+        log.log("Starting world migration.");
+        for (World world : worldManager.getAllWorlds()) {
+            log.log("Migrating world: " + world.getName());
+
+            // Migrate all groups
+            log.log("Starting group migration in world " + world.getName() + ".");
+            AtomicInteger groupCount = new AtomicInteger(0);
+            for (Calculable group : world.getAll(CalculableType.GROUP)) {
+                String groupName = group.getName().toLowerCase();
+                if (group.getName().equalsIgnoreCase(world.getDefaultGroup())) {
+                    groupName = "default";
+                }
+
+                // Make a LuckPerms group for the one being migrated.
+                plugin.getStorage().createAndLoadGroup(groupName, CreationCause.INTERNAL).join();
+                me.lucko.luckperms.common.core.model.Group lpGroup = plugin.getGroupManager().getIfLoaded(groupName);
+
+                migrateHolder(log, world, group, lpGroup);
+                plugin.getStorage().saveGroup(lpGroup);
+
+                log.logAllProgress("Migrated {} groups so far.", groupCount.incrementAndGet());
+            }
+            log.log("Migrated " + groupCount.get() + " groups in world " + world.getName() + ".");
+
+            // Migrate all users
+            log.log("Starting user migration in world " + world.getName() + ".");
+            AtomicInteger userCount = new AtomicInteger(0);
+            for (Calculable user : world.getAll(CalculableType.USER)) {
+                // There is no mention of UUIDs in the API. I assume that name = uuid. idk?
+                UUID uuid;
+                try {
+                    uuid = UUID.fromString(user.getName());
+                } catch (IllegalArgumentException e) {
+                    uuid = plugin.getUuidFromUsername(user.getName());
+                }
+
+                if (uuid == null) {
+                    log.logErr("Unable to migrate user " + user.getName() + ". Cannot to get UUID.");
+                    continue;
+                }
+
+                // Make a LuckPerms user for the one being migrated.
+                plugin.getStorage().loadUser(uuid, "null").join();
+                User lpUser = plugin.getUserManager().get(uuid);
+
+                migrateHolder(log, world, user, lpUser);
+
+                plugin.getStorage().saveUser(lpUser);
+                plugin.getUserManager().cleanup(lpUser);
+
+                log.logProgress("Migrated {} users so far.", userCount.incrementAndGet());
+            }
+
+            log.log("Migrated " + userCount.get() + " users in world " + world.getName() + ".");
+        }
+
+        log.log("Success! Migration complete.");
+        return CommandResult.SUCCESS;
+    }
+
+    @SuppressWarnings("unchecked")
+    private static Set<String> getUsers(World world) {
+        try {
+            Object yamlWorldUsers = uConfigField.get(world);
+            if (getConfigurationSectionMethod == null) {
+                getConfigurationSectionMethod = yamlWorldUsers.getClass().getMethod("getConfigurationSection", String.class);
+                getConfigurationSectionMethod.setAccessible(true);
+            }
+
+            Object configSection = getConfigurationSectionMethod.invoke(yamlWorldUsers, "users");
+            if (configSection == null) {
+                return Collections.emptySet();
+            }
+
+            if (getKeysMethod == null) {
+                getKeysMethod = configSection.getClass().getMethod("getKeys", boolean.class);
+                getKeysMethod.setAccessible(true);
+            }
+
+            return (Set<String>) getKeysMethod.invoke(configSection, false);
+        } catch (Throwable t) {
+            t.printStackTrace();
+            return null;
+        }
+    }
+
+    private static void migrateHolder(ProgressLogger log, World world, Calculable c, PermissionHolder holder) {
+        // Migrate the groups permissions in this world
+        for (Permission p : c.getPermissions()) {
+            try {
+                holder.setPermission(p.name(), p.isTrue(), "global", world.getName());
+            } catch (Exception ex) {
+                log.handleException(ex);
+            }
+
+            // Include any child permissions
+            for (Map.Entry<String, Boolean> child : p.getChildren().entrySet()) {
+                try {
+                    holder.setPermission(child.getKey(), child.getValue(), "global", world.getName());
+                } catch (Exception ex) {
+                    log.handleException(ex);
+                }
+            }
+        }
+
+        // Migrate any inherited groups
+        for (Group parent : c.getGroups()) {
+            try {
+                holder.setPermission("group." + parent.getName(), true, "global", world.getName());
+            } catch (Exception ex) {
+                log.handleException(ex);
+            }
+        }
+
+        // Migrate existing meta
+        for (Map.Entry<String, String> meta : c.getMeta().entrySet()) {
+            if (meta.getKey().equalsIgnoreCase("prefix") || meta.getKey().equalsIgnoreCase("suffix")) {
+                String chatMeta = MetaUtils.escapeCharacters(meta.getValue());
+                try {
+                    holder.setPermission(meta.getKey().toLowerCase() + "." + c.getPriority() + "." + chatMeta, true);
+                } catch (Exception ex) {
+                    log.handleException(ex);
+                }
+                continue;
+            }
+
+            try {
+                holder.setPermission("meta." + meta.getKey() + "." + meta.getValue(), true, "global", world.getName());
+            } catch (Exception ex) {
+                log.handleException(ex);
+            }
+        }
+    }
+
+}
@@ -0,0 +1,282 @@
+/*
+ * 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.bukkit.migration;
+
+import com.google.common.collect.Maps;
+
+import me.lucko.luckperms.api.event.cause.CreationCause;
+import me.lucko.luckperms.common.commands.Arg;
+import me.lucko.luckperms.common.commands.CommandException;
+import me.lucko.luckperms.common.commands.CommandResult;
+import me.lucko.luckperms.common.commands.SubCommand;
+import me.lucko.luckperms.common.commands.sender.Sender;
+import me.lucko.luckperms.common.constants.Permission;
+import me.lucko.luckperms.common.plugin.LuckPermsPlugin;
+import me.lucko.luckperms.common.utils.Predicates;
+import me.lucko.luckperms.common.utils.ProgressLogger;
+import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
+import me.lucko.luckperms.exceptions.ObjectLacksException;
+
+import org.anjocaido.groupmanager.GlobalGroups;
+import org.anjocaido.groupmanager.GroupManager;
+import org.anjocaido.groupmanager.data.Group;
+import org.anjocaido.groupmanager.data.User;
+import org.anjocaido.groupmanager.dataholder.WorldDataHolder;
+import org.anjocaido.groupmanager.dataholder.worlds.WorldsHolder;
+import org.bukkit.Bukkit;
+import org.bukkit.World;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+public class MigrationGroupManager extends SubCommand<Object> {
+    public MigrationGroupManager() {
+        super("groupmanager", "Migration from GroupManager", Permission.MIGRATION, Predicates.is(0),
+                Arg.list(Arg.create("migrate as global", true, "if world permissions should be ignored, and just migrated as global"))
+        );
+    }
+
+    @Override
+    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Object o, List<String> args, String label) throws CommandException {
+        ProgressLogger log = new ProgressLogger("GroupManager");
+        log.addListener(plugin.getConsoleSender());
+        log.addListener(sender);
+
+        log.log("Starting.");
+
+        if (!args.get(0).equalsIgnoreCase("true") && !args.get(0).equalsIgnoreCase("false")) {
+            log.logErr("Was expecting true/false, but got " + args.get(0) + " instead.");
+            return CommandResult.STATE_ERROR;
+        }
+        boolean migrateAsGlobal = Boolean.parseBoolean(args.get(0));
+        final Function<String, String> worldMappingFunc = s -> migrateAsGlobal ? "" : s;
+        
+        if (!Bukkit.getPluginManager().isPluginEnabled("GroupManager")) {
+            log.logErr("Plugin not loaded.");
+            return CommandResult.STATE_ERROR;
+        }
+
+        List<String> worlds = Bukkit.getWorlds().stream().map(World::getName).map(String::toLowerCase).collect(Collectors.toList());
+
+        GroupManager gm = (GroupManager) Bukkit.getPluginManager().getPlugin("GroupManager");
+
+        // Migrate Global Groups
+        log.log("Starting global group migration.");
+        GlobalGroups gg = GroupManager.getGlobalGroups();
+
+        AtomicInteger globalGroupCount = new AtomicInteger(0);
+        for (Group g : gg.getGroupList()) {
+            plugin.getStorage().createAndLoadGroup(g.getName().toLowerCase(), CreationCause.INTERNAL).join();
+            me.lucko.luckperms.common.core.model.Group group = plugin.getGroupManager().getIfLoaded(g.getName().toLowerCase());
+
+            for (String node : g.getPermissionList()) {
+                boolean value = true;
+                if (node.startsWith("!") || node.startsWith("-")) {
+                    node = node.substring(1);
+                    value = false;
+                } else if (node.startsWith("+")) {
+                    node = node.substring(1);
+                    value = true;
+                }
+
+                try {
+                    group.setPermission(node, value);
+                } catch (Exception ex) {
+                    log.handleException(ex);
+                }
+            }
+
+            for (String s : g.getInherits()) {
+                try {
+                    group.setPermission("group." + s.toLowerCase(), true);
+                } catch (Exception ex) {
+                    log.handleException(ex);
+                }
+            }
+
+            plugin.getStorage().saveGroup(group);
+            log.logAllProgress("Migrated {} groups so far.", globalGroupCount.incrementAndGet());
+        }
+        log.log("Migrated " + globalGroupCount.get() + " global groups");
+
+        // Collect data
+
+        // UUID --> Map<Entry<String, String>, Boolean> where k=world, v = node
+        Map<UUID, Map<Map.Entry<String, String>, Boolean>> users = new HashMap<>();
+        // UUID --> primary group name
+        Map<UUID, String> primaryGroups = new HashMap<>();
+
+        // String --> Map<Entry<String, String>, Boolean> where k=world, v = node
+        Map<String, Map<Map.Entry<String, String>, Boolean>> groups = new HashMap<>();
+
+        WorldsHolder wh = gm.getWorldsHolder();
+
+        // Collect data for all users and groups.
+        log.log("Collecting user and group data.");
+        for (String world : worlds) {
+            world = world.toLowerCase();
+            log.log("Querying world " + world);
+
+            WorldDataHolder wdh = wh.getWorldData(world);
+
+            AtomicInteger groupWorldCount = new AtomicInteger(0);
+            for (Group g : wdh.getGroupList()) {
+                groups.putIfAbsent(g.getName().toLowerCase(), new HashMap<>());
+
+                for (String node : g.getPermissionList()) {
+                    boolean value = true;
+                    if (node.startsWith("!") || node.startsWith("-")) {
+                        node = node.substring(1);
+                        value = false;
+                    } else if (node.startsWith("+")) {
+                        node = node.substring(1);
+                        value = true;
+                    }
+
+                    groups.get(g.getName().toLowerCase()).put(Maps.immutableEntry(worldMappingFunc.apply(world), node), value);
+                }
+
+                for (String s : g.getInherits()) {
+                    groups.get(g.getName().toLowerCase()).put(Maps.immutableEntry(worldMappingFunc.apply(world), "group." + s.toLowerCase()), true);
+                }
+                log.logAllProgress("Migrated {} groups so far in world " + world, groupWorldCount.incrementAndGet());
+            }
+            log.log("Migrated " + groupWorldCount.get() + " groups in world " + world);
+
+            AtomicInteger userWorldCount = new AtomicInteger(0);
+            for (User user : wdh.getUserList()) {
+                UUID uuid;
+                try {
+                    uuid = UUID.fromString(user.getUUID());
+                } catch (IllegalArgumentException e) {
+                    log.logErr("Could not parse UUID for user: " + user.getUUID());
+                    continue;
+                }
+
+                users.putIfAbsent(uuid, new HashMap<>());
+
+                for (String node : user.getPermissionList()) {
+                    boolean value = true;
+                    if (node.startsWith("!") || node.startsWith("-")) {
+                        node = node.substring(1);
+                        value = false;
+                    } else if (node.startsWith("+")) {
+                        node = node.substring(1);
+                        value = true;
+                    }
+
+                    users.get(uuid).put(Maps.immutableEntry(worldMappingFunc.apply(world), node), value);
+                }
+
+                String finalWorld = worldMappingFunc.apply(world);
+
+                // Collect sub groups
+                users.get(uuid).putAll(user.subGroupListStringCopy().stream()
+                        .map(n -> "group." + n)
+                        .map(n -> Maps.immutableEntry(finalWorld, n))
+                        .collect(Collectors.toMap(n -> n, n -> true))
+                );
+                primaryGroups.put(uuid, user.getGroupName());
+
+                log.logProgress("Migrated {} users so far in world " + world, userWorldCount.incrementAndGet());
+            }
+            log.log("Migrated " + userWorldCount.get() + " users in world " + world);
+
+        }
+
+        log.log("All data has now been processed, now starting the import process.");
+        log.log("Found a total of " + users.size() + " users and " + groups.size() + " groups.");
+
+        log.log("Starting group migration.");
+        AtomicInteger groupCount = new AtomicInteger(0);
+        for (Map.Entry<String, Map<Map.Entry<String, String>, Boolean>> e : groups.entrySet()) {
+            plugin.getStorage().createAndLoadGroup(e.getKey(), CreationCause.INTERNAL).join();
+            me.lucko.luckperms.common.core.model.Group group = plugin.getGroupManager().getIfLoaded(e.getKey());
+
+            for (Map.Entry<Map.Entry<String, String>, Boolean> n : e.getValue().entrySet()) {
+                // n.key.key = world
+                // n.key.value = node
+                // n.value = true/false
+                try {
+                    if (n.getKey().getKey().equals("")) {
+                        group.setPermission(n.getKey().getValue(), n.getValue());
+                    } else {
+                        group.setPermission(n.getKey().getValue(), n.getValue(), "global", n.getKey().getKey());
+                    }
+                } catch (Exception ex) {
+                    log.handleException(ex);
+                }
+            }
+
+            plugin.getStorage().saveGroup(group);
+            log.logAllProgress("Migrated {} groups so far.", groupCount.incrementAndGet());
+        }
+        log.log("Migrated " + groupCount.get() + " groups");
+
+        log.log("Starting user migration.");
+        AtomicInteger userCount = new AtomicInteger(0);
+        for (Map.Entry<UUID, Map<Map.Entry<String, String>, Boolean>> e : users.entrySet()) {
+            plugin.getStorage().loadUser(e.getKey(), "null").join();
+            me.lucko.luckperms.common.core.model.User user = plugin.getUserManager().get(e.getKey());
+
+            for (Map.Entry<Map.Entry<String, String>, Boolean> n : e.getValue().entrySet()) {
+                // n.key.key = world
+                // n.key.value = node
+                // n.value = true/false
+                try {
+                    if (n.getKey().getKey().equals("")) {
+                        user.setPermission(n.getKey().getValue(), n.getValue());
+                    } else {
+                        user.setPermission(n.getKey().getValue(), n.getValue(), "global", n.getKey().getKey());
+                    }
+                } catch (Exception ex) {
+                    log.handleException(ex);
+                }
+            }
+
+            String primaryGroup = primaryGroups.get(e.getKey());
+            if (primaryGroup != null) {
+                try {
+                    user.setPermission("group." + primaryGroup, true);
+                } catch (ObjectAlreadyHasException ignored) {}
+                user.setPrimaryGroup(primaryGroup);
+                try {
+                    user.unsetPermission("group.default");
+                } catch (ObjectLacksException ignored) {}
+            }
+
+            plugin.getStorage().saveUser(user);
+            plugin.getUserManager().cleanup(user);
+            log.logProgress("Migrated {} users so far.", userCount.incrementAndGet());
+        }
+
+        log.log("Migrated " + userCount.get() + " users.");
+        log.log("Success! Migration complete.");
+        return CommandResult.SUCCESS;
+    }
+}
@@ -0,0 +1,312 @@
+/*
+ * 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.bukkit.migration;
+
+import me.lucko.luckperms.api.MetaUtils;
+import me.lucko.luckperms.api.event.cause.CreationCause;
+import me.lucko.luckperms.common.commands.CommandException;
+import me.lucko.luckperms.common.commands.CommandResult;
+import me.lucko.luckperms.common.commands.SubCommand;
+import me.lucko.luckperms.common.commands.sender.Sender;
+import me.lucko.luckperms.common.constants.Permission;
+import me.lucko.luckperms.common.core.model.Group;
+import me.lucko.luckperms.common.core.model.User;
+import me.lucko.luckperms.common.plugin.LuckPermsPlugin;
+import me.lucko.luckperms.common.utils.Predicates;
+import me.lucko.luckperms.common.utils.ProgressLogger;
+import me.lucko.luckperms.exceptions.ObjectAlreadyHasException;
+import me.lucko.luckperms.exceptions.ObjectLacksException;
+
+import org.bukkit.Bukkit;
+import org.bukkit.World;
+
+import ru.tehkode.permissions.NativeInterface;
+import ru.tehkode.permissions.PermissionGroup;
+import ru.tehkode.permissions.PermissionManager;
+import ru.tehkode.permissions.PermissionUser;
+import ru.tehkode.permissions.bukkit.PermissionsEx;
+
+import java.lang.reflect.Field;
+import java.util.List;
+import java.util.UUID;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.stream.Collectors;
+
+public class MigrationPermissionsEx extends SubCommand<Object> {
+    public MigrationPermissionsEx() {
+        super("permissionsex", "Migration from PermissionsEx", Permission.MIGRATION, Predicates.alwaysFalse(), null);
+    }
+
+    @SuppressWarnings("deprecation")
+    @Override
+    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Object o, List<String> args, String label) throws CommandException {
+        ProgressLogger log = new ProgressLogger("PermissionsEx");
+        log.addListener(plugin.getConsoleSender());
+        log.addListener(sender);
+
+        log.log("Starting.");
+
+        if (!Bukkit.getPluginManager().isPluginEnabled("PermissionsEx")) {
+            log.logErr("Plugin not loaded.");
+            return CommandResult.STATE_ERROR;
+        }
+
+        List<String> worlds = Bukkit.getWorlds().stream().map(World::getName).map(String::toLowerCase).collect(Collectors.toList());
+
+        PermissionsEx pex = (PermissionsEx) Bukkit.getPluginManager().getPlugin("PermissionsEx");
+        PermissionManager manager = pex.getPermissionsManager();
+
+        NativeInterface ni;
+        try {
+            Field f = manager.getClass().getDeclaredField("nativeI");
+            f.setAccessible(true);
+            ni = (NativeInterface) f.get(manager);
+        } catch (Throwable t) {
+            t.printStackTrace();
+            return CommandResult.FAILURE;
+        }
+
+        log.log("Calculating group weightings.");
+        int maxWeight = 0;
+        for (PermissionGroup group : manager.getGroupList()) {
+            maxWeight = Math.max(maxWeight, group.getRank());
+        }
+        maxWeight += 5;
+
+        // Migrate all groups.
+        log.log("Starting group migration.");
+        AtomicInteger groupCount = new AtomicInteger(0);
+        for (PermissionGroup group : manager.getGroupList()) {
+            int groupWeight = maxWeight - group.getRank();
+
+            final String name = group.getName().toLowerCase();
+            plugin.getStorage().createAndLoadGroup(name, CreationCause.INTERNAL).join();
+            Group lpGroup = plugin.getGroupManager().getIfLoaded(name);
+
+            try {
+                for (String node : group.getOwnPermissions(null)) {
+                    boolean value = true;
+                    if (node.startsWith("-")) {
+                        node = node.substring(1);
+                        value = false;
+                    }
+
+                    try {
+                        lpGroup.setPermission(node, value);
+                    } catch (Exception ex) {
+                        log.handleException(ex);
+                    }
+                }
+            } catch (NullPointerException ignored) {
+                // No docs on if #getOwnPermissions(null) is ok. Should be fine though.
+            }
+
+            for (String world : worlds) {
+                for (String node : group.getOwnPermissions(world)) {
+                    boolean value = true;
+                    if (node.startsWith("-")) {
+                        node = node.substring(1);
+                        value = false;
+                    }
+
+                    try {
+                        lpGroup.setPermission(node, value, "global", world.toLowerCase());
+                    } catch (Exception ex) {
+                        log.handleException(ex);
+                    }
+                }
+            }
+
+            for (PermissionGroup g : group.getParents()) {
+                try {
+                    lpGroup.setPermission("group." + g.getName().toLowerCase(), true);
+                } catch (Exception ex) {
+                    log.handleException(ex);
+                }
+            }
+
+            for (String world : worlds) {
+                for (PermissionGroup g : group.getParents(world)) {
+                    try {
+                        lpGroup.setPermission("group." + g.getName().toLowerCase(), true, "global", world.toLowerCase());
+                    } catch (Exception ex) {
+                        log.handleException(ex);
+                    }
+                }
+            }
+
+            String prefix = group.getOwnPrefix();
+            String suffix = group.getOwnSuffix();
+
+            if (prefix != null && !prefix.equals("")) {
+                prefix = MetaUtils.escapeCharacters(prefix);
+                try {
+                    lpGroup.setPermission("prefix." + groupWeight + "." + prefix, true);
+                } catch (Exception ex) {
+                    log.handleException(ex);
+                }
+            }
+
+            if (suffix != null && !suffix.equals("")) {
+                suffix = MetaUtils.escapeCharacters(suffix);
+                try {
+                    lpGroup.setPermission("suffix." + groupWeight + "." + suffix, true);
+                } catch (Exception ex) {
+                    log.handleException(ex);
+                }
+            }
+
+            plugin.getStorage().saveGroup(lpGroup);
+            log.logAllProgress("Migrated {} groups so far.", groupCount.incrementAndGet());
+        }
+        log.log("Migrated " + groupCount.get() + " groups");
+
+        // Migrate all users
+        log.log("Starting user migration.");
+        AtomicInteger userCount = new AtomicInteger(0);
+
+        // Increment the max weight from the group migrations. All user meta should override.
+        maxWeight += 5;
+
+        for (PermissionUser user : manager.getUsers()) {
+            UUID u;
+            try {
+                u = UUID.fromString(user.getIdentifier());
+            } catch (IllegalArgumentException e) {
+                u = ni.nameToUUID(user.getIdentifier());
+                if (u == null) {
+                    u = plugin.getUuidFromUsername(user.getIdentifier());
+                }
+            }
+
+            if (u == null) {
+                log.logErr("Unable to get a UUID for user identifier: " + user.getIdentifier());
+                continue;
+            }
+
+            plugin.getStorage().loadUser(u, user.getName()).join();
+            User lpUser = plugin.getUserManager().get(u);
+
+            try {
+                for (String node : user.getOwnPermissions(null)) {
+                    boolean value = true;
+                    if (node.startsWith("-")) {
+                        node = node.substring(1);
+                        value = false;
+                    }
+
+                    try {
+                        lpUser.setPermission(node, value);
+                    } catch (Exception ex) {
+                        log.handleException(ex);
+                    }
+                }
+            } catch (NullPointerException ignored) {
+                // No docs on if #getOwnPermissions(null) is ok. Should be fine though.
+            }
+
+            for (String world : worlds) {
+                for (String node : user.getOwnPermissions(world)) {
+                    boolean value = true;
+                    if (node.startsWith("-")) {
+                        node = node.substring(1);
+                        value = false;
+                    }
+
+                    try {
+                        lpUser.setPermission(node, value, "global", world.toLowerCase());
+                    } catch (Exception ex) {
+                        log.handleException(ex);
+                    }
+                }
+            }
+
+            for (String s : user.getGroupNames()) {
+                try {
+                    lpUser.setPermission("group." + s.toLowerCase(), true);
+                } catch (Exception ex) {
+                    log.handleException(ex);
+                }
+            }
+
+            for (String world : worlds) {
+                for (String s : user.getGroupNames(world)) {
+                    try {
+                        lpUser.setPermission("group." + s.toLowerCase(), true, "global", world.toLowerCase());
+                    } catch (Exception ex) {
+                        log.handleException(ex);
+                    }
+                }
+            }
+
+            String prefix = user.getOwnPrefix();
+            String suffix = user.getOwnSuffix();
+
+            if (prefix != null && !prefix.equals("")) {
+                prefix = MetaUtils.escapeCharacters(prefix);
+                try {
+                    lpUser.setPermission("prefix." + maxWeight + "." + prefix, true);
+                } catch (Exception ex) {
+                    log.handleException(ex);
+                }
+            }
+
+            if (suffix != null && !suffix.equals("")) {
+                suffix = MetaUtils.escapeCharacters(suffix);
+                try {
+                    lpUser.setPermission("suffix." + maxWeight + "." + suffix, true);
+                } catch (Exception ex) {
+                    log.handleException(ex);
+                }
+            }
+
+            // Lowest rank is the highest group #logic
+            String primary = null;
+            int weight = Integer.MAX_VALUE;
+            for (PermissionGroup group : user.getOwnParents()) {
+                if (group.getRank() < weight) {
+                    primary = group.getName();
+                    weight = group.getRank();
+                }
+            }
+
+            if (primary != null && !primary.equalsIgnoreCase("default")) {
+                try {
+                    lpUser.setPermission("group." + primary.toLowerCase(), true);
+                } catch (ObjectAlreadyHasException ignored) {}
+                lpUser.setPrimaryGroup(primary);
+                try {
+                    lpUser.unsetPermission("group.default");
+                } catch (ObjectLacksException ignored) {}
+            }
+
+            plugin.getUserManager().cleanup(lpUser);
+            plugin.getStorage().saveUser(lpUser);
+            log.logProgress("Migrated {} users so far.", userCount.incrementAndGet());
+        }
+
+        log.log("Migrated " + userCount.get() + " users.");
+        log.log("Success! Migration complete.");
+        return CommandResult.SUCCESS;
+    }
+}
@@ -0,0 +1,535 @@
+/*
+ * 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.bukkit.migration;
+
+import com.github.cheesesoftware.PowerfulPermsAPI.CachedGroup;
+import com.github.cheesesoftware.PowerfulPermsAPI.Group;
+import com.github.cheesesoftware.PowerfulPermsAPI.Permission;
+import com.github.cheesesoftware.PowerfulPermsAPI.PermissionManager;
+import com.github.cheesesoftware.PowerfulPermsAPI.PowerfulPermsPlugin;
+import com.github.cheesesoftware.PowerfulPermsAPI.ResultRunnable;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.zaxxer.hikari.HikariDataSource;
+
+import me.lucko.luckperms.api.event.cause.CreationCause;
+import me.lucko.luckperms.bukkit.migration.utils.LPResultRunnable;
+import me.lucko.luckperms.common.commands.Arg;
+import me.lucko.luckperms.common.commands.CommandException;
+import me.lucko.luckperms.common.commands.CommandResult;
+import me.lucko.luckperms.common.commands.SubCommand;
+import me.lucko.luckperms.common.commands.sender.Sender;
+import me.lucko.luckperms.common.core.model.PermissionHolder;
+import me.lucko.luckperms.common.core.model.User;
+import me.lucko.luckperms.common.plugin.LuckPermsPlugin;
+import me.lucko.luckperms.common.utils.Predicates;
+import me.lucko.luckperms.common.utils.ProgressLogger;
+
+import org.bukkit.Bukkit;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.sql.Connection;
+import java.sql.DatabaseMetaData;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.function.Consumer;
+
+import static me.lucko.luckperms.common.constants.Permission.MIGRATION;
+
+
+public class MigrationPowerfulPerms extends SubCommand<Object> {
+    private static Method getPlayerPermissionsMethod = null;
+    private static Method getPlayerGroupsMethod = null;
+    private static Method getGroupMethod = null;
+
+    // lol, nice "api"
+    private static boolean superLegacy = false;
+    private static boolean legacy = false;
+
+    static {
+        try {
+            Class.forName("com.github.cheesesoftware.PowerfulPermsAPI.ResponseRunnable");
+            legacy = true;
+        } catch (ClassNotFoundException ignored) {}
+
+        if (legacy) {
+            try {
+                getPlayerPermissionsMethod = PermissionManager.class.getMethod("getPlayerOwnPermissions", UUID.class, ResultRunnable.class);
+                getPlayerPermissionsMethod.setAccessible(true);
+            } catch (NoSuchMethodException ignored) {}
+        } else {
+            try {
+                getPlayerPermissionsMethod = PermissionManager.class.getMethod("getPlayerOwnPermissions", UUID.class);
+                getPlayerPermissionsMethod.setAccessible(true);
+            } catch (NoSuchMethodException ignored) {}
+        }
+
+        try {
+            getGroupMethod = CachedGroup.class.getMethod("getGroup");
+            getGroupMethod.setAccessible(true);
+            superLegacy = true;
+        } catch (NoSuchMethodException ignored) {}
+
+        if (!legacy) {
+            try {
+                getPlayerGroupsMethod = PermissionManager.class.getMethod("getPlayerOwnGroups", UUID.class);
+                getPlayerGroupsMethod.setAccessible(true);
+            } catch (NoSuchMethodException e) {
+                e.printStackTrace();
+            }
+        } else {
+            try {
+                getPlayerGroupsMethod = PermissionManager.class.getMethod("getPlayerOwnGroups", UUID.class, ResultRunnable.class);
+                getPlayerGroupsMethod.setAccessible(true);
+            } catch (NoSuchMethodException e) {
+                try {
+                    getPlayerGroupsMethod = PermissionManager.class.getMethod("getPlayerGroups", UUID.class, ResultRunnable.class);
+                    getPlayerGroupsMethod.setAccessible(true);
+                } catch (NoSuchMethodException e1) {
+                    e1.printStackTrace();
+                }
+            }
+        }
+    }
+
+    public MigrationPowerfulPerms() {
+        super("powerfulperms", "Migration from PowerfulPerms", MIGRATION, Predicates.not(5),
+                Arg.list(
+                        Arg.create("address", true, "the address of the PP database"),
+                        Arg.create("database", true, "the name of the PP database"),
+                        Arg.create("username", true, "the username to log into the DB"),
+                        Arg.create("password", true, "the password to log into the DB"),
+                        Arg.create("db table", true, "the name of the PP table where player data is stored")
+                )
+        );
+    }
+
+    @Override
+    public CommandResult execute(LuckPermsPlugin plugin, Sender sender, Object o, List<String> args, String label) throws CommandException {
+        try {
+            return run(plugin, sender, args);
+        } catch (Throwable t) {
+            t.printStackTrace();
+            return CommandResult.FAILURE;
+        }
+    }
+
+    private CommandResult run(LuckPermsPlugin plugin, Sender sender, List<String> args) {
+        ProgressLogger log = new ProgressLogger("PowerfulPerms");
+        log.addListener(plugin.getConsoleSender());
+        log.addListener(sender);
+
+        log.log("Starting.");
+        
+        if (!Bukkit.getPluginManager().isPluginEnabled("PowerfulPerms")) {
+            log.logErr("PowerfulPerms is not loaded.");
+            return CommandResult.STATE_ERROR;
+        }
+
+        final String address = args.get(0);
+        final String database = args.get(1);
+        final String username = args.get(2);
+        final String password = args.get(3);
+        final String dbTable = args.get(4);
+
+        // Find a list of UUIDs
+        log.log("Getting a list of UUIDs to migrate.");
+        Set<UUID> uuids = new HashSet<>();
+
+        try (HikariDataSource hikari = new HikariDataSource()) {
+            hikari.setMaximumPoolSize(2);
+            hikari.setDataSourceClassName("com.mysql.jdbc.jdbc2.optional.MysqlDataSource");
+            hikari.addDataSourceProperty("serverName", address.split(":")[0]);
+            hikari.addDataSourceProperty("port", address.split(":")[1]);
+            hikari.addDataSourceProperty("databaseName", database);
+            hikari.addDataSourceProperty("user", username);
+            hikari.addDataSourceProperty("password", password);
+
+            try (Connection c = hikari.getConnection()) {
+                DatabaseMetaData meta = c.getMetaData();
+
+                try (ResultSet rs = meta.getTables(null, null, dbTable, null)) {
+                    if (!rs.next()) {
+                        log.log("Error - Couldn't find table.");
+                        return CommandResult.FAILURE;
+                    }
+                }
+            }
+
+            try (Connection c = hikari.getConnection()) {
+                try (PreparedStatement ps = c.prepareStatement("SELECT COLUMN_NAME, COLUMN_TYPE FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_NAME=?")) {
+                    ps.setString(1, dbTable);
+
+                    try (ResultSet rs = ps.executeQuery()) {
+                        log.log("Found table: " + dbTable);
+                        while (rs.next()) {
+                            log.log("" + rs.getString("COLUMN_NAME") + " - " + rs.getString("COLUMN_TYPE"));
+                        }
+                    }
+                }
+
+                try (PreparedStatement ps = c.prepareStatement("SELECT `uuid` FROM " + dbTable)) {
+                    try (ResultSet rs = ps.executeQuery()) {
+                        while (rs.next()) {
+                            uuids.add(UUID.fromString(rs.getString("uuid")));
+                        }
+                    }
+                }
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+
+        if (uuids.isEmpty()) {
+            log.logErr("Unable to find any UUIDs to migrate.");
+            return CommandResult.FAILURE;
+        }
+
+        log.log("Found " + uuids.size() + " uuids. Starting migration.");
+
+        PowerfulPermsPlugin ppPlugin = (PowerfulPermsPlugin) Bukkit.getPluginManager().getPlugin("PowerfulPerms");
+        PermissionManager pm = ppPlugin.getPermissionManager();
+
+        // Groups first.
+        log.log("Starting group migration.");
+        AtomicInteger groupCount = new AtomicInteger(0);
+        Map<Integer, Group> groups = pm.getGroups(); // All versions
+        for (Group g : groups.values()) {
+            plugin.getStorage().createAndLoadGroup(g.getName().toLowerCase(), CreationCause.INTERNAL).join();
+            final me.lucko.luckperms.common.core.model.Group group = plugin.getGroupManager().getIfLoaded(g.getName().toLowerCase());
+
+            for (Permission p : g.getOwnPermissions()) { // All versions
+                applyPerm(group, p, log);
+            }
+
+            for (Group parent : g.getParents()) { // All versions
+                try {
+                    group.setPermission("group." + parent.getName().toLowerCase(), true);
+                } catch (Exception ex) {
+                    log.handleException(ex);
+                }
+            }
+
+            plugin.getStorage().saveGroup(group);
+            log.logAllProgress("Migrated {} groups so far.", groupCount.incrementAndGet());
+        }
+        log.log("Migrated " + groupCount.get() + " groups");
+
+        // Now users.
+        log.log("Starting user migration.");
+        final Map<UUID, CountDownLatch> progress = new HashMap<>();
+
+        // Migrate all users and their groups
+        for (UUID uuid : uuids) {
+            progress.put(uuid, new CountDownLatch(2));
+
+            // Create a LuckPerms user for the UUID
+            plugin.getStorage().loadUser(uuid, "null").join();
+            User user = plugin.getUserManager().get(uuid);
+
+            // Get a list of Permissions held by the user from the PP API.
+            getPlayerPermissions(pm, uuid, perms -> { // Changes each version
+                perms.forEach(p -> applyPerm(user, p, log));
+
+                // Update the progress so the user can be saved and unloaded.
+                synchronized (progress) {
+                    progress.get(uuid).countDown();
+                    if (progress.get(uuid).getCount() == 0) {
+                        plugin.getStorage().saveUser(user);
+                        plugin.getUserManager().cleanup(user);
+                    }
+                }
+            });
+
+            // Migrate the user's groups to LuckPerms from PP.
+            Consumer<Map<String, List<CachedGroup>>> callback = groups1 -> {
+                for (Map.Entry<String, List<CachedGroup>> e : groups1.entrySet()) {
+                    final String server;
+                    if (e.getKey() != null && (e.getKey().equals("") || e.getKey().equalsIgnoreCase("all"))) {
+                        server = null;
+                    } else {
+                        server = e.getKey();
+                    }
+
+                    if (superLegacy) {
+                        e.getValue().stream()
+                                .filter(cg -> !cg.isNegated())
+                                .map(cg -> {
+                                    try {
+                                        return (Group) getGroupMethod.invoke(cg);
+                                    } catch (IllegalAccessException | InvocationTargetException e1) {
+                                        e1.printStackTrace();
+                                        return null;
+                                    }
+                                })
+                                .forEach(g -> {
+                                    if (g != null) {
+                                        if (server == null) {
+                                            try {
+                                                user.setPermission("group." + g.getName().toLowerCase(), true);
+                                            } catch (Exception ex) {
+                                                log.handleException(ex);
+                                            }
+                                        } else {
+                                            try {
+                                                user.setPermission("group." + g.getName().toLowerCase(), true, server);
+                                            } catch (Exception ex) {
+                                                log.handleException(ex);
+                                            }
+                                        }
+                                    }
+                                });
+                    } else {
+                        e.getValue().stream()
+                                .filter(g -> !g.hasExpired() && !g.isNegated())
+                                .forEach(g -> {
+                                    final Group group = pm.getGroup(g.getGroupId());
+                                    if (g.willExpire()) {
+                                        if (server == null) {
+                                            try {
+                                                user.setPermission("group." + group.getName().toLowerCase(), true, g.getExpirationDate().getTime() / 1000L);
+                                            } catch (Exception ex) {
+                                                log.handleException(ex);
+                                            }
+                                        } else {
+                                            try {
+                                                user.setPermission("group." + group.getName().toLowerCase(), true, server, g.getExpirationDate().getTime() / 1000L);
+                                            } catch (Exception ex) {
+                                                log.handleException(ex);
+                                            }
+                                        }
+
+                                    } else {
+                                        if (server == null) {
+                                            try {
+                                                user.setPermission("group." + group.getName().toLowerCase(), true);
+                                            } catch (Exception ex) {
+                                                log.handleException(ex);
+                                            }
+                                        } else {
+                                            try {
+                                                user.setPermission("group." + group.getName().toLowerCase(), true, server);
+                                            } catch (Exception ex) {
+                                                log.handleException(ex);
+                                            }
+                                        }
+                                    }
+                                });
+                    }
+                }
+
+                // Update the progress so the user can be saved and unloaded.
+                synchronized (progress) {
+                    progress.get(uuid).countDown();
+                    if (progress.get(uuid).getCount() == 0) {
+                        plugin.getStorage().saveUser(user);
+                        plugin.getUserManager().cleanup(user);
+                    }
+                }
+            };
+
+            if (!legacy) {
+                try {
+                    ListenableFuture<LinkedHashMap<String, List<CachedGroup>>> future = (ListenableFuture<LinkedHashMap<String, List<CachedGroup>>>) getPlayerGroupsMethod.invoke(pm, uuid);
+                    try {
+                        if (future.isDone()) {
+                            callback.accept(future.get());
+                        } else {
+                            future.addListener(() -> {
+                                try {
+                                    callback.accept(future.get());
+                                } catch (InterruptedException | ExecutionException e) {
+                                    e.printStackTrace();
+                                }
+                            }, Runnable::run);
+                        }
+                    } catch (InterruptedException | ExecutionException e) {
+                        e.printStackTrace();
+                    }
+                } catch (IllegalAccessException | InvocationTargetException e) {
+                    e.printStackTrace();
+                }
+            } else {
+                try {
+                    getPlayerGroupsMethod.invoke(pm, uuid, new LPResultRunnable<LinkedHashMap<String, List<CachedGroup>>>() {
+                        @Override
+                        public void run() {
+                            callback.accept(getResult());
+                        }
+                    });
+                } catch (IllegalAccessException | InvocationTargetException e) {
+                    e.printStackTrace();
+                }
+            }
+        }
+
+        // All groups are migrated, but there may still be some users being migrated.
+        // This block will wait for all users to be completed.
+        log.log("Waiting for user migration to complete. This may take some time");
+        boolean sleep = true;
+        while (sleep) {
+            sleep = false;
+
+            for (Map.Entry<UUID, CountDownLatch> e : progress.entrySet()) {
+                if (e.getValue().getCount() != 0) {
+                    sleep = true;
+                    break;
+                }
+            }
+
+            if (sleep) {
+                try {
+                    Thread.sleep(5000);
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+            }
+
+        }
+
+        // We done.
+        log.log("Success! Migration complete.");
+        return CommandResult.SUCCESS;
+    }
+
+    private void applyPerm(PermissionHolder holder, Permission p, ProgressLogger log) {
+        String node = p.getPermissionString();
+        boolean value = true;
+        if (node.startsWith("!")) {
+            node = node.substring(1);
+            value = false;
+        }
+
+        String server = p.getServer();
+        if (server != null && server.equalsIgnoreCase("all")) {
+            server = null;
+        }
+
+        String world = p.getWorld();
+        if (world != null && world.equalsIgnoreCase("all")) {
+            world = null;
+        }
+
+        long expireAt = 0L;
+        if (!superLegacy) {
+            if (p.willExpire()) {
+                expireAt = p.getExpirationDate().getTime() / 1000L;
+            }
+        }
+
+        if (world != null && server == null) {
+            server = "global";
+        }
+
+        if (world != null) {
+            if (expireAt == 0L) {
+                try {
+                    holder.setPermission(node, value, server, world);
+                } catch (Exception ex) {
+                    log.handleException(ex);
+                }
+            } else {
+                try {
+                    holder.setPermission(node, value, server, world, expireAt);
+                } catch (Exception ex) {
+                    log.handleException(ex);
+                }
+            }
+
+        } else if (server != null) {
+            if (expireAt == 0L) {
+                try {
+                    holder.setPermission(node, value, server);
+                } catch (Exception ex) {
+                    log.handleException(ex);
+                }
+            } else {
+                try {
+                    holder.setPermission(node, value, server, expireAt);
+                } catch (Exception ex) {
+                    log.handleException(ex);
+                }
+            }
+        } else {
+            if (expireAt == 0L) {
+                try {
+                    holder.setPermission(node, value);
+                } catch (Exception ex) {
+                    log.handleException(ex);
+                }
+            } else {
+                try {
+                    holder.setPermission(node, value, expireAt);
+                } catch (Exception ex) {
+                    log.handleException(ex);
+                }
+            }
+        }
+    }
+
+    private static void getPlayerPermissions(PermissionManager manager, UUID uuid, Consumer<List<Permission>> callback) {
+        if (legacy) {
+            try {
+                getPlayerPermissionsMethod.invoke(manager, uuid, new LPResultRunnable<List<Permission>>() {
+                    @Override
+                    public void run() {
+                        callback.accept(getResult());
+                    }
+                });
+            } catch (IllegalAccessException | InvocationTargetException e) {
+                e.printStackTrace();
+            }
+        } else {
+            try {
+                ListenableFuture<List<Permission>> lf = (ListenableFuture<List<Permission>>) getPlayerPermissionsMethod.invoke(manager, uuid);
+                try {
+                    if (lf.isDone()) {
+                        callback.accept(lf.get());
+                    } else {
+                        lf.addListener(() -> {
+                            try {
+                                callback.accept(lf.get());
+                            } catch (InterruptedException | ExecutionException e) {
+                                e.printStackTrace();
+                            }
+                        }, Runnable::run);
+                    }
+                } catch (InterruptedException | ExecutionException e) {
+                    e.printStackTrace();
+                }
+            } catch (IllegalAccessException | InvocationTargetException e) {
+                e.printStackTrace();
+            }
+        }
+    }
+}