diff --git a/pom.xml b/pom.xml
index 8602430..56e4c9a 100644
--- a/pom.xml
+++ b/pom.xml
@@ -6,7 +6,7 @@
 
     <groupId>codes.wasabi</groupId>
     <artifactId>xclaim</artifactId>
-    <version>1.13.1</version>
+    <version>1.14.0</version>
     <packaging>jar</packaging>
 
     <name>XClaim</name>
@@ -190,7 +190,7 @@
         <dependency>
             <groupId>org.apache.commons</groupId>
             <artifactId>commons-text</artifactId>
-            <version>1.9</version>
+            <version>1.12.0</version>
             <scope>compile</scope>
         </dependency>
         <dependency>
@@ -222,7 +222,7 @@
         <dependency>
             <groupId>com.github.BlueMap-Minecraft</groupId>
             <artifactId>BlueMapAPI</artifactId>
-            <version>v2.4.0</version>
+            <version>2.7.0</version>
             <scope>provided</scope>
         </dependency>
         <dependency>
@@ -234,13 +234,13 @@
         <dependency>
             <groupId>org.jetbrains</groupId>
             <artifactId>annotations</artifactId>
-            <version>23.0.0</version>
+            <version>24.1.0</version>
             <scope>compile</scope>
         </dependency>
         <dependency>
             <groupId>com.github.MilkBowl</groupId>
             <artifactId>VaultAPI</artifactId>
-            <version>1.7</version>
+            <version>1.7.1</version>
             <scope>provided</scope>
         </dependency>
         <dependency>
@@ -252,7 +252,7 @@
         <dependency>
             <groupId>de.tr7zw</groupId>
             <artifactId>item-nbt-api-plugin</artifactId>
-            <version>2.10.0</version>
+            <version>2.13.1</version>
             <scope>provided</scope>
         </dependency>
         <!--
@@ -266,7 +266,7 @@
         <dependency>
             <groupId>org.bstats</groupId>
             <artifactId>bstats-bukkit</artifactId>
-            <version>3.0.0</version>
+            <version>3.0.2</version>
             <scope>compile</scope>
         </dependency>
     </dependencies>
diff --git a/src/main/java/codes/wasabi/xclaim/XClaim.java b/src/main/java/codes/wasabi/xclaim/XClaim.java
index dc66a77..2bf2f72 100644
--- a/src/main/java/codes/wasabi/xclaim/XClaim.java
+++ b/src/main/java/codes/wasabi/xclaim/XClaim.java
@@ -100,7 +100,7 @@ private void loadGeneralConfig() {
     }
 
     private static final String[] bundledLangs = new String[] {
-            "en-US", "de", "zh"
+            "en-US", "de", "zh", "tr"
     };
     private void setupLang() {
         String l = mainConfig.getString("language", "en-US");
@@ -387,6 +387,10 @@ public static class Lang {
             return map.get(key);
         }
 
+        public boolean has(String key) {
+            return map.containsKey(key);
+        }
+
         public String get(String key) {
             return get(key, new String[0]);
         }
diff --git a/src/main/java/codes/wasabi/xclaim/api/Claim.java b/src/main/java/codes/wasabi/xclaim/api/Claim.java
index 566601a..3f51bf5 100644
--- a/src/main/java/codes/wasabi/xclaim/api/Claim.java
+++ b/src/main/java/codes/wasabi/xclaim/api/Claim.java
@@ -5,8 +5,8 @@
 import codes.wasabi.xclaim.api.enums.TrustLevel;
 import codes.wasabi.xclaim.api.enums.permission.PermissionHandler;
 import codes.wasabi.xclaim.gui.ChunkEditor;
-import codes.wasabi.xclaim.map.MapMarker;
 import codes.wasabi.xclaim.map.MapService;
+import codes.wasabi.xclaim.map.MapServiceOp;
 import codes.wasabi.xclaim.platform.Platform;
 import codes.wasabi.xclaim.platform.PlatformPersistentDataContainer;
 import codes.wasabi.xclaim.platform.PlatformPersistentDataType;
@@ -197,9 +197,7 @@ public class Claim {
     private void validateMarkers() {
         if (MapService.isAvailable()) {
             MapService ms = MapService.getNonNull();
-            ms.getMarkerAsync(this, (MapMarker marker) -> {
-                if (marker != null) marker.update(this);
-            });
+            ms.queueOperation(MapServiceOp.update(this));
         }
     }
 
@@ -358,15 +356,19 @@ public boolean addChunk(@NotNull Chunk chunk) throws IllegalArgumentException {
         if (ret) {
             generateBounds();
             if (manageHandlers) {
+                List<Claim> collides = new ArrayList<>(1);
                 registryLock.readLock().lock();
                 try {
                     for (Claim c : registry) {
                         if (c == this) continue;
-                        if (c.chunks.contains(ref)) c.removeChunk(chunk);
+                        if (c.chunks.contains(ref)) {
+                            collides.add(c);
+                        }
                     }
                 } finally {
                     registryLock.readLock().unlock();
                 }
+                for (Claim collided : collides) collided.removeChunk(ref);
             } else if (claim) {
                 claim();
             }
@@ -615,9 +617,7 @@ public boolean unclaim() {
             ownerChangeCallbacks.clear();
             if (MapService.isAvailable()) {
                 MapService ms = MapService.getNonNull();
-                ms.getMarkerAsync(this, (MapMarker marker) -> {
-                    if (marker != null) marker.deleteMarker();
-                });
+                ms.queueOperation(MapServiceOp.delete(this));
             }
             return true;
         }
diff --git a/src/main/java/codes/wasabi/xclaim/api/XCPlayer.java b/src/main/java/codes/wasabi/xclaim/api/XCPlayer.java
index 45fa1ee..d1aa3cd 100644
--- a/src/main/java/codes/wasabi/xclaim/api/XCPlayer.java
+++ b/src/main/java/codes/wasabi/xclaim/api/XCPlayer.java
@@ -10,6 +10,7 @@
 
 import java.util.*;
 import java.util.concurrent.locks.ReentrantReadWriteLock;
+import java.util.concurrent.locks.StampedLock;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
@@ -18,28 +19,44 @@ public class XCPlayer {
     private static final ReentrantReadWriteLock trustConfigLock = new ReentrantReadWriteLock();
 
     public static @NotNull XCPlayer of(@NotNull OfflinePlayer ply) {
-        if (ply instanceof XCPlayer) return (XCPlayer) ply;
         return new XCPlayer(ply);
     }
 
-    private final String uuidString;
-    private final OfflinePlayer op;
+    public static @NotNull XCPlayer of(@NotNull UUID uuid) {
+        return new XCPlayer(uuid);
+    }
+
+    private final UUID uuid;
+    private final StampedLock valuesLock = new StampedLock();
+    private int valuesFlag = 0;
+    private OfflinePlayer op;
+    private String uuidString;
 
     protected XCPlayer(@NotNull UUID uuid) {
-        uuidString = uuid.toString();
-        op = Bukkit.getOfflinePlayer(uuid);
+        this.uuid = uuid;
     }
 
     protected XCPlayer(@NotNull OfflinePlayer ply) {
         this(ply.getUniqueId());
+        this.valuesFlag = 1;
+        this.op = ply;
     }
 
     public @NotNull OfflinePlayer getOfflinePlayer() {
-        return op;
+        long stamp = this.valuesLock.readLock();
+        try {
+            if ((this.valuesFlag & 1) == 1) return this.op;
+            stamp = this.valuesLock.tryConvertToWriteLock(stamp);
+            this.op = Bukkit.getOfflinePlayer(this.uuid);
+            this.valuesFlag |= 1;
+            return this.op;
+        } finally {
+            this.valuesLock.unlock(stamp);
+        }
     }
 
     public @Nullable Player getPlayer() {
-        return op.getPlayer();
+        return this.getOfflinePlayer().getPlayer();
     }
 
     public boolean trustPlayer(@NotNull OfflinePlayer player) {
@@ -64,7 +81,7 @@ public boolean playerTrusted(@NotNull OfflinePlayer player) {
         List<?> entries;
         trustConfigLock.readLock().lock();
         try {
-            entries = XClaim.trustConfig.getList(uuidString, new ArrayList<String>());
+            entries = XClaim.trustConfig.getList(this.getUUIDString(), new ArrayList<String>());
         } finally {
             trustConfigLock.readLock().unlock();
         }
@@ -76,11 +93,22 @@ public boolean playerTrusted(@NotNull OfflinePlayer player) {
         return false;
     }
 
+    public int getNumTrustedPlayers() {
+        List<?> entries;
+        trustConfigLock.readLock().lock();
+        try {
+            entries = XClaim.trustConfig.getList(this.getUUIDString(), new ArrayList<String>());
+        } finally {
+            trustConfigLock.readLock().unlock();
+        }
+        return entries.size();
+    }
+
     private @NotNull List<OfflinePlayer> getCurrentTrustedPlayers() {
         List<?> entries;
         trustConfigLock.readLock().lock();
         try {
-            entries = XClaim.trustConfig.getList(uuidString, new ArrayList<String>());
+            entries = XClaim.trustConfig.getList(this.getUUIDString(), new ArrayList<String>());
         } finally {
             trustConfigLock.readLock().unlock();
         }
@@ -100,7 +128,7 @@ public void setTrustedPlayers(@NotNull List<OfflinePlayer> players) {
         List<String> list = players.stream().flatMap((OfflinePlayer op) -> Stream.of(op.getUniqueId().toString())).collect(Collectors.toList());
         trustConfigLock.writeLock().lock();
         try {
-            XClaim.trustConfig.set(uuidString, list);
+            XClaim.trustConfig.set(this.getUUIDString(), list);
         } finally {
             trustConfigLock.writeLock().unlock();
         }
@@ -119,6 +147,7 @@ private double[] getPermGroup() {
             boolean inGroup = true;
             if (!groupName.equalsIgnoreCase("default")) {
                 inGroup = false;
+                final OfflinePlayer op = this.getOfflinePlayer();
                 Player ply = op.getPlayer();
                 if (ply != null) {
                     inGroup = ply.hasPermission("xclaim.group." + groupName);
@@ -184,192 +213,98 @@ public int getMaxClaimsInWorld() {
     }
 
     public @NotNull List<OfflinePlayer> getTrustedPlayers() {
-        return new List<OfflinePlayer>() {
+        return new AbstractList<OfflinePlayer>() {
             @Override
-            public int size() {
-                return getCurrentTrustedPlayers().size();
+            public OfflinePlayer get(int i) {
+                return XCPlayer.this.getCurrentTrustedPlayers().get(i);
             }
 
             @Override
-            public boolean isEmpty() {
-                return size() > 0;
+            public int size() {
+                return XCPlayer.this.getNumTrustedPlayers();
             }
 
             @Override
             public boolean contains(Object o) {
-                return getCurrentTrustedPlayers().contains(o);
-            }
-
-            @NotNull
-            @Override
-            public Iterator<OfflinePlayer> iterator() {
-                return getCurrentTrustedPlayers().iterator();
-            }
-
-            @NotNull
-            @Override
-            public Object[] toArray() {
-                return getCurrentTrustedPlayers().toArray();
-            }
-
-            @NotNull
-            @Override
-            public <T> T[] toArray(@NotNull T[] a) {
-                return getCurrentTrustedPlayers().toArray(a);
+                return XCPlayer.this.getCurrentTrustedPlayers().contains(o);
             }
 
             @Override
             public boolean add(OfflinePlayer offlinePlayer) {
-                List<OfflinePlayer> cur = getCurrentTrustedPlayers();
+                List<OfflinePlayer> cur = XCPlayer.this.getCurrentTrustedPlayers();
                 cur.add(offlinePlayer);
-                setTrustedPlayers(cur);
+                XCPlayer.this.setTrustedPlayers(cur);
                 return true;
             }
 
             @Override
-            public boolean remove(Object o) {
-                List<OfflinePlayer> cur = getCurrentTrustedPlayers();
-                if (cur.remove(o)) {
-                    setTrustedPlayers(cur);
-                    return true;
-                }
-                return false;
-            }
-
-            @Override
-            public boolean containsAll(@NotNull Collection<?> c) {
-                return new HashSet<>(getCurrentTrustedPlayers()).containsAll(c);
-            }
-
-            @Override
-            public boolean addAll(@NotNull Collection<? extends OfflinePlayer> c) {
-                List<OfflinePlayer> cur = getCurrentTrustedPlayers();
-                if (cur.addAll(c)) {
-                    setTrustedPlayers(cur);
-                    return true;
-                }
-                return false;
-            }
-
-            @Override
-            public boolean addAll(int index, @NotNull Collection<? extends OfflinePlayer> c) {
-                List<OfflinePlayer> cur = getCurrentTrustedPlayers();
-                if (cur.addAll(index, c)) {
-                    setTrustedPlayers(cur);
-                    return true;
-                }
-                return false;
-            }
-
-            @Override
-            public boolean removeAll(@NotNull Collection<?> c) {
-                List<OfflinePlayer> cur = getCurrentTrustedPlayers();
-                if (cur.removeAll(c)) {
-                    setTrustedPlayers(cur);
-                    return true;
-                }
-                return false;
-            }
-
-            @Override
-            public boolean retainAll(@NotNull Collection<?> c) {
-                List<OfflinePlayer> cur = getCurrentTrustedPlayers();
-                if (cur.retainAll(c)) {
-                    setTrustedPlayers(cur);
-                    return true;
-                }
-                return false;
-            }
-
-            @Override
-            public void clear() {
-                setTrustedPlayers(Collections.emptyList());
-            }
-
-            @Override
-            public OfflinePlayer get(int index) {
-                return getCurrentTrustedPlayers().get(index);
+            public void add(int index, OfflinePlayer element) {
+                List<OfflinePlayer> cur = XCPlayer.this.getCurrentTrustedPlayers();
+                cur.add(index, element);
+                XCPlayer.this.setTrustedPlayers(cur);
             }
 
             @Override
             public OfflinePlayer set(int index, OfflinePlayer element) {
-                List<OfflinePlayer> cur = getCurrentTrustedPlayers();
+                List<OfflinePlayer> cur = XCPlayer.this.getCurrentTrustedPlayers();
                 OfflinePlayer ret = cur.set(index, element);
-                setTrustedPlayers(cur);
+                XCPlayer.this.setTrustedPlayers(cur);
                 return ret;
             }
 
-            @Override
-            public void add(int index, OfflinePlayer element) {
-                List<OfflinePlayer> cur = getCurrentTrustedPlayers();
-                cur.add(index, element);
-                setTrustedPlayers(cur);
-            }
-
             @Override
             public OfflinePlayer remove(int index) {
-                List<OfflinePlayer> cur = getCurrentTrustedPlayers();
+                List<OfflinePlayer> cur = XCPlayer.this.getCurrentTrustedPlayers();
                 OfflinePlayer ret = cur.remove(index);
-                setTrustedPlayers(cur);
+                XCPlayer.this.setTrustedPlayers(cur);
                 return ret;
             }
 
             @Override
-            public int indexOf(Object o) {
-                return getCurrentTrustedPlayers().indexOf(o);
-            }
-
-            @Override
-            public int lastIndexOf(Object o) {
-                return getCurrentTrustedPlayers().lastIndexOf(o);
-            }
-
-            @NotNull
-            @Override
-            public ListIterator<OfflinePlayer> listIterator() {
-                return getCurrentTrustedPlayers().listIterator();
-            }
-
-            @NotNull
-            @Override
-            public ListIterator<OfflinePlayer> listIterator(int index) {
-                return getCurrentTrustedPlayers().listIterator(index);
-            }
-
-            @NotNull
-            @Override
-            public List<OfflinePlayer> subList(int fromIndex, int toIndex) {
-                return getCurrentTrustedPlayers().subList(fromIndex, toIndex);
+            public @NotNull Iterator<OfflinePlayer> iterator() {
+                return XCPlayer.this.getCurrentTrustedPlayers().iterator();
             }
         };
     }
 
     @Override
     public int hashCode() {
-        return Objects.hashCode(op);
+        return Objects.hashCode(this.uuid);
     }
 
     @Override
     public boolean equals(Object obj) {
-        if (this == obj) return true;
         if (obj == null) return false;
         if (obj instanceof XCPlayer) {
-            return ((XCPlayer) obj).op.equals(op);
+            return ((XCPlayer) obj).uuid.equals(this.uuid);
         }
         return super.equals(obj);
     }
 
     @Override
     public String toString() {
-        return "XCPlayer[uuid=" + op.getUniqueId() + "]";
+        return "XCPlayer[uuid=" + this.uuid + "]";
     }
 
     public @NotNull UUID getUniqueId() {
-        return op.getUniqueId();
+        return this.uuid;
+    }
+
+    public @NotNull String getUUIDString() {
+        long stamp = this.valuesLock.readLock();
+        try {
+            if ((this.valuesFlag & 2) == 2) return this.uuidString;
+            stamp = this.valuesLock.tryConvertToWriteLock(stamp);
+            this.uuidString = this.uuid.toString();
+            this.valuesFlag |= 2;
+            return this.uuidString;
+        } finally {
+            this.valuesLock.unlock(stamp);
+        }
     }
 
     public @Nullable String getName() {
-        return op.getName();
+        return this.getOfflinePlayer().getName();
     }
 
 }
diff --git a/src/main/java/codes/wasabi/xclaim/api/event/XClaimAddChunkToClaimEvent.java b/src/main/java/codes/wasabi/xclaim/api/event/XClaimAddChunkToClaimEvent.java
new file mode 100644
index 0000000..1c27986
--- /dev/null
+++ b/src/main/java/codes/wasabi/xclaim/api/event/XClaimAddChunkToClaimEvent.java
@@ -0,0 +1,39 @@
+package codes.wasabi.xclaim.api.event;
+
+import codes.wasabi.xclaim.api.Claim;
+import org.bukkit.Chunk;
+import org.bukkit.entity.Player;
+import org.bukkit.event.HandlerList;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Collections;
+
+public class XClaimAddChunkToClaimEvent extends XClaimAddChunksToClaimEvent {
+
+    private static final HandlerList HANDLERS = new HandlerList();
+
+    public static @NotNull HandlerList getHandlerList() {
+        return HANDLERS;
+    }
+
+    //
+
+    public XClaimAddChunkToClaimEvent(@NotNull Player player, @NotNull Claim claim, @NotNull Chunk chunk) {
+        super(player, claim, Collections.singletonList(chunk));
+    }
+
+    public @NotNull Chunk getChunk() {
+        return this.chunks.get(0);
+    }
+
+    @Override
+    public @NotNull HandlerList getHandlers() {
+        return HANDLERS;
+    }
+
+    @Override
+    protected @NotNull String getTranslatableFailMessage() {
+        return "event-fail-add-chunk";
+    }
+
+}
diff --git a/src/main/java/codes/wasabi/xclaim/api/event/XClaimAddChunksToClaimEvent.java b/src/main/java/codes/wasabi/xclaim/api/event/XClaimAddChunksToClaimEvent.java
new file mode 100644
index 0000000..2de1d7c
--- /dev/null
+++ b/src/main/java/codes/wasabi/xclaim/api/event/XClaimAddChunksToClaimEvent.java
@@ -0,0 +1,39 @@
+package codes.wasabi.xclaim.api.event;
+
+import codes.wasabi.xclaim.api.Claim;
+import org.bukkit.Chunk;
+import org.bukkit.entity.Player;
+import org.bukkit.event.HandlerList;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.List;
+
+public class XClaimAddChunksToClaimEvent extends XClaimModifyClaimChunksEvent {
+
+    private static final HandlerList HANDLERS = new HandlerList();
+
+    public static @NotNull HandlerList getHandlerList() {
+        return HANDLERS;
+    }
+
+    //
+
+    public XClaimAddChunksToClaimEvent(@NotNull Player player, @NotNull Claim claim, @NotNull Chunk... chunks) {
+        super(player, claim, chunks);
+    }
+
+    public XClaimAddChunksToClaimEvent(@NotNull Player player, @NotNull Claim claim, @NotNull List<Chunk> chunks) {
+        super(player, claim, chunks);
+    }
+
+    @Override
+    public @NotNull HandlerList getHandlers() {
+        return HANDLERS;
+    }
+
+    @Override
+    protected @NotNull String getTranslatableFailMessage() {
+        return "event-fail-add-chunks";
+    }
+
+}
diff --git a/src/main/java/codes/wasabi/xclaim/api/event/XClaimCreateClaimEvent.java b/src/main/java/codes/wasabi/xclaim/api/event/XClaimCreateClaimEvent.java
new file mode 100644
index 0000000..6905b63
--- /dev/null
+++ b/src/main/java/codes/wasabi/xclaim/api/event/XClaimCreateClaimEvent.java
@@ -0,0 +1,36 @@
+package codes.wasabi.xclaim.api.event;
+
+import codes.wasabi.xclaim.api.Claim;
+import org.bukkit.entity.Player;
+import org.bukkit.event.HandlerList;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * Called when a Claim has been initialized (all checks have passed), but not yet canonized.
+ * Cancelling the event will stop the Claim from being effectively created.
+ */
+public class XClaimCreateClaimEvent extends XClaimModifyClaimEvent {
+
+    private static final HandlerList HANDLERS = new HandlerList();
+
+    public static @NotNull HandlerList getHandlerList() {
+        return HANDLERS;
+    }
+
+    //
+
+    public XClaimCreateClaimEvent(@NotNull Player player, @NotNull Claim claim) {
+        super(player, claim);
+    }
+
+    @Override
+    public @NotNull HandlerList getHandlers() {
+        return HANDLERS;
+    }
+
+    @Override
+    protected @NotNull String getTranslatableFailMessage() {
+        return "event-fail-create-claim";
+    }
+
+}
diff --git a/src/main/java/codes/wasabi/xclaim/api/event/XClaimDeleteClaimEvent.java b/src/main/java/codes/wasabi/xclaim/api/event/XClaimDeleteClaimEvent.java
new file mode 100644
index 0000000..459e6f7
--- /dev/null
+++ b/src/main/java/codes/wasabi/xclaim/api/event/XClaimDeleteClaimEvent.java
@@ -0,0 +1,36 @@
+package codes.wasabi.xclaim.api.event;
+
+import codes.wasabi.xclaim.api.Claim;
+import org.bukkit.entity.Player;
+import org.bukkit.event.HandlerList;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * Called before a Claim is deleted by a player.
+ * Cancelling the event will prevent the Claim from being deleted.
+ */
+public class XClaimDeleteClaimEvent extends XClaimModifyClaimEvent {
+
+    private static final HandlerList HANDLERS = new HandlerList();
+
+    public static @NotNull HandlerList getHandlerList() {
+        return HANDLERS;
+    }
+
+    //
+
+    public XClaimDeleteClaimEvent(@NotNull Player player, @NotNull Claim claim) {
+        super(player, claim);
+    }
+
+    @Override
+    public @NotNull HandlerList getHandlers() {
+        return HANDLERS;
+    }
+
+    @Override
+    protected @NotNull String getTranslatableFailMessage() {
+        return "event-fail-delete-claim";
+    }
+
+}
diff --git a/src/main/java/codes/wasabi/xclaim/api/event/XClaimEvent.java b/src/main/java/codes/wasabi/xclaim/api/event/XClaimEvent.java
new file mode 100644
index 0000000..4b31a0c
--- /dev/null
+++ b/src/main/java/codes/wasabi/xclaim/api/event/XClaimEvent.java
@@ -0,0 +1,103 @@
+package codes.wasabi.xclaim.api.event;
+
+import codes.wasabi.xclaim.XClaim;
+import codes.wasabi.xclaim.platform.Platform;
+import net.kyori.adventure.audience.Audience;
+import net.kyori.adventure.text.Component;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.bukkit.event.Cancellable;
+import org.bukkit.event.Event;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.annotations.UnmodifiableView;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * Superclass & helpers for all XClaim events.
+ * @see XClaimCreateClaimEvent
+ * @see XClaimDeleteClaimEvent
+ * @see XClaimAddChunksToClaimEvent
+ * @see XClaimAddChunkToClaimEvent
+ * @see XClaimRemoveChunksFromClaimEvent
+ * @see XClaimRemoveChunkFromClaimEvent
+ * @see XClaimTransferOwnerEvent
+ * @see XClaimGrantUserPermissionEvent
+ * @see XClaimRevokeUserPermissionEvent
+ */
+public abstract class XClaimEvent extends Event implements Cancellable {
+
+    @ApiStatus.Internal
+    public static boolean dispatch(
+            @NotNull XClaimEvent event,
+            @NotNull Player player
+    ) {
+        Bukkit.getPluginManager().callEvent(event);
+        if (!event.cancelled) return true;
+
+        final String langFailMessage = event.getTranslatableFailMessage();
+        List<String> detail = event.cancelMessages;
+        Component failMessage = XClaim.lang.has(langFailMessage) ? XClaim.lang.getComponent(langFailMessage) : null;
+
+        if ((!detail.isEmpty()) && XClaim.lang.has(langFailMessage + "-single")) {
+            failMessage = XClaim.lang.getComponent(langFailMessage + "-single", detail.get(0));
+        }
+
+        if (detail.size() > 1 && XClaim.lang.has(langFailMessage + "-multi")) {
+            failMessage = XClaim.lang.getComponent(langFailMessage + "-multi", String.join(", ", detail));
+        }
+
+        final Audience audience = Platform.getAdventure().player(player);
+        if (failMessage != null) {
+            audience.sendMessage(failMessage);
+        }
+
+        return false;
+    }
+
+    @ApiStatus.Internal
+    public static boolean dispatch(
+            @NotNull XClaimEvent event
+    ) throws UnsupportedOperationException {
+        return dispatch(event, event.getPlayer());
+    }
+
+    //
+
+    protected boolean cancelled = false;
+    protected List<String> cancelMessages = new ArrayList<>(1);
+
+    @Override
+    public boolean isCancelled() {
+        return this.cancelled;
+    }
+
+    /**
+     * @deprecated Favor {@link #cancel(String)} instead of this
+     */
+    @ApiStatus.Obsolete
+    @Override
+    public void setCancelled(boolean b) {
+        this.cancelled = b;
+    }
+
+    public void cancel(@Nullable String cancelMessage) {
+        this.cancelMessages.add(cancelMessage);
+        this.cancelled = true;
+    }
+
+    public @NotNull @UnmodifiableView List<String> getCancelMessages() {
+        return Collections.unmodifiableList(this.cancelMessages);
+    }
+
+    protected abstract @NotNull String getTranslatableFailMessage();
+
+    protected @NotNull Player getPlayer() throws UnsupportedOperationException {
+        throw new UnsupportedOperationException("Event has no associated Player");
+    }
+
+}
diff --git a/src/main/java/codes/wasabi/xclaim/api/event/XClaimGrantUserPermissionEvent.java b/src/main/java/codes/wasabi/xclaim/api/event/XClaimGrantUserPermissionEvent.java
new file mode 100644
index 0000000..a6b319f
--- /dev/null
+++ b/src/main/java/codes/wasabi/xclaim/api/event/XClaimGrantUserPermissionEvent.java
@@ -0,0 +1,39 @@
+package codes.wasabi.xclaim.api.event;
+
+import codes.wasabi.xclaim.api.Claim;
+import codes.wasabi.xclaim.api.XCPlayer;
+import codes.wasabi.xclaim.api.enums.Permission;
+import org.bukkit.entity.Player;
+import org.bukkit.event.HandlerList;
+import org.jetbrains.annotations.NotNull;
+
+public class XClaimGrantUserPermissionEvent extends XClaimModifyClaimUserPermissionEvent {
+
+    private static final HandlerList HANDLERS = new HandlerList();
+
+    public static @NotNull HandlerList getHandlerList() {
+        return HANDLERS;
+    }
+
+    //
+
+    public XClaimGrantUserPermissionEvent(
+            @NotNull Player player,
+            @NotNull Claim claim,
+            @NotNull Permission permission,
+            @NotNull XCPlayer target
+    ) {
+        super(player, claim, permission, target, true);
+    }
+
+    @Override
+    public @NotNull HandlerList getHandlers() {
+        return HANDLERS;
+    }
+
+    @Override
+    protected @NotNull String getTranslatableFailMessage() {
+        return "event-fail-grant-user-permission";
+    }
+
+}
diff --git a/src/main/java/codes/wasabi/xclaim/api/event/XClaimModifyClaimChunksEvent.java b/src/main/java/codes/wasabi/xclaim/api/event/XClaimModifyClaimChunksEvent.java
new file mode 100644
index 0000000..f720934
--- /dev/null
+++ b/src/main/java/codes/wasabi/xclaim/api/event/XClaimModifyClaimChunksEvent.java
@@ -0,0 +1,33 @@
+package codes.wasabi.xclaim.api.event;
+
+import codes.wasabi.xclaim.api.Claim;
+import org.bukkit.Chunk;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Unmodifiable;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+public abstract class XClaimModifyClaimChunksEvent extends XClaimModifyClaimEvent {
+
+    protected final List<Chunk> chunks;
+
+    public XClaimModifyClaimChunksEvent(@NotNull Player player, @NotNull Claim claim, @NotNull Chunk... chunks) {
+        super(player, claim);
+        this.chunks = Collections.unmodifiableList(Arrays.asList(chunks));
+    }
+
+    public XClaimModifyClaimChunksEvent(@NotNull Player player, @NotNull Claim claim, @NotNull List<Chunk> chunks) {
+        super(player, claim);
+        this.chunks = Collections.unmodifiableList(chunks);
+    }
+
+    //
+
+    public @NotNull @Unmodifiable List<Chunk> getChunks() {
+        return this.chunks;
+    }
+
+}
diff --git a/src/main/java/codes/wasabi/xclaim/api/event/XClaimModifyClaimEvent.java b/src/main/java/codes/wasabi/xclaim/api/event/XClaimModifyClaimEvent.java
new file mode 100644
index 0000000..0d282c0
--- /dev/null
+++ b/src/main/java/codes/wasabi/xclaim/api/event/XClaimModifyClaimEvent.java
@@ -0,0 +1,29 @@
+package codes.wasabi.xclaim.api.event;
+
+import codes.wasabi.xclaim.api.Claim;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+
+public abstract class XClaimModifyClaimEvent extends XClaimEvent {
+
+    private final Player player;
+    private final Claim claim;
+    public XClaimModifyClaimEvent(@NotNull Player player, @NotNull Claim claim) {
+        this.player = player;
+        this.claim = claim;
+    }
+
+    /**
+     * Gets the player responsible for the modification; e.g. the player that clicked a GUI item or
+     * ran a command that caused this event to be called.
+     */
+    @Override
+    public final @NotNull Player getPlayer() {
+        return this.player;
+    }
+
+    public final @NotNull Claim getClaim() {
+        return this.claim;
+    }
+
+}
diff --git a/src/main/java/codes/wasabi/xclaim/api/event/XClaimModifyClaimPermissionEvent.java b/src/main/java/codes/wasabi/xclaim/api/event/XClaimModifyClaimPermissionEvent.java
new file mode 100644
index 0000000..5f40fa5
--- /dev/null
+++ b/src/main/java/codes/wasabi/xclaim/api/event/XClaimModifyClaimPermissionEvent.java
@@ -0,0 +1,23 @@
+package codes.wasabi.xclaim.api.event;
+
+import codes.wasabi.xclaim.api.Claim;
+import codes.wasabi.xclaim.api.enums.Permission;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+
+public abstract class XClaimModifyClaimPermissionEvent extends XClaimModifyClaimEvent {
+
+    private final Permission permission;
+    public XClaimModifyClaimPermissionEvent(@NotNull Player player, @NotNull Claim claim, @NotNull Permission permission) {
+        super(player, claim);
+        this.permission = permission;
+    }
+
+    /**
+     * Gets the permission being modified
+     */
+    public final @NotNull Permission getPermission() {
+        return this.permission;
+    }
+
+}
diff --git a/src/main/java/codes/wasabi/xclaim/api/event/XClaimModifyClaimUserPermissionEvent.java b/src/main/java/codes/wasabi/xclaim/api/event/XClaimModifyClaimUserPermissionEvent.java
new file mode 100644
index 0000000..6b60461
--- /dev/null
+++ b/src/main/java/codes/wasabi/xclaim/api/event/XClaimModifyClaimUserPermissionEvent.java
@@ -0,0 +1,40 @@
+package codes.wasabi.xclaim.api.event;
+
+import codes.wasabi.xclaim.api.Claim;
+import codes.wasabi.xclaim.api.XCPlayer;
+import codes.wasabi.xclaim.api.enums.Permission;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+
+public abstract class XClaimModifyClaimUserPermissionEvent extends XClaimModifyClaimPermissionEvent {
+
+    private final XCPlayer target;
+    private final boolean value;
+
+    public XClaimModifyClaimUserPermissionEvent(
+            @NotNull Player player,
+            @NotNull Claim claim,
+            @NotNull Permission permission,
+            @NotNull XCPlayer target,
+            boolean value
+    ) {
+        super(player, claim, permission);
+        this.target = target;
+        this.value = value;
+    }
+
+    /**
+     * Gets the player whose permissions are being modified.
+     */
+    public @NotNull XCPlayer getTarget() {
+        return this.target;
+    }
+
+    /**
+     * Returns true if the permission is being granted, false if the permission is being revoked.
+     */
+    public boolean getValue() {
+        return this.value;
+    }
+
+}
diff --git a/src/main/java/codes/wasabi/xclaim/api/event/XClaimRemoveChunkFromClaimEvent.java b/src/main/java/codes/wasabi/xclaim/api/event/XClaimRemoveChunkFromClaimEvent.java
new file mode 100644
index 0000000..7cf7e33
--- /dev/null
+++ b/src/main/java/codes/wasabi/xclaim/api/event/XClaimRemoveChunkFromClaimEvent.java
@@ -0,0 +1,38 @@
+package codes.wasabi.xclaim.api.event;
+
+import codes.wasabi.xclaim.api.Claim;
+import org.bukkit.Chunk;
+import org.bukkit.entity.Player;
+import org.bukkit.event.HandlerList;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Collections;
+
+public class XClaimRemoveChunkFromClaimEvent extends XClaimRemoveChunksFromClaimEvent {
+
+    private static final HandlerList HANDLERS = new HandlerList();
+
+    public static @NotNull HandlerList getHandlerList() {
+        return HANDLERS;
+    }
+
+    //
+
+    public XClaimRemoveChunkFromClaimEvent(@NotNull Player player, @NotNull Claim claim, @NotNull Chunk chunk) {
+        super(player, claim, Collections.singletonList(chunk));
+    }
+
+    public @NotNull Chunk getChunk() {
+        return this.chunks.get(0);
+    }
+
+    @Override
+    public @NotNull HandlerList getHandlers() {
+        return HANDLERS;
+    }
+
+    @Override
+    protected @NotNull String getTranslatableFailMessage() {
+        return "event-fail-remove-chunk";
+    }
+}
diff --git a/src/main/java/codes/wasabi/xclaim/api/event/XClaimRemoveChunksFromClaimEvent.java b/src/main/java/codes/wasabi/xclaim/api/event/XClaimRemoveChunksFromClaimEvent.java
new file mode 100644
index 0000000..823adec
--- /dev/null
+++ b/src/main/java/codes/wasabi/xclaim/api/event/XClaimRemoveChunksFromClaimEvent.java
@@ -0,0 +1,39 @@
+package codes.wasabi.xclaim.api.event;
+
+import codes.wasabi.xclaim.api.Claim;
+import org.bukkit.Chunk;
+import org.bukkit.entity.Player;
+import org.bukkit.event.HandlerList;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.List;
+
+public class XClaimRemoveChunksFromClaimEvent extends XClaimModifyClaimChunksEvent {
+
+    private static final HandlerList HANDLERS = new HandlerList();
+
+    public static @NotNull HandlerList getHandlerList() {
+        return HANDLERS;
+    }
+
+    //
+
+    public XClaimRemoveChunksFromClaimEvent(@NotNull Player player, @NotNull Claim claim, @NotNull Chunk... chunks) {
+        super(player, claim, chunks);
+    }
+
+    public XClaimRemoveChunksFromClaimEvent(@NotNull Player player, @NotNull Claim claim, @NotNull List<Chunk> chunks) {
+        super(player, claim, chunks);
+    }
+
+    @Override
+    public @NotNull HandlerList getHandlers() {
+        return HANDLERS;
+    }
+
+    @Override
+    protected @NotNull String getTranslatableFailMessage() {
+        return "event-fail-remove-chunks";
+    }
+
+}
diff --git a/src/main/java/codes/wasabi/xclaim/api/event/XClaimRevokeUserPermissionEvent.java b/src/main/java/codes/wasabi/xclaim/api/event/XClaimRevokeUserPermissionEvent.java
new file mode 100644
index 0000000..046f553
--- /dev/null
+++ b/src/main/java/codes/wasabi/xclaim/api/event/XClaimRevokeUserPermissionEvent.java
@@ -0,0 +1,39 @@
+package codes.wasabi.xclaim.api.event;
+
+import codes.wasabi.xclaim.api.Claim;
+import codes.wasabi.xclaim.api.XCPlayer;
+import codes.wasabi.xclaim.api.enums.Permission;
+import org.bukkit.entity.Player;
+import org.bukkit.event.HandlerList;
+import org.jetbrains.annotations.NotNull;
+
+public class XClaimRevokeUserPermissionEvent extends XClaimModifyClaimUserPermissionEvent {
+
+    private static final HandlerList HANDLERS = new HandlerList();
+
+    public static @NotNull HandlerList getHandlerList() {
+        return HANDLERS;
+    }
+
+    //
+
+    public XClaimRevokeUserPermissionEvent(
+            @NotNull Player player,
+            @NotNull Claim claim,
+            @NotNull Permission permission,
+            @NotNull XCPlayer target
+    ) {
+        super(player, claim, permission, target, false);
+    }
+
+    @Override
+    public @NotNull HandlerList getHandlers() {
+        return HANDLERS;
+    }
+
+    @Override
+    protected @NotNull String getTranslatableFailMessage() {
+        return "event-fail-revoke-user-permission";
+    }
+
+}
diff --git a/src/main/java/codes/wasabi/xclaim/api/event/XClaimSetPermissionEvent.java b/src/main/java/codes/wasabi/xclaim/api/event/XClaimSetPermissionEvent.java
new file mode 100644
index 0000000..e73aa9f
--- /dev/null
+++ b/src/main/java/codes/wasabi/xclaim/api/event/XClaimSetPermissionEvent.java
@@ -0,0 +1,53 @@
+package codes.wasabi.xclaim.api.event;
+
+import codes.wasabi.xclaim.api.Claim;
+import codes.wasabi.xclaim.api.enums.Permission;
+import codes.wasabi.xclaim.api.enums.TrustLevel;
+import org.bukkit.entity.Player;
+import org.bukkit.event.HandlerList;
+import org.jetbrains.annotations.NotNull;
+
+public class XClaimSetPermissionEvent extends XClaimModifyClaimPermissionEvent {
+
+    private static final HandlerList HANDLERS = new HandlerList();
+
+    public static @NotNull HandlerList getHandlerList() {
+        return HANDLERS;
+    }
+
+    //
+
+    private final TrustLevel previousLevel;
+    private final TrustLevel newLevel;
+
+    public XClaimSetPermissionEvent(
+            @NotNull Player player,
+            @NotNull Claim claim,
+            @NotNull Permission permission,
+            @NotNull TrustLevel previousLevel,
+            @NotNull TrustLevel newLevel
+    ) {
+        super(player, claim, permission);
+        this.previousLevel = previousLevel;
+        this.newLevel = newLevel;
+    }
+
+    public final @NotNull TrustLevel getPreviousLevel() {
+        return this.previousLevel;
+    }
+
+    public final @NotNull TrustLevel getNewLevel() {
+        return this.newLevel;
+    }
+
+    @Override
+    public @NotNull HandlerList getHandlers() {
+        return HANDLERS;
+    }
+
+    @Override
+    protected @NotNull String getTranslatableFailMessage() {
+        return "event-fail-set-permission";
+    }
+
+}
diff --git a/src/main/java/codes/wasabi/xclaim/api/event/XClaimTransferOwnerEvent.java b/src/main/java/codes/wasabi/xclaim/api/event/XClaimTransferOwnerEvent.java
new file mode 100644
index 0000000..6ec3b41
--- /dev/null
+++ b/src/main/java/codes/wasabi/xclaim/api/event/XClaimTransferOwnerEvent.java
@@ -0,0 +1,57 @@
+package codes.wasabi.xclaim.api.event;
+
+import codes.wasabi.xclaim.api.Claim;
+import codes.wasabi.xclaim.api.XCPlayer;
+import org.bukkit.entity.Player;
+import org.bukkit.event.HandlerList;
+import org.jetbrains.annotations.NotNull;
+
+public class XClaimTransferOwnerEvent extends XClaimModifyClaimEvent {
+
+    private static final HandlerList HANDLERS = new HandlerList();
+
+    public static @NotNull HandlerList getHandlerList() {
+        return HANDLERS;
+    }
+
+    //
+
+    private final XCPlayer previousOwner;
+    private final XCPlayer newOwner;
+
+    public XClaimTransferOwnerEvent(
+            @NotNull Player player,
+            @NotNull Claim claim,
+            @NotNull XCPlayer previousOwner,
+            @NotNull XCPlayer newOwner
+    ) {
+        super(player, claim);
+        this.previousOwner = previousOwner;
+        this.newOwner = newOwner;
+    }
+
+    /**
+     * Gets the current owner of the claim
+     */
+    public @NotNull XCPlayer getPreviousOwner() {
+        return this.previousOwner;
+    }
+
+    /**
+     * Gets the target owner of the claim
+     */
+    public @NotNull XCPlayer getNewOwner() {
+        return this.newOwner;
+    }
+
+    @Override
+    public @NotNull HandlerList getHandlers() {
+        return HANDLERS;
+    }
+
+    @Override
+    protected @NotNull String getTranslatableFailMessage() {
+        return "event-fail-transfer-owner";
+    }
+
+}
diff --git a/src/main/java/codes/wasabi/xclaim/gui/ChunkEditor.java b/src/main/java/codes/wasabi/xclaim/gui/ChunkEditor.java
index 003a5f9..36aabe2 100644
--- a/src/main/java/codes/wasabi/xclaim/gui/ChunkEditor.java
+++ b/src/main/java/codes/wasabi/xclaim/gui/ChunkEditor.java
@@ -4,6 +4,9 @@
 import codes.wasabi.xclaim.api.Claim;
 import codes.wasabi.xclaim.api.XCPlayer;
 import codes.wasabi.xclaim.api.enums.Permission;
+import codes.wasabi.xclaim.api.event.XClaimAddChunkToClaimEvent;
+import codes.wasabi.xclaim.api.event.XClaimEvent;
+import codes.wasabi.xclaim.api.event.XClaimRemoveChunkFromClaimEvent;
 import codes.wasabi.xclaim.economy.Economy;
 import codes.wasabi.xclaim.particle.ParticleBuilder;
 import codes.wasabi.xclaim.particle.ParticleEffect;
@@ -16,12 +19,14 @@
 import net.kyori.adventure.text.Component;
 import net.kyori.adventure.text.format.TextColor;
 import org.bukkit.*;
+import org.bukkit.entity.Entity;
 import org.bukkit.entity.HumanEntity;
 import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.EventPriority;
 import org.bukkit.event.Listener;
 import org.bukkit.event.block.Action;
+import org.bukkit.event.entity.EntityDamageEvent;
 import org.bukkit.event.entity.PlayerDeathEvent;
 import org.bukkit.event.inventory.InventoryClickEvent;
 import org.bukkit.event.inventory.InventoryDragEvent;
@@ -227,6 +232,7 @@ public void onInteract(@NotNull PlayerInteractEvent event) {
                             Platform.getAdventure().player(ply).sendMessage(XClaim.lang.getComponent("chunk-editor-max"));
                             break;
                         }
+                        if (!XClaimEvent.dispatch(new XClaimAddChunkToClaimEvent(ply, claim, chunk))) return;
                         if (claim.addChunk(chunk)) {
                             if (Economy.isAvailable()) {
                                 if (numChunks >= xcp.getFreeChunks()) {
@@ -255,6 +261,7 @@ public void onInteract(@NotNull PlayerInteractEvent event) {
                         break;
                     case 4:
                         Chunk chunk1 = ply.getLocation().getChunk();
+                        if (!XClaimEvent.dispatch(new XClaimRemoveChunkFromClaimEvent(ply, claim, chunk1))) return;
                         if (claim.removeChunk(chunk1)) {
                             if (Economy.isAvailable()) {
                                 Economy eco = Economy.getAssert();
@@ -304,6 +311,30 @@ public void onDeath(@NotNull PlayerDeathEvent event) {
             }
         }
 
+        @EventHandler
+        public void onDamage(@NotNull EntityDamageEvent event) {
+            Entity ent = event.getEntity();
+            if (!(ent instanceof Player)) return;
+            Player ply = (Player) ent;
+            if (getEditing(ply) == null) return;
+
+            final ItemStack[] inventory = getRetainedInventory(ply);
+            double damage = event.getDamage();
+            try {
+                damage = codes.wasabi.xclaim.util.AttributeUtil.scaleDamage(
+                        damage,
+                        (inventory.length > 36) ? inventory[36] : null,
+                        (inventory.length > 37) ? inventory[37] : null,
+                        (inventory.length > 38) ? inventory[38] : null,
+                        (inventory.length > 39) ? inventory[39] : null
+                );
+            } catch (Throwable ignored) {
+                // Attribute APIs may be too modern for the current server environment
+                damage *= 0.5d;
+            }
+            event.setDamage(damage);
+        }
+
         @EventHandler
         public void onMove(@NotNull PlayerMoveEvent event) {
             Player ply = event.getPlayer();
@@ -443,7 +474,7 @@ public static boolean stopEditing(@NotNull Player ply) {
         PlatformPersistentDataContainer pdc = Platform.get().getPersistentDataContainer(ply);
         pdc.set(KEY_FLAG, PlatformPersistentDataType.BYTE, (byte) 0);
         try {
-            InventorySerializer.deserialize(pdc.getOrDefaultAssert(KEY_INVENTORY, PlatformPersistentDataType.BYTE_ARRAY, byte[].class, new byte[0]), ply.getInventory());
+            ply.getInventory().setContents(getRetainedInventory(ply));
         } catch (IllegalArgumentException e) {
             ply.getInventory().clear();
         }
@@ -451,6 +482,12 @@ public static boolean stopEditing(@NotNull Player ply) {
         return true;
     }
 
+    static ItemStack @NotNull [] getRetainedInventory(@NotNull Player ply) throws IllegalArgumentException {
+        PlatformPersistentDataContainer pdc = Platform.get().getPersistentDataContainer(ply);
+        byte[] inventoryData = pdc.getOrDefaultAssert(KEY_INVENTORY, PlatformPersistentDataType.BYTE_ARRAY, byte[].class, new byte[0]);
+        return InventorySerializer.deserialize(inventoryData);
+    }
+
     public static boolean violatesDistanceCheck(Player owner, Chunk chunk) {
         double minDistance = XClaim.mainConfig.getDouble("claim-min-distance", 0d);
         if (minDistance < 1d) return false;
diff --git a/src/main/java/codes/wasabi/xclaim/gui/page/MainPage.java b/src/main/java/codes/wasabi/xclaim/gui/page/MainPage.java
index 0ede891..7133396 100644
--- a/src/main/java/codes/wasabi/xclaim/gui/page/MainPage.java
+++ b/src/main/java/codes/wasabi/xclaim/gui/page/MainPage.java
@@ -4,6 +4,9 @@
 import codes.wasabi.xclaim.api.Claim;
 import codes.wasabi.xclaim.api.XCPlayer;
 import codes.wasabi.xclaim.api.enums.Permission;
+import codes.wasabi.xclaim.api.event.XClaimCreateClaimEvent;
+import codes.wasabi.xclaim.api.event.XClaimDeleteClaimEvent;
+import codes.wasabi.xclaim.api.event.XClaimEvent;
 import codes.wasabi.xclaim.gui.ChunkEditor;
 import codes.wasabi.xclaim.gui.GUIHandler;
 import codes.wasabi.xclaim.gui.Page;
@@ -155,7 +158,14 @@ protected void onSelect(@NotNull OfflinePlayer ply) {
                 switchPage(new ClearAllPage(getParent()));
                 break;
             case DELETE_POS:
-                switchPage(new ClaimSelectorPage(getParent(), Claim::unclaim) {
+                switchPage(new ClaimSelectorPage(getParent(), (Claim c) -> {
+                    final Player ply = getTarget();
+                    if (!XClaimEvent.dispatch(new XClaimDeleteClaimEvent(ply, c))) {
+                        this.getParent().close();
+                        return;
+                    }
+                    c.unclaim();
+                }) {
                     @Override
                     protected boolean showClaim(@NotNull Claim claim, @NotNull OfflinePlayer ply) {
                         return claim.hasPermission(ply, Permission.DELETE);
diff --git a/src/main/java/codes/wasabi/xclaim/gui/page/NewClaimPage.java b/src/main/java/codes/wasabi/xclaim/gui/page/NewClaimPage.java
index 28e34e5..070a53f 100644
--- a/src/main/java/codes/wasabi/xclaim/gui/page/NewClaimPage.java
+++ b/src/main/java/codes/wasabi/xclaim/gui/page/NewClaimPage.java
@@ -3,6 +3,8 @@
 import codes.wasabi.xclaim.XClaim;
 import codes.wasabi.xclaim.api.Claim;
 import codes.wasabi.xclaim.api.XCPlayer;
+import codes.wasabi.xclaim.api.event.XClaimCreateClaimEvent;
+import codes.wasabi.xclaim.api.event.XClaimEvent;
 import codes.wasabi.xclaim.gui.ChunkEditor;
 import codes.wasabi.xclaim.gui.GUIHandler;
 import codes.wasabi.xclaim.gui.Page;
@@ -149,6 +151,7 @@ public void onClick(int slot) {
             }
             String name = XClaim.lang.get("new-claim") + " #" + nextIndex();
             Claim newClaim = new Claim(name, Collections.singleton(chunk), ply);
+            if (!XClaimEvent.dispatch(new XClaimCreateClaimEvent(ply, newClaim))) return;
             newClaim.claim();
             Platform.getAdventure().player(ply).sendMessage(XClaim.lang.getComponent("gui-new-success", name));
             ply.playSound(ply.getLocation(), Platform.get().getLevelSound(), 1f, 1f);
diff --git a/src/main/java/codes/wasabi/xclaim/gui/page/PermissionPage.java b/src/main/java/codes/wasabi/xclaim/gui/page/PermissionPage.java
index 6584b9a..7e762cd 100644
--- a/src/main/java/codes/wasabi/xclaim/gui/page/PermissionPage.java
+++ b/src/main/java/codes/wasabi/xclaim/gui/page/PermissionPage.java
@@ -5,6 +5,10 @@
 import codes.wasabi.xclaim.api.XCPlayer;
 import codes.wasabi.xclaim.api.enums.Permission;
 import codes.wasabi.xclaim.api.enums.TrustLevel;
+import codes.wasabi.xclaim.api.event.XClaimEvent;
+import codes.wasabi.xclaim.api.event.XClaimGrantUserPermissionEvent;
+import codes.wasabi.xclaim.api.event.XClaimRevokeUserPermissionEvent;
+import codes.wasabi.xclaim.api.event.XClaimSetPermissionEvent;
 import codes.wasabi.xclaim.gui.GUIHandler;
 import codes.wasabi.xclaim.gui.Page;
 import codes.wasabi.xclaim.platform.Platform;
@@ -294,6 +298,13 @@ public void onClick(int slot) {
                     default:
                         return;
                 }
+                if (!XClaimEvent.dispatch(new XClaimSetPermissionEvent(
+                        this.getTarget(),
+                        claim,
+                        modifyingPermission,
+                        claim.getPermission(modifyingPermission),
+                        set
+                ))) break;
                 claim.setPermission(modifyingPermission, set);
                 subPage = 1;
                 populate();
@@ -314,15 +325,31 @@ public void onClick(int slot) {
                 }
                 break;
             case 5:
+                boolean value;
                 if (slot == 11) {
-                    claim.setUserPermission(managingPlayer, modifyingPermission, true);
-                    subPage = 4;
-                    populate();
+                    value = true;
                 } else if (slot == 15) {
-                    claim.setUserPermission(managingPlayer, modifyingPermission, false);
-                    subPage = 4;
-                    populate();
+                    value = false;
+                } else {
+                    break;
                 }
+                if (!XClaimEvent.dispatch(value ?
+                        new XClaimGrantUserPermissionEvent(
+                                this.getTarget(),
+                                claim,
+                                modifyingPermission,
+                                XCPlayer.of(managingPlayer)
+                        ) :
+                        new XClaimRevokeUserPermissionEvent(
+                                this.getTarget(),
+                                claim,
+                                modifyingPermission,
+                                XCPlayer.of(managingPlayer)
+                        )
+                )) return;
+                claim.setUserPermission(managingPlayer, modifyingPermission, value);
+                subPage = 4;
+                populate();
                 break;
         }
     }
diff --git a/src/main/java/codes/wasabi/xclaim/gui/page/TransferPage.java b/src/main/java/codes/wasabi/xclaim/gui/page/TransferPage.java
index 4dbeee8..ca04c80 100644
--- a/src/main/java/codes/wasabi/xclaim/gui/page/TransferPage.java
+++ b/src/main/java/codes/wasabi/xclaim/gui/page/TransferPage.java
@@ -2,7 +2,10 @@
 
 import codes.wasabi.xclaim.XClaim;
 import codes.wasabi.xclaim.api.Claim;
+import codes.wasabi.xclaim.api.XCPlayer;
 import codes.wasabi.xclaim.api.enums.Permission;
+import codes.wasabi.xclaim.api.event.XClaimEvent;
+import codes.wasabi.xclaim.api.event.XClaimTransferOwnerEvent;
 import codes.wasabi.xclaim.gui.GUIHandler;
 import codes.wasabi.xclaim.gui.Page;
 import codes.wasabi.xclaim.platform.Platform;
@@ -95,6 +98,15 @@ public void onClick(int slot) {
         if (slot == 11) {
             if (matchPlayer != null) {
                 Player target = getTarget();
+                if (!XClaimEvent.dispatch(new XClaimTransferOwnerEvent(
+                        target,
+                        claim,
+                        claim.getOwner(),
+                        XCPlayer.of(matchPlayer)
+                ))) {
+                    getParent().close();
+                    return;
+                }
                 claim.setOwner(matchPlayer);
                 claim.setUserPermission(target, Permission.MANAGE, true);
                 Platform.getAdventure().player(target).sendMessage(XClaim.lang.getComponent("gui-tx-success"));
diff --git a/src/main/java/codes/wasabi/xclaim/map/MapService.java b/src/main/java/codes/wasabi/xclaim/map/MapService.java
index 1a7d18e..8f70ac7 100644
--- a/src/main/java/codes/wasabi/xclaim/map/MapService.java
+++ b/src/main/java/codes/wasabi/xclaim/map/MapService.java
@@ -12,7 +12,6 @@
 import org.jetbrains.annotations.Nullable;
 
 import java.util.Objects;
-import java.util.function.Consumer;
 
 public abstract class MapService {
 
@@ -63,8 +62,9 @@ protected MapService() throws MapServiceInitException {
 
     public abstract @Nullable MapMarker getMarker(@NotNull Claim claim);
 
-    public void getMarkerAsync(@NotNull Claim claim, @NotNull Consumer<@Nullable MapMarker> callback) {
-        callback.accept(this.getMarker(claim));
+    public void queueOperation(@NotNull MapServiceOp op) {
+        MapMarker marker = this.getMarker(op.getClaim());
+        if (marker != null) op.apply(marker);
     }
 
     public abstract void cleanup();
diff --git a/src/main/java/codes/wasabi/xclaim/map/MapServiceOp.java b/src/main/java/codes/wasabi/xclaim/map/MapServiceOp.java
new file mode 100644
index 0000000..9db94ac
--- /dev/null
+++ b/src/main/java/codes/wasabi/xclaim/map/MapServiceOp.java
@@ -0,0 +1,64 @@
+package codes.wasabi.xclaim.map;
+
+import codes.wasabi.xclaim.api.Claim;
+import org.jetbrains.annotations.NotNull;
+
+public interface MapServiceOp {
+
+    static @NotNull MapServiceOp update(@NotNull Claim claim) {
+        return new MapServiceOp.Update(claim);
+    }
+
+    static @NotNull MapServiceOp delete(@NotNull Claim claim) {
+        return new MapServiceOp.Delete(claim);
+    }
+
+    //
+
+    @NotNull Claim getClaim();
+
+    void apply(@NotNull MapMarker marker);
+
+    //
+
+    final class Update implements MapServiceOp {
+
+        private final Claim claim;
+        public Update(Claim claim) {
+            this.claim = claim;
+        }
+
+        @Override
+        public @NotNull Claim getClaim() {
+            return this.claim;
+        }
+
+        @Override
+        public void apply(@NotNull MapMarker marker) {
+            marker.update(this.claim);
+        }
+
+    }
+
+    //
+
+    final class Delete implements MapServiceOp {
+
+        private final Claim claim;
+        public Delete(Claim claim) {
+            this.claim = claim;
+        }
+
+        @Override
+        public @NotNull Claim getClaim() {
+            return this.claim;
+        }
+
+        @Override
+        public void apply(@NotNull MapMarker marker) {
+            marker.deleteMarker();
+        }
+
+    }
+
+}
diff --git a/src/main/java/codes/wasabi/xclaim/map/impl/bluemap/BluemapAPITracker.java b/src/main/java/codes/wasabi/xclaim/map/impl/bluemap/BluemapAPITracker.java
new file mode 100644
index 0000000..1b11bef
--- /dev/null
+++ b/src/main/java/codes/wasabi/xclaim/map/impl/bluemap/BluemapAPITracker.java
@@ -0,0 +1,85 @@
+package codes.wasabi.xclaim.map.impl.bluemap;
+
+import de.bluecolored.bluemap.api.BlueMapAPI;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.*;
+import java.util.concurrent.locks.StampedLock;
+import java.util.function.Consumer;
+
+class BluemapAPITracker {
+
+    private final StampedLock stateLock = new StampedLock();
+    private final LinkedList<Consumer<Object>> callbacks = new LinkedList<>();
+    private boolean ready;
+    private BlueMapAPI value;
+
+    public BluemapAPITracker() {
+        Optional<BlueMapAPI> current = BlueMapAPI.getInstance();
+        if (current.isPresent()) {
+            this.value = current.get();
+            this.ready = true;
+        } else {
+            this.value = null;
+            this.ready = false;
+            BlueMapAPI.onEnable(this::setValue);
+        }
+        BlueMapAPI.onDisable(this::clearValue);
+    }
+
+    public @Nullable BlueMapAPI get() {
+        long stamp = this.stateLock.readLock();
+        try {
+            return this.value;
+        } finally {
+            this.stateLock.unlock(stamp);
+        }
+    }
+
+    public void with(Consumer<Object> apiConsumer) {
+        long stamp = this.stateLock.readLock();
+        try {
+            if (this.ready) {
+                apiConsumer.accept(this.value);
+            } else {
+                stamp = this.stateLock.tryConvertToWriteLock(stamp);
+                this.callbacks.add(apiConsumer);
+            }
+        } finally {
+            this.stateLock.unlock(stamp);
+        }
+    }
+
+    protected void setValue(BlueMapAPI api) {
+        long stamp = this.stateLock.writeLock();
+        try {
+            final boolean wasReady = this.ready;
+            this.value = api;
+            this.ready = true;
+            if (wasReady) return;
+
+            final List<Consumer<Object>> callbacks = new ArrayList<>(this.callbacks);
+            this.callbacks.clear();
+            stamp = this.stateLock.tryConvertToReadLock(stamp);
+
+            for (Consumer<Object> callback : callbacks) {
+                callback.accept(api);
+            }
+        } finally {
+            this.stateLock.unlock(stamp);
+        }
+    }
+
+    protected void clearValue(BlueMapAPI api) {
+        long stamp = this.stateLock.readLock();
+        try {
+            if (!Objects.equals(api, this.value)) return;
+            stamp = this.stateLock.tryConvertToWriteLock(stamp);
+            this.value = null;
+            this.ready = false;
+        } finally {
+            this.stateLock.unlock(stamp);
+        }
+    }
+
+}
diff --git a/src/main/java/codes/wasabi/xclaim/map/impl/bluemap/BluemapMapMarker.java b/src/main/java/codes/wasabi/xclaim/map/impl/bluemap/BluemapMapMarker.java
index 8e0f673..646f3cd 100644
--- a/src/main/java/codes/wasabi/xclaim/map/impl/bluemap/BluemapMapMarker.java
+++ b/src/main/java/codes/wasabi/xclaim/map/impl/bluemap/BluemapMapMarker.java
@@ -52,7 +52,7 @@ public void update(@NotNull Claim claim) {
         ChunkBitmap bmp = new ChunkBitmap(claim.getChunks());
         List<List<Point>> edges = bmp.traceBlocks(true);
 
-        if (edges.size() < 1) return;
+        if (edges.isEmpty()) return;
 
         this.marker.setShape(
                 this.buildShapeFromPoints(edges.get(0)),
diff --git a/src/main/java/codes/wasabi/xclaim/map/impl/bluemap/BluemapMapService.java b/src/main/java/codes/wasabi/xclaim/map/impl/bluemap/BluemapMapService.java
index 0d6064a..0e25ea6 100644
--- a/src/main/java/codes/wasabi/xclaim/map/impl/bluemap/BluemapMapService.java
+++ b/src/main/java/codes/wasabi/xclaim/map/impl/bluemap/BluemapMapService.java
@@ -3,72 +3,57 @@
 import codes.wasabi.xclaim.api.Claim;
 import codes.wasabi.xclaim.map.MapMarker;
 import codes.wasabi.xclaim.map.MapService;
+import codes.wasabi.xclaim.map.MapServiceOp;
 import codes.wasabi.xclaim.map.exception.MapServiceInitException;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
+import java.lang.reflect.Constructor;
 import java.lang.reflect.Method;
-import java.util.Optional;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.ExecutionException;
 import java.util.function.Consumer;
 
 public class BluemapMapService extends MapService {
 
-    private final CompletableFuture<Object> apiInstanceFuture = new CompletableFuture<>();
+    private final Object tracker;
+    private final Method trackerGet;
+    private final Method trackerWith;
 
     public BluemapMapService() throws MapServiceInitException {
-        Class<?> apiClass = this.findClass("de.bluecolored.bluemap.api.BlueMapAPI", Object.class);
-        Object optionalObject;
+        Class<?> trackerClass = this.findClass("codes.wasabi.xclaim.map.impl.bluemap.BluemapAPITracker", Object.class);
+
+        Object tracker;
+        Method trackerGet;
+        Method trackerWith;
         try {
-            Method m = apiClass.getDeclaredMethod("getInstance");
-            optionalObject = m.invoke(null);
+            Constructor<?> con = trackerClass.getConstructor();
+            tracker = con.newInstance();
+            trackerGet = trackerClass.getMethod("get");
+            trackerWith = trackerClass.getMethod("with", Consumer.class);
         } catch (ReflectiveOperationException | SecurityException e) {
             throw new MapServiceInitException("Failed to get instance of BlueMap API");
         }
-        Optional<?> optional;
-        try {
-            optional = (Optional<?>) optionalObject;
-        } catch (ClassCastException e) {
-            throw new MapServiceInitException("BlueMap API gave an unexpected value");
-        }
-        if (optional.isPresent()) {
-            Object apiInstance = optional.get();
-            if (!apiClass.isInstance(apiInstance)) {
-                throw new MapServiceInitException(
-                        "BlueMap API gave an instance of class " +
-                        "\"" + apiInstance.getClass().getName() + "\"" +
-                        "that is not a subclass of \"" + apiClass.getName() + "\""
-                );
-            }
-            this.apiInstanceFuture.complete(apiInstance);
-        } else {
-            try {
-                de.bluecolored.bluemap.api.BlueMapAPI.onEnable(this.apiInstanceFuture::complete);
-            } catch (Exception e) {
-                throw new MapServiceInitException("Uncategorized exception while attaching enable listener to BlueMap API");
-            }
-        }
+
+        this.tracker = tracker;
+        this.trackerGet = trackerGet;
+        this.trackerWith = trackerWith;
     }
 
-    @Override
-    public @Nullable MapMarker getMarker(@NotNull Claim claim) {
+    private Object getInstanceNow() {
+        Object instance;
         try {
-            return this.getMarker(claim, this.apiInstanceFuture.get());
-        } catch (ExecutionException | InterruptedException e) {
+            instance = this.trackerGet.invoke(this.tracker);
+        } catch (ReflectiveOperationException | SecurityException e) {
             throw new IllegalStateException(e);
         }
+        return instance;
     }
 
     @Override
-    public void getMarkerAsync(@NotNull Claim claim, @NotNull Consumer<@Nullable MapMarker> callback) {
-        if (this.apiInstanceFuture.isDone()) {
-            callback.accept(this.getMarker(claim));
-            return;
-        }
-        this.apiInstanceFuture.whenCompleteAsync((Object instance, Throwable t) -> {
-            if (instance != null) callback.accept(this.getMarker(claim, instance));
-        });
+    public @Nullable MapMarker getMarker(@NotNull Claim claim) {
+        Object instance = this.getInstanceNow();
+        if (instance == null) return null;
+
+        return this.getMarker(claim, instance);
     }
 
     private @Nullable MapMarker getMarker(@NotNull Claim claim, @NotNull Object instance) {
@@ -82,14 +67,23 @@ public void getMarkerAsync(@NotNull Claim claim, @NotNull Consumer<@Nullable Map
     }
 
     @Override
-    public void cleanup() {
-        Object instance;
+    public void queueOperation(@NotNull MapServiceOp op) {
+        Consumer<Object> action = o -> {
+            MapMarker marker = BluemapMapService.this.getMarker(op.getClaim(), o);
+            if (marker == null) return;
+            op.apply(marker);
+        };
         try {
-            instance = this.apiInstanceFuture.getNow(null);
-            if (instance == null) return;
-        } catch (Exception ignored) {
-            return;
+            this.trackerWith.invoke(this.tracker, action);
+        } catch (ReflectiveOperationException | SecurityException e) {
+            throw new IllegalStateException(e);
         }
+    }
+
+    @Override
+    public void cleanup() {
+        Object instance = this.getInstanceNow();
+        if (instance == null) return;
 
         try {
             Class.forName("codes.wasabi.xclaim.map.impl.bluemap.BluemapMapMarker")
diff --git a/src/main/java/codes/wasabi/xclaim/map/util/ArrayBitmap.java b/src/main/java/codes/wasabi/xclaim/map/util/ArrayBitmap.java
index f7f0312..eb5bb41 100644
--- a/src/main/java/codes/wasabi/xclaim/map/util/ArrayBitmap.java
+++ b/src/main/java/codes/wasabi/xclaim/map/util/ArrayBitmap.java
@@ -1,24 +1,30 @@
 package codes.wasabi.xclaim.map.util;
 
+import org.jetbrains.annotations.Nullable;
+
 public class ArrayBitmap implements Bitmap {
 
-    private boolean[][] array;
-    private int width;
-    private int height;
-    public ArrayBitmap(boolean[][] array) {
-        setArray(array);
-    }
+    private static final byte FULL_BYTE = (byte) 0xFF;
+
+    private final byte[] data;
+    private final int width;
+    private final int height;
 
-    public boolean[][] getArray() {
-        return array.clone();
+    protected ArrayBitmap(byte[] data, int width, int height) {
+        this.data = data;
+        this.width = width;
+        this.height = height;
     }
 
-    public void setArray(boolean[][] array) {
-        this.array = array;
-        height = array.length;
-        int w = 0;
-        for (boolean[] a: array) w = Math.max(w, a.length);
-        width = w;
+    public ArrayBitmap(int width, int height) throws IllegalArgumentException {
+        if (width < 0) throw new IllegalArgumentException("Width cannot be negative");
+        if (height < 0) throw new IllegalArgumentException("Height cannot be negative");
+
+        final int bytes = (int) ((((((long) width) * ((long) height)) - 1L) >> 3L) + 1L);
+
+        this.data = new byte[bytes];
+        this.width = width;
+        this.height = height;
     }
 
     @Override
@@ -33,10 +39,70 @@ public int getHeight() {
 
     @Override
     public boolean getPixel(int x, int y) {
-        if (y < 0 || y >= height) return false;
-        boolean[] row = array[y];
-        if (x < 0 || x >= row.length) return false;
-        return row[x];
+        if (x < 0 || x >= this.width) return false;
+        if (y < 0 || y >= this.height) return false;
+
+        final int index = (y * this.width) + x;
+        final int byteIndex = index >> 3;
+        final byte flag = (byte) (1 << (index & 7));
+
+        return (this.data[byteIndex] & flag) == flag;
+    }
+
+    public void setPixel(int x, int y) {
+        this.setPixel(x, y, true);
+    }
+
+    public void setPixel(int x, int y, boolean value) {
+        if (x < 0 || x >= this.width)
+            throw new IndexOutOfBoundsException("X " + x + " out of bounds for width " + this.width);
+        if (y < 0 || y >= this.height)
+            throw new IndexOutOfBoundsException("Y " + x + " out of bounds for height " + this.height);
+
+        final int index = (y * this.width) + x;
+        final int byteIndex = index >> 3;
+        final int flag = 1 << (index & 7);
+
+        if (value) {
+            this.data[byteIndex] |= ((byte) flag);
+        } else {
+            this.data[byteIndex] &= ((byte) (~flag));
+        }
+    }
+
+    public @Nullable Point firstUnset() {
+        byte b = 0;
+        int bIndex = -1;
+
+        for (int i=0; i < this.data.length; i++) {
+            b = this.data[i];
+            if (b == FULL_BYTE) continue;
+            bIndex = i;
+            break;
+        }
+
+        if (bIndex == -1) return null;
+        bIndex <<= 3;
+
+        final int ib = b & 0xFF;
+        if (ib != 0) {
+            final int startBit = Integer.numberOfTrailingZeros(~ib);
+            final int endBit = 32 - Integer.numberOfLeadingZeros(ib);
+
+            int flag;
+            for (int z = startBit; z <= endBit; z++) {
+                flag = (1 << z);
+                if ((ib & flag) == 0) {
+                    bIndex |= z;
+                    break;
+                }
+            }
+        }
+
+        final int y = Math.floorDiv(bIndex, this.width);
+        final int x = bIndex - (y * this.width);
+
+        return new Point(x, y);
     }
 
 }
diff --git a/src/main/java/codes/wasabi/xclaim/map/util/Bitmap.java b/src/main/java/codes/wasabi/xclaim/map/util/Bitmap.java
index 14dda5d..fee7b89 100644
--- a/src/main/java/codes/wasabi/xclaim/map/util/Bitmap.java
+++ b/src/main/java/codes/wasabi/xclaim/map/util/Bitmap.java
@@ -48,53 +48,28 @@ default List<Point> trace() {
      * @return The list of edges
      */
     default List<List<Point>> trace(boolean includeAll) {
-        List<Line> lines = new CopyOnWriteArrayList<>();
-        for (int x = 0; x < getWidth(); x++) {
-            for (int y = 0; y < getHeight(); y++) {
-                boolean value = getPixel(x, y);
-                if (value) {
-                    if (!getPixel(x - 1, y)) lines.add(Line.of( x, y, x, y + 1 ));
-                    if (!getPixel(x, y - 1)) lines.add(Line.of( x, y, x + 1, y ));
-                    if (!getPixel(x + 1, y)) lines.add(Line.of( x + 1, y, x + 1, y + 1 ));
-                    if (!getPixel(x, y + 1)) lines.add(Line.of( x, y + 1, x + 1, y + 1 ));
-                }
-            }
-        }
-        List<List<Point>> ret = new ArrayList<>();
-        while (lines.size() > 0) {
-            Line root = lines.remove(0);
-            List<Point> path = new ArrayList<>();
-            Point head = root.a();
-            Point tail = root.b();
-            path.add(head);
-            path.add(tail);
-            while (true) {
-                boolean anyAction = false;
-                for (Line l : lines) {
-                    Point lhead = l.a();
-                    Point ltail = l.b();
-                    if (lhead.equals(tail)) {
-                        path.add(ltail);
-                        tail = ltail;
-                        lines.remove(l);
-                        anyAction = true;
-                    } else if (ltail.equals(tail)) {
-                        path.add(lhead);
-                        tail = lhead;
-                        lines.remove(l);
-                        anyAction = true;
-                    }
+        BitmapTracer tracer = new BitmapTracer(this);
+        List<List<Point>> ret = tracer.poll();
+        if (ret == null) return Collections.emptyList();
+
+        if (includeAll) {
+            ret.sort(Comparator.comparingInt((List<Point> l) -> l.size()).reversed());
+
+            return ret;
+        } else {
+            List<Point> longest = null;
+            int longestSize = 0;
+
+            int candidateSize;
+            for (List<Point> candidate : ret) {
+                if ((candidateSize = candidate.size()) > longestSize) {
+                    longest = candidate;
+                    longestSize = candidateSize;
                 }
-                if (!anyAction) break;
-            }
-            if (includeAll || ret.size() < 1) {
-                ret.add(path);
-            } else if (ret.get(0).size() <= path.size()) {
-                ret.set(0, path);
             }
+
+            return (longest == null) ? Collections.emptyList() : Collections.singletonList(longest);
         }
-        if (includeAll) ret.sort(Comparator.comparingInt((List<Point> l) -> l.size()).reversed());
-        return ret;
     }
 
 }
diff --git a/src/main/java/codes/wasabi/xclaim/map/util/BitmapTracer.java b/src/main/java/codes/wasabi/xclaim/map/util/BitmapTracer.java
new file mode 100644
index 0000000..cce09da
--- /dev/null
+++ b/src/main/java/codes/wasabi/xclaim/map/util/BitmapTracer.java
@@ -0,0 +1,220 @@
+package codes.wasabi.xclaim.map.util;
+
+import it.unimi.dsi.fastutil.ints.*;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.*;
+
+/**
+ * I ported this from another, much more recent project of mine
+ * https://github.com/WasabiThumb/enqr/blob/master/src/renderer/impl/svg.ts#L244
+ */
+public class BitmapTracer {
+
+    private final Bitmap bitmap;
+    private final ArrayBitmap traversed;
+
+    public BitmapTracer(@NotNull Bitmap bitmap) {
+        this.bitmap = bitmap;
+        this.traversed = new ArrayBitmap(bitmap.getWidth(), bitmap.getHeight());
+        for (int y=0; y < bitmap.getHeight(); y++) {
+            for (int x=0; x < bitmap.getWidth(); x++) {
+                if (!bitmap.getPixel(x, y)) this.traversed.setPixel(x, y);
+            }
+        }
+    }
+
+    public @Nullable List<List<Point>> poll() {
+        List<Line> lines = this.pollLines();
+        if (lines == null) return null;
+
+        final LineGroup lineGroup = new LineGroup(lines, this.bitmap.getWidth());
+
+        final List<List<Point>> paths = new ArrayList<>(1);
+        List<Point> path;
+        while ((path = lineGroup.popLoopAsPoints()) != null) paths.add(Collections.unmodifiableList(path));
+
+        return paths;
+    }
+
+    private @Nullable List<Line> pollLines() {
+        Point coord = this.pollUnprocessed();
+        if (coord == null) return null;
+
+        List<Line> ret = new ArrayList<>(4);
+        this.pullLines(coord.x(), coord.y(), ret);
+        return ret;
+    }
+
+    private void pullLines(int x, int y, List<Line> lines) {
+        if (this.traversed.getPixel(x, y)) return;
+        this.traversed.setPixel(x, y);
+
+        Line[] identity = new Line[4];
+        int identityCount = 0;
+
+        int nx;
+        int ny = y;
+
+        nx = x - 1;
+        if (this.bitmap.getPixel(nx, ny)) {
+            this.pullLines(nx, ny, lines);
+        } else {
+            identity[identityCount++] = new Line(x, y + 1, x, y, Line.Direction.LEFT);
+        }
+
+        nx = x + 1;
+        if (this.bitmap.getPixel(nx, ny)) {
+            this.pullLines(nx, ny, lines);
+        } else {
+            identity[identityCount++] = new Line(x + 1, y, x + 1, y + 1, Line.Direction.RIGHT);
+        }
+
+        nx = x;
+        ny = y - 1;
+        if (this.bitmap.getPixel(nx, ny)) {
+            this.pullLines(nx, ny, lines);
+        } else {
+            identity[identityCount++] = new Line(x, y, x + 1, y, Line.Direction.UP);
+        }
+
+        ny = y + 1;
+        if (this.bitmap.getPixel(nx, ny)) {
+            this.pullLines(nx, ny, lines);
+        } else {
+            identity[identityCount++] = new Line(x + 1, y + 1, x, y + 1, Line.Direction.DOWN);
+        }
+
+        if (identityCount != 0) {
+            lines.addAll(Arrays.asList(identity).subList(0, identityCount));
+        }
+    }
+
+    private @Nullable Point pollUnprocessed() {
+        return this.traversed.firstUnset();
+    }
+
+    //
+
+    private static class Line extends codes.wasabi.xclaim.map.util.Line {
+
+        private final Direction direction;
+        Line(Point a, Point b, Direction direction) {
+            super(a, b);
+            this.direction = direction;
+        }
+
+        Line(int ax, int ay, int bx, int by, Direction direction) {
+            this(new Point(ax, ay), new Point(bx, by), direction);
+        }
+
+        enum Direction {
+            RESERVED,
+            LEFT,
+            RIGHT,
+            UP,
+            DOWN
+        }
+
+    }
+
+    private static class LineGroup {
+
+        private final List<Line> lines;
+        private final int width;
+        private final boolean[] traversed;
+        private final Int2ObjectMap<IntList> starts;
+        LineGroup(List<Line> lines, int width) {
+            // This fixes ID collision, don't @ me
+            width <<= 2;
+
+            this.lines = lines;
+            this.width = width;
+            this.traversed = new boolean[lines.size()];
+            this.starts = new Int2ObjectLinkedOpenHashMap<>();
+
+            Point start;
+            for (int i=0; i < lines.size(); i++) {
+                start = lines.get(i).a();
+                int index = (start.y() * width) + start.x();
+                this.starts.computeIfAbsent(index, (int ignored) -> new IntArrayList(1)).add(i);
+            }
+        }
+
+        public @Nullable List<Point> popLoopAsPoints() {
+            final List<Line> lines = this.popLoop();
+            if (lines == null) return null;
+            final int size = lines.size();
+
+            return new AbstractList<Point>() {
+                @Override
+                public Point get(int i) {
+                    return lines.get(i).a();
+                }
+
+                @Override
+                public int size() {
+                    return size;
+                }
+            };
+        }
+
+        @Nullable List<Line> popLoop() {
+            int startIndex = -1;
+            for (int i=0; i < this.traversed.length; i++) {
+                if (!this.traversed[i]) {
+                    startIndex = i;
+                    break;
+                }
+            }
+            if (startIndex == -1) return null;
+            this.traversed[startIndex] = true;
+
+            Line.Direction lastDirection = Line.Direction.RESERVED;
+            Line cur = this.lines.get(startIndex);
+            List<Line> ret = new ArrayList<>(this.traversed.length - startIndex);
+
+            int nextIndex;
+            Line next;
+            while (true) {
+                IntList starting = this.getStartingAt(cur.b().x(), cur.b().y());
+                if (starting.size() == 0) break;
+
+                nextIndex = starting.getInt(0);
+                if (nextIndex == startIndex) break;
+                next = this.lines.get(nextIndex);
+                this.traversed[nextIndex] = true;
+
+                if (cur.direction != lastDirection) {
+                    ret.add(cur);
+                    lastDirection = cur.direction;
+                }
+                cur = next;
+            }
+
+            if (cur.direction != lastDirection) ret.add(cur);
+            return ret;
+        }
+
+        private @NotNull IntList getStartingAt(int x, int y) {
+            final int index = (y * this.width) + x;
+            final IntList allStarts = this.starts.get(index);
+            if (allStarts == null) return IntLists.emptyList();
+
+            final int count = allStarts.size();
+            final IntList nonTraversedStarts = new IntArrayList(count);
+
+            int start;
+            for (int i=0; i < count; i++) {
+                start = allStarts.getInt(i);
+                if (this.traversed[start]) continue;
+                nonTraversedStarts.add(start);
+            }
+
+            return nonTraversedStarts;
+        }
+
+    }
+
+}
diff --git a/src/main/java/codes/wasabi/xclaim/map/util/ChunkBitmap.java b/src/main/java/codes/wasabi/xclaim/map/util/ChunkBitmap.java
index e86c2bc..9c936c4 100644
--- a/src/main/java/codes/wasabi/xclaim/map/util/ChunkBitmap.java
+++ b/src/main/java/codes/wasabi/xclaim/map/util/ChunkBitmap.java
@@ -2,10 +2,11 @@
 
 import codes.wasabi.xclaim.platform.Platform;
 import codes.wasabi.xclaim.util.ChunkReference;
-import org.bukkit.Chunk;
+import it.unimi.dsi.fastutil.longs.LongLinkedOpenHashSet;
+import it.unimi.dsi.fastutil.longs.LongSet;
+import it.unimi.dsi.fastutil.longs.LongSets;
 import org.bukkit.Location;
 import org.bukkit.World;
-import org.bukkit.block.Block;
 import org.jetbrains.annotations.NotNull;
 
 import java.util.*;
@@ -20,13 +21,9 @@ public class ChunkBitmap implements Bitmap {
     private int width;
     private int height;
     private World world;
-    private final Set<Long> indices = new HashSet<>();
+    private LongSet indices;
     public ChunkBitmap() {
-        originX = 0;
-        originZ = 0;
-        width = 0;
-        height = 0;
-        world = null;
+        clear();
     }
 
     public ChunkBitmap(@NotNull Collection<ChunkReference> chunks) {
@@ -37,15 +34,22 @@ public ChunkBitmap(@NotNull ChunkReference @NotNull ... chunks) {
         setChunks(Arrays.asList(chunks));
     }
 
+    public void clear() {
+        originX = 0;
+        originZ = 0;
+        width = 0;
+        height = 0;
+        world = null;
+        indices = LongSets.emptySet();
+    }
+
     public void setChunks(@NotNull Collection<ChunkReference> chunks) {
-        indices.clear();
-        if (chunks.size() == 0) {
-            originX = 0;
-            originZ = 0;
-            width = 0;
-            height = 0;
-            world = null;
+        final int size = chunks.size();
+        if (size == 0) {
+            clear();
         } else {
+            indices = new LongLinkedOpenHashSet(size);
+
             int xMin = Integer.MAX_VALUE;
             int zMin = Integer.MAX_VALUE;
             int xMax = Integer.MIN_VALUE;
@@ -57,12 +61,14 @@ public void setChunks(@NotNull Collection<ChunkReference> chunks) {
                 zMin = Math.min(zMin, c.z);
                 zMax = Math.max(zMax, c.z);
             }
+
             ChunkReference originChunk = new ChunkReference(world, xMin, zMin);
             Location originBlock = originChunk.getLocation(0, Platform.get().getWorldMinHeight(world), 0);
             originX = originBlock.getBlockX();
             originZ = originBlock.getBlockZ();
             width = xMax - xMin + 1;
             height = zMax - zMin + 1;
+
             for (ChunkReference c : chunks) {
                 indices.add(intToLong(c.x - xMin, c.z - zMin));
             }
@@ -89,7 +95,10 @@ public boolean getPixel(int x, int y) {
     }
 
     private List<Point> transformPoints(List<Point> points) {
-        return points.stream().map((Point p) -> p.product(16).sum(originX, originZ)).collect(Collectors.toCollection(ArrayList::new));
+        final int size = points.size();
+        Point[] transformed = new Point[size];
+        for (int i=0; i < size; i++) transformed[i] = points.get(i).product(16).sum(originX, originZ);
+        return Arrays.asList(transformed);
     }
 
     public List<Point> traceBlocks() {
diff --git a/src/main/java/codes/wasabi/xclaim/map/util/Line.java b/src/main/java/codes/wasabi/xclaim/map/util/Line.java
index 6e63fe6..a33c0c5 100644
--- a/src/main/java/codes/wasabi/xclaim/map/util/Line.java
+++ b/src/main/java/codes/wasabi/xclaim/map/util/Line.java
@@ -43,7 +43,7 @@ public boolean equals(Object obj) {
 
     @Override
     public String toString() {
-        return "Line[a=" + a + ",b=" + b + "]";
+        return "{" + this.a + " -> " + this.b + "}";
     }
 
 }
diff --git a/src/main/java/codes/wasabi/xclaim/map/util/Point.java b/src/main/java/codes/wasabi/xclaim/map/util/Point.java
index 1e4fcef..6d01015 100644
--- a/src/main/java/codes/wasabi/xclaim/map/util/Point.java
+++ b/src/main/java/codes/wasabi/xclaim/map/util/Point.java
@@ -3,8 +3,6 @@
 import org.jetbrains.annotations.Contract;
 import org.jetbrains.annotations.NotNull;
 
-import java.util.Objects;
-
 public class Point implements Comparable<Point> {
 
     private final int x;
@@ -45,7 +43,7 @@ public int compareTo(@NotNull Point other) {
 
     @Override
     public int hashCode() {
-        return Objects.hash(x, y);
+        return 31 * (31 + this.x) + this.y;
     }
 
     @Override
@@ -65,7 +63,7 @@ public boolean equals(Object obj) {
 
     @Override
     public String toString() {
-        return "Point[x=" + x + ",y=" + y + "]";
+        return "(" + x + ", " + y + ")";
     }
 
 }
diff --git a/src/main/java/codes/wasabi/xclaim/util/AttributeUtil.java b/src/main/java/codes/wasabi/xclaim/util/AttributeUtil.java
new file mode 100644
index 0000000..ea4289c
--- /dev/null
+++ b/src/main/java/codes/wasabi/xclaim/util/AttributeUtil.java
@@ -0,0 +1,124 @@
+package codes.wasabi.xclaim.util;
+
+import com.google.common.collect.Multimap;
+import org.bukkit.Material;
+import org.bukkit.attribute.Attribute;
+import org.bukkit.attribute.AttributeModifier;
+import org.bukkit.enchantments.Enchantment;
+import org.bukkit.inventory.EquipmentSlot;
+import org.bukkit.inventory.ItemStack;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Collection;
+import java.util.Locale;
+import java.util.Map;
+
+public final class AttributeUtil {
+
+    public static double scaleDamage(
+            double damage,
+            @Nullable ItemStack boots,
+            @Nullable ItemStack leggings,
+            @Nullable ItemStack chestplate,
+            @Nullable ItemStack helmet
+    ) {
+        damage = scaleDamage(damage, boots, EquipmentSlot.FEET, 3);
+        damage = scaleDamage(damage, leggings, EquipmentSlot.LEGS, 2);
+        damage = scaleDamage(damage, chestplate, EquipmentSlot.CHEST, 1);
+        damage = scaleDamage(damage, helmet, EquipmentSlot.HEAD, 0);
+        return damage;
+    }
+
+    private static final double[][] ARMOR_TABLE = new double[][] {
+            new double[] { 1d, 3d, 2d, 1d }, // LEATHER
+            new double[] { 2d, 5d, 3d, 1d }, // GOLDEN
+            new double[] { 2d, 5d, 4d, 1d }, // CHAINMAIL
+            new double[] { 2d, 6d, 5d, 2d }, // IRON
+            new double[] { 3d, 8d, 6d, 3d }, // DIAMOND & NETHERITE
+    };
+
+    private static double scaleDamage(double damage, @Nullable ItemStack item, @NotNull EquipmentSlot slot, int slotCode) {
+        if (item == null) return damage;
+        if (item.getAmount() < 1) return damage;
+        Material type = item.getType();
+        if (!type.isItem()) return damage;
+
+        String armorType = type.name().toUpperCase(Locale.ROOT);
+        int temp = armorType.indexOf('_');
+        if (temp != -1) armorType = armorType.substring(0, temp);
+
+        double armor = 0d;
+        double toughness = 0d;
+        switch (armorType) {
+            case "TURTLE":
+                armor = 2d;
+                break;
+            case "LEATHER":
+                armor = ARMOR_TABLE[0][slotCode];
+                break;
+            case "GOLDEN":
+                armor = ARMOR_TABLE[1][slotCode];
+                break;
+            case "CHAINMAIL":
+                armor = ARMOR_TABLE[2][slotCode];
+                break;
+            case "IRON":
+                armor = ARMOR_TABLE[3][slotCode];
+                break;
+            case "DIAMOND":
+                armor = ARMOR_TABLE[4][slotCode];
+                toughness = 2d;
+                break;
+            case "NETHERITE":
+                armor = ARMOR_TABLE[4][slotCode];
+                toughness = 3d;
+                break;
+        }
+        armor = scaleByAttributes(armor, type, slot, Attribute.GENERIC_ARMOR);
+        toughness = scaleByAttributes(toughness, type, slot, Attribute.GENERIC_ARMOR_TOUGHNESS);
+
+        double modification = armor - ((4d * damage) / (toughness + 8d));
+        modification = Math.min(20d, Math.max(armor / 5d, modification));
+        modification = 1d - (modification / 25d);
+        damage *= modification;
+
+        // Enchants (Protection)
+        Map<Enchantment, Integer> enchants = item.getEnchantments();
+        Integer protectionLevel = enchants.get(Enchantment.PROTECTION_ENVIRONMENTAL);
+        if (protectionLevel != null && protectionLevel > 0) {
+            damage *= (1d - (protectionLevel * 0.04d));
+        }
+
+        return damage;
+    }
+
+    private static double scaleByAttributes(
+            double value,
+            @NotNull Material type,
+            @NotNull EquipmentSlot slot,
+            @NotNull Attribute attribute
+    ) {
+        Multimap<Attribute, AttributeModifier> allModifiers = type.getDefaultAttributeModifiers(slot);
+        if (allModifiers.isEmpty()) return value;
+        Collection<AttributeModifier> modifier = allModifiers.get(attribute);
+        if (modifier.isEmpty()) return value;
+
+        for (AttributeModifier am : modifier) {
+            switch (am.getOperation()) {
+                case ADD_NUMBER:
+                    value += am.getAmount();
+                    break;
+                case ADD_SCALAR:
+                    value += (am.getAmount() * value);
+                    break;
+                case MULTIPLY_SCALAR_1:
+                    value *= (am.getAmount() + 1);
+                    break;
+            }
+        }
+
+        return value;
+    }
+
+}
diff --git a/src/main/resources/lang/en-US.json b/src/main/resources/lang/en-US.json
index 99bcdd4..b4e55e4 100644
--- a/src/main/resources/lang/en-US.json
+++ b/src/main/resources/lang/en-US.json
@@ -334,5 +334,25 @@
   "move-exit": "<white>Leaving <green>$1</green></white>",
   "grace-alert": "<red><dark_red>WARNING</dark_red>: You have <dark_red>$1</dark_red> claims in blacklisted worlds that will be removed soon</red>",
   "grace-remove": "<red>Your claim named <dark_red>$1</dark_red> was removed due to being in a blacklisted world</red>",
+  "event-fail-create-claim": "<red>* You cannot create a claim at this time.</red>",
+  "event-fail-create-claim-single": "<red>* Cannot create this claim ($1)</red>",
+  "event-fail-delete-claim": "<red>* You cannot delete a claim at this time.</red>",
+  "event-fail-delete-claim-single": "<red>* Cannot delete this claim ($1)</red>",
+  "event-fail-add-chunks": "<red>* You cannot add chunks to a claim at this time.</red>",
+  "event-fail-add-chunks-single": "<red>* Cannot add chunks to this claim ($1)</red>",
+  "event-fail-add-chunk": "<red>* You cannot add a chunk to a claim at this time.</red>",
+  "event-fail-add-chunk-single": "<red>* Cannot add a chunk to this claim ($1)</red>",
+  "event-fail-remove-chunks": "<red>* You cannot remove chunks from a claim at this time.</red>",
+  "event-fail-remove-chunks-single": "<red>* Cannot remove chunks from this claim ($1)</red>",
+  "event-fail-remove-chunk": "<red>* You cannot remove a chunk from a claim at this time.</red>",
+  "event-fail-remove-chunk-single": "<red>* Cannot remove a chunk from this claim ($1)</red>",
+  "event-fail-transfer-owner": "<red>* You cannot transfer the claim owner at this time.</red>",
+  "event-fail-transfer-owner-single": "<red>* Cannot transfer this claim's owner ($1)</red>",
+  "event-fail-set-permission": "<red>* You cannot set this permission on the claim at this time.</red>",
+  "event-fail-set-permission-single": "<red>* Cannot set permission on this claim ($1)</red>",
+  "event-fail-grant-user-permission": "<red>* You cannot grant a user permission at this time.</red>",
+  "event-fail-grant-user-permission-single": "<red>* Cannot grant user permission on this claim ($1)</red>",
+  "event-fail-revoke-user-permission": "<red>* You cannot revoke a user permission at this time.</red>",
+  "event-fail-revoke-user-permission-single": "<red>* Cannot revoke user permission on this claim ($1)</red>",
   "unknown": "Unknown"
 }
\ No newline at end of file
diff --git a/src/main/resources/lang/tr.json b/src/main/resources/lang/tr.json
new file mode 100644
index 0000000..0bc1209
--- /dev/null
+++ b/src/main/resources/lang/tr.json
@@ -0,0 +1,358 @@
+{
+  "startup-done": "Tamamlandı",
+  "disable-done": "Tamamlandı",
+  "new-claim": "Yeni alan",
+  "data-folder-created": "Veri klasörü oluşturuldu.",
+  "locating-jar": "JAR dosyasının yeri belirleniyor.",
+  "ext-dl": "Gerekli kitaplıklar çekiliyor...",
+  "update-available-line1": "<yellow><b><gold>(!)</gold></b> XClaim için bir güncelleme mevcut (<white>$1</white>)!</yellow>",
+  "update-available-line2": "<yellow><b><gold>(!)</gold></b> Otomatik olarak güncellemek için <click:run_command:'/xc update'><white>/xc update</white></click> kullanabilirsin.</yellow>",
+  "dynmap-check": "Dynmap kontrol ediliyor",
+  "dynmap-warn-core": "Dynmap doğrulanamadı, yine de devam ediliyor...", 
+  "dynmap-hooked": "Dynmap'in $1 sürümüne bağlanıldı",
+  "dynmap-marker-name": "Alanlar",
+  "eco-fail": "Uygun ekonomi plugini bulunamadı",
+  "trust-load": "Güvenilir oyuncular yükleniyor",
+  "trust-load-err": "Güvenilir oyuncuları yüklerken bir hata belirdi. Detaylarına aşağıdan bakabilirsiniz.",
+  "claims-load": "Alanlar yükleniyor",
+  "claims-load-err": "Alanlar yüklenirken bir hata belirdi. Detaylarını aşağıdan bakabilirsiniz.",
+  "claims-unpack": "Claimler açılıyor",
+  "claims-unpack-err": "Alan \"$1\" bozulmuş halde. (Sebebi ise: $2). Atlanıyor...",
+  "claims-unpack-err-section": "Bir bölüm değil",
+  "services-chunk-editor": "Alan düzenleyicisi başlatılıyor",
+  "services-command": "Komut yöneticisi başlatılıyor",
+  "services-command-register": "Varsayılan komutlar kayıta geçiriliyor",
+  "services-movement": "Movement rutini başlatılıyor",
+  "services-grace": "Grace rutini başlatılıyor",
+  "trust-save": "Güvenilir oyuncular kaydediliyor.",
+  "trust-save-new": "Yeni trust.yml oluşturuldu",
+  "trust-save-err": "Güvenilir oyuncuları kaydederken bir sorun oluştu. Detaylarını aşağıdan bakabilirsiniz.",
+  "claims-save": "Alanlar kaydediliyor",
+  "claims-save-new": "Yeni claims.yml oluşturuldu",
+  "claims-save-err": "Alanlar kaydedilirken bir sorun oluştu. Detaylarını aşağıdan bakabilirsiniz.",
+  "services-stop": "Durduruluyor",
+  "chunk-editor-taken": "<red>* Bu alan zaten alınmış!</red>",
+  "chunk-editor-wrong-world": "<red>* Bu dünyadaki chunklardan yeni alan elde edemezsin!</red>",
+  "chunk-editor-protection-deny": "<red>* Bir bölge koruma plugini seni bu chunkda alan oluşturmanı engelliyor!</red>", 
+  "chunk-editor-min-distance-deny": "<red>* Yetkin olmayan bir alana bu kadar yakın şekilde başka bir alan oluşturamazsın!</red>",
+  "chunk-editor-adjacent": "<red>* Seçtiğin chunklar alanınla dipdibe olmalı!</red>",
+  "chunk-editor-max": "<red>* Maksimum chunk sınırına ulaştın. Belki de birazını silmeyi denemelisin?</red>",
+  "chunk-editor-add": "<b><gold>X</gold></b><white>=$1, </white><b><gold>Z</gold></b><white>=$2</white> <green>* koordinatlarında yeni alan oluşturuldu.</green>",
+  "chunk-editor-redundant-add": "<yellow>* Bu chunk zaten alanın içinde.</yellow>",
+  "chunk-editor-remove": "<green>Chunk artık sahipsiz!</green>",
+  "chunk-editor-redundant-remove": "<yellow>* Bu chunk halihazırda zaten alanın bir parçası değildi.</yellow>",
+  "chunk-editor-info": "<gold>= Chunk'ın bulunduğu yer $1, $2 =</gold>",
+  "chunk-editor-info-open": "Açık",
+  "chunk-editor-info-claimed": "Alınmış",
+  "chunk-editor-info-owned": "Sahip olduğun başka bir alanda",
+  "chunk-editor-info-taken": "$1 tarafından alınmış",
+  "chunk-editor-claim": "<green>Alanı sahiplen</green>",
+  "chunk-editor-unclaim": "<red>Alanı serbest bırak</red>",
+  "chunk-editor-quit": "<dark_red>Çık</dark_red>",
+  "chunk-editor-cant-afford": "<red>* Bu chunk'ı alabilmek için <gold>$1</gold> lazım!</red>",
+  "chunk-editor-pay-fail": "<red>* Hesabından <gold>$1</gold> kesilemedi.</red>",
+  "chunk-editor-pay-success": "<green>* Bu chunk için <gold>$1</gold> kadar ödenildi.</green>",
+  "chunk-editor-reward": "<green>* Bu chunk'ı bıraktığın için <gold>$1</gold> kadar kazandın!</green>",
+  "permHandler-stdError": "<b><red>Hey!</red></b> <gray>Bunu burada yapamazsın.</gray>",
+  "perm-build-name": "Yapı yapmak",
+  "perm-build-description": "Blok koyabilmek",
+  "perm-break-name": "Kırmak",
+  "perm-break-description": "Blok kırabilmek",
+  "perm-enter-name": "Giriş",
+  "perm-enter-description": "Alana yürüyebilmek",
+  "perm-interact-name": "Etkileşim",
+  "perm-interact-description": "Sandık, buton vs. gibi şeylerle etkileşime girebilmek",
+  "perm-chest-open-name": "Sandıkları açmak",
+  "perm-chest-open-description": "Sandıklarla etkileşime girmek eğer genel etkileşimlere bakmak istiyorsanız Etkileşim'e bakın.",
+  "perm-ent-place-name": "Varlık yerleştirmek",
+  "perm-ent-place-description": "Bot, vagon, zırh standı gibi şeyleri koyabilmek yetkisi",
+  "perm-vehicle-place-name": "Araç yerleştirmek",
+  "perm-vehicle-place-description": "Vagon gibi araçlaro yerleştirebilmek",
+  "perm-fire-use-name": "Yakıcı madde kullanımı",
+  "perm-fire-use-description": "Çakmak ile ateş yakabilmek",
+  "perm-entity-damage-friendly-name": "Arkadaş canlısı varlıklara vurabilmek",
+  "perm-entity-damage-friendly-description": "İnek, koyun, ahtapot gibi varlıklara hasar verebilmek",
+  "perm-entity-damage-hostile-name": "Düşmancıl varlıklara vurabilmek",
+  "perm-entity-damage-hostile-description": "Zombi, iskelet, balçık gibi canlılara hasar verebilmek",
+  "perm-entity-damage-vehicle-name": "Araçlara hasar vermek",
+  "perm-entity-damage-vehicle-description": "Vagon ve bot gibi varlıklara hasar verebilmek",
+  "perm-entity-damage-nl-name": "Yaşamayan varlıklara vurabilmek",
+  "perm-entity-damage-nl-description": "Zırh standı ve tablo gibi cansız eşyalara vurabilmek",
+  "perm-entity-damage-misc-name": "Diğer türlere zarar verebilmek",
+  "perm-entity-damage-misc-description": "Belirtilen kategoriler haricindeki varlıklara hasar vurabilmek",
+  "perm-explode-name": "Patlamalar",
+  "perm-explode-description": "Patlamalara yol açın; fakat kaynağı belirsiz patlamalar olursa GÜVENİLİR ve TECRÜBELİ grupları yokmuş gibi davranılır",
+  "perm-item-drop-name": "Eşya düşürmek",
+  "perm-item-drop-description": "Eşya düşürebilmek",
+  "perm-manage-name": "Alanı yönetmek",
+  "perm-manage-description": "Alan yetkilerini yönetebilmek",
+  "perm-delete-name": "Alanı simek",
+  "perm-delete-description": "Alanı silebilme yetkisi",
+  "gui-name": "XClaim",
+  "gui-main-new": "<gold>Yeni Alan</gold>",
+  "gui-main-edit-trust": "<blue>Güvenilir oyuncuları ayarla</blue>",
+  "gui-main-edit-chunk": "<green>Alanın chunklarını ayarla</green>",
+  "gui-main-rename-chunk": "<dark_purple>Alan adını değiştir</dark_purple>",
+  "gui-main-edit-perm": "<dark_aqua>Alan yetkilerini değiştir</dark_aqua>",
+  "gui-main-transfer-owner": "<gray>Sahipliği başkasına aktar</gray>",
+  "gui-main-clear-all": "<dark_red>Tüm Alanları Sil</dark_red>",
+  "gui-main-delete": "<red>Alanı sil</red>",
+  "gui-main-version": "<light_purple>Versiyon Bilgisi</light_purple>",
+  "gui-main-exit": "<gray>Çıkış</gray>",
+  "gui-vinf-version": "Versiyon",
+  "gui-vinf-mc-version": "MC Versiyon $1 için tasarlanmıştır",
+  "gui-vinf-mc-version-unspecified": "Belirtilmemiş",
+  "gui-vinf-author": "Tasarlayan",
+  "gui-vinf-back": "Geri",
+  "gui-tx-yes": "<dark_green>Evet</dark_green>",
+  "gui-tx-yes-line1": "<gray>İstediğimden eminim</gray>",
+  "gui-tx-yes-line2": "<gray>alanın sahipliğini</gray>",
+  "gui-tx-yes-line3": "<gray>adlı kullanıcıya aktarmaya</gray>",
+  "gui-tx-no": "<dark_red>Hayır</dark_red>",
+  "gui-tx-no-line1": "<gray>Beni geri götür</gray>",
+  "gui-tx-no-line2": "<gray>güvenli bir yere!</gray>",
+  "gui-tx-prompt": "Sohbete alanın sahipliğini vermek istediğiniz kişinin nickini giriniz.",
+  "gui-tx-prompt-fail": "<red>* Belirttiğiniz kişi bulunamadı!</red>",
+  "gui-tx-success": "<green>* Sahiplik devredildi!</green>",
+  "gui-comb-previous": "<gold>Önceki sayfa</gold>",
+  "gui-comb-next": "<gold>Sonraki sayfa</gold>",
+  "gui-comb-add": "<green>Oyuncu ekle</green>",
+  "gui-comb-back": "<red>Geri</red>",
+  "gui-comb-prompt": "Eklemek için sohbete oyuncunun nickini yazınınz.",
+  "gui-comb-prompt-fail": "<red>* Bu isimde bir oyuncu bulunamadı.</red>",
+  "gui-comb-prompt-success": "<green>Oyuncu başarıyla eklendi.</green>",
+  "gui-perm-general": "<dark_gray>Genel yetkiler</dark_gray>",
+  "gui-perm-general-line1": "<gray>Güvendiğin oyuncular, tecrübeli oyuncu-</gray>",
+  "gui-perm-general-line2": "<gray>lar ve oyuncular için bu sekmeden</gray>",
+  "gui-perm-general-line3": "<gray>yetkileri ayarlayabilirsin</gray>",
+  "gui-perm-player": "<dark_aqua>Oyuncu yetkileri</dark_aqua>",
+  "gui-perm-player-line1": "<aqua>Oyuncu başına</aqua>",
+  "gui-perm-player-line2": "<aqua>özel yetki atayın</aqua>",
+  "gui-perm-player-line3": "<aqua>(mesela belirli bir</aqua>",
+  "gui-perm-player-line4": "<aqua>oyuncuya alanınıza girme</aqua>",
+  "gui-perm-player-line5": "<aqua>yetkisini kapatmak gibi)</aqua>",
+  "gui-perm-back": "<red>Geri</red>",
+  "gui-perm-tl-none": "<red>Hiçbiri</red>",
+  "gui-perm-tl-none-line1": "Senden başka kimsede",
+  "gui-perm-tl-none-line2": "bu yetki yok.",
+  "gui-perm-tl-trusted": "<gold>Güvenilir</gold>",
+  "gui-perm-tl-trusted-line1": "Sadece senin özel olarak",
+  "gui-perm-tl-trusted-line2": "güvendiğin kişiler",
+  "gui-perm-tl-trusted-line3": "bu yetkiye sahip olacak.",
+  "gui-perm-tl-veterans": "<yellow>Tecrübeliler</yellow>",
+  "gui-perm-tl-veterans-line1": "Sadece sunucuda",
+  "gui-perm-tl-veterans-line2": "bir süre oynamış oyuncular",
+  "gui-perm-tl-veterans-line3": "bu yetkiye sahip olacak.",
+  "gui-perm-tl-all": "<green>Herkes</green>",
+  "gui-perm-tl-all-line1": "Tüm oyuncular bu yetkiye",
+  "gui-perm-tl-all-line2": "erişebilecek.",
+  "gui-perm-enabled": "<green>Aktif</green>",
+  "gui-perm-enabled-line1": "<gray>Bu oyuncunun bu yetkiye</gray>",
+  "gui-perm-enabled-line2": "<gray>sahip olmasını sağla.</gray>",
+  "gui-perm-disabled": "<red>Devre dışı</red>",
+  "gui-perm-disabled-line1": "<gray>Bu yetkiyi bu oyuncu</gray>",
+  "gui-perm-disabled-line2": "<gray>için kaldır. Yetki genel</gray>",
+  "gui-perm-disabled-line3": "<gray>ayarlarda nasıl ayarlandıysa öyle işleyecek.</gray>",
+  "gui-new-confirm": "<dark_green>Onayla</dark_green>",
+  "gui-new-confirm-line1": "<green>Bulunduğunuz chunkdan</green>",
+  "gui-new-confirm-line2": "<green>başlayarak yeni bir</green>",
+  "gui-new-confirm-line3": "<green>alan oluşturun.</green>",
+  "gui-new-cancel": "<dark_red>İptal</dark_red>",
+  "gui-new-cancel-line1": "<red>Ana menüye geri</red>",
+  "gui-new-cancel-line2": "<red>dönün.</red>",
+  "gui-new-claimed": "<red>* Bu chunk zaten sahiplenilmiş!</red>",
+  "gui-new-disallowed": "<red>* Kara listede olan bir dünyada yeni bir alan oluşturamazsın!</red>",
+  "gui-new-max-claims": "<red>* Oluşturabileceğin maksimum alan sayısına ulaştın! Belki de birazını silmeyi denemelisin?</red>",
+  "gui-new-max-chunks": "<red>* Bu alan oluşturulamıyor çünkü oluşturulduğu takdirde maksimum chunk sınırını aşmış olacaksın.</red>",
+  "gui-new-success": "<b><white>* Yeni alan oluşturuldu</white> <i><gold>$1</gold></i></b>",
+  "gui-edit-chunk-fail": "<red>* Dünyalar arasında alan oluşturamazsın!</red>",
+  "gui-edit-chunk-disallowed": "<red>* Kara listede bulunan bir dünyadasın</red>",
+  "gui-rename-chunk-prompt": "Alanın adını belirlemek için belirleyeceğiniz adı sohbete yazınız.",
+  "gui-rename-chunk-fail": "<red>* İsim çok uzun! İsim 50 karakterden az olmak zorunda.</red>",
+  "gui-rename-chunk-success": "<green>Alanın adı başarıyla değiştirildi.</green>",
+  "gui-clear-yes": "<green>Evet, eminim.</green>",
+  "gui-clear-yes2": "<green>Kesinlikle EMİNİM!</green>",
+  "gui-clear-yes-line1": "<gray>Bu karardan geri</gray>",
+  "gui-clear-yes-line2": "<gray>dönemezsin!</gray>",
+  "gui-clear-no": "<red>Hayır, beni geri götür!</red>",
+  "gui-clear-no-line1": "<gray>Alanlarını olduğu gibi</gray>",
+  "gui-clear-no-line2": "<gray>bırak</gray>",
+  "gui-sel-owned": "<b><white>Sahibi</white></b> <gold>$1</gold>",
+  "gui-sel-chunk-count": "<gold>$1</gold> <b><white>chunk</white></b>",
+  "gui-sel-chunk-count-plural": "<gold>$1</gold> <b><white>chunklar</white></b>",
+  "gui-sel-first-chunk": "<dark_gray>Chunk #1'in koordinatları </dark_gray><b><white>X=</white></b><gold>$1</gold><b><white>, Z=</white></b><gold>$2</gold>",
+  "gui-sel-within": "<gray>Şu an bulunduğun</gray>",
+  "gui-sel-previous": "<gold>Önceki</gold>",
+  "gui-sel-search": "<dark_purple>Ara</dark_purple>",
+  "gui-sel-cancel": "<red>İptal</red>",
+  "gui-sel-next": "<gold>Sonraki</gold>",
+  "gui-sel-prompt": "Arama yapmak için aramak istediğin şeyi sohbete yaz.",
+  "cmdmgr-err-player": "<red>* Bu komutu çalıştırmak için oyuncu olman gerek!</red>",
+  "cmdmgr-err-min-args": "<red>* Yeterli argüman yok! Bu komut şunu gerektiriyor $1</red>",
+  "cmdmgr-err-max-args": "<red>* Çok fazla argüman var! Bu komut maksimum şu kadar gerektiriyor $1</red>",
+  "cmdmgr-err-malformed": "<red>* Kötü argüman! Daha fazla bilgi için yardım sayfasına bakın</red>",
+  "cmdmgr-err-unexpected": "<red>* Komut çalışırken beklenmeyen bir istisna ($1) ortaya çıktı.</red>", 
+  "cmdmgr-err-undefined": "Could not register command \"$1\", does not exist in plugin.yml",
+  "cmdmgr-err-reflect": "$1 sınıfı için yapıcıya erişilemedi, Detaylarını aşağıdan bakabilirsiniz",
+  "cmd-xc-description": "XClaim ana komudu",
+  "cmd-import-name": "importclaims",
+  "cmd-import-description": "ClaimChunk pluginindeki alanları geçirir.",
+  "cmd-import-err-disabled": "<red>ClaimChunk plugini aktif gözükmüyor gibi.</red>",
+  "cmd-import-err-installed": "<red>* ClaimChunk plugini indirilip kurulmamış.</red>",
+  "cmd-import-status-handler": "<green>Veri işleyici alınıyor...</green>",
+  "cmd-import-err-reflect": "<red>Başarılamadı. Detaylara konsoldan bakabilirsiniz.</red>",
+  "cmd-import-status-world": "<dark_green><i>Dünya işleniyor</i></dark_green> <gold>$1</gold>",
+  "cmd-import-status-chunk": "<gold>$1, $2</gold> <green>koordinatlarında alan içine alınmış chunklar bulundu.</green> ",
+  "cmd-import-status-fill": "<green>Taşırma algoritması çalıştırılıyor</green>",
+  "cmd-import-status-player": "<gold>$1</gold> <green>oyuncusu için alanları oluşturuluyor</green>",
+  "cmd-import-status-success": "<green>Başarılı</green>",
+  "cmd-import-status-disabling": "<green>Tüm dünyalar başarıyla işlendi. ClaimChunk plugini devre dışı bırakılıyor...</green>",
+  "cmd-import-status-done": "<green>Başarılı</green>",
+  "cmd-update-name": "update",
+  "cmd-update-description": "XClaim için internetten güncellemelere bakar",
+  "cmd-update-arg-proceed-description": "Güncelleme bulunduktan sonra devam edilsin mi?",
+  "cmd-update-arg-proceed-yes": "evet",
+  "cmd-update-arg-proceed-no": "hayır",
+  "cmd-update-err-perms": "<red>* Bu komutu kullanmak için gerekli yetkilerin yok!</red>",
+  "cmd-update-err-perms2": "<red>* XClaim pluginini güncellemek için gerekli yetkilerin yok!</red>",
+  "cmd-update-declined": "<green>* Güncelleme reddedildi.</green>",
+  "cmd-update-searching": "<yellow>* Güncellemelere bakılıyor...</yellow>",
+  "cmd-update-err-check": "<red>* Güncellemek için başka bir sürüm ararken hata meydana geldi. Daha fazla detay için konsola bakabilirsiniz.</red>",
+  "cmd-update-none": "<red>* Yeni bir güncelleme bulunamadı.</red>",
+  "cmd-update-start": "<yellow>* Güncelleme yükleniyor...</yellow>",
+  "cmd-update-err-unexpected": "<red>* Güncelleme yapılırken hata meydana geldi. Daha fazla detay için konsola bakabilirsiniz.</red>",
+  "cmd-update-success": "<green>* Başarıyla güncellendi! Değişiklikler bir sonraki yeniden başlatma işleminde uygulanacak. Restarting soon is recommended to avoid any unpredictable bugs.</green>",
+  "cmd-update-promote-restart-player-pre": "<b><gold>YENİ: </gold></b><yellow>Tıkla </yellow>",
+  "cmd-update-promote-restart-player-click": "<u><gold>buraya</gold></u>",
+  "cmd-update-promote-restart-player-post": "<yellow> böylece sunucuyu yeniden başlatmadan sadece XClaim'i yeniden başlatabilirsiniz</yellow><dark_red>(DENEYSEL)</dark_red>",
+  "cmd-update-promote-restart-console": "<b><gold>YENİ: </gold></b><gold>/xclaim restart yes</gold> <yellow>komudunu kullanarak sunucuyu yeniden başlatmadan XClaim pluginini yeniden başlatabilirsiniz </yellow><dark_red>(DENEYSEL)</dark_red>",
+  "cmd-update-redundant": "<green>* Zaten en güncel XClaim sürümünü kullanıyorsunuz!</green>",
+  "cmd-update-found": "<green>* Versiyon </green><gold>$1</gold> <green>bulundu.</green>",
+  "cmd-update-confirm-console": "<green>* /xclaim update yes kullanarak yeni versiyonu indirebilirsiniz.</green>",
+  "cmd-update-confirm-player-prompt": "Bu versiyon yüklensin mi?",
+  "cmd-update-confirm-player-yes": "<green>Evet</green>",
+  "cmd-update-confirm-player-no": "<red>Hayır</red>",
+  "cmd-restart-name": "restart",
+  "cmd-restart-description": "Sunucuyu yeniden başlatmadan XClaim'i yeniden başlatır",
+  "cmd-restart-arg-confirm-description": "Eğer evetse, onaylamadan yeniden başlatır",
+  "cmd-restart-arg-confirm-yes": "evet",
+  "cmd-restart-arg-confirm-no": "hayır",
+  "cmd-restart-err-perm": "<red>* Bu komutu çalıştırmak için gerekli yetkilerin yok!</red>",
+  "cmd-restart-status-disabling": "<green>XClaim devre dışı bırakılıyor...</green>",
+  "cmd-restart-warn-pm": "<yellow>XClaim'i plugin yöneticisinden çıkarılamadı. Yine de devam ediliyor...</yellow>",
+  "cmd-restart-status-enabling": "<green>XClaim aktifleştiriliyor...</green>",
+  "cmd-restart-err-load": "<red>XClaim yüklenemedi</red>",
+  "cmd-restart-err-enable": "<red>XClaim aktive edilemedi</red>",
+  "cmd-restart-status-success": "<gold>XClaim'in $1 versiyonu aktive edildi.</gold>",
+  "cmd-restart-warn-header": "<b><gold>UYARI!</gold></b>",
+  "cmd-restart-warn-body": "<red>Bu özellik <b>deneyseldir</b>.</red>",
+  "cmd-restart-confirm-player-pre": "<yellow>Tıkla </yellow>",
+  "cmd-restart-confirm-player-click": "<gold>buraya</gold>",
+  "cmd-restart-confirm-player-post": "<yellow> yine de devam etmek için.</yellow>",
+  "cmd-restart-confirm-console": "<gold>/xclaim restart yes</gold> <yellow>komudunu çalıştırarak yine de devam edebilirsiniz.</yellow>", 
+  "cmd-list-name": "list",
+  "cmd-list-description": "Seçili üyenin alanlarını listeler",
+  "cmd-list-arg-player-description": "Alanını listeleyeceğini oyuncu(belirtilmemişse kendiniz ve de oyuncu iseniz)",
+  "cmd-list-arg-chunks-description": "Her alan için gösterilecek maksimum chunk (varsayılan olarak 3'tür)",
+  "cmd-list-err-player": "<red>* Bir oyuncu belirtmelisiniz (oyuncu değilsiniz)!</red>",
+  "cmd-list-none": "$1 <dark_gray>adlı oyuncunun hiç alanı yok</dark_gray>",
+  "cmd-list-claim-header": "<dark_purple>Alan #$1: $2</dark_purple>",
+  "cmd-list-claim-chunk": "<light_purple>Chunk koordinatları X=$1, Z=$2</light_purple>",
+  "cmd-list-claim-more": "<dark_gray>ve $1 daha...</dark_gray>",
+  "cmd-info-name": "info",
+  "cmd-info-description": "XClaim hakkında basit bilgiler gösterir",
+  "cmd-info-author": "<gold>$1 tarafından yapıldı</gold>",
+  "cmd-info-version": "<gold>Versiyon $1</gold>",
+  "cmd-info-apiVersion": "<gold>API versiyonu $1</gold>",
+  "cmd-info-claims-not-plural": "<gold>Toplam <white>1</white> alanınız ve kaplayan <white>1</white> chunk var</gold>",
+  "cmd-info-claims-chunk-plural": "<gold>Toplam <white>1</white> alanınız ve kaplayan <white>$2</white> chunk var</gold>",
+  "cmd-info-claims-both-plural": "<gold>Toplam <white>$1</white> alanınız ve kaplayan <white>$2</white> chunk var</gold>",
+  "cmd-help-name": "help",
+  "cmd-help-description": "Belirli bir komut için olası komutların bir listesini veya ayrıntılı bilgileri sağlar",
+  "cmd-help-arg-name": "Sayfa sayısı ya da komut ismi",
+  "cmd-help-arg-description": "Görüntülenecek yardım sayfası veya hakkında ayrıntılı bilgi görüntülenecek komutun adı",
+  "cmd-help-err-404": "<red>* Komut bulunamadı</red>",
+  "cmd-help-no-args": "<i><gray>Argüman bulunmamakta</gray></i>",
+  "cmd-help-page": "<yellow>Sayfa $1</yellow>",
+  "cmd-gui-name": "gui",
+  "cmd-gui-description": "Tüm XClaim işlevleri için erişilebilir bir arayüz",
+  "cmd-gui-err-restricted": "<red>* GUI'ye erişmeden önce chunk düzenleyiciden çıkman gerekiyor..</red>",
+  "cmd-current-name": "current",
+  "cmd-current-description": "Bulunduğun alan hakkında bilgi verir.",
+  "cmd-current-err-404": "<red>* Bir alanın içinde değilsin!</red>",
+  "cmd-current-world-unset": "Unset",
+  "cmd-current-output-line1": "<gold>= <dark_aqua>$1</dark_aqua> =</gold>",
+  "cmd-current-output-line2": "<dark_gray>Sahibi <gray>$1</gray></dark_gray>",
+  "cmd-current-output-line3": "<dark_gray>Bulunduğu dünya <gray>$1</gray></dark_gray>",
+  "cmd-current-output-line4-plural": "<dark_gray><gray>$1</gray> chunk</dark_gray>",
+  "cmd-current-output-line4-singular": "<dark_gray><gray>$1</gray> chunk</dark_gray>",
+  "cmd-clear-name": "clear",
+  "cmd-clear-description": "Belirli oyuncunun sahip olduğu tüm alanları siler.",
+  "cmd-clear-arg-player-description": "Alanını sileceğiniz oyuncu(belirtilmemişse kendiniz ve de oyuncu iseniz)",
+  "cmd-clear-arg-confirm-description": "Eğer evetse bu komut izin sormadan çalışır",
+  "cmd-clear-arg-confirm-yes": "evet",
+  "cmd-clear-arg-confirm-no": "hayır",
+  "cmd-clear-err-missing": "<red>* Bir oyuncu belirtmelisiniz (siz oyuncu değilsiniz)!</red>",
+  "cmd-clear-err-perm": "<red>* Diğer oyuncuların komutlarını temizleme izniniz yok!</red>",
+  "cmd-clear-player-unknown": "Bilinmeyen",
+  "cmd-clear-player-console": "KONSOL",
+  "cmd-clear-success": "<green>* $1 adlı oyuncunun tüm alanları temizlendi.</green>",
+  "cmd-clear-notify": "<gray>* Alanların $1 tarafından temizlendi.</gray>",
+  "cmd-clear-prompt": "<red>$1 adlı oyuncunun tüm alanlarını temizlemek istediğine emin misin?</red>",
+  "cmd-clear-prompt-player-pre": "<gold>Tıkla </gold>",
+  "cmd-clear-prompt-player-click": "<u><yellow>buraya</yellow></u>",
+  "cmd-clear-prompt-player-post": "<gold> onaylamak için</gold>",
+  "cmd-clear-prompt-console": "<gold>Onaylamak için <yellow>$1</yellow> komudunu çalıştırın</gold>",
+  "cmd-chunks-name": "chunks",
+  "cmd-chunks-description": "Alanın chunk düzenleyicisini açar. Bir alan adı belirtilirse o alanı düzenleyecektir. Aksi takdirde içinde bulunduğunuz alanını kullanır.",
+  "cmd-chunks-arg-name": "Alan ismi",
+  "cmd-chunks-arg-description": "Düzenlenecek olan alanın adı. Eğer yoksa, içinde bulunulan alan varsayılır.",
+  "cmd-chunks-err-state": "<red>* Zaten chunk düzenleyicidesiniz! Önce oradan çıkın!</red>",
+  "cmd-chunks-err-404": "<red>* Şu anda bir alanın içinde değilsiniz!</red>",
+  "cmd-chunks-err-perm": "<red>* Bu alanı yönetmek için iznin yok!</red>",
+  "cmd-chunks-err-disallowed": "<red>* Kara listeye alınmış bir dünyada alanları düzenleyemezsiniz</red>",
+  "cmd-chunks-success": "<green>Düzenlenen alan <gold>$1</gold></green>",
+  "arg-string-name": "Yazı",
+  "arg-string-sample": "yazı",
+  "arg-range-name": "$1 ile $2 arasında tamsayı",
+  "arg-player-name": "Aktif Oyuncular",
+  "arg-offlinePlayer-name": "Aktif",
+  "arg-material-name": "Materyal",
+  "arg-itemMaterial-name": "Eşya",
+  "arg-blockMaterial-name": "Blok",
+  "arg-int-name": "Tamsayı",
+  "arg-float-name": "Ondalık",
+  "arg-combo-many": "Birçok",
+  "arg-combo-separator": ", ",
+  "arg-combo-or": " ya da ",
+  "arg-choice-root": "Seçimi ",
+  "arg-choice-nothing": "Hiçbir şey",
+  "arg-choice-many": "Birçok",
+  "arg-choice-separator": ", ",
+  "arg-choice-or": " ya da ",
+  "move-enter": "<white><gold>$1</gold> adlı oyuncunun <green>$2</green> alanına giriliyor</white>",
+  "move-exit": "<white><green>$1</green> alanından çıkılıyor</white>",
+  "grace-alert": "<red><dark_red>UYARI</dark_red>: Kara listeye alınmış dünyalarda yakında kaldırılacak <dark_red>$1</dark_red> alanınız var</red>",
+  "grace-remove": "<red><dark_red>$1</dark_red> adlı alanınız kara listede yer aldığı için kaldırıldı</red>",
+  "event-fail-create-claim": "<red>* Şu anda alan oluşturamazsınız.</red>",
+  "event-fail-create-claim-single": "<red>* Bu alan oluşturulamaz ($1)</red>",
+  "event-fail-delete-claim": "<red>* Şu anda alan silemezsiniz.</red>",
+  "event-fail-delete-claim-single": "<red>* Bu alan silinemez ($1)</red>",
+  "event-fail-add-chunks": "<red>* Şu anda bu alana chunk ekleyemezsiniz.</red>",
+  "event-fail-add-chunks-single": "<red>* Bu alana chunk eklenemez ($1)</red>",
+  "event-fail-add-chunk": "<red>* Şu anda bu alana chunk ekleyemezsiniz.</red>",
+  "event-fail-add-chunk-single": "<red>* Bu alana chunk eklenemez ($1)</red>",
+  "event-fail-remove-chunks": "<red>* Şu anda bu alandan chunk silemezsiniz.</red>",
+  "event-fail-remove-chunks-single": "<red>* Bu alandan chunk silinemez ($1)</red>",
+  "event-fail-remove-chunk": "<red>* Şu anda bu alandan chunk silemezsiniz.</red>",
+  "event-fail-remove-chunk-single": "<red>* Bu alandan chunk silinemez ($1)</red>",
+  "event-fail-transfer-owner": "<red>* Şu anda alanın sahipliğini devredemezsiniz.</red>",
+  "event-fail-transfer-owner-single": "<red>* Bu alanın sahipliği devredilemez ($1)</red>",
+  "event-fail-set-permission": "<red>* Bu izni şu anda bu alanda ayarlayamazsınız.</red>",
+  "event-fail-set-permission-single": "<red>* Bu alanda yetki ayarlanamaz ($1)</red>",
+  "event-fail-grant-user-permission": "<red>* Şu anda bir kullanıcıya izin veremezsiniz.</red>",
+  "event-fail-grant-user-permission-single": "<red>* Bu alanda kullanıcıya izin verilemiyor ($1)</red>",
+  "event-fail-revoke-user-permission": "<red>* Şu anda bir kullanıcı iznini iptal edemezsiniz.</red>",
+  "event-fail-revoke-user-permission-single": "<red>* Bu alana ilişkin kullanıcı izni iptal edilemiyor ($1)</red>",
+  "unknown": "Bilinmiyor"
+}
\ No newline at end of file